Adding map settings

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

@@ -20,7 +20,12 @@ namespace SettingsManager
 static const std::string logPrefix_ = "scwx::qt::manager::settings_manager";
 static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
 
+static const std::string kGeneralKey = "general";
+static const std::string kMapKey     = "maps";
+static const std::string kPaletteKey = "palette";
+
 static std::shared_ptr<settings::GeneralSettings> generalSettings_ = nullptr;
+static std::shared_ptr<settings::MapSettings>     mapSettings_     = nullptr;
 static std::shared_ptr<settings::PaletteSettings> paletteSettings_ = nullptr;
 
 static boost::json::value ConvertSettingsToJson();
@@ -79,6 +84,11 @@ std::shared_ptr<settings::GeneralSettings> general_settings()
    return generalSettings_;
 }
 
+std::shared_ptr<settings::MapSettings> map_settings()
+{
+   return mapSettings_;
+}
+
 std::shared_ptr<settings::PaletteSettings> palette_settings()
 {
    return paletteSettings_;
@@ -88,8 +98,9 @@ static boost::json::value ConvertSettingsToJson()
 {
    boost::json::object settingsJson;
 
-   settingsJson["general"] = generalSettings_->ToJson();
-   settingsJson["palette"] = paletteSettings_->ToJson();
+   settingsJson[kGeneralKey] = generalSettings_->ToJson();
+   settingsJson[kMapKey]     = mapSettings_->ToJson();
+   settingsJson[kPaletteKey] = paletteSettings_->ToJson();
 
    return settingsJson;
 }
@@ -99,6 +110,7 @@ static void GenerateDefaultSettings()
    logger_->info("Generating default settings");
 
    generalSettings_ = settings::GeneralSettings::Create();
+   mapSettings_     = settings::MapSettings::Create();
    paletteSettings_ = settings::PaletteSettings::Create();
 }
 
@@ -109,9 +121,11 @@ static bool LoadSettings(const boost::json::object& settingsJson)
    bool jsonDirty = false;
 
    generalSettings_ = settings::GeneralSettings::Load(
-      settingsJson.if_contains("general"), jsonDirty);
+      settingsJson.if_contains(kGeneralKey), jsonDirty);
+   mapSettings_ =
+      settings::MapSettings::Load(settingsJson.if_contains(kMapKey), jsonDirty);
    paletteSettings_ = settings::PaletteSettings::Load(
-      settingsJson.if_contains("palette"), jsonDirty);
+      settingsJson.if_contains(kPaletteKey), jsonDirty);
 
    return jsonDirty;
 }

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <scwx/qt/settings/general_settings.hpp>
+#include <scwx/qt/settings/map_settings.hpp>
 #include <scwx/qt/settings/palette_settings.hpp>
 
 namespace scwx
@@ -16,6 +17,7 @@ void Initialize();
 void ReadSettings(const std::string& settingsPath);
 
 std::shared_ptr<settings::GeneralSettings> general_settings();
+std::shared_ptr<settings::MapSettings>     map_settings();
 std::shared_ptr<settings::PaletteSettings> palette_settings();
 
 } // namespace SettingsManager

scwx-qt/source/scwx/qt/settings/map_settings.cpp

@@ -0,0 +1,222 @@
+#include <scwx/qt/settings/map_settings.hpp>
+#include <scwx/qt/config/radar_site.hpp>
+#include <scwx/qt/util/json.hpp>
+#include <scwx/common/products.hpp>
+#include <scwx/util/logger.hpp>
+
+#include <array>
+#include <execution>
+
+namespace scwx
+{
+namespace qt
+{
+namespace settings
+{
+
+static const std::string logPrefix_ = "scwx::qt::settings::map_settings";
+static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
+
+static constexpr size_t  kCount_                    = 4u;
+static const std::string kDefaultRadarSite_         = "KLSX";
+static const std::string kDefaultRadarProductGroup_ = "L3";
+
+static const std::array<std::string, kCount_> kDefaultRadarProduct_ {
+   "N0B", "N0G", "N0C", "N0X"};
+
+class MapSettingsImpl
+{
+public:
+   struct MapData
+   {
+      std::string radarSite_;
+      std::string radarProductGroup_;
+      std::string radarProduct_;
+   };
+
+   explicit MapSettingsImpl() { SetDefaults(); }
+
+   ~MapSettingsImpl() {}
+
+   void SetDefaults(size_t i)
+   {
+      map_[i].radarSite_         = kDefaultRadarSite_;
+      map_[i].radarProductGroup_ = kDefaultRadarProductGroup_;
+      map_[i].radarProduct_      = kDefaultRadarProduct_[i];
+   }
+
+   void SetDefaults()
+   {
+      for (size_t i = 0; i < kCount_; i++)
+      {
+         SetDefaults(i);
+      }
+   }
+
+   std::array<MapData, kCount_> map_;
+};
+
+MapSettings::MapSettings() : p(std::make_unique<MapSettingsImpl>()) {}
+MapSettings::~MapSettings() = default;
+
+MapSettings::MapSettings(MapSettings&&) noexcept = default;
+MapSettings& MapSettings::operator=(MapSettings&&) noexcept = default;
+
+size_t MapSettings::count() const
+{
+   return kCount_;
+}
+
+std::string MapSettings::radar_site(size_t i) const
+{
+   return p->map_[i].radarSite_;
+}
+
+std::string MapSettings::radar_product_group(size_t i) const
+{
+   return p->map_[i].radarProductGroup_;
+}
+
+std::string MapSettings::radar_product(size_t i) const
+{
+   return p->map_[i].radarProduct_;
+}
+
+boost::json::value MapSettings::ToJson() const
+{
+   boost::json::value json;
+
+   json = boost::json::value_from(p->map_);
+
+   return json;
+}
+
+std::shared_ptr<MapSettings> MapSettings::Create()
+{
+   std::shared_ptr<MapSettings> generalSettings =
+      std::make_shared<MapSettings>();
+
+   generalSettings->p->SetDefaults();
+
+   return generalSettings;
+}
+
+std::shared_ptr<MapSettings> MapSettings::Load(const boost::json::value* json,
+                                               bool& jsonDirty)
+{
+   std::shared_ptr<MapSettings> mapSettings = std::make_shared<MapSettings>();
+
+   if (json != nullptr && json->is_array())
+   {
+      const boost::json::array& mapArray = json->as_array();
+
+      for (size_t i = 0; i < kCount_; ++i)
+      {
+         if (i < mapArray.size() && mapArray.at(i).is_object())
+         {
+            const boost::json::object& mapRecord = mapArray.at(i).as_object();
+            MapSettingsImpl::MapData&  mapRecordSettings =
+               mapSettings->p->map_[i];
+
+            // Load JSON Elements
+            jsonDirty |=
+               !util::json::FromJsonString(mapRecord,
+                                           "radar_site",
+                                           mapRecordSettings.radarSite_,
+                                           kDefaultRadarSite_);
+            jsonDirty |=
+               !util::json::FromJsonString(mapRecord,
+                                           "radar_product_group",
+                                           mapRecordSettings.radarProductGroup_,
+                                           kDefaultRadarSite_);
+            jsonDirty |=
+               !util::json::FromJsonString(mapRecord,
+                                           "radar_product",
+                                           mapRecordSettings.radarProduct_,
+                                           kDefaultRadarSite_);
+
+            // Validate Radar Site
+            if (config::RadarSite::Get(mapRecordSettings.radarSite_) == nullptr)
+            {
+               mapRecordSettings.radarSite_ = kDefaultRadarSite_;
+               jsonDirty                    = true;
+            }
+
+            // Validate Radar Product Group
+            common::RadarProductGroup radarProductGroup =
+               common::GetRadarProductGroup(
+                  mapRecordSettings.radarProductGroup_);
+            if (radarProductGroup == common::RadarProductGroup::Unknown)
+            {
+               mapRecordSettings.radarProductGroup_ =
+                  kDefaultRadarProductGroup_;
+               radarProductGroup =
+                  common::GetRadarProductGroup(kDefaultRadarProductGroup_);
+               jsonDirty = true;
+            }
+
+            // Validate Radar Product
+            if (radarProductGroup == common::RadarProductGroup::Level2 &&
+                common::GetLevel2Product(mapRecordSettings.radarProduct_) ==
+                   common::Level2Product::Unknown)
+            {
+               mapRecordSettings.radarProductGroup_ =
+                  kDefaultRadarProductGroup_;
+               mapRecordSettings.radarProduct_ = kDefaultRadarProduct_[i];
+               jsonDirty                       = true;
+            }
+
+            // TODO: Validate level 3 product
+         }
+         else
+         {
+            logger_->warn(
+               "Too few array entries, resetting record {} to defaults", i + 1);
+            jsonDirty = true;
+            mapSettings->p->SetDefaults(i);
+         }
+      }
+   }
+   else
+   {
+      if (json == nullptr)
+      {
+         logger_->warn("Key is not present, resetting to defaults");
+      }
+      else if (!json->is_array())
+      {
+         logger_->warn("Invalid json, resetting to defaults");
+      }
+
+      mapSettings->p->SetDefaults();
+      jsonDirty = true;
+   }
+
+   return mapSettings;
+}
+
+void tag_invoke(boost::json::value_from_tag,
+                boost::json::value&             jv,
+                const MapSettingsImpl::MapData& data)
+{
+   jv = {{"radar_site", data.radarSite_},
+         {"radar_product_group", data.radarProductGroup_},
+         {"radar_product", data.radarProduct_}};
+}
+
+bool operator==(const MapSettings& lhs, const MapSettings& rhs)
+{
+   return (lhs.p->map_ == rhs.p->map_);
+}
+
+bool operator==(const MapSettingsImpl::MapData& lhs,
+                const MapSettingsImpl::MapData& rhs)
+{
+   return (lhs.radarSite_ == rhs.radarSite_ &&
+           lhs.radarProductGroup_ == rhs.radarProductGroup_ &&
+           lhs.radarProduct_ == rhs.radarProduct_);
+}
+
+} // namespace settings
+} // namespace qt
+} // namespace scwx

scwx-qt/source/scwx/qt/settings/map_settings.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <boost/json.hpp>
+
+namespace scwx
+{
+namespace qt
+{
+namespace settings
+{
+
+class MapSettingsImpl;
+
+class MapSettings
+{
+public:
+   explicit MapSettings();
+   ~MapSettings();
+
+   MapSettings(const MapSettings&) = delete;
+   MapSettings& operator=(const MapSettings&) = delete;
+
+   MapSettings(MapSettings&&) noexcept;
+   MapSettings& operator=(MapSettings&&) noexcept;
+
+   size_t      count() const;
+   std::string radar_site(size_t i) const;
+   std::string radar_product_group(size_t i) const;
+   std::string radar_product(size_t i) const;
+
+   boost::json::value ToJson() const;
+
+   static std::shared_ptr<MapSettings> Create();
+   static std::shared_ptr<MapSettings> Load(const boost::json::value* json,
+                                            bool& jsonDirty);
+
+   friend bool operator==(const MapSettings& lhs, const MapSettings& rhs);
+
+private:
+   std::unique_ptr<MapSettingsImpl> p;
+};
+
+} // namespace settings
+} // namespace qt
+} // namespace scwx