Refactoring, making level 2 message classes more explicitly named

wxdata/source/scwx/wsr88d/ar2v_file.cpp

@@ -1,5 +1,5 @@
 #include <scwx/wsr88d/ar2v_file.hpp>
-#include <scwx/wsr88d/rda/message_factory.hpp>
+#include <scwx/wsr88d/rda/level2_message_factory.hpp>
 #include <scwx/wsr88d/rda/types.hpp>
 #include <scwx/util/rangebuf.hpp>
 #include <scwx/util/time.hpp>
@@ -35,7 +35,7 @@ public:
        index_ {} {};
    ~Ar2vFileImpl() = default;
 
-   void HandleMessage(std::shared_ptr<rda::Message>& message);
+   void HandleMessage(std::shared_ptr<rda::Level2Message>& message);
    void IndexFile();
    void LoadLDMRecords(std::ifstream& f);
    void ParseLDMRecords();
@@ -291,7 +291,7 @@ void Ar2vFileImpl::ParseLDMRecords()
 
       while (!ss.eof())
       {
-         rda::MessageInfo msgInfo = rda::MessageFactory::Create(ss);
+         rda::Level2MessageInfo msgInfo = rda::Level2MessageFactory::Create(ss);
          if (!msgInfo.headerValid)
          {
             // Invalid message
@@ -329,7 +329,7 @@ void Ar2vFileImpl::ParseLDMRecords()
    rawRecords_.clear();
 }
 
-void Ar2vFileImpl::HandleMessage(std::shared_ptr<rda::Message>& message)
+void Ar2vFileImpl::HandleMessage(std::shared_ptr<rda::Level2Message>& message)
 {
    switch (message->header().message_type())
    {

wxdata/source/scwx/wsr88d/message.cpp

@@ -0,0 +1,24 @@
+#include <scwx/wsr88d/message.hpp>
+
+namespace scwx
+{
+namespace wsr88d
+{
+
+static const std::string logPrefix_ = "[scwx::wsr88d::message] ";
+
+class MessageImpl
+{
+public:
+   explicit MessageImpl() {};
+   ~MessageImpl() = default;
+};
+
+Message::Message() : p(std::make_unique<MessageImpl>()) {}
+Message::~Message() = default;
+
+Message::Message(Message&&) noexcept = default;
+Message& Message::operator=(Message&&) noexcept = default;
+
+} // namespace wsr88d
+} // namespace scwx

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

@@ -34,7 +34,7 @@ public:
 };
 
 ClutterFilterMap::ClutterFilterMap() :
-    Message(), p(std::make_unique<ClutterFilterMapImpl>())
+    Level2Message(), p(std::make_unique<ClutterFilterMapImpl>())
 {
 }
 ClutterFilterMap::~ClutterFilterMap() = default;
@@ -187,7 +187,7 @@ bool ClutterFilterMap::Parse(std::istream& is)
 }
 
 std::shared_ptr<ClutterFilterMap>
-ClutterFilterMap::Create(MessageHeader&& header, std::istream& is)
+ClutterFilterMap::Create(Level2MessageHeader&& header, std::istream& is)
 {
    std::shared_ptr<ClutterFilterMap> message =
       std::make_shared<ClutterFilterMap>();

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

@@ -540,7 +540,7 @@ public:
 };
 
 DigitalRadarData::DigitalRadarData() :
-    Message(), p(std::make_unique<DigitalRadarDataImpl>())
+    Level2Message(), p(std::make_unique<DigitalRadarDataImpl>())
 {
 }
 DigitalRadarData::~DigitalRadarData() = default;
@@ -787,7 +787,7 @@ bool DigitalRadarData::Parse(std::istream& is)
 }
 
 std::shared_ptr<DigitalRadarData>
-DigitalRadarData::Create(MessageHeader&& header, std::istream& is)
+DigitalRadarData::Create(Level2MessageHeader&& header, std::istream& is)
 {
    std::shared_ptr<DigitalRadarData> message =
       std::make_shared<DigitalRadarData>();

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

@@ -1,4 +1,4 @@
-#include <scwx/wsr88d/rda/message.hpp>
+#include <scwx/wsr88d/rda/level2_message.hpp>
 
 #include <boost/log/trivial.hpp>
 
@@ -9,24 +9,27 @@ namespace wsr88d
 namespace rda
 {
 
-static const std::string logPrefix_ = "[scwx::wsr88d::rda::message] ";
+static const std::string logPrefix_ = "[scwx::wsr88d::rda::level2_message] ";
 
-class MessageImpl
+class Level2MessageImpl
 {
 public:
-   explicit MessageImpl() : header_() {};
-   ~MessageImpl() = default;
+   explicit Level2MessageImpl() : header_() {};
+   ~Level2MessageImpl() = default;
 
-   MessageHeader header_;
+   Level2MessageHeader header_;
 };
 
-Message::Message() : p(std::make_unique<MessageImpl>()) {}
-Message::~Message() = default;
+Level2Message::Level2Message() :
+    Message(), p(std::make_unique<Level2MessageImpl>())
+{
+}
+Level2Message::~Level2Message() = default;
 
-Message::Message(Message&&) noexcept = default;
-Message& Message::operator=(Message&&) noexcept = default;
+Level2Message::Level2Message(Level2Message&&) noexcept = default;
+Level2Message& Level2Message::operator=(Level2Message&&) noexcept = default;
 
-bool Message::ValidateMessage(std::istream& is, size_t bytesRead) const
+bool Level2Message::ValidateMessage(std::istream& is, size_t bytesRead) const
 {
    bool   messageValid = true;
    size_t dataSize     = header().message_size() * 2 - header().SIZE;
@@ -66,12 +69,12 @@ bool Message::ValidateMessage(std::istream& is, size_t bytesRead) const
    return messageValid;
 }
 
-const MessageHeader& Message::header() const
+const Level2MessageHeader& Level2Message::header() const
 {
    return p->header_;
 }
 
-void Message::set_header(MessageHeader&& header)
+void Level2Message::set_header(Level2MessageHeader&& header)
 {
    p->header_ = std::move(header);
 }

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

@@ -1,4 +1,4 @@
-#include <scwx/wsr88d/rda/message_factory.hpp>
+#include <scwx/wsr88d/rda/level2_message_factory.hpp>
 
 #include <scwx/util/vectorbuf.hpp>
 #include <scwx/wsr88d/rda/clutter_filter_map.hpp>
@@ -20,12 +20,14 @@ namespace wsr88d
 namespace rda
 {
 
-static const std::string logPrefix_ = "[scwx::wsr88d::rda::message_factory] ";
+static const std::string logPrefix_ =
+   "[scwx::wsr88d::rda::level2_message_factory] ";
 
-typedef std::function<std::shared_ptr<Message>(MessageHeader&&, std::istream&)>
-   CreateMessageFunction;
+typedef std::function<std::shared_ptr<Level2Message>(Level2MessageHeader&&,
+                                                     std::istream&)>
+   CreateLevel2MessageFunction;
 
-static const std::unordered_map<uint8_t, CreateMessageFunction> create_ {
+static const std::unordered_map<uint8_t, CreateLevel2MessageFunction> create_ {
    {2, RdaStatusData::Create},
    {3, PerformanceMaintenanceData::Create},
    {5, VolumeCoveragePatternData::Create},
@@ -38,10 +40,10 @@ static size_t            bufferedSize_;
 static util::vectorbuf   messageBuffer_(messageData_);
 static std::istream      messageBufferStream_(&messageBuffer_);
 
-MessageInfo MessageFactory::Create(std::istream& is)
+Level2MessageInfo Level2MessageFactory::Create(std::istream& is)
 {
-   MessageInfo   info;
-   MessageHeader header;
+   Level2MessageInfo   info;
+   Level2MessageHeader header;
    info.headerValid  = header.Parse(is);
    info.messageValid = info.headerValid;
 
@@ -58,7 +60,7 @@ MessageInfo MessageFactory::Create(std::istream& is)
       uint16_t segment       = header.message_segment_number();
       uint16_t totalSegments = header.number_of_message_segments();
       uint8_t  messageType   = header.message_type();
-      size_t   dataSize      = header.message_size() * 2 - MessageHeader::SIZE;
+      size_t   dataSize = header.message_size() * 2 - Level2MessageHeader::SIZE;
 
       std::istream* messageStream = nullptr;
 
@@ -110,8 +112,8 @@ MessageInfo MessageFactory::Create(std::istream& is)
          else if (segment == totalSegments)
          {
             messageBuffer_.update_read_pointers(bufferedSize_);
-            header.set_message_size(
-               static_cast<uint16_t>(bufferedSize_ / 2 + MessageHeader::SIZE));
+            header.set_message_size(static_cast<uint16_t>(
+               bufferedSize_ / 2 + Level2MessageHeader::SIZE));
 
             messageStream = &messageBufferStream_;
          }
@@ -129,7 +131,7 @@ MessageInfo MessageFactory::Create(std::istream& is)
    else if (info.headerValid)
    {
       // Seek to the end of the current message
-      is.seekg(header.message_size() * 2 - rda::MessageHeader::SIZE,
+      is.seekg(header.message_size() * 2 - rda::Level2MessageHeader::SIZE,
                std::ios_base::cur);
    }
 

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

@@ -1,4 +1,4 @@
-#include <scwx/wsr88d/rda/message_header.hpp>
+#include <scwx/wsr88d/rda/level2_message_header.hpp>
 
 #include <istream>
 #include <string>
@@ -18,12 +18,13 @@ namespace wsr88d
 namespace rda
 {
 
-static const std::string logPrefix_ = "[scwx::wsr88d::rda::message_header] ";
+static const std::string logPrefix_ =
+   "[scwx::wsr88d::rda::level2_message_header] ";
 
-class MessageHeaderImpl
+class Level2MessageHeaderImpl
 {
 public:
-   explicit MessageHeaderImpl() :
+   explicit Level2MessageHeaderImpl() :
        messageSize_(),
        rdaRedundantChannel_(),
        messageType_(),
@@ -32,7 +33,7 @@ public:
        millisecondsOfDay_(),
        numberOfMessageSegments_(),
        messageSegmentNumber_() {};
-   ~MessageHeaderImpl() = default;
+   ~Level2MessageHeaderImpl() = default;
 
    uint16_t messageSize_;
    uint8_t  rdaRedundantChannel_;
@@ -44,58 +45,63 @@ public:
    uint16_t messageSegmentNumber_;
 };
 
-MessageHeader::MessageHeader() : p(std::make_unique<MessageHeaderImpl>()) {}
-MessageHeader::~MessageHeader() = default;
+Level2MessageHeader::Level2MessageHeader() :
+    p(std::make_unique<Level2MessageHeaderImpl>())
+{
+}
+Level2MessageHeader::~Level2MessageHeader() = default;
 
-MessageHeader::MessageHeader(MessageHeader&&) noexcept = default;
-MessageHeader& MessageHeader::operator=(MessageHeader&&) noexcept = default;
+Level2MessageHeader::Level2MessageHeader(Level2MessageHeader&&) noexcept =
+   default;
+Level2MessageHeader&
+Level2MessageHeader::operator=(Level2MessageHeader&&) noexcept = default;
 
-uint16_t MessageHeader::message_size() const
+uint16_t Level2MessageHeader::message_size() const
 {
    return p->messageSize_;
 }
 
-uint8_t MessageHeader::rda_redundant_channel() const
+uint8_t Level2MessageHeader::rda_redundant_channel() const
 {
    return p->rdaRedundantChannel_;
 }
 
-uint8_t MessageHeader::message_type() const
+uint8_t Level2MessageHeader::message_type() const
 {
    return p->messageType_;
 }
 
-uint16_t MessageHeader::id_sequence_number() const
+uint16_t Level2MessageHeader::id_sequence_number() const
 {
    return p->idSequenceNumber_;
 }
 
-uint16_t MessageHeader::julian_date() const
+uint16_t Level2MessageHeader::julian_date() const
 {
    return p->julianDate_;
 }
 
-uint32_t MessageHeader::milliseconds_of_day() const
+uint32_t Level2MessageHeader::milliseconds_of_day() const
 {
    return p->millisecondsOfDay_;
 }
 
-uint16_t MessageHeader::number_of_message_segments() const
+uint16_t Level2MessageHeader::number_of_message_segments() const
 {
    return p->numberOfMessageSegments_;
 }
 
-uint16_t MessageHeader::message_segment_number() const
+uint16_t Level2MessageHeader::message_segment_number() const
 {
    return p->messageSegmentNumber_;
 }
 
-void MessageHeader::set_message_size(uint16_t messageSize)
+void Level2MessageHeader::set_message_size(uint16_t messageSize)
 {
    p->messageSize_ = messageSize;
 }
 
-bool MessageHeader::Parse(std::istream& is)
+bool Level2MessageHeader::Parse(std::istream& is)
 {
    bool headerValid = true;
 

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

@@ -550,7 +550,7 @@ public:
 };
 
 PerformanceMaintenanceData::PerformanceMaintenanceData() :
-    Message(), p(std::make_unique<PerformanceMaintenanceDataImpl>())
+    Level2Message(), p(std::make_unique<PerformanceMaintenanceDataImpl>())
 {
 }
 PerformanceMaintenanceData::~PerformanceMaintenanceData() = default;
@@ -2469,7 +2469,8 @@ bool PerformanceMaintenanceData::Parse(std::istream& is)
 }
 
 std::shared_ptr<PerformanceMaintenanceData>
-PerformanceMaintenanceData::Create(MessageHeader&& header, std::istream& is)
+PerformanceMaintenanceData::Create(Level2MessageHeader&& header,
+                                   std::istream&         is)
 {
    std::shared_ptr<PerformanceMaintenanceData> message =
       std::make_shared<PerformanceMaintenanceData>();

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

@@ -369,7 +369,7 @@ public:
 };
 
 RdaAdaptationData::RdaAdaptationData() :
-    Message(), p(std::make_unique<RdaAdaptationDataImpl>())
+    Level2Message(), p(std::make_unique<RdaAdaptationDataImpl>())
 {
 }
 RdaAdaptationData::~RdaAdaptationData() = default;
@@ -1747,7 +1747,7 @@ bool RdaAdaptationData::Parse(std::istream& is)
 }
 
 std::shared_ptr<RdaAdaptationData>
-RdaAdaptationData::Create(MessageHeader&& header, std::istream& is)
+RdaAdaptationData::Create(Level2MessageHeader&& header, std::istream& is)
 {
    std::shared_ptr<RdaAdaptationData> message =
       std::make_shared<RdaAdaptationData>();

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

@@ -78,7 +78,7 @@ public:
 };
 
 RdaStatusData::RdaStatusData() :
-    Message(), p(std::make_unique<RdaStatusDataImpl>())
+    Level2Message(), p(std::make_unique<RdaStatusDataImpl>())
 {
 }
 RdaStatusData::~RdaStatusData() = default;
@@ -322,8 +322,8 @@ bool RdaStatusData::Parse(std::istream& is)
    return messageValid;
 }
 
-std::shared_ptr<RdaStatusData> RdaStatusData::Create(MessageHeader&& header,
-                                                     std::istream&   is)
+std::shared_ptr<RdaStatusData>
+RdaStatusData::Create(Level2MessageHeader&& header, std::istream& is)
 {
    std::shared_ptr<RdaStatusData> message = std::make_shared<RdaStatusData>();
    message->set_header(std::move(header));

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

@@ -96,7 +96,7 @@ public:
 };
 
 VolumeCoveragePatternData::VolumeCoveragePatternData() :
-    Message(), p(std::make_unique<VolumeCoveragePatternDataImpl>())
+    Level2Message(), p(std::make_unique<VolumeCoveragePatternDataImpl>())
 {
 }
 VolumeCoveragePatternData::~VolumeCoveragePatternData() = default;
@@ -503,7 +503,8 @@ bool VolumeCoveragePatternData::Parse(std::istream& is)
 }
 
 std::shared_ptr<VolumeCoveragePatternData>
-VolumeCoveragePatternData::Create(MessageHeader&& header, std::istream& is)
+VolumeCoveragePatternData::Create(Level2MessageHeader&& header,
+                                  std::istream&         is)
 {
    std::shared_ptr<VolumeCoveragePatternData> message =
       std::make_shared<VolumeCoveragePatternData>();