blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-30 18:10:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use ntoh instead of hton when byte swapping for consistency

Browse source
This commit is contained in:
Dan Paulat 2021-06-20 21:23:44 -05:00
parent ded87eb937
commit 9daee7b8c6
6 changed files with 245 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

6
wxdata/source/scwx/wsr88d/ar2v_file.cpp
View file

@ -76,8 +76,8 @@ bool Ar2vFile::LoadFile(const std::string& filename)
f.read(reinterpret_cast<char*>(&p->milliseconds_), 4); f.read(reinterpret_cast<char*>(&p->milliseconds_), 4);
f.read(&p->icao_[0], 4); f.read(&p->icao_[0], 4);
p->julianDate_ = htonl(p->julianDate_); p->julianDate_ = ntohl(p->julianDate_);
p->milliseconds_ = htonl(p->milliseconds_); p->milliseconds_ = ntohl(p->milliseconds_);
} }
if (f.eof()) if (f.eof())
@ -118,7 +118,7 @@ void Ar2vFileImpl::LoadLDMRecords(std::ifstream& f)
f.read(reinterpret_cast<char*>(&controlWord), 4); f.read(reinterpret_cast<char*>(&controlWord), 4);
controlWord = htonl(controlWord); controlWord = ntohl(controlWord);
recordSize = std::abs(controlWord); recordSize = std::abs(controlWord);
BOOST_LOG_TRIVIAL(trace) BOOST_LOG_TRIVIAL(trace)

12
wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp
View file

@ -87,9 +87,9 @@ bool ClutterFilterMap::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&numElevationSegments), 2); is.read(reinterpret_cast<char*>(&numElevationSegments), 2);
bytesRead += 6; bytesRead += 6;
p->mapGenerationDate_ = htons(p->mapGenerationDate_); p->mapGenerationDate_ = ntohs(p->mapGenerationDate_);
p->mapGenerationTime_ = htons(p->mapGenerationTime_); p->mapGenerationTime_ = ntohs(p->mapGenerationTime_);
numElevationSegments = htons(numElevationSegments); numElevationSegments = ntohs(numElevationSegments);
if (p->mapGenerationDate_ < 1) if (p->mapGenerationDate_ < 1)
{ {
@ -128,7 +128,7 @@ bool ClutterFilterMap::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&numRangeZones), 2); is.read(reinterpret_cast<char*>(&numRangeZones), 2);
bytesRead += 2; bytesRead += 2;
numRangeZones = htons(numRangeZones); numRangeZones = ntohs(numRangeZones);
if (numRangeZones < 1 || numRangeZones > 20) if (numRangeZones < 1 || numRangeZones > 20)
{ {
@ -153,8 +153,8 @@ bool ClutterFilterMap::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&zone.endRange), 2); is.read(reinterpret_cast<char*>(&zone.endRange), 2);
bytesRead += 4; bytesRead += 4;
zone.opCode = htons(zone.opCode); zone.opCode = ntohs(zone.opCode);
zone.endRange = htons(zone.endRange); zone.endRange = ntohs(zone.endRange);
if (zone.opCode > 2) if (zone.opCode > 2)
{ {

12
wxdata/source/scwx/wsr88d/rda/message_header.cpp
View file

@ -108,12 +108,12 @@ bool MessageHeader::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->numberOfMessageSegments_), 2); is.read(reinterpret_cast<char*>(&p->numberOfMessageSegments_), 2);
is.read(reinterpret_cast<char*>(&p->messageSegmentNumber_), 2); is.read(reinterpret_cast<char*>(&p->messageSegmentNumber_), 2);
p->messageSize_ = htons(p->messageSize_); p->messageSize_ = ntohs(p->messageSize_);
p->idSequenceNumber_ = htons(p->idSequenceNumber_); p->idSequenceNumber_ = ntohs(p->idSequenceNumber_);
p->julianDate_ = htons(p->julianDate_); p->julianDate_ = ntohs(p->julianDate_);
p->millisecondsOfDay_ = htonl(p->millisecondsOfDay_); p->millisecondsOfDay_ = ntohl(p->millisecondsOfDay_);
p->numberOfMessageSegments_ = htons(p->numberOfMessageSegments_); p->numberOfMessageSegments_ = ntohs(p->numberOfMessageSegments_);
p->messageSegmentNumber_ = htons(p->messageSegmentNumber_); p->messageSegmentNumber_ = ntohs(p->messageSegmentNumber_);
if (is.eof()) if (is.eof())
{ {

364
wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp
View file

@ -2174,46 +2174,46 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
bytesRead += 960; bytesRead += 960;
// Communications // Communications
p->loopBackSetStatus_ = htons(p->loopBackSetStatus_); p->loopBackSetStatus_ = ntohs(p->loopBackSetStatus_);
p->t1OutputFrames_ = htonl(p->t1OutputFrames_); p->t1OutputFrames_ = ntohl(p->t1OutputFrames_);
p->t1InputFrames_ = htonl(p->t1InputFrames_); p->t1InputFrames_ = ntohl(p->t1InputFrames_);
p->routerMemoryUsed_ = htonl(p->routerMemoryUsed_); p->routerMemoryUsed_ = ntohl(p->routerMemoryUsed_);
p->routerMemoryFree_ = htonl(p->routerMemoryFree_); p->routerMemoryFree_ = ntohl(p->routerMemoryFree_);
p->routerMemoryUtilization_ = htons(p->routerMemoryUtilization_); p->routerMemoryUtilization_ = ntohs(p->routerMemoryUtilization_);
p->routeToRpg_ = htons(p->routeToRpg_); p->routeToRpg_ = ntohs(p->routeToRpg_);
p->csuLossOfSignal_ = htonl(p->csuLossOfSignal_); p->csuLossOfSignal_ = ntohl(p->csuLossOfSignal_);
p->csuLossOfFrames_ = htonl(p->csuLossOfFrames_); p->csuLossOfFrames_ = ntohl(p->csuLossOfFrames_);
p->csuYellowAlarms_ = htonl(p->csuYellowAlarms_); p->csuYellowAlarms_ = ntohl(p->csuYellowAlarms_);
p->csuBlueAlarms_ = htonl(p->csuBlueAlarms_); p->csuBlueAlarms_ = ntohl(p->csuBlueAlarms_);
p->csu24HrErroredSeconds_ = htonl(p->csu24HrErroredSeconds_); p->csu24HrErroredSeconds_ = ntohl(p->csu24HrErroredSeconds_);
p->csu24HrSeverelyErroredSeconds_ = htonl(p->csu24HrSeverelyErroredSeconds_); p->csu24HrSeverelyErroredSeconds_ = ntohl(p->csu24HrSeverelyErroredSeconds_);
p->csu24HrSeverelyErroredFramingSeconds_ = p->csu24HrSeverelyErroredFramingSeconds_ =
htonl(p->csu24HrSeverelyErroredFramingSeconds_); ntohl(p->csu24HrSeverelyErroredFramingSeconds_);
p->csu24HrUnavailableSeconds_ = htonl(p->csu24HrUnavailableSeconds_); p->csu24HrUnavailableSeconds_ = ntohl(p->csu24HrUnavailableSeconds_);
p->csu24HrControlledSlipSeconds_ = htonl(p->csu24HrControlledSlipSeconds_); p->csu24HrControlledSlipSeconds_ = ntohl(p->csu24HrControlledSlipSeconds_);
p->csu24HrPathCodingViolations_ = htonl(p->csu24HrPathCodingViolations_); p->csu24HrPathCodingViolations_ = ntohl(p->csu24HrPathCodingViolations_);
p->csu24HrLineErroredSeconds_ = htonl(p->csu24HrLineErroredSeconds_); p->csu24HrLineErroredSeconds_ = ntohl(p->csu24HrLineErroredSeconds_);
p->csu24HrBurstyErroredSeconds_ = htonl(p->csu24HrBurstyErroredSeconds_); p->csu24HrBurstyErroredSeconds_ = ntohl(p->csu24HrBurstyErroredSeconds_);
p->csu24HrDegradedMinutes_ = htonl(p->csu24HrDegradedMinutes_); p->csu24HrDegradedMinutes_ = ntohl(p->csu24HrDegradedMinutes_);
p->lanSwitchCpuUtilization_ = htonl(p->lanSwitchCpuUtilization_); p->lanSwitchCpuUtilization_ = ntohl(p->lanSwitchCpuUtilization_);
p->lanSwitchMemoryUtilization_ = htons(p->lanSwitchMemoryUtilization_); p->lanSwitchMemoryUtilization_ = ntohs(p->lanSwitchMemoryUtilization_);
p->ifdrChasisTemperature_ = htons(p->ifdrChasisTemperature_); p->ifdrChasisTemperature_ = ntohs(p->ifdrChasisTemperature_);
p->ifdrFpgaTemperature_ = htons(p->ifdrFpgaTemperature_); p->ifdrFpgaTemperature_ = ntohs(p->ifdrFpgaTemperature_);
p->gpsSatellites_ = htonl(p->gpsSatellites_); p->gpsSatellites_ = ntohl(p->gpsSatellites_);
p->ipcStatus_ = htons(p->ipcStatus_); p->ipcStatus_ = ntohs(p->ipcStatus_);
p->commandedChannelControl_ = htons(p->commandedChannelControl_); p->commandedChannelControl_ = ntohs(p->commandedChannelControl_);
// AME // AME
p->polarization_ = htons(p->polarization_); p->polarization_ = ntohs(p->polarization_);
p->ameInternalTemperature_ = SwapFloat(p->ameInternalTemperature_); p->ameInternalTemperature_ = SwapFloat(p->ameInternalTemperature_);
p->ameReceiverModuleTemperature_ = p->ameReceiverModuleTemperature_ =
SwapFloat(p->ameReceiverModuleTemperature_); SwapFloat(p->ameReceiverModuleTemperature_);
p->ameBiteCalModuleTemperature_ = SwapFloat(p->ameBiteCalModuleTemperature_); p->ameBiteCalModuleTemperature_ = SwapFloat(p->ameBiteCalModuleTemperature_);
p->amePeltierPulseWidthModulation_ = p->amePeltierPulseWidthModulation_ =
htons(p->amePeltierPulseWidthModulation_); ntohs(p->amePeltierPulseWidthModulation_);
p->amePeltierStatus_ = htons(p->amePeltierStatus_); p->amePeltierStatus_ = ntohs(p->amePeltierStatus_);
p->ameADConverterStatus_ = htons(p->ameADConverterStatus_); p->ameADConverterStatus_ = ntohs(p->ameADConverterStatus_);
p->ameState_ = htons(p->ameState_); p->ameState_ = ntohs(p->ameState_);
p->ame3_3VPsVoltage_ = SwapFloat(p->ame3_3VPsVoltage_); p->ame3_3VPsVoltage_ = SwapFloat(p->ame3_3VPsVoltage_);
p->ame5VPsVoltage_ = SwapFloat(p->ame5VPsVoltage_); p->ame5VPsVoltage_ = SwapFloat(p->ame5VPsVoltage_);
p->ame6_5VPsVoltage_ = SwapFloat(p->ame6_5VPsVoltage_); p->ame6_5VPsVoltage_ = SwapFloat(p->ame6_5VPsVoltage_);
@ -2223,8 +2223,8 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
p->peltierCurrent_ = SwapFloat(p->peltierCurrent_); p->peltierCurrent_ = SwapFloat(p->peltierCurrent_);
p->adcCalibrationReferenceVoltage_ = p->adcCalibrationReferenceVoltage_ =
SwapFloat(p->adcCalibrationReferenceVoltage_); SwapFloat(p->adcCalibrationReferenceVoltage_);
p->ameMode_ = htons(p->ameMode_); p->ameMode_ = ntohs(p->ameMode_);
p->amePeltierMode_ = htons(p->amePeltierMode_); p->amePeltierMode_ = ntohs(p->amePeltierMode_);
p->amePeltierInsideFanCurrent_ = SwapFloat(p->amePeltierInsideFanCurrent_); p->amePeltierInsideFanCurrent_ = SwapFloat(p->amePeltierInsideFanCurrent_);
p->amePeltierOutsideFanCurrent_ = SwapFloat(p->amePeltierOutsideFanCurrent_); p->amePeltierOutsideFanCurrent_ = SwapFloat(p->amePeltierOutsideFanCurrent_);
p->horizontalTrLimiterVoltage_ = SwapFloat(p->horizontalTrLimiterVoltage_); p->horizontalTrLimiterVoltage_ = SwapFloat(p->horizontalTrLimiterVoltage_);
@ -2234,8 +2234,8 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
SwapFloat(p->adcCalibrationGainCorrection_); SwapFloat(p->adcCalibrationGainCorrection_);
// RCP/SPIP Power Button Status // RCP/SPIP Power Button Status
p->rcpStatus_ = htons(p->rcpStatus_); p->rcpStatus_ = ntohs(p->rcpStatus_);
p->spipPowerButtons_ = htons(p->spipPowerButtons_); p->spipPowerButtons_ = ntohs(p->spipPowerButtons_);
// Power // Power
p->masterPowerAdministratorLoad_ = p->masterPowerAdministratorLoad_ =
@ -2244,95 +2244,95 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
SwapFloat(p->expansionPowerAdministratorLoad_); SwapFloat(p->expansionPowerAdministratorLoad_);
// Transmitter // Transmitter
p->_5VdcPs_ = htons(p->_5VdcPs_); p->_5VdcPs_ = ntohs(p->_5VdcPs_);
p->_15VdcPs_ = htons(p->_15VdcPs_); p->_15VdcPs_ = ntohs(p->_15VdcPs_);
p->_28VdcPs_ = htons(p->_28VdcPs_); p->_28VdcPs_ = ntohs(p->_28VdcPs_);
p->neg15VdcPs_ = htons(p->neg15VdcPs_); p->neg15VdcPs_ = ntohs(p->neg15VdcPs_);
p->_45VdcPs_ = htons(p->_45VdcPs_); p->_45VdcPs_ = ntohs(p->_45VdcPs_);
p->filamentPsVoltage_ = htons(p->filamentPsVoltage_); p->filamentPsVoltage_ = ntohs(p->filamentPsVoltage_);
p->vacuumPumpPsVoltage_ = htons(p->vacuumPumpPsVoltage_); p->vacuumPumpPsVoltage_ = ntohs(p->vacuumPumpPsVoltage_);
p->focusCoilPsVoltage_ = htons(p->focusCoilPsVoltage_); p->focusCoilPsVoltage_ = ntohs(p->focusCoilPsVoltage_);
p->filamentPs_ = htons(p->filamentPs_); p->filamentPs_ = ntohs(p->filamentPs_);
p->klystronWarmup_ = htons(p->klystronWarmup_); p->klystronWarmup_ = ntohs(p->klystronWarmup_);
p->transmitterAvailable_ = htons(p->transmitterAvailable_); p->transmitterAvailable_ = ntohs(p->transmitterAvailable_);
p->wgSwitchPosition_ = htons(p->wgSwitchPosition_); p->wgSwitchPosition_ = ntohs(p->wgSwitchPosition_);
p->wgPfnTransferInterlock_ = htons(p->wgPfnTransferInterlock_); p->wgPfnTransferInterlock_ = ntohs(p->wgPfnTransferInterlock_);
p->maintenanceMode_ = htons(p->maintenanceMode_); p->maintenanceMode_ = ntohs(p->maintenanceMode_);
p->maintenanceRequired_ = htons(p->maintenanceRequired_); p->maintenanceRequired_ = ntohs(p->maintenanceRequired_);
p->pfnSwitchPosition_ = htons(p->pfnSwitchPosition_); p->pfnSwitchPosition_ = ntohs(p->pfnSwitchPosition_);
p->modulatorOverload_ = htons(p->modulatorOverload_); p->modulatorOverload_ = ntohs(p->modulatorOverload_);
p->modulatorInvCurrent_ = htons(p->modulatorInvCurrent_); p->modulatorInvCurrent_ = ntohs(p->modulatorInvCurrent_);
p->modulatorSwitchFail_ = htons(p->modulatorSwitchFail_); p->modulatorSwitchFail_ = ntohs(p->modulatorSwitchFail_);
p->mainPowerVoltage_ = htons(p->mainPowerVoltage_); p->mainPowerVoltage_ = ntohs(p->mainPowerVoltage_);
p->chargingSystemFail_ = htons(p->chargingSystemFail_); p->chargingSystemFail_ = ntohs(p->chargingSystemFail_);
p->inverseDiodeCurrent_ = htons(p->inverseDiodeCurrent_); p->inverseDiodeCurrent_ = ntohs(p->inverseDiodeCurrent_);
p->triggerAmplifier_ = htons(p->triggerAmplifier_); p->triggerAmplifier_ = ntohs(p->triggerAmplifier_);
p->circulatorTemperature_ = htons(p->circulatorTemperature_); p->circulatorTemperature_ = ntohs(p->circulatorTemperature_);
p->spectrumFilterPressure_ = htons(p->spectrumFilterPressure_); p->spectrumFilterPressure_ = ntohs(p->spectrumFilterPressure_);
p->wgArcVswr_ = htons(p->wgArcVswr_); p->wgArcVswr_ = ntohs(p->wgArcVswr_);
p->cabinetInterlock_ = htons(p->cabinetInterlock_); p->cabinetInterlock_ = ntohs(p->cabinetInterlock_);
p->cabinetAirTemperature_ = htons(p->cabinetAirTemperature_); p->cabinetAirTemperature_ = ntohs(p->cabinetAirTemperature_);
p->cabinetAirflow_ = htons(p->cabinetAirflow_); p->cabinetAirflow_ = ntohs(p->cabinetAirflow_);
p->klystronCurrent_ = htons(p->klystronCurrent_); p->klystronCurrent_ = ntohs(p->klystronCurrent_);
p->klystronFilamentCurrent_ = htons(p->klystronFilamentCurrent_); p->klystronFilamentCurrent_ = ntohs(p->klystronFilamentCurrent_);
p->klystronVacionCurrent_ = htons(p->klystronVacionCurrent_); p->klystronVacionCurrent_ = ntohs(p->klystronVacionCurrent_);
p->klystronAirTemperature_ = htons(p->klystronAirTemperature_); p->klystronAirTemperature_ = ntohs(p->klystronAirTemperature_);
p->klystronAirflow_ = htons(p->klystronAirflow_); p->klystronAirflow_ = ntohs(p->klystronAirflow_);
p->modulatorSwitchMaintenance_ = htons(p->modulatorSwitchMaintenance_); p->modulatorSwitchMaintenance_ = ntohs(p->modulatorSwitchMaintenance_);
p->postChargeRegulatorMaintenance_ = p->postChargeRegulatorMaintenance_ =
htons(p->postChargeRegulatorMaintenance_); ntohs(p->postChargeRegulatorMaintenance_);
p->wgPressureHumidity_ = htons(p->wgPressureHumidity_); p->wgPressureHumidity_ = ntohs(p->wgPressureHumidity_);
p->transmitterOvervoltage_ = htons(p->transmitterOvervoltage_); p->transmitterOvervoltage_ = ntohs(p->transmitterOvervoltage_);
p->transmitterOvercurrent_ = htons(p->transmitterOvercurrent_); p->transmitterOvercurrent_ = ntohs(p->transmitterOvercurrent_);
p->focusCoilCurrent_ = htons(p->focusCoilCurrent_); p->focusCoilCurrent_ = ntohs(p->focusCoilCurrent_);
p->focusCoilAirflow_ = htons(p->focusCoilAirflow_); p->focusCoilAirflow_ = ntohs(p->focusCoilAirflow_);
p->oilTemperature_ = htons(p->oilTemperature_); p->oilTemperature_ = ntohs(p->oilTemperature_);
p->prfLimit_ = htons(p->prfLimit_); p->prfLimit_ = ntohs(p->prfLimit_);
p->transmitterOilLevel_ = htons(p->transmitterOilLevel_); p->transmitterOilLevel_ = ntohs(p->transmitterOilLevel_);
p->transmitterBatteryCharging_ = htons(p->transmitterBatteryCharging_); p->transmitterBatteryCharging_ = ntohs(p->transmitterBatteryCharging_);
p->highVoltageStatus_ = htons(p->highVoltageStatus_); p->highVoltageStatus_ = ntohs(p->highVoltageStatus_);
p->transmitterRecyclingSummary_ = htons(p->transmitterRecyclingSummary_); p->transmitterRecyclingSummary_ = ntohs(p->transmitterRecyclingSummary_);
p->transmitterInoperable_ = htons(p->transmitterInoperable_); p->transmitterInoperable_ = ntohs(p->transmitterInoperable_);
p->transmitterAirFilter_ = htons(p->transmitterAirFilter_); p->transmitterAirFilter_ = ntohs(p->transmitterAirFilter_);
SwapArray(p->zeroTestBit_); SwapArray(p->zeroTestBit_);
SwapArray(p->oneTestBit_); SwapArray(p->oneTestBit_);
p->xmtrSpipInterface_ = htons(p->xmtrSpipInterface_); p->xmtrSpipInterface_ = ntohs(p->xmtrSpipInterface_);
p->transmitterSummaryStatus_ = htons(p->transmitterSummaryStatus_); p->transmitterSummaryStatus_ = ntohs(p->transmitterSummaryStatus_);
p->transmitterRfPower_ = SwapFloat(p->transmitterRfPower_); p->transmitterRfPower_ = SwapFloat(p->transmitterRfPower_);
p->horizontalXmtrPeakPower_ = SwapFloat(p->horizontalXmtrPeakPower_); p->horizontalXmtrPeakPower_ = SwapFloat(p->horizontalXmtrPeakPower_);
p->xmtrPeakPower_ = SwapFloat(p->xmtrPeakPower_); p->xmtrPeakPower_ = SwapFloat(p->xmtrPeakPower_);
p->verticalXmtrPeakPower_ = SwapFloat(p->verticalXmtrPeakPower_); p->verticalXmtrPeakPower_ = SwapFloat(p->verticalXmtrPeakPower_);
p->xmtrRfAvgPower_ = SwapFloat(p->xmtrRfAvgPower_); p->xmtrRfAvgPower_ = SwapFloat(p->xmtrRfAvgPower_);
p->xmtrRecycleCount_ = htonl(p->xmtrRecycleCount_); p->xmtrRecycleCount_ = ntohl(p->xmtrRecycleCount_);
p->receiverBias_ = SwapFloat(p->receiverBias_); p->receiverBias_ = SwapFloat(p->receiverBias_);
p->transmitImbalance_ = SwapFloat(p->transmitImbalance_); p->transmitImbalance_ = SwapFloat(p->transmitImbalance_);
p->xmtrPowerMeterZero_ = SwapFloat(p->xmtrPowerMeterZero_); p->xmtrPowerMeterZero_ = SwapFloat(p->xmtrPowerMeterZero_);
// Tower/Utilities // Tower/Utilities
p->acUnit1CompressorShutOff_ = htons(p->acUnit1CompressorShutOff_); p->acUnit1CompressorShutOff_ = ntohs(p->acUnit1CompressorShutOff_);
p->acUnit2CompressorShutOff_ = htons(p->acUnit2CompressorShutOff_); p->acUnit2CompressorShutOff_ = ntohs(p->acUnit2CompressorShutOff_);
p->generatorMaintenanceRequired_ = htons(p->generatorMaintenanceRequired_); p->generatorMaintenanceRequired_ = ntohs(p->generatorMaintenanceRequired_);
p->generatorBatteryVoltage_ = htons(p->generatorBatteryVoltage_); p->generatorBatteryVoltage_ = ntohs(p->generatorBatteryVoltage_);
p->generatorEngine_ = htons(p->generatorEngine_); p->generatorEngine_ = ntohs(p->generatorEngine_);
p->generatorVoltFrequency_ = htons(p->generatorVoltFrequency_); p->generatorVoltFrequency_ = ntohs(p->generatorVoltFrequency_);
p->powerSource_ = htons(p->powerSource_); p->powerSource_ = ntohs(p->powerSource_);
p->transitionalPowerSource_ = htons(p->transitionalPowerSource_); p->transitionalPowerSource_ = ntohs(p->transitionalPowerSource_);
p->generatorAutoRunOffSwitch_ = htons(p->generatorAutoRunOffSwitch_); p->generatorAutoRunOffSwitch_ = ntohs(p->generatorAutoRunOffSwitch_);
p->aircraftHazardLighting_ = htons(p->aircraftHazardLighting_); p->aircraftHazardLighting_ = ntohs(p->aircraftHazardLighting_);
// Equipment Shelter // Equipment Shelter
p->equipmentShelterFireDetectionSystem_ = p->equipmentShelterFireDetectionSystem_ =
htons(p->equipmentShelterFireDetectionSystem_); ntohs(p->equipmentShelterFireDetectionSystem_);
p->equipmentShelterFireSmoke_ = htons(p->equipmentShelterFireSmoke_); p->equipmentShelterFireSmoke_ = ntohs(p->equipmentShelterFireSmoke_);
p->generatorShelterFireSmoke_ = htons(p->generatorShelterFireSmoke_); p->generatorShelterFireSmoke_ = ntohs(p->generatorShelterFireSmoke_);
p->utilityVoltageFrequency_ = htons(p->utilityVoltageFrequency_); p->utilityVoltageFrequency_ = ntohs(p->utilityVoltageFrequency_);
p->siteSecurityAlarm_ = htons(p->siteSecurityAlarm_); p->siteSecurityAlarm_ = ntohs(p->siteSecurityAlarm_);
p->securityEquipment_ = htons(p->securityEquipment_); p->securityEquipment_ = ntohs(p->securityEquipment_);
p->securitySystem_ = htons(p->securitySystem_); p->securitySystem_ = ntohs(p->securitySystem_);
p->receiverConnectedToAntenna_ = htons(p->receiverConnectedToAntenna_); p->receiverConnectedToAntenna_ = ntohs(p->receiverConnectedToAntenna_);
p->radomeHatch_ = htons(p->radomeHatch_); p->radomeHatch_ = ntohs(p->radomeHatch_);
p->acUnit1FilterDirty_ = htons(p->acUnit1FilterDirty_); p->acUnit1FilterDirty_ = ntohs(p->acUnit1FilterDirty_);
p->acUnit2FilterDirty_ = htons(p->acUnit2FilterDirty_); p->acUnit2FilterDirty_ = ntohs(p->acUnit2FilterDirty_);
p->equipmentShelterTemperature_ = SwapFloat(p->equipmentShelterTemperature_); p->equipmentShelterTemperature_ = SwapFloat(p->equipmentShelterTemperature_);
p->outsideAmbientTemperature_ = SwapFloat(p->outsideAmbientTemperature_); p->outsideAmbientTemperature_ = SwapFloat(p->outsideAmbientTemperature_);
p->transmitterLeavingAirTemp_ = SwapFloat(p->transmitterLeavingAirTemp_); p->transmitterLeavingAirTemp_ = SwapFloat(p->transmitterLeavingAirTemp_);
@ -2342,52 +2342,52 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
p->acUnit2DischargeAirTemp_ = SwapFloat(p->acUnit2DischargeAirTemp_); p->acUnit2DischargeAirTemp_ = SwapFloat(p->acUnit2DischargeAirTemp_);
p->spip15VPs_ = SwapFloat(p->spip15VPs_); p->spip15VPs_ = SwapFloat(p->spip15VPs_);
p->spipNeg15VPs_ = SwapFloat(p->spipNeg15VPs_); p->spipNeg15VPs_ = SwapFloat(p->spipNeg15VPs_);
p->spip28VPsStatus_ = htons(p->spip28VPsStatus_); p->spip28VPsStatus_ = ntohs(p->spip28VPsStatus_);
p->spip5VPs_ = SwapFloat(p->spip5VPs_); p->spip5VPs_ = SwapFloat(p->spip5VPs_);
p->convertedGeneratorFuelLevel_ = htons(p->convertedGeneratorFuelLevel_); p->convertedGeneratorFuelLevel_ = ntohs(p->convertedGeneratorFuelLevel_);
// Antenna/Pedestal // Antenna/Pedestal
p->elevationPosDeadLimit_ = htons(p->elevationPosDeadLimit_); p->elevationPosDeadLimit_ = ntohs(p->elevationPosDeadLimit_);
p->_150VOvervoltage_ = htons(p->_150VOvervoltage_); p->_150VOvervoltage_ = ntohs(p->_150VOvervoltage_);
p->_150VUndervoltage_ = htons(p->_150VUndervoltage_); p->_150VUndervoltage_ = ntohs(p->_150VUndervoltage_);
p->elevationServoAmpInhibit_ = htons(p->elevationServoAmpInhibit_); p->elevationServoAmpInhibit_ = ntohs(p->elevationServoAmpInhibit_);
p->elevationServoAmpShortCircuit_ = htons(p->elevationServoAmpShortCircuit_); p->elevationServoAmpShortCircuit_ = ntohs(p->elevationServoAmpShortCircuit_);
p->elevationServoAmpOvertemp_ = htons(p->elevationServoAmpOvertemp_); p->elevationServoAmpOvertemp_ = ntohs(p->elevationServoAmpOvertemp_);
p->elevationMotorOvertemp_ = htons(p->elevationMotorOvertemp_); p->elevationMotorOvertemp_ = ntohs(p->elevationMotorOvertemp_);
p->elevationStowPin_ = htons(p->elevationStowPin_); p->elevationStowPin_ = ntohs(p->elevationStowPin_);
p->elevationHousing5VPs_ = htons(p->elevationHousing5VPs_); p->elevationHousing5VPs_ = ntohs(p->elevationHousing5VPs_);
p->elevationNegDeadLimit_ = htons(p->elevationNegDeadLimit_); p->elevationNegDeadLimit_ = ntohs(p->elevationNegDeadLimit_);
p->elevationPosNormalLimit_ = htons(p->elevationPosNormalLimit_); p->elevationPosNormalLimit_ = ntohs(p->elevationPosNormalLimit_);
p->elevationNegNormalLimit_ = htons(p->elevationNegNormalLimit_); p->elevationNegNormalLimit_ = ntohs(p->elevationNegNormalLimit_);
p->elevationEncoderLight_ = htons(p->elevationEncoderLight_); p->elevationEncoderLight_ = ntohs(p->elevationEncoderLight_);
p->elevationGearboxOil_ = htons(p->elevationGearboxOil_); p->elevationGearboxOil_ = ntohs(p->elevationGearboxOil_);
p->elevationHandwheel_ = htons(p->elevationHandwheel_); p->elevationHandwheel_ = ntohs(p->elevationHandwheel_);
p->elevationAmpPs_ = htons(p->elevationAmpPs_); p->elevationAmpPs_ = ntohs(p->elevationAmpPs_);
p->azimuthServoAmpInhibit_ = htons(p->azimuthServoAmpInhibit_); p->azimuthServoAmpInhibit_ = ntohs(p->azimuthServoAmpInhibit_);
p->azimuthServoAmpShortCircuit_ = htons(p->azimuthServoAmpShortCircuit_); p->azimuthServoAmpShortCircuit_ = ntohs(p->azimuthServoAmpShortCircuit_);
p->azimuthServoAmpOvertemp_ = htons(p->azimuthServoAmpOvertemp_); p->azimuthServoAmpOvertemp_ = ntohs(p->azimuthServoAmpOvertemp_);
p->azimuthMotorOvertemp_ = htons(p->azimuthMotorOvertemp_); p->azimuthMotorOvertemp_ = ntohs(p->azimuthMotorOvertemp_);
p->azimuthStowPin_ = htons(p->azimuthStowPin_); p->azimuthStowPin_ = ntohs(p->azimuthStowPin_);
p->azimuthHousing5VPs_ = htons(p->azimuthHousing5VPs_); p->azimuthHousing5VPs_ = ntohs(p->azimuthHousing5VPs_);
p->azimuthEncoderLight_ = htons(p->azimuthEncoderLight_); p->azimuthEncoderLight_ = ntohs(p->azimuthEncoderLight_);
p->azimuthGearboxOil_ = htons(p->azimuthGearboxOil_); p->azimuthGearboxOil_ = ntohs(p->azimuthGearboxOil_);
p->azimuthBullGearOil_ = htons(p->azimuthBullGearOil_); p->azimuthBullGearOil_ = ntohs(p->azimuthBullGearOil_);
p->azimuthHandwheel_ = htons(p->azimuthHandwheel_); p->azimuthHandwheel_ = ntohs(p->azimuthHandwheel_);
p->azimuthServoAmpPs_ = htons(p->azimuthServoAmpPs_); p->azimuthServoAmpPs_ = ntohs(p->azimuthServoAmpPs_);
p->servo_ = htons(p->servo_); p->servo_ = ntohs(p->servo_);
p->pedestalInterlockSwitch_ = htons(p->pedestalInterlockSwitch_); p->pedestalInterlockSwitch_ = ntohs(p->pedestalInterlockSwitch_);
// RF Generator/Receiver // RF Generator/Receiver
p->cohoClock_ = htons(p->cohoClock_); p->cohoClock_ = ntohs(p->cohoClock_);
p->rfGeneratorFrequencySelectOscillator_ = p->rfGeneratorFrequencySelectOscillator_ =
htons(p->rfGeneratorFrequencySelectOscillator_); ntohs(p->rfGeneratorFrequencySelectOscillator_);
p->rfGeneratorRfStalo_ = htons(p->rfGeneratorRfStalo_); p->rfGeneratorRfStalo_ = ntohs(p->rfGeneratorRfStalo_);
p->rfGeneratorPhaseShiftedCoho_ = htons(p->rfGeneratorPhaseShiftedCoho_); p->rfGeneratorPhaseShiftedCoho_ = ntohs(p->rfGeneratorPhaseShiftedCoho_);
p->_9VReceiverPs_ = htons(p->_9VReceiverPs_); p->_9VReceiverPs_ = ntohs(p->_9VReceiverPs_);
p->_5VReceiverPs_ = htons(p->_5VReceiverPs_); p->_5VReceiverPs_ = ntohs(p->_5VReceiverPs_);
p->_18VReceiverPs_ = htons(p->_18VReceiverPs_); p->_18VReceiverPs_ = ntohs(p->_18VReceiverPs_);
p->neg9VReceiverPs_ = htons(p->neg9VReceiverPs_); p->neg9VReceiverPs_ = ntohs(p->neg9VReceiverPs_);
p->_5VSingleChannelRdaiuPs_ = htons(p->_5VSingleChannelRdaiuPs_); p->_5VSingleChannelRdaiuPs_ = ntohs(p->_5VSingleChannelRdaiuPs_);
p->horizontalShortPulseNoise_ = SwapFloat(p->horizontalShortPulseNoise_); p->horizontalShortPulseNoise_ = SwapFloat(p->horizontalShortPulseNoise_);
p->horizontalLongPulseNoise_ = SwapFloat(p->horizontalLongPulseNoise_); p->horizontalLongPulseNoise_ = SwapFloat(p->horizontalLongPulseNoise_);
p->horizontalNoiseTemperature_ = SwapFloat(p->horizontalNoiseTemperature_); p->horizontalNoiseTemperature_ = SwapFloat(p->horizontalNoiseTemperature_);
@ -2403,10 +2403,10 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
p->kdPeakMeasured_ = SwapFloat(p->kdPeakMeasured_); p->kdPeakMeasured_ = SwapFloat(p->kdPeakMeasured_);
p->shortPulseHorizontalDbz0_ = SwapFloat(p->shortPulseHorizontalDbz0_); p->shortPulseHorizontalDbz0_ = SwapFloat(p->shortPulseHorizontalDbz0_);
p->longPulseHorizontalDbz0_ = SwapFloat(p->longPulseHorizontalDbz0_); p->longPulseHorizontalDbz0_ = SwapFloat(p->longPulseHorizontalDbz0_);
p->velocityProcessed_ = htons(p->velocityProcessed_); p->velocityProcessed_ = ntohs(p->velocityProcessed_);
p->widthProcessed_ = htons(p->widthProcessed_); p->widthProcessed_ = ntohs(p->widthProcessed_);
p->velocityRfGen_ = htons(p->velocityRfGen_); p->velocityRfGen_ = ntohs(p->velocityRfGen_);
p->widthRfGen_ = htons(p->widthRfGen_); p->widthRfGen_ = ntohs(p->widthRfGen_);
p->horizontalI0_ = SwapFloat(p->horizontalI0_); p->horizontalI0_ = SwapFloat(p->horizontalI0_);
p->verticalI0_ = SwapFloat(p->verticalI0_); p->verticalI0_ = SwapFloat(p->verticalI0_);
p->verticalDynamicRange_ = SwapFloat(p->verticalDynamicRange_); p->verticalDynamicRange_ = SwapFloat(p->verticalDynamicRange_);
@ -2423,42 +2423,42 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
p->verticalLinearity_ = SwapFloat(p->verticalLinearity_); p->verticalLinearity_ = SwapFloat(p->verticalLinearity_);
// File Status // File Status
p->stateFileReadStatus_ = htons(p->stateFileReadStatus_); p->stateFileReadStatus_ = ntohs(p->stateFileReadStatus_);
p->stateFileWriteStatus_ = htons(p->stateFileWriteStatus_); p->stateFileWriteStatus_ = ntohs(p->stateFileWriteStatus_);
p->bypassMapFileReadStatus_ = htons(p->bypassMapFileReadStatus_); p->bypassMapFileReadStatus_ = ntohs(p->bypassMapFileReadStatus_);
p->bypassMapFileWriteStatus_ = htons(p->bypassMapFileWriteStatus_); p->bypassMapFileWriteStatus_ = ntohs(p->bypassMapFileWriteStatus_);
p->currentAdaptationFileReadStatus_ = p->currentAdaptationFileReadStatus_ =
htons(p->currentAdaptationFileReadStatus_); ntohs(p->currentAdaptationFileReadStatus_);
p->currentAdaptationFileWriteStatus_ = p->currentAdaptationFileWriteStatus_ =
htons(p->currentAdaptationFileWriteStatus_); ntohs(p->currentAdaptationFileWriteStatus_);
p->censorZoneFileReadStatus_ = htons(p->censorZoneFileReadStatus_); p->censorZoneFileReadStatus_ = ntohs(p->censorZoneFileReadStatus_);
p->censorZoneFileWriteStatus_ = htons(p->censorZoneFileWriteStatus_); p->censorZoneFileWriteStatus_ = ntohs(p->censorZoneFileWriteStatus_);
p->remoteVcpFileReadStatus_ = htons(p->remoteVcpFileReadStatus_); p->remoteVcpFileReadStatus_ = ntohs(p->remoteVcpFileReadStatus_);
p->remoteVcpFileWriteStatus_ = htons(p->remoteVcpFileWriteStatus_); p->remoteVcpFileWriteStatus_ = ntohs(p->remoteVcpFileWriteStatus_);
p->baselineAdaptationFileReadStatus_ = p->baselineAdaptationFileReadStatus_ =
htons(p->baselineAdaptationFileReadStatus_); ntohs(p->baselineAdaptationFileReadStatus_);
p->readStatusOfPrfSets_ = htons(p->readStatusOfPrfSets_); p->readStatusOfPrfSets_ = ntohs(p->readStatusOfPrfSets_);
p->clutterFilterMapFileReadStatus_ = p->clutterFilterMapFileReadStatus_ =
htons(p->clutterFilterMapFileReadStatus_); ntohs(p->clutterFilterMapFileReadStatus_);
p->clutterFilterMapFileWriteStatus_ = p->clutterFilterMapFileWriteStatus_ =
htons(p->clutterFilterMapFileWriteStatus_); ntohs(p->clutterFilterMapFileWriteStatus_);
p->generatlDiskIoError_ = htons(p->generatlDiskIoError_); p->generatlDiskIoError_ = ntohs(p->generatlDiskIoError_);
p->cpu1FanSpeed_ = htons(p->cpu1FanSpeed_); p->cpu1FanSpeed_ = ntohs(p->cpu1FanSpeed_);
p->cpu2FanSpeed_ = htons(p->cpu2FanSpeed_); p->cpu2FanSpeed_ = ntohs(p->cpu2FanSpeed_);
p->rspFan1Speed_ = htons(p->rspFan1Speed_); p->rspFan1Speed_ = ntohs(p->rspFan1Speed_);
p->rspFan2Speed_ = htons(p->rspFan2Speed_); p->rspFan2Speed_ = ntohs(p->rspFan2Speed_);
p->rspFan3Speed_ = htons(p->rspFan3Speed_); p->rspFan3Speed_ = ntohs(p->rspFan3Speed_);
// Device Status // Device Status
p->spipCommStatus_ = htons(p->spipCommStatus_); p->spipCommStatus_ = ntohs(p->spipCommStatus_);
p->hciCommStatus_ = htons(p->hciCommStatus_); p->hciCommStatus_ = ntohs(p->hciCommStatus_);
p->signalProcessorCommandStatus_ = htons(p->signalProcessorCommandStatus_); p->signalProcessorCommandStatus_ = ntohs(p->signalProcessorCommandStatus_);
p->ameCommunicationStatus_ = htons(p->ameCommunicationStatus_); p->ameCommunicationStatus_ = ntohs(p->ameCommunicationStatus_);
p->rmsLinkStatus_ = htons(p->rmsLinkStatus_); p->rmsLinkStatus_ = ntohs(p->rmsLinkStatus_);
p->rpgLinkStatus_ = htons(p->rpgLinkStatus_); p->rpgLinkStatus_ = ntohs(p->rpgLinkStatus_);
p->interpanelLinkStatus_ = htons(p->interpanelLinkStatus_); p->interpanelLinkStatus_ = ntohs(p->interpanelLinkStatus_);
p->performanceCheckTime_ = htonl(p->performanceCheckTime_); p->performanceCheckTime_ = ntohl(p->performanceCheckTime_);
p->version_ = htons(p->version_); p->version_ = ntohs(p->version_);
if (!ValidateMessage(is, bytesRead)) if (!ValidateMessage(is, bytesRead))
{ {

56
wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp
View file

@ -279,40 +279,40 @@ bool RdaStatusData::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->statusVersion_), 2); // 42 is.read(reinterpret_cast<char*>(&p->statusVersion_), 2); // 42
bytesRead += 120; bytesRead += 120;
p->rdaStatus_ = htons(p->rdaStatus_); p->rdaStatus_ = ntohs(p->rdaStatus_);
p->operabilityStatus_ = htons(p->operabilityStatus_); p->operabilityStatus_ = ntohs(p->operabilityStatus_);
p->controlStatus_ = htons(p->controlStatus_); p->controlStatus_ = ntohs(p->controlStatus_);
p->auxiliaryPowerGeneratorState_ = htons(p->auxiliaryPowerGeneratorState_); p->auxiliaryPowerGeneratorState_ = ntohs(p->auxiliaryPowerGeneratorState_);
p->averageTransmitterPower_ = htons(p->averageTransmitterPower_); p->averageTransmitterPower_ = ntohs(p->averageTransmitterPower_);
p->horizontalReflectivityCalibrationCorrection_ = p->horizontalReflectivityCalibrationCorrection_ =
htons(p->horizontalReflectivityCalibrationCorrection_); ntohs(p->horizontalReflectivityCalibrationCorrection_);
p->dataTransmissionEnabled_ = htons(p->dataTransmissionEnabled_); p->dataTransmissionEnabled_ = ntohs(p->dataTransmissionEnabled_);
p->volumeCoveragePatternNumber_ = htons(p->volumeCoveragePatternNumber_); p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_);
p->rdaControlAuthorization_ = htons(p->rdaControlAuthorization_); p->rdaControlAuthorization_ = ntohs(p->rdaControlAuthorization_);
p->rdaBuildNumber_ = htons(p->rdaBuildNumber_); p->rdaBuildNumber_ = ntohs(p->rdaBuildNumber_);
p->operationalMode_ = htons(p->operationalMode_); p->operationalMode_ = ntohs(p->operationalMode_);
p->superResolutionStatus_ = htons(p->superResolutionStatus_); p->superResolutionStatus_ = ntohs(p->superResolutionStatus_);
p->clutterMitigationDecisionStatus_ = p->clutterMitigationDecisionStatus_ =
htons(p->clutterMitigationDecisionStatus_); ntohs(p->clutterMitigationDecisionStatus_);
p->avsetEbcRdaLogDataStatus_ = htons(p->avsetEbcRdaLogDataStatus_); p->avsetEbcRdaLogDataStatus_ = ntohs(p->avsetEbcRdaLogDataStatus_);
p->rdaAlarmSummary_ = htons(p->rdaAlarmSummary_); p->rdaAlarmSummary_ = ntohs(p->rdaAlarmSummary_);
p->commandAcknowledgement_ = htons(p->commandAcknowledgement_); p->commandAcknowledgement_ = ntohs(p->commandAcknowledgement_);
p->channelControlStatus_ = htons(p->channelControlStatus_); p->channelControlStatus_ = ntohs(p->channelControlStatus_);
p->spotBlankingStatus_ = htons(p->spotBlankingStatus_); p->spotBlankingStatus_ = ntohs(p->spotBlankingStatus_);
p->bypassMapGenerationDate_ = htons(p->bypassMapGenerationDate_); p->bypassMapGenerationDate_ = ntohs(p->bypassMapGenerationDate_);
p->bypassMapGenerationTime_ = htons(p->bypassMapGenerationTime_); p->bypassMapGenerationTime_ = ntohs(p->bypassMapGenerationTime_);
p->clutterFilterMapGenerationDate_ = p->clutterFilterMapGenerationDate_ =
htons(p->clutterFilterMapGenerationDate_); ntohs(p->clutterFilterMapGenerationDate_);
p->clutterFilterMapGenerationTime_ = p->clutterFilterMapGenerationTime_ =
htons(p->clutterFilterMapGenerationTime_); ntohs(p->clutterFilterMapGenerationTime_);
p->verticalReflectivityCalibrationCorrection_ = p->verticalReflectivityCalibrationCorrection_ =
htons(p->verticalReflectivityCalibrationCorrection_); ntohs(p->verticalReflectivityCalibrationCorrection_);
p->transitionPowerSourceStatus_ = htons(p->transitionPowerSourceStatus_); p->transitionPowerSourceStatus_ = ntohs(p->transitionPowerSourceStatus_);
p->rmsControlStatus_ = htons(p->rmsControlStatus_); p->rmsControlStatus_ = ntohs(p->rmsControlStatus_);
p->performanceCheckStatus_ = htons(p->performanceCheckStatus_); p->performanceCheckStatus_ = ntohs(p->performanceCheckStatus_);
SwapArray(p->alarmCodes_); SwapArray(p->alarmCodes_);
p->signalProcessingOptions_ = htons(p->signalProcessingOptions_); p->signalProcessingOptions_ = ntohs(p->signalProcessingOptions_);
p->statusVersion_ = htons(p->statusVersion_); p->statusVersion_ = ntohs(p->statusVersion_);
if (!ValidateMessage(is, bytesRead)) if (!ValidateMessage(is, bytesRead))
{ {

40
wxdata/source/scwx/wsr88d/rda/volume_coverage_pattern_data.cpp
View file

@ -385,12 +385,12 @@ bool VolumeCoveragePatternData::Parse(std::istream& is)
is.seekg(2, std::ios_base::cur); // 11 is.seekg(2, std::ios_base::cur); // 11
bytesRead += 22; bytesRead += 22;
messageSize = htons(messageSize); messageSize = ntohs(messageSize);
p->patternType_ = htons(p->patternType_); p->patternType_ = ntohs(p->patternType_);
p->patternNumber_ = htons(p->patternNumber_); p->patternNumber_ = ntohs(p->patternNumber_);
numberOfElevationCuts = htons(numberOfElevationCuts); numberOfElevationCuts = ntohs(numberOfElevationCuts);
p->vcpSequencing_ = htons(p->vcpSequencing_); p->vcpSequencing_ = ntohs(p->vcpSequencing_);
p->vcpSupplementalData_ = htons(p->vcpSupplementalData_); p->vcpSupplementalData_ = ntohs(p->vcpSupplementalData_);
if (messageSize < 34 || messageSize > 747) if (messageSize < 34 || messageSize > 747)
{ {
@ -442,20 +442,20 @@ bool VolumeCoveragePatternData::Parse(std::istream& is)
is.seekg(2, std::ios_base::cur); // E23 is.seekg(2, std::ios_base::cur); // E23
bytesRead += 46; bytesRead += 46;
c.elevationAngle_ = htons(c.elevationAngle_); c.elevationAngle_ = ntohs(c.elevationAngle_);
c.surveillancePrfPulseCountRadial_ = c.surveillancePrfPulseCountRadial_ =
htons(c.surveillancePrfPulseCountRadial_); ntohs(c.surveillancePrfPulseCountRadial_);
c.azimuthRate_ = htons(c.azimuthRate_); c.azimuthRate_ = ntohs(c.azimuthRate_);
c.reflectivityThreshold_ = htons(c.reflectivityThreshold_); c.reflectivityThreshold_ = ntohs(c.reflectivityThreshold_);
c.velocityThreshold_ = htons(c.velocityThreshold_); c.velocityThreshold_ = ntohs(c.velocityThreshold_);
c.spectrumWidthThreshold_ = htons(c.spectrumWidthThreshold_); c.spectrumWidthThreshold_ = ntohs(c.spectrumWidthThreshold_);
c.differentialReflectivityThreshold_ = c.differentialReflectivityThreshold_ =
htons(c.differentialReflectivityThreshold_); ntohs(c.differentialReflectivityThreshold_);
c.differentialPhaseThreshold_ = htons(c.differentialPhaseThreshold_); c.differentialPhaseThreshold_ = ntohs(c.differentialPhaseThreshold_);
c.correlationCoefficientThreshold_ = c.correlationCoefficientThreshold_ =
htons(c.correlationCoefficientThreshold_); ntohs(c.correlationCoefficientThreshold_);
c.supplementalData_ = htons(c.supplementalData_); c.supplementalData_ = ntohs(c.supplementalData_);
c.ebcAngle_ = htons(c.ebcAngle_); c.ebcAngle_ = ntohs(c.ebcAngle_);
for (size_t s = 0; s < c.sector_.size(); s++) for (size_t s = 0; s < c.sector_.size(); s++)
{ {
@ -503,9 +503,9 @@ static void ReadSector(std::istream& is, Sector& s)
static void SwapSector(Sector& s) static void SwapSector(Sector& s)
{ {
s.edgeAngle_ = htons(s.edgeAngle_); s.edgeAngle_ = ntohs(s.edgeAngle_);
s.dopplerPrfNumber_ = htons(s.dopplerPrfNumber_); s.dopplerPrfNumber_ = ntohs(s.dopplerPrfNumber_);
s.dopplerPrfPulseCountRadial_ = htons(s.dopplerPrfPulseCountRadial_); s.dopplerPrfPulseCountRadial_ = ntohs(s.dopplerPrfPulseCountRadial_);
} }
} // namespace rda } // namespace rda