mirror of
https://github.com/ciphervance/supercell-wx.git
synced 2025-10-30 19:50:05 +00:00
Parse Digital Radar Data (Message Type 31)
This commit is contained in:
Dan Paulat
parent
6acb6a8c9d
commit
f0386cda27
8 changed files with 589 additions and 28 deletions
510
wxdata/source/scwx/wsr88d/rda/digital_radar_data.cpp
Normal file
510
wxdata/source/scwx/wsr88d/rda/digital_radar_data.cpp
Normal file
|
|
@ -0,0 +1,510 @@
|
|||
#include <scwx/wsr88d/rda/digital_radar_data.hpp>
|
||||
|
||||
#include <boost/log/trivial.hpp>
|
||||
|
||||
namespace scwx
|
||||
{
|
||||
namespace wsr88d
|
||||
{
|
||||
namespace rda
|
||||
{
|
||||
|
||||
static const std::string logPrefix_ =
|
||||
"[scwx::wsr88d::rda::digital_radar_data] ";
|
||||
|
||||
enum class DataBlockType
|
||||
{
|
||||
Volume,
|
||||
Elevation,
|
||||
Radial,
|
||||
MomentRef,
|
||||
MomentVel,
|
||||
MomentSw,
|
||||
MomentZdr,
|
||||
MomentPhi,
|
||||
MomentRho,
|
||||
MomentCfp,
|
||||
Unknown
|
||||
};
|
||||
|
||||
static const std::unordered_map<std::string, DataBlockType> strToDataBlock_ {
|
||||
{"VOL", DataBlockType::Volume},
|
||||
{"ELV", DataBlockType::Elevation},
|
||||
{"RAD", DataBlockType::Radial},
|
||||
{"REF", DataBlockType::MomentRef},
|
||||
{"VEL", DataBlockType::MomentVel},
|
||||
{"SW ", DataBlockType::MomentSw},
|
||||
{"ZDR", DataBlockType::MomentZdr},
|
||||
{"PHI", DataBlockType::MomentPhi},
|
||||
{"RHO", DataBlockType::MomentRho},
|
||||
{"CFP", DataBlockType::MomentCfp}};
|
||||
|
||||
struct DataBlock
|
||||
{
|
||||
explicit DataBlock(const std::string& dataBlockType,
|
||||
const std::string& dataName) :
|
||||
dataBlockType_ {dataBlockType}, dataName_ {dataName}
|
||||
{
|
||||
}
|
||||
|
||||
std::string dataBlockType_;
|
||||
std::string dataName_;
|
||||
};
|
||||
|
||||
struct MomentDataBlock : DataBlock
|
||||
{
|
||||
explicit MomentDataBlock(const std::string& dataBlockType,
|
||||
const std::string& dataName) :
|
||||
DataBlock(dataBlockType, dataName),
|
||||
numberOfDataMomentGates_ {0},
|
||||
dataMomentRange_ {0},
|
||||
dataMomentRangeSampleInterval_ {0},
|
||||
tover_ {0},
|
||||
snrThreshold_ {0},
|
||||
controlFlags_ {0},
|
||||
dataWordSize_ {0},
|
||||
scale_ {0.0f},
|
||||
offset_ {0.0f}
|
||||
{
|
||||
}
|
||||
|
||||
uint16_t numberOfDataMomentGates_;
|
||||
uint16_t dataMomentRange_;
|
||||
uint16_t dataMomentRangeSampleInterval_;
|
||||
uint16_t tover_;
|
||||
int16_t snrThreshold_;
|
||||
uint8_t controlFlags_;
|
||||
uint8_t dataWordSize_;
|
||||
float scale_;
|
||||
float offset_;
|
||||
|
||||
static std::unique_ptr<MomentDataBlock>
|
||||
Create(const std::string& dataBlockType,
|
||||
const std::string& dataName,
|
||||
std::istream& is)
|
||||
{
|
||||
std::unique_ptr<MomentDataBlock> p =
|
||||
std::make_unique<MomentDataBlock>(dataBlockType, dataName);
|
||||
|
||||
is.seekg(4, std::ios_base::cur); // 4-7
|
||||
is.read(reinterpret_cast<char*>(&p->numberOfDataMomentGates_), 2); // 8-9
|
||||
is.read(reinterpret_cast<char*>(&p->dataMomentRange_), 2); // 10-11
|
||||
is.read(reinterpret_cast<char*>(&p->dataMomentRangeSampleInterval_),
|
||||
2); // 12-13
|
||||
is.read(reinterpret_cast<char*>(&p->tover_), 2); // 14-15
|
||||
is.read(reinterpret_cast<char*>(&p->snrThreshold_), 2); // 16-17
|
||||
is.read(reinterpret_cast<char*>(&p->controlFlags_), 1); // 18
|
||||
is.read(reinterpret_cast<char*>(&p->dataWordSize_), 1); // 19
|
||||
is.read(reinterpret_cast<char*>(&p->scale_), 4); // 20-23
|
||||
is.read(reinterpret_cast<char*>(&p->offset_), 4); // 24-27
|
||||
|
||||
p->numberOfDataMomentGates_ = ntohs(p->numberOfDataMomentGates_);
|
||||
p->dataMomentRange_ = ntohs(p->dataMomentRange_);
|
||||
p->dataMomentRangeSampleInterval_ =
|
||||
ntohs(p->dataMomentRangeSampleInterval_);
|
||||
p->tover_ = ntohs(p->tover_);
|
||||
p->snrThreshold_ = ntohs(p->snrThreshold_);
|
||||
p->scale_ = Message::SwapFloat(p->scale_);
|
||||
p->offset_ = Message::SwapFloat(p->offset_);
|
||||
|
||||
// TODO: Moment gates
|
||||
|
||||
return p;
|
||||
}
|
||||
};
|
||||
|
||||
struct VolumeDataBlock : DataBlock
|
||||
{
|
||||
explicit VolumeDataBlock(const std::string& dataBlockType,
|
||||
const std::string& dataName) :
|
||||
DataBlock(dataBlockType, dataName),
|
||||
lrtup_ {0},
|
||||
versionNumberMajor_ {0},
|
||||
versionNumberMinor_ {0},
|
||||
latitude_ {0.0f},
|
||||
longitude_ {0.0f},
|
||||
siteHeight_ {0},
|
||||
feedhornHeight_ {0},
|
||||
calibrationConstant_ {0.0f},
|
||||
horizontaShvTxPower_ {0.0f},
|
||||
verticalShvTxPower_ {0.0f},
|
||||
systemDifferentialReflectivity_ {0.0f},
|
||||
initialSystemDifferentialPhase_ {0.0f},
|
||||
volumeCoveragePatternNumber_ {0},
|
||||
processingStatus_ {0}
|
||||
{
|
||||
}
|
||||
|
||||
uint16_t lrtup_;
|
||||
uint8_t versionNumberMajor_;
|
||||
uint8_t versionNumberMinor_;
|
||||
float latitude_;
|
||||
float longitude_;
|
||||
int16_t siteHeight_;
|
||||
uint16_t feedhornHeight_;
|
||||
float calibrationConstant_;
|
||||
float horizontaShvTxPower_;
|
||||
float verticalShvTxPower_;
|
||||
float systemDifferentialReflectivity_;
|
||||
float initialSystemDifferentialPhase_;
|
||||
uint16_t volumeCoveragePatternNumber_;
|
||||
uint16_t processingStatus_;
|
||||
|
||||
static std::unique_ptr<VolumeDataBlock>
|
||||
Create(const std::string& dataBlockType,
|
||||
const std::string& dataName,
|
||||
std::istream& is)
|
||||
{
|
||||
std::unique_ptr<VolumeDataBlock> p =
|
||||
std::make_unique<VolumeDataBlock>(dataBlockType, dataName);
|
||||
|
||||
is.read(reinterpret_cast<char*>(&p->lrtup_), 2); // 4-5
|
||||
is.read(reinterpret_cast<char*>(&p->versionNumberMajor_), 1); // 6
|
||||
is.read(reinterpret_cast<char*>(&p->versionNumberMinor_), 1); // 7
|
||||
is.read(reinterpret_cast<char*>(&p->latitude_), 4); // 8-11
|
||||
is.read(reinterpret_cast<char*>(&p->longitude_), 4); // 12-15
|
||||
is.read(reinterpret_cast<char*>(&p->siteHeight_), 2); // 16-17
|
||||
is.read(reinterpret_cast<char*>(&p->feedhornHeight_), 2); // 18-19
|
||||
is.read(reinterpret_cast<char*>(&p->calibrationConstant_), 4); // 20-23
|
||||
is.read(reinterpret_cast<char*>(&p->horizontaShvTxPower_), 4); // 24-27
|
||||
is.read(reinterpret_cast<char*>(&p->verticalShvTxPower_), 4); // 28-31
|
||||
is.read(reinterpret_cast<char*>(&p->systemDifferentialReflectivity_),
|
||||
4); // 32-35
|
||||
is.read(reinterpret_cast<char*>(&p->initialSystemDifferentialPhase_),
|
||||
4); // 36-39
|
||||
is.read(reinterpret_cast<char*>(&p->volumeCoveragePatternNumber_),
|
||||
2); // 40-41
|
||||
is.read(reinterpret_cast<char*>(&p->processingStatus_), 2); // 42-43
|
||||
|
||||
p->lrtup_ = ntohs(p->lrtup_);
|
||||
p->latitude_ = Message::SwapFloat(p->latitude_);
|
||||
p->longitude_ = Message::SwapFloat(p->longitude_);
|
||||
p->siteHeight_ = ntohs(p->siteHeight_);
|
||||
p->feedhornHeight_ = ntohs(p->feedhornHeight_);
|
||||
p->calibrationConstant_ = Message::SwapFloat(p->calibrationConstant_);
|
||||
p->horizontaShvTxPower_ = Message::SwapFloat(p->horizontaShvTxPower_);
|
||||
p->verticalShvTxPower_ = Message::SwapFloat(p->verticalShvTxPower_);
|
||||
p->systemDifferentialReflectivity_ =
|
||||
Message::SwapFloat(p->systemDifferentialReflectivity_);
|
||||
p->initialSystemDifferentialPhase_ =
|
||||
Message::SwapFloat(p->initialSystemDifferentialPhase_);
|
||||
p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_);
|
||||
p->processingStatus_ = ntohs(p->processingStatus_);
|
||||
|
||||
return p;
|
||||
}
|
||||
};
|
||||
|
||||
struct ElevationDataBlock : DataBlock
|
||||
{
|
||||
explicit ElevationDataBlock(const std::string& dataBlockType,
|
||||
const std::string& dataName) :
|
||||
DataBlock(dataBlockType, dataName),
|
||||
lrtup_ {0},
|
||||
atmos_ {0},
|
||||
calibrationConstant_ {0.0f}
|
||||
{
|
||||
}
|
||||
|
||||
uint16_t lrtup_;
|
||||
int16_t atmos_;
|
||||
float calibrationConstant_;
|
||||
|
||||
static std::unique_ptr<ElevationDataBlock>
|
||||
Create(const std::string& dataBlockType,
|
||||
const std::string& dataName,
|
||||
std::istream& is)
|
||||
{
|
||||
std::unique_ptr<ElevationDataBlock> p =
|
||||
std::make_unique<ElevationDataBlock>(dataBlockType, dataName);
|
||||
|
||||
is.read(reinterpret_cast<char*>(&p->lrtup_), 2); // 4-5
|
||||
is.read(reinterpret_cast<char*>(&p->atmos_), 2); // 6-7
|
||||
is.read(reinterpret_cast<char*>(&p->calibrationConstant_), 4); // 8-11
|
||||
|
||||
p->lrtup_ = ntohs(p->lrtup_);
|
||||
p->atmos_ = ntohs(p->atmos_);
|
||||
p->calibrationConstant_ = Message::SwapFloat(p->calibrationConstant_);
|
||||
|
||||
return p;
|
||||
}
|
||||
};
|
||||
|
||||
struct RadialDataBlock : DataBlock
|
||||
{
|
||||
explicit RadialDataBlock(const std::string& dataBlockType,
|
||||
const std::string& dataName) :
|
||||
DataBlock(dataBlockType, dataName),
|
||||
lrtup_ {0},
|
||||
unambigiousRange_ {0},
|
||||
noiseLevelHorizontal_ {0.0f},
|
||||
noiseLevelVertical_ {0.0f},
|
||||
nyquistVelocity_ {0},
|
||||
radialFlags_ {0},
|
||||
calibrationConstantHorizontal_ {0.0f},
|
||||
calibrationConstantVertical_ {0.0f}
|
||||
{
|
||||
}
|
||||
|
||||
uint16_t lrtup_;
|
||||
uint16_t unambigiousRange_;
|
||||
float noiseLevelHorizontal_;
|
||||
float noiseLevelVertical_;
|
||||
uint16_t nyquistVelocity_;
|
||||
uint16_t radialFlags_;
|
||||
float calibrationConstantHorizontal_;
|
||||
float calibrationConstantVertical_;
|
||||
|
||||
static std::unique_ptr<RadialDataBlock>
|
||||
Create(const std::string& dataBlockType,
|
||||
const std::string& dataName,
|
||||
std::istream& is)
|
||||
{
|
||||
std::unique_ptr<RadialDataBlock> p =
|
||||
std::make_unique<RadialDataBlock>(dataBlockType, dataName);
|
||||
|
||||
is.read(reinterpret_cast<char*>(&p->lrtup_), 2); // 4-5
|
||||
is.read(reinterpret_cast<char*>(&p->unambigiousRange_), 2); // 6-7
|
||||
is.read(reinterpret_cast<char*>(&p->noiseLevelHorizontal_), 4); // 8-11
|
||||
is.read(reinterpret_cast<char*>(&p->noiseLevelVertical_), 4); // 12-15
|
||||
is.read(reinterpret_cast<char*>(&p->nyquistVelocity_), 2); // 16-17
|
||||
is.read(reinterpret_cast<char*>(&p->radialFlags_), 2); // 18-19
|
||||
is.read(reinterpret_cast<char*>(&p->calibrationConstantHorizontal_),
|
||||
4); // 20-23
|
||||
is.read(reinterpret_cast<char*>(&p->calibrationConstantVertical_),
|
||||
4); // 24-27
|
||||
|
||||
p->lrtup_ = ntohs(p->lrtup_);
|
||||
p->unambigiousRange_ = ntohs(p->unambigiousRange_);
|
||||
p->noiseLevelHorizontal_ = Message::SwapFloat(p->noiseLevelHorizontal_);
|
||||
p->noiseLevelVertical_ = Message::SwapFloat(p->noiseLevelVertical_);
|
||||
p->nyquistVelocity_ = ntohs(p->nyquistVelocity_);
|
||||
p->radialFlags_ = ntohs(p->radialFlags_);
|
||||
p->calibrationConstantHorizontal_ =
|
||||
Message::SwapFloat(p->calibrationConstantHorizontal_);
|
||||
p->calibrationConstantVertical_ =
|
||||
Message::SwapFloat(p->calibrationConstantVertical_);
|
||||
|
||||
return p;
|
||||
}
|
||||
};
|
||||
|
||||
class DigitalRadarDataImpl
|
||||
{
|
||||
public:
|
||||
explicit DigitalRadarDataImpl() :
|
||||
radarIdentifier_ {},
|
||||
collectionTime_ {0},
|
||||
modifiedJulianDate_ {0},
|
||||
azimuthNumber_ {0},
|
||||
azimuthAngle_ {0.0f},
|
||||
compressionIndicator_ {0},
|
||||
radialLength_ {0},
|
||||
azimuthResolutionSpacing_ {0},
|
||||
radialStatus_ {0},
|
||||
elevationNumber_ {0},
|
||||
cutSectorNumber_ {0},
|
||||
elevationAngle_ {0.0f},
|
||||
radialSpotBlankingStatus_ {0},
|
||||
azimuthIndexingMode_ {0},
|
||||
dataBlockCount_ {0},
|
||||
dataBlockPointer_ {0},
|
||||
volumeDataBlock_ {nullptr},
|
||||
elevationDataBlock_ {nullptr},
|
||||
radialDataBlock_ {nullptr},
|
||||
momentRefDataBlock_ {nullptr},
|
||||
momentVelDataBlock_ {nullptr},
|
||||
momentSwDataBlock_ {nullptr},
|
||||
momentZdrDataBlock_ {nullptr},
|
||||
momentPhiDataBlock_ {nullptr},
|
||||
momentRhoDataBlock_ {nullptr},
|
||||
momentCfpDataBlock_ {nullptr} {};
|
||||
~DigitalRadarDataImpl() = default;
|
||||
|
||||
std::string radarIdentifier_;
|
||||
uint32_t collectionTime_;
|
||||
uint16_t modifiedJulianDate_;
|
||||
uint16_t azimuthNumber_;
|
||||
float azimuthAngle_;
|
||||
uint8_t compressionIndicator_;
|
||||
uint16_t radialLength_;
|
||||
uint8_t azimuthResolutionSpacing_;
|
||||
uint8_t radialStatus_;
|
||||
uint8_t elevationNumber_;
|
||||
uint8_t cutSectorNumber_;
|
||||
float elevationAngle_;
|
||||
uint8_t radialSpotBlankingStatus_;
|
||||
uint8_t azimuthIndexingMode_;
|
||||
uint16_t dataBlockCount_;
|
||||
std::array<uint32_t, 10> dataBlockPointer_;
|
||||
|
||||
std::unique_ptr<VolumeDataBlock> volumeDataBlock_;
|
||||
std::unique_ptr<ElevationDataBlock> elevationDataBlock_;
|
||||
std::unique_ptr<RadialDataBlock> radialDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentRefDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentVelDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentSwDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentZdrDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentPhiDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentRhoDataBlock_;
|
||||
std::unique_ptr<MomentDataBlock> momentCfpDataBlock_;
|
||||
};
|
||||
|
||||
DigitalRadarData::DigitalRadarData() :
|
||||
Message(), p(std::make_unique<DigitalRadarDataImpl>())
|
||||
{
|
||||
}
|
||||
DigitalRadarData::~DigitalRadarData() = default;
|
||||
|
||||
DigitalRadarData::DigitalRadarData(DigitalRadarData&&) noexcept = default;
|
||||
DigitalRadarData&
|
||||
DigitalRadarData::operator=(DigitalRadarData&&) noexcept = default;
|
||||
|
||||
bool DigitalRadarData::Parse(std::istream& is)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(debug)
|
||||
<< logPrefix_ << "Parsing Digital Radar Data (Message Type 31)";
|
||||
|
||||
bool messageValid = true;
|
||||
size_t bytesRead = 0;
|
||||
|
||||
std::streampos isBegin = is.tellg();
|
||||
|
||||
p->radarIdentifier_.resize(4);
|
||||
|
||||
is.read(&p->radarIdentifier_[0], 4); // 0-3
|
||||
is.read(reinterpret_cast<char*>(&p->collectionTime_), 4); // 4-7
|
||||
is.read(reinterpret_cast<char*>(&p->modifiedJulianDate_), 2); // 8-9
|
||||
is.read(reinterpret_cast<char*>(&p->azimuthNumber_), 2); // 10-11
|
||||
is.read(reinterpret_cast<char*>(&p->azimuthAngle_), 4); // 12-15
|
||||
is.read(reinterpret_cast<char*>(&p->compressionIndicator_), 1); // 16
|
||||
is.seekg(1, std::ios_base::cur); // 17
|
||||
is.read(reinterpret_cast<char*>(&p->radialLength_), 2); // 18-19
|
||||
is.read(reinterpret_cast<char*>(&p->azimuthResolutionSpacing_), 1); // 20
|
||||
is.read(reinterpret_cast<char*>(&p->radialStatus_), 1); // 21
|
||||
is.read(reinterpret_cast<char*>(&p->elevationNumber_), 1); // 22
|
||||
is.read(reinterpret_cast<char*>(&p->cutSectorNumber_), 1); // 23
|
||||
is.read(reinterpret_cast<char*>(&p->elevationAngle_), 4); // 24-27
|
||||
is.read(reinterpret_cast<char*>(&p->radialSpotBlankingStatus_), 1); // 28
|
||||
is.read(reinterpret_cast<char*>(&p->azimuthIndexingMode_), 1); // 29
|
||||
is.read(reinterpret_cast<char*>(&p->dataBlockCount_), 2); // 30-31
|
||||
|
||||
p->collectionTime_ = ntohl(p->collectionTime_);
|
||||
p->modifiedJulianDate_ = ntohs(p->modifiedJulianDate_);
|
||||
p->azimuthNumber_ = ntohs(p->azimuthNumber_);
|
||||
p->azimuthAngle_ = SwapFloat(p->azimuthAngle_);
|
||||
p->radialLength_ = ntohs(p->radialLength_);
|
||||
p->elevationAngle_ = SwapFloat(p->elevationAngle_);
|
||||
p->dataBlockCount_ = ntohs(p->dataBlockCount_);
|
||||
|
||||
if (p->dataBlockCount_ < 4 || p->dataBlockCount_ > 10)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(warning)
|
||||
<< logPrefix_
|
||||
<< "Invalid number of data blocks: " << p->dataBlockCount_;
|
||||
p->dataBlockCount_ = 0;
|
||||
messageValid = false;
|
||||
}
|
||||
if (p->compressionIndicator_ != 0)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(warning) << logPrefix_ << "Compression not supported";
|
||||
p->dataBlockCount_ = 0;
|
||||
messageValid = false;
|
||||
}
|
||||
|
||||
is.read(reinterpret_cast<char*>(&p->dataBlockPointer_),
|
||||
p->dataBlockCount_ * 4);
|
||||
|
||||
SwapArray(p->dataBlockPointer_, p->dataBlockCount_);
|
||||
|
||||
for (uint16_t b = 0; b < p->dataBlockCount_; ++b)
|
||||
{
|
||||
is.seekg(isBegin + std::streamoff(p->dataBlockPointer_[b]),
|
||||
std::ios_base::beg);
|
||||
|
||||
std::string dataBlockType(1, 0);
|
||||
std::string dataName(3, 0);
|
||||
|
||||
is.read(&dataBlockType[0], 1);
|
||||
is.read(&dataName[0], 3);
|
||||
|
||||
DataBlockType dataBlock = DataBlockType::Unknown;
|
||||
try
|
||||
{
|
||||
dataBlock = strToDataBlock_.at(dataName);
|
||||
}
|
||||
catch (const std::exception&)
|
||||
{
|
||||
}
|
||||
|
||||
switch (dataBlock)
|
||||
{
|
||||
case DataBlockType::Volume:
|
||||
p->volumeDataBlock_ =
|
||||
std::move(VolumeDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::Elevation:
|
||||
p->elevationDataBlock_ =
|
||||
std::move(ElevationDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::Radial:
|
||||
p->radialDataBlock_ =
|
||||
std::move(RadialDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentRef:
|
||||
p->momentRefDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentVel:
|
||||
p->momentVelDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentSw:
|
||||
p->momentSwDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentZdr:
|
||||
p->momentZdrDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentPhi:
|
||||
p->momentPhiDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentRho:
|
||||
p->momentRhoDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
case DataBlockType::MomentCfp:
|
||||
p->momentCfpDataBlock_ =
|
||||
std::move(MomentDataBlock::Create(dataBlockType, dataName, is));
|
||||
break;
|
||||
default:
|
||||
BOOST_LOG_TRIVIAL(warning)
|
||||
<< logPrefix_ << "Unknown data name: " << dataName;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
is.seekg(isBegin, std::ios_base::beg);
|
||||
if (!ValidateMessage(is, bytesRead))
|
||||
{
|
||||
messageValid = false;
|
||||
}
|
||||
|
||||
return messageValid;
|
||||
}
|
||||
|
||||
std::unique_ptr<DigitalRadarData>
|
||||
DigitalRadarData::Create(MessageHeader&& header, std::istream& is)
|
||||
{
|
||||
std::unique_ptr<DigitalRadarData> message =
|
||||
std::make_unique<DigitalRadarData>();
|
||||
message->set_header(std::move(header));
|
||||
message->Parse(is);
|
||||
return message;
|
||||
}
|
||||
|
||||
} // namespace rda
|
||||
} // namespace wsr88d
|
||||
} // namespace scwx
|
||||
Loading…
Add table
Add a link
Reference in a new issue