Store radar data in Ar2vFile object

wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp

@@ -186,13 +186,18 @@ bool ClutterFilterMap::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<ClutterFilterMap>
+std::shared_ptr<ClutterFilterMap>
 ClutterFilterMap::Create(MessageHeader&& header, std::istream& is)
 {
-   std::unique_ptr<ClutterFilterMap> message =
-      std::make_unique<ClutterFilterMap>();
+   std::shared_ptr<ClutterFilterMap> message =
+      std::make_shared<ClutterFilterMap>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }
 

wxdata/source/scwx/wsr88d/rda/digital_radar_data.cpp

@@ -501,19 +501,34 @@ bool DigitalRadarData::Parse(std::istream& is)
    p->elevationAngle_     = SwapFloat(p->elevationAngle_);
    p->dataBlockCount_     = ntohs(p->dataBlockCount_);
 
+   if (p->azimuthNumber_ < 1 || p->azimuthNumber_ > 720)
+   {
+      BOOST_LOG_TRIVIAL(warning)
+         << logPrefix_ << "Invalid azimuth number: " << p->azimuthNumber_;
+      messageValid = false;
+   }
+   if (p->elevationNumber_ < 1 || p->elevationNumber_ > 32)
+   {
+      BOOST_LOG_TRIVIAL(warning)
+         << logPrefix_ << "Invalid elevation number: " << p->elevationNumber_;
+      messageValid = false;
+   }
    if (p->dataBlockCount_ < 4 || p->dataBlockCount_ > 10)
    {
       BOOST_LOG_TRIVIAL(warning)
          << logPrefix_
          << "Invalid number of data blocks: " << p->dataBlockCount_;
-      p->dataBlockCount_ = 0;
-      messageValid       = false;
+      messageValid = false;
    }
    if (p->compressionIndicator_ != 0)
    {
       BOOST_LOG_TRIVIAL(warning) << logPrefix_ << "Compression not supported";
+      messageValid = false;
+   }
+
+   if (!messageValid)
+   {
       p->dataBlockCount_ = 0;
-      messageValid       = false;
    }
 
    is.read(reinterpret_cast<char*>(&p->dataBlockPointer_),
@@ -599,13 +614,18 @@ bool DigitalRadarData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<DigitalRadarData>
+std::shared_ptr<DigitalRadarData>
 DigitalRadarData::Create(MessageHeader&& header, std::istream& is)
 {
-   std::unique_ptr<DigitalRadarData> message =
-      std::make_unique<DigitalRadarData>();
+   std::shared_ptr<DigitalRadarData> message =
+      std::make_shared<DigitalRadarData>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }
 

wxdata/source/scwx/wsr88d/rda/message_factory.cpp

@@ -22,7 +22,7 @@ namespace rda
 
 static const std::string logPrefix_ = "[scwx::wsr88d::rda::message_factory] ";
 
-typedef std::function<std::unique_ptr<Message>(MessageHeader&&, std::istream&)>
+typedef std::function<std::shared_ptr<Message>(MessageHeader&&, std::istream&)>
    CreateMessageFunction;
 
 static const std::unordered_map<uint8_t, CreateMessageFunction> create_ {
@@ -133,6 +133,11 @@ MessageInfo MessageFactory::Create(std::istream& is)
                std::ios_base::cur);
    }
 
+   if (info.message == nullptr)
+   {
+      info.messageValid = false;
+   }
+
    return info;
 }
 

wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp

@@ -2468,13 +2468,18 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<PerformanceMaintenanceData>
+std::shared_ptr<PerformanceMaintenanceData>
 PerformanceMaintenanceData::Create(MessageHeader&& header, std::istream& is)
 {
-   std::unique_ptr<PerformanceMaintenanceData> message =
-      std::make_unique<PerformanceMaintenanceData>();
+   std::shared_ptr<PerformanceMaintenanceData> message =
+      std::make_shared<PerformanceMaintenanceData>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }
 

wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp

@@ -1746,13 +1746,18 @@ bool RdaAdaptationData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<RdaAdaptationData>
+std::shared_ptr<RdaAdaptationData>
 RdaAdaptationData::Create(MessageHeader&& header, std::istream& is)
 {
-   std::unique_ptr<RdaAdaptationData> message =
-      std::make_unique<RdaAdaptationData>();
+   std::shared_ptr<RdaAdaptationData> message =
+      std::make_shared<RdaAdaptationData>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }
 

wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp

@@ -322,12 +322,17 @@ bool RdaStatusData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<RdaStatusData> RdaStatusData::Create(MessageHeader&& header,
+std::shared_ptr<RdaStatusData> RdaStatusData::Create(MessageHeader&& header,
                                                      std::istream&   is)
 {
-   std::unique_ptr<RdaStatusData> message = std::make_unique<RdaStatusData>();
+   std::shared_ptr<RdaStatusData> message = std::make_shared<RdaStatusData>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }
 

wxdata/source/scwx/wsr88d/rda/volume_coverage_pattern_data.cpp

@@ -236,22 +236,22 @@ uint8_t VolumeCoveragePatternData::super_resolution_control(uint16_t e) const
 
 bool VolumeCoveragePatternData::half_degree_azimuth(uint16_t e) const
 {
-   return p->elevationCuts_[e].superResolutionControl_ & 0x0001;
+   return p->elevationCuts_[e].superResolutionControl_ & 0x01;
 }
 
 bool VolumeCoveragePatternData::quarter_km_reflectivity(uint16_t e) const
 {
-   return p->elevationCuts_[e].superResolutionControl_ & 0x0002;
+   return p->elevationCuts_[e].superResolutionControl_ & 0x02;
 }
 
 bool VolumeCoveragePatternData::doppler_to_300km(uint16_t e) const
 {
-   return p->elevationCuts_[e].superResolutionControl_ & 0x0004;
+   return p->elevationCuts_[e].superResolutionControl_ & 0x04;
 }
 
 bool VolumeCoveragePatternData::dual_polarization_to_300km(uint16_t e) const
 {
-   return p->elevationCuts_[e].superResolutionControl_ & 0x0008;
+   return p->elevationCuts_[e].superResolutionControl_ & 0x08;
 }
 
 uint8_t VolumeCoveragePatternData::surveillance_prf_number(uint16_t e) const
@@ -484,13 +484,18 @@ bool VolumeCoveragePatternData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::unique_ptr<VolumeCoveragePatternData>
+std::shared_ptr<VolumeCoveragePatternData>
 VolumeCoveragePatternData::Create(MessageHeader&& header, std::istream& is)
 {
-   std::unique_ptr<VolumeCoveragePatternData> message =
-      std::make_unique<VolumeCoveragePatternData>();
+   std::shared_ptr<VolumeCoveragePatternData> message =
+      std::make_shared<VolumeCoveragePatternData>();
    message->set_header(std::move(header));
-   message->Parse(is);
+
+   if (!message->Parse(is))
+   {
+      message.reset();
+   }
+
    return message;
 }