Create record for loaded NEXRAD file in preparation for storage

scwx-qt/source/scwx/qt/main/main_window.cpp

@@ -226,19 +226,22 @@ void MainWindow::on_actionOpen_triggered()
          std::shared_ptr<request::NexradFileRequest> request =
             std::make_shared<request::NexradFileRequest>();
 
-         connect(
+         connect( //
             request.get(),
             &request::NexradFileRequest::RequestComplete,
             this,
             [=](std::shared_ptr<request::NexradFileRequest> request)
             {
-               std::shared_ptr<wsr88d::NexradFile> nexradFile =
-                  request->nexrad_file();
+               std::shared_ptr<types::RadarProductRecord> record =
+                  request->radar_product_record();
+               std::shared_ptr<wsr88d::Ar2vFile>   level2File = nullptr;
+               std::shared_ptr<wsr88d::Level3File> level3File = nullptr;
 
-               std::shared_ptr<wsr88d::Ar2vFile> level2File =
-                  std::dynamic_pointer_cast<wsr88d::Ar2vFile>(nexradFile);
-               std::shared_ptr<wsr88d::Level3File> level3File =
-                  std::dynamic_pointer_cast<wsr88d::Level3File>(nexradFile);
+               if (record != nullptr)
+               {
+                  level2File = record->level2_file();
+                  level3File = record->level3_file();
+               }
 
                if (level2File != nullptr)
                {

scwx-qt/source/scwx/qt/manager/radar_product_manager.cpp

@@ -1,9 +1,6 @@
 #include <scwx/qt/manager/radar_product_manager.hpp>
 #include <scwx/common/constants.hpp>
-#include <scwx/common/sites.hpp>
-#include <scwx/qt/config/radar_site.hpp>
 #include <scwx/util/threads.hpp>
-#include <scwx/util/time.hpp>
 #include <scwx/wsr88d/nexrad_file_factory.hpp>
 
 #include <deque>
@@ -27,12 +24,6 @@ namespace manager
 static const std::string logPrefix_ =
    "[scwx::qt::manager::radar_product_manager] ";
 
-typedef std::function<std::shared_ptr<wsr88d::NexradFile>()>
-   CreateNexradFileFunction;
-
-static void LoadNexradFile(CreateNexradFileFunction                    load,
-                           std::shared_ptr<request::NexradFileRequest> request);
-
 static constexpr uint32_t NUM_RADIAL_GATES_0_5_DEGREE =
    common::MAX_0_5_DEGREE_RADIALS * common::MAX_DATA_MOMENT_GATES;
 static constexpr uint32_t NUM_RADIAL_GATES_1_DEGREE =
@@ -65,6 +56,9 @@ public:
    }
    ~RadarProductManagerImpl() = default;
 
+   void
+   StoreRadarProductRecord(std::shared_ptr<types::RadarProductRecord> record);
+
    std::string radarId_;
    bool        initialized_;
 
@@ -214,26 +208,23 @@ void RadarProductManager::Initialize()
 void RadarProductManager::LoadData(
    std::istream& is, std::shared_ptr<request::NexradFileRequest> request)
 {
-   LoadNexradFile(
-      [=, &is]() -> std::shared_ptr<wsr88d::NexradFile> {
-         return wsr88d::NexradFileFactory::Create(is);
-      },
-      request);
+   LoadNexradFile([=, &is]() -> std::shared_ptr<wsr88d::NexradFile>
+                  { return wsr88d::NexradFileFactory::Create(is); },
+                  request);
 }
 
 void RadarProductManager::LoadFile(
    const std::string&                          filename,
    std::shared_ptr<request::NexradFileRequest> request)
 {
-   LoadNexradFile(
-      [=]() -> std::shared_ptr<wsr88d::NexradFile> {
-         return wsr88d::NexradFileFactory::Create(filename);
-      },
-      request);
+   LoadNexradFile([=]() -> std::shared_ptr<wsr88d::NexradFile>
+                  { return wsr88d::NexradFileFactory::Create(filename); },
+                  request);
 }
 
-static void LoadNexradFile(CreateNexradFileFunction                    load,
-                           std::shared_ptr<request::NexradFileRequest> request)
+void RadarProductManager::LoadNexradFile(
+   CreateNexradFileFunction                    load,
+   std::shared_ptr<request::NexradFileRequest> request)
 {
    scwx::util::async(
       [=]()
@@ -241,45 +232,19 @@ static void LoadNexradFile(CreateNexradFileFunction                    load,
          std::unique_lock                    lock(fileLoadMutex_);
          std::shared_ptr<wsr88d::NexradFile> nexradFile = load();
 
-         std::shared_ptr<wsr88d::Ar2vFile> level2File =
-            std::dynamic_pointer_cast<wsr88d::Ar2vFile>(nexradFile);
-         std::shared_ptr<wsr88d::Level3File> level3File =
-            std::dynamic_pointer_cast<wsr88d::Level3File>(nexradFile);
+         std::shared_ptr<types::RadarProductRecord> record = nullptr;
 
-         bool        fileValid    = false;
-         std::string radarId      = "????";
-         std::string siteId       = "???";
-         uint16_t    julianDate   = 0;
-         uint32_t    milliseconds = 0;
-
-         std::chrono::system_clock::time_point time;
-
-         if (level2File != nullptr)
-         {
-            fileValid    = true;
-            radarId      = level2File->icao();
-            siteId       = common::GetSiteId(radarId);
-            julianDate   = level2File->julian_date();
-            milliseconds = level2File->milliseconds();
-         }
-         else if (level3File != nullptr)
-         {
-            fileValid  = true;
-            siteId     = level3File->wmo_header()->product_designator();
-            radarId    = config::GetRadarIdFromSiteId(siteId);
-            julianDate = level3File->message()->header().date_of_message();
-            milliseconds =
-               level3File->message()->header().time_of_message() * 1000u;
-         }
+         bool fileValid = (nexradFile != nullptr);
 
          if (fileValid)
          {
-            time = util::TimePoint(julianDate, milliseconds);
+            record = types::RadarProductRecord::Create(nexradFile);
 
             std::shared_ptr<RadarProductManager> manager =
-               RadarProductManager::Instance(radarId);
+               RadarProductManager::Instance(record->radar_id());
+
+            manager->p->StoreRadarProductRecord(record);
 
-            // TODO: Store and index
             // TODO: When to initialize?
          }
 
@@ -287,10 +252,7 @@ static void LoadNexradFile(CreateNexradFileFunction                    load,
 
          if (request != nullptr)
          {
-            request->set_nexrad_file(nexradFile);
-            request->set_radar_id(radarId);
-            request->set_site_id(siteId);
-            request->set_time(time);
+            request->set_radar_product_record(record);
             emit request->RequestComplete(request);
          }
       });
@@ -317,6 +279,12 @@ void RadarProductManager::LoadLevel2Data(const std::string& filename)
    emit Level2DataLoaded();
 }
 
+void RadarProductManagerImpl::StoreRadarProductRecord(
+   std::shared_ptr<types::RadarProductRecord> record)
+{
+   // TODO
+}
+
 std::tuple<std::shared_ptr<wsr88d::rda::ElevationScan>,
            float,
            std::vector<float>>

scwx-qt/source/scwx/qt/manager/radar_product_manager.hpp

@@ -3,6 +3,7 @@
 #include <scwx/common/types.hpp>
 #include <scwx/qt/config/radar_site.hpp>
 #include <scwx/qt/request/nexrad_file_request.hpp>
+#include <scwx/qt/types/radar_product_record.hpp>
 #include <scwx/wsr88d/ar2v_file.hpp>
 #include <scwx/wsr88d/level3_file.hpp>
 
@@ -58,6 +59,13 @@ signals:
    void Level2DataLoaded();
 
 private:
+   typedef std::function<std::shared_ptr<wsr88d::NexradFile>()>
+      CreateNexradFileFunction;
+
+   static void
+   LoadNexradFile(CreateNexradFileFunction                    load,
+                  std::shared_ptr<request::NexradFileRequest> request);
+
    std::unique_ptr<RadarProductManagerImpl> p;
 };
 

scwx-qt/source/scwx/qt/request/nexrad_file_request.cpp

@@ -15,17 +15,11 @@ static const std::string logPrefix_ =
 class NexradFileRequestImpl
 {
 public:
-   explicit NexradFileRequestImpl() :
-       nexradFile_ {nullptr}, radarId_ {}, siteId_ {}, time_ {}
-   {
-   }
+   explicit NexradFileRequestImpl() : radarProductRecord_ {nullptr} {}
 
    ~NexradFileRequestImpl() {}
 
-   std::shared_ptr<wsr88d::NexradFile>   nexradFile_;
-   std::string                           radarId_;
-   std::string                           siteId_;
-   std::chrono::system_clock::time_point time_;
+   std::shared_ptr<types::RadarProductRecord> radarProductRecord_;
 };
 
 NexradFileRequest::NexradFileRequest() :
@@ -34,45 +28,16 @@ NexradFileRequest::NexradFileRequest() :
 }
 NexradFileRequest::~NexradFileRequest() = default;
 
-std::shared_ptr<wsr88d::NexradFile> NexradFileRequest::nexrad_file() const
+std::shared_ptr<types::RadarProductRecord>
+NexradFileRequest::radar_product_record() const
 {
-   return p->nexradFile_;
+   return p->radarProductRecord_;
 }
 
-std::string NexradFileRequest::radar_id() const
+void NexradFileRequest::set_radar_product_record(
+   std::shared_ptr<types::RadarProductRecord> record)
 {
-   return p->radarId_;
-}
-
-std::string NexradFileRequest::site_id() const
-{
-   return p->siteId_;
-}
-
-std::chrono::system_clock::time_point NexradFileRequest::time() const
-{
-   return p->time_;
-}
-
-void NexradFileRequest::set_nexrad_file(
-   std::shared_ptr<wsr88d::NexradFile> nexradFile)
-{
-   p->nexradFile_ = nexradFile;
-}
-
-void NexradFileRequest::set_radar_id(const std::string& radarId)
-{
-   p->radarId_ = radarId;
-}
-
-void NexradFileRequest::set_site_id(const std::string& siteId)
-{
-   p->siteId_ = siteId;
-}
-
-void NexradFileRequest::set_time(std::chrono::system_clock::time_point time)
-{
-   p->time_ = time;
+   p->radarProductRecord_ = record;
 }
 
 } // namespace request

scwx-qt/source/scwx/qt/request/nexrad_file_request.hpp

@@ -1,8 +1,7 @@
 #pragma once
 
-#include <scwx/wsr88d/nexrad_file.hpp>
+#include <scwx/qt/types/radar_product_record.hpp>
 
-#include <chrono>
 #include <memory>
 
 #include <QObject>
@@ -24,15 +23,10 @@ public:
    explicit NexradFileRequest();
    ~NexradFileRequest();
 
-   std::shared_ptr<wsr88d::NexradFile>   nexrad_file() const;
-   std::string                           radar_id() const;
-   std::string                           site_id() const;
-   std::chrono::system_clock::time_point time() const;
+   std::shared_ptr<types::RadarProductRecord> radar_product_record() const;
 
-   void set_nexrad_file(std::shared_ptr<wsr88d::NexradFile> nexradFile);
-   void set_radar_id(const std::string& radarId);
-   void set_site_id(const std::string& siteId);
-   void set_time(std::chrono::system_clock::time_point time);
+   void
+   set_radar_product_record(std::shared_ptr<types::RadarProductRecord> record);
 
 private:
    std::unique_ptr<NexradFileRequestImpl> p;

scwx-qt/source/scwx/qt/types/radar_product_record.cpp

@@ -0,0 +1,148 @@
+#include <scwx/qt/types/radar_product_record.hpp>
+#include <scwx/qt/config/radar_site.hpp>
+#include <scwx/common/sites.hpp>
+#include <scwx/util/time.hpp>
+
+#include <boost/log/trivial.hpp>
+
+namespace scwx
+{
+namespace qt
+{
+namespace types
+{
+
+static const std::string logPrefix_ =
+   "[scwx::qt::types::radar_product_record] ";
+
+class RadarProductRecordImpl
+{
+public:
+   explicit RadarProductRecordImpl(
+      std::shared_ptr<wsr88d::NexradFile> nexradFile) :
+       nexradFile_ {nexradFile},
+       radarId_ {"????"},
+       radarProduct_ {"???"},
+       radarProductGroup_ {common::RadarProductGroup::Unknown},
+       siteId_ {"???"},
+       time_ {util::TimePoint(0, 0)}
+   {
+   }
+
+   ~RadarProductRecordImpl() {}
+
+   std::shared_ptr<wsr88d::NexradFile>   nexradFile_;
+   std::string                           radarId_;
+   std::string                           radarProduct_;
+   common::RadarProductGroup             radarProductGroup_;
+   std::string                           siteId_;
+   std::chrono::system_clock::time_point time_;
+};
+
+RadarProductRecord::RadarProductRecord(
+   std::shared_ptr<wsr88d::NexradFile> nexradFile) :
+    p(std::make_unique<RadarProductRecordImpl>(nexradFile))
+{
+   std::shared_ptr<wsr88d::Ar2vFile>   level2File = level2_file();
+   std::shared_ptr<wsr88d::Level3File> level3File = level3_file();
+
+   uint16_t julianDate   = 0;
+   uint32_t milliseconds = 0;
+
+   std::chrono::system_clock::time_point time;
+
+   if (level2File != nullptr)
+   {
+      p->radarProductGroup_ = common::RadarProductGroup::Level2;
+      p->radarId_           = level2File->icao();
+      p->siteId_            = common::GetSiteId(p->radarId_);
+      julianDate            = level2File->julian_date();
+      milliseconds          = level2File->milliseconds();
+   }
+   else if (level3File != nullptr)
+   {
+      p->radarProductGroup_ = common::RadarProductGroup::Level3;
+      p->radarProduct_      = level3File->wmo_header()->product_category();
+      p->siteId_            = level3File->wmo_header()->product_designator();
+      p->radarId_           = config::GetRadarIdFromSiteId(p->siteId_);
+
+      auto descriptionBlock = level3File->message()->description_block();
+
+      if (descriptionBlock != nullptr)
+      {
+         julianDate   = descriptionBlock->volume_scan_date();
+         milliseconds = descriptionBlock->volume_scan_start_time() * 1000u;
+      }
+      else
+      {
+         julianDate = level3File->message()->header().date_of_message();
+         milliseconds =
+            level3File->message()->header().time_of_message() * 1000u;
+      }
+   }
+
+   time = util::TimePoint(julianDate, milliseconds);
+}
+
+RadarProductRecord::~RadarProductRecord() = default;
+
+RadarProductRecord::RadarProductRecord(RadarProductRecord&&) noexcept = default;
+RadarProductRecord&
+RadarProductRecord::operator=(RadarProductRecord&&) noexcept = default;
+
+std::shared_ptr<wsr88d::Ar2vFile> RadarProductRecord::level2_file() const
+{
+   return std::dynamic_pointer_cast<wsr88d::Ar2vFile>(p->nexradFile_);
+}
+
+std::shared_ptr<wsr88d::Level3File> RadarProductRecord::level3_file() const
+{
+   return std::dynamic_pointer_cast<wsr88d::Level3File>(p->nexradFile_);
+}
+
+std::shared_ptr<wsr88d::NexradFile> RadarProductRecord::nexrad_file() const
+{
+   return p->nexradFile_;
+}
+
+std::string RadarProductRecord::radar_id() const
+{
+   return p->radarId_;
+}
+
+std::string RadarProductRecord::radar_product() const
+{
+   return p->radarProduct_;
+}
+
+common::RadarProductGroup RadarProductRecord::radar_product_group() const
+{
+   return p->radarProductGroup_;
+}
+
+std::string RadarProductRecord::site_id() const
+{
+   return p->siteId_;
+}
+
+std::chrono::system_clock::time_point RadarProductRecord::time() const
+{
+   return p->time_;
+}
+
+std::shared_ptr<RadarProductRecord>
+RadarProductRecord::Create(std::shared_ptr<wsr88d::NexradFile> nexradFile)
+{
+   std::shared_ptr<RadarProductRecord> record = nullptr;
+
+   if (nexradFile != nullptr)
+   {
+      record = std::make_shared<RadarProductRecord>(nexradFile);
+   }
+
+   return record;
+}
+
+} // namespace types
+} // namespace qt
+} // namespace scwx

scwx-qt/source/scwx/qt/types/radar_product_record.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <scwx/common/products.hpp>
+#include <scwx/wsr88d/ar2v_file.hpp>
+#include <scwx/wsr88d/level3_file.hpp>
+
+#include <chrono>
+#include <memory>
+
+namespace scwx
+{
+namespace qt
+{
+namespace types
+{
+
+class RadarProductRecordImpl;
+
+class RadarProductRecord
+{
+public:
+   explicit RadarProductRecord(std::shared_ptr<wsr88d::NexradFile> nexradFile);
+   ~RadarProductRecord();
+
+   RadarProductRecord(const RadarProductRecord&) = delete;
+   RadarProductRecord& operator=(const RadarProductRecord&) = delete;
+
+   RadarProductRecord(RadarProductRecord&&) noexcept;
+   RadarProductRecord& operator=(RadarProductRecord&&) noexcept;
+
+   std::shared_ptr<wsr88d::Ar2vFile>     level2_file() const;
+   std::shared_ptr<wsr88d::Level3File>   level3_file() const;
+   std::shared_ptr<wsr88d::NexradFile>   nexrad_file() const;
+   std::string                           radar_id() const;
+   std::string                           radar_product() const;
+   common::RadarProductGroup             radar_product_group() const;
+   std::string                           site_id() const;
+   std::chrono::system_clock::time_point time() const;
+
+   static std::shared_ptr<RadarProductRecord>
+   Create(std::shared_ptr<wsr88d::NexradFile> nexradFile);
+
+private:
+   std::unique_ptr<RadarProductRecordImpl> p;
+};
+
+} // namespace types
+} // namespace qt
+} // namespace scwx