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

Refactoring, making level 2 message classes more explicitly named

Browse source
This commit is contained in:
Dan Paulat 2021-12-23 11:55:26 -06:00
parent cae04fad37
commit a280f37289
23 changed files with 236 additions and 155 deletions
Download patch file Download diff file Expand all files Collapse all files

21
wxdata/include/scwx/wsr88d/rda/message.hpp → wxdata/include/scwx/wsr88d/message.hpp
View file

@ -1,7 +1,5 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message_header.hpp>
#include <array> #include <array>
#include <execution> #include <execution>
#include <istream> #include <istream>
@ -18,8 +16,6 @@ namespace scwx
{ {
namespace wsr88d namespace wsr88d
{ {
namespace rda
{
class MessageImpl; class MessageImpl;
@ -34,20 +30,13 @@ protected:
Message(Message&&) noexcept; Message(Message&&) noexcept;
Message& operator=(Message&&) noexcept; Message& operator=(Message&&) noexcept;
bool ValidateMessage(std::istream& is, size_t bytesRead) const; virtual bool ValidateMessage(std::istream& is, size_t bytesRead) const = 0;
public: public:
virtual ~Message(); virtual ~Message();
const MessageHeader& header() const;
void set_header(MessageHeader&& header);
virtual bool Parse(std::istream& is) = 0; virtual bool Parse(std::istream& is) = 0;
static constexpr double ANGLE_DATA_SCALE = 0.005493125;
static constexpr double AZ_EL_RATE_DATA_SCALE = 0.001373291015625;
static void ReadBoolean(std::istream& is, bool& value) static void ReadBoolean(std::istream& is, bool& value)
{ {
std::string data(4, ' '); std::string data(4, ' ');
@ -100,9 +89,10 @@ public:
template<typename T> template<typename T>
static void SwapMap(std::map<T, float>& m) static void SwapMap(std::map<T, float>& m)
{ {
std::for_each(std::execution::par_unseq, m.begin(), m.end(), [](auto& p) { std::for_each(std::execution::par_unseq,
p.second = SwapFloat(p.second); m.begin(),
}); m.end(),
[](auto& p) { p.second = SwapFloat(p.second); });
} }
static void SwapVector(std::vector<uint16_t>& v) static void SwapVector(std::vector<uint16_t>& v)
@ -118,6 +108,5 @@ private:
std::unique_ptr<MessageImpl> p; std::unique_ptr<MessageImpl> p;
}; };
} // namespace rda
} // namespace wsr88d } // namespace wsr88d
} // namespace scwx } // namespace scwx

6
wxdata/include/scwx/wsr88d/rda/clutter_filter_map.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx
{ {
@ -11,7 +11,7 @@ namespace rda
class ClutterFilterMapImpl; class ClutterFilterMapImpl;
class ClutterFilterMap : public Message class ClutterFilterMap : public Level2Message
{ {
public: public:
explicit ClutterFilterMap(); explicit ClutterFilterMap();
@ -32,7 +32,7 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<ClutterFilterMap> Create(MessageHeader&& header, static std::shared_ptr<ClutterFilterMap> Create(Level2MessageHeader&& header,
std::istream& is); std::istream& is);
static const size_t NUM_AZIMUTH_SEGMENTS = 360u; static const size_t NUM_AZIMUTH_SEGMENTS = 360u;

6
wxdata/include/scwx/wsr88d/rda/digital_radar_data.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <scwx/util/iterator.hpp> #include <scwx/util/iterator.hpp>
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx
{ {
@ -170,7 +170,7 @@ private:
bool Parse(std::istream& is); bool Parse(std::istream& is);
}; };
class DigitalRadarData : public Message class DigitalRadarData : public Level2Message
{ {
public: public:
explicit DigitalRadarData(); explicit DigitalRadarData();
@ -205,7 +205,7 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<DigitalRadarData> Create(MessageHeader&& header, static std::shared_ptr<DigitalRadarData> Create(Level2MessageHeader&& header,
std::istream& is); std::istream& is);
private: private:

50
wxdata/include/scwx/wsr88d/rda/level2_message.hpp Normal file
View file

@ -0,0 +1,50 @@
#pragma once
#include <scwx/wsr88d/rda/level2_message_header.hpp>
#include <scwx/wsr88d/message.hpp>
#ifdef WIN32
# include <WinSock2.h>
#else
# include <arpa/inet.h>
#endif
namespace scwx
{
namespace wsr88d
{
namespace rda
{
class Level2MessageImpl;
class Level2Message : public Message
{
protected:
explicit Level2Message();
Level2Message(const Level2Message&) = delete;
Level2Message& operator=(const Level2Message&) = delete;
Level2Message(Level2Message&&) noexcept;
Level2Message& operator=(Level2Message&&) noexcept;
bool ValidateMessage(std::istream& is, size_t bytesRead) const override;
public:
virtual ~Level2Message();
const Level2MessageHeader& header() const;
void set_header(Level2MessageHeader&& header);
static constexpr double ANGLE_DATA_SCALE = 0.005493125;
static constexpr double AZ_EL_RATE_DATA_SCALE = 0.001373291015625;
private:
std::unique_ptr<Level2MessageImpl> p;
};
} // namespace rda
} // namespace wsr88d
} // namespace scwx

42
wxdata/include/scwx/wsr88d/rda/level2_message_factory.hpp Normal file
View file

@ -0,0 +1,42 @@
#pragma once
#include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx
{
namespace wsr88d
{
namespace rda
{
struct Level2MessageInfo
{
std::shared_ptr<Level2Message> message;
bool headerValid;
bool messageValid;
Level2MessageInfo() :
message(nullptr), headerValid(false), messageValid(false)
{
}
};
class Level2MessageFactory
{
private:
explicit Level2MessageFactory() = delete;
~Level2MessageFactory() = delete;
Level2MessageFactory(const Level2MessageFactory&) = delete;
Level2MessageFactory& operator=(const Level2MessageFactory&) = delete;
Level2MessageFactory(Level2MessageFactory&&) noexcept = delete;
Level2MessageFactory& operator=(Level2MessageFactory&&) noexcept = delete;
public:
static Level2MessageInfo Create(std::istream& is);
};
} // namespace rda
} // namespace wsr88d
} // namespace scwx

18
wxdata/include/scwx/wsr88d/rda/message_header.hpp → wxdata/include/scwx/wsr88d/rda/level2_message_header.hpp
View file

@ -10,19 +10,19 @@ namespace wsr88d
namespace rda namespace rda
{ {
class MessageHeaderImpl; class Level2MessageHeaderImpl;
class MessageHeader class Level2MessageHeader
{ {
public: public:
explicit MessageHeader(); explicit Level2MessageHeader();
~MessageHeader(); ~Level2MessageHeader();
MessageHeader(const MessageHeader&) = delete; Level2MessageHeader(const Level2MessageHeader&) = delete;
MessageHeader& operator=(const MessageHeader&) = delete; Level2MessageHeader& operator=(const Level2MessageHeader&) = delete;
MessageHeader(MessageHeader&&) noexcept; Level2MessageHeader(Level2MessageHeader&&) noexcept;
MessageHeader& operator=(MessageHeader&&) noexcept; Level2MessageHeader& operator=(Level2MessageHeader&&) noexcept;
uint16_t message_size() const; uint16_t message_size() const;
uint8_t rda_redundant_channel() const; uint8_t rda_redundant_channel() const;
@ -40,7 +40,7 @@ public:
static const size_t SIZE = 16u; static const size_t SIZE = 16u;
private: private:
std::unique_ptr<MessageHeaderImpl> p; std::unique_ptr<Level2MessageHeaderImpl> p;
}; };
} // namespace rda } // namespace rda

39
wxdata/include/scwx/wsr88d/rda/message_factory.hpp
View file

@ -1,39 +0,0 @@
#pragma once
#include <scwx/wsr88d/rda/message.hpp>
namespace scwx
{
namespace wsr88d
{
namespace rda
{
struct MessageInfo
{
std::shared_ptr<Message> message;
bool headerValid;
bool messageValid;
MessageInfo() : message(nullptr), headerValid(false), messageValid(false) {}
};
class MessageFactory
{
private:
explicit MessageFactory() = delete;
~MessageFactory() = delete;
MessageFactory(const MessageFactory&) = delete;
MessageFactory& operator=(const MessageFactory&) = delete;
MessageFactory(MessageFactory&&) noexcept = delete;
MessageFactory& operator=(MessageFactory&&) noexcept = delete;
public:
static MessageInfo Create(std::istream& is);
};
} // namespace rda
} // namespace wsr88d
} // namespace scwx

6
wxdata/include/scwx/wsr88d/rda/performance_maintenance_data.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx
{ {
@ -11,7 +11,7 @@ namespace rda
class PerformanceMaintenanceDataImpl; class PerformanceMaintenanceDataImpl;
class PerformanceMaintenanceData : public Message class PerformanceMaintenanceData : public Level2Message
{ {
public: public:
explicit PerformanceMaintenanceData(); explicit PerformanceMaintenanceData();
@ -279,7 +279,7 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<PerformanceMaintenanceData> static std::shared_ptr<PerformanceMaintenanceData>
Create(MessageHeader&& header, std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
private: private:
std::unique_ptr<PerformanceMaintenanceDataImpl> p; std::unique_ptr<PerformanceMaintenanceDataImpl> p;

8
wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx
{ {
@ -11,7 +11,7 @@ namespace rda
class RdaAdaptationDataImpl; class RdaAdaptationDataImpl;
class RdaAdaptationData : public Message class RdaAdaptationData : public Level2Message
{ {
public: public:
explicit RdaAdaptationData(); explicit RdaAdaptationData();
@ -203,8 +203,8 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<RdaAdaptationData> Create(MessageHeader&& header, static std::shared_ptr<RdaAdaptationData>
std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
private: private:
std::unique_ptr<RdaAdaptationDataImpl> p; std::unique_ptr<RdaAdaptationDataImpl> p;

6
wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx
{ {
@ -11,7 +11,7 @@ namespace rda
class RdaStatusDataImpl; class RdaStatusDataImpl;
class RdaStatusData : public Message class RdaStatusData : public Level2Message
{ {
public: public:
explicit RdaStatusData(); explicit RdaStatusData();
@ -55,7 +55,7 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<RdaStatusData> Create(MessageHeader&& header, static std::shared_ptr<RdaStatusData> Create(Level2MessageHeader&& header,
std::istream& is); std::istream& is);
private: private:

6
wxdata/include/scwx/wsr88d/rda/volume_coverage_pattern_data.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
#include <string> #include <string>
@ -23,7 +23,7 @@ enum class WaveformType
class VolumeCoveragePatternDataImpl; class VolumeCoveragePatternDataImpl;
class VolumeCoveragePatternData : public Message class VolumeCoveragePatternData : public Level2Message
{ {
public: public:
explicit VolumeCoveragePatternData(); explicit VolumeCoveragePatternData();
@ -90,7 +90,7 @@ public:
bool Parse(std::istream& is); bool Parse(std::istream& is);
static std::shared_ptr<VolumeCoveragePatternData> static std::shared_ptr<VolumeCoveragePatternData>
Create(MessageHeader&& header, std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
private: private:
std::unique_ptr<VolumeCoveragePatternDataImpl> p; std::unique_ptr<VolumeCoveragePatternDataImpl> p;

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

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

24
wxdata/source/scwx/wsr88d/message.cpp Normal file
View file

@ -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

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

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

4
wxdata/source/scwx/wsr88d/rda/digital_radar_data.cpp
View file

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

29
wxdata/source/scwx/wsr88d/rda/message.cpp → wxdata/source/scwx/wsr88d/rda/level2_message.cpp
View file

@ -1,4 +1,4 @@
#include <scwx/wsr88d/rda/message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
#include <boost/log/trivial.hpp> #include <boost/log/trivial.hpp>
@ -9,24 +9,27 @@ namespace wsr88d
namespace rda 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: public:
explicit MessageImpl() : header_() {}; explicit Level2MessageImpl() : header_() {};
~MessageImpl() = default; ~Level2MessageImpl() = default;
MessageHeader header_; Level2MessageHeader header_;
}; };
Message::Message() : p(std::make_unique<MessageImpl>()) {} Level2Message::Level2Message() :
Message::~Message() = default; Message(), p(std::make_unique<Level2MessageImpl>())
{
}
Level2Message::~Level2Message() = default;
Message::Message(Message&&) noexcept = default; Level2Message::Level2Message(Level2Message&&) noexcept = default;
Message& Message::operator=(Message&&) 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; bool messageValid = true;
size_t dataSize = header().message_size() * 2 - header().SIZE; 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; return messageValid;
} }
const MessageHeader& Message::header() const const Level2MessageHeader& Level2Message::header() const
{ {
return p->header_; return p->header_;
} }
void Message::set_header(MessageHeader&& header) void Level2Message::set_header(Level2MessageHeader&& header)
{ {
p->header_ = std::move(header); p->header_ = std::move(header);
} }

26
wxdata/source/scwx/wsr88d/rda/message_factory.cpp → wxdata/source/scwx/wsr88d/rda/level2_message_factory.cpp
View file

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

44
wxdata/source/scwx/wsr88d/rda/message_header.cpp → wxdata/source/scwx/wsr88d/rda/level2_message_header.cpp
View file

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

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

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

4
wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp
View file

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

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

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

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

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

18
wxdata/wxdata.cmake
View file

@ -21,13 +21,15 @@ set(SRC_UTIL source/scwx/util/rangebuf.cpp
source/scwx/util/streams.cpp source/scwx/util/streams.cpp
source/scwx/util/time.cpp source/scwx/util/time.cpp
source/scwx/util/vectorbuf.cpp) source/scwx/util/vectorbuf.cpp)
set(HDR_WSR88D include/scwx/wsr88d/ar2v_file.hpp) set(HDR_WSR88D include/scwx/wsr88d/ar2v_file.hpp
set(SRC_WSR88D source/scwx/wsr88d/ar2v_file.cpp) include/scwx/wsr88d/message.hpp)
set(SRC_WSR88D source/scwx/wsr88d/ar2v_file.cpp
source/scwx/wsr88d/message.cpp)
set(HDR_WSR88D_RDA include/scwx/wsr88d/rda/clutter_filter_map.hpp set(HDR_WSR88D_RDA include/scwx/wsr88d/rda/clutter_filter_map.hpp
include/scwx/wsr88d/rda/digital_radar_data.hpp include/scwx/wsr88d/rda/digital_radar_data.hpp
include/scwx/wsr88d/rda/message.hpp include/scwx/wsr88d/rda/level2_message.hpp
include/scwx/wsr88d/rda/message_factory.hpp include/scwx/wsr88d/rda/level2_message_factory.hpp
include/scwx/wsr88d/rda/message_header.hpp include/scwx/wsr88d/rda/level2_message_header.hpp
include/scwx/wsr88d/rda/performance_maintenance_data.hpp include/scwx/wsr88d/rda/performance_maintenance_data.hpp
include/scwx/wsr88d/rda/rda_adaptation_data.hpp include/scwx/wsr88d/rda/rda_adaptation_data.hpp
include/scwx/wsr88d/rda/rda_status_data.hpp include/scwx/wsr88d/rda/rda_status_data.hpp
@ -35,9 +37,9 @@ set(HDR_WSR88D_RDA include/scwx/wsr88d/rda/clutter_filter_map.hpp
include/scwx/wsr88d/rda/volume_coverage_pattern_data.hpp) include/scwx/wsr88d/rda/volume_coverage_pattern_data.hpp)
set(SRC_WSR88D_RDA source/scwx/wsr88d/rda/clutter_filter_map.cpp set(SRC_WSR88D_RDA source/scwx/wsr88d/rda/clutter_filter_map.cpp
source/scwx/wsr88d/rda/digital_radar_data.cpp source/scwx/wsr88d/rda/digital_radar_data.cpp
source/scwx/wsr88d/rda/message.cpp source/scwx/wsr88d/rda/level2_message.cpp
source/scwx/wsr88d/rda/message_factory.cpp source/scwx/wsr88d/rda/level2_message_factory.cpp
source/scwx/wsr88d/rda/message_header.cpp source/scwx/wsr88d/rda/level2_message_header.cpp
source/scwx/wsr88d/rda/performance_maintenance_data.cpp source/scwx/wsr88d/rda/performance_maintenance_data.cpp
source/scwx/wsr88d/rda/rda_adaptation_data.cpp source/scwx/wsr88d/rda/rda_adaptation_data.cpp
source/scwx/wsr88d/rda/rda_status_data.cpp source/scwx/wsr88d/rda/rda_status_data.cpp