rename files to marker instead of poi

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

@@ -0,0 +1,276 @@
+#include <scwx/qt/manager/poi_manager.hpp>
+#include <scwx/qt/types/poi_types.hpp>
+#include <scwx/qt/util/json.hpp>
+#include <scwx/qt/main/application.hpp>
+#include <scwx/util/logger.hpp>
+
+#include <filesystem>
+#include <vector>
+#include <string>
+
+#include <QStandardPaths>
+#include <boost/json.hpp>
+
+namespace scwx
+{
+namespace qt
+{
+namespace manager
+{
+
+static const std::string logPrefix_ = "scwx::qt::manager::poi_manager";
+static const auto        logger_    = scwx::util::Logger::Create(logPrefix_);
+
+static const std::string kNameName_      = "name";
+static const std::string kLatitudeName_  = "latitude";
+static const std::string kLongitudeName_ = "longitude";
+
+class POIManager::Impl
+{
+public:
+   class POIRecord;
+
+   explicit Impl(POIManager* self) : self_ {self} {}
+   ~Impl() {}
+
+   std::string poiSettingsPath_ {};
+   std::vector<std::shared_ptr<POIRecord>> poiRecords_ {};
+
+   POIManager* self_;
+
+   void InitializePOISettings();
+   void ReadPOISettings();
+   void WritePOISettings();
+   std::shared_ptr<POIRecord> GetPOIByName(const std::string& name);
+
+};
+
+class POIManager::Impl::POIRecord
+{
+public:
+   POIRecord(std::string name, double latitude, double longitude) :
+       name_ {name}, latitude_ {latitude}, longitude_ {longitude}
+   {
+   }
+
+   std::string name_;
+   double      latitude_;
+   double      longitude_;
+
+   friend void tag_invoke(boost::json::value_from_tag,
+                          boost::json::value&                     jv,
+                          const std::shared_ptr<POIRecord>& record)
+   {
+      jv = {{kNameName_, record->name_},
+            {kLatitudeName_, record->latitude_},
+            {kLongitudeName_, record->longitude_}};
+   }
+
+   friend POIRecord tag_invoke(boost::json::value_to_tag<POIRecord>,
+                                     const boost::json::value& jv)
+   {
+      return POIRecord(
+         boost::json::value_to<std::string>(jv.at(kNameName_)),
+         boost::json::value_to<double>(jv.at(kLatitudeName_)),
+         boost::json::value_to<double>(jv.at(kLongitudeName_)));
+   }
+};
+
+
+void POIManager::Impl::InitializePOISettings()
+{
+   std::string appDataPath {
+      QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)
+         .toStdString()};
+
+   if (!std::filesystem::exists(appDataPath))
+   {
+      if (!std::filesystem::create_directories(appDataPath))
+      {
+         logger_->error("Unable to create application data directory: \"{}\"",
+                        appDataPath);
+      }
+   }
+
+   poiSettingsPath_ = appDataPath + "/points_of_interest.json";
+}
+
+void POIManager::Impl::ReadPOISettings()
+{
+   logger_->info("Reading point of interest settings");
+
+   boost::json::value poiJson = nullptr;
+
+   // Determine if poi settings exists
+   if (std::filesystem::exists(poiSettingsPath_))
+   {
+      poiJson = util::json::ReadJsonFile(poiSettingsPath_);
+   }
+
+   if (poiJson != nullptr && poiJson.is_array())
+   {
+      // For each poi entry
+      auto& poiArray = poiJson.as_array();
+      poiRecords_.reserve(poiArray.size());
+      for (auto& poiEntry : poiArray)
+      {
+         try
+         {
+            POIRecord record =
+               boost::json::value_to<POIRecord>(poiEntry);
+
+            if (!record.name_.empty())
+            {
+               poiRecords_.emplace_back(std::make_shared<POIRecord>(
+                  record.name_, record.latitude_, record.longitude_));
+            }
+         }
+         catch (const std::exception& ex)
+         {
+            logger_->warn("Invalid point of interest entry: {}", ex.what());
+         }
+      }
+
+      logger_->debug("{} point of interest entries", poiRecords_.size());
+   }
+}
+
+void POIManager::Impl::WritePOISettings()
+{
+   logger_->info("Saving point of interest settings");
+
+   auto poiJson = boost::json::value_from(poiRecords_);
+   util::json::WriteJsonFile(poiSettingsPath_, poiJson);
+}
+
+std::shared_ptr<POIManager::Impl::POIRecord>
+POIManager::Impl::GetPOIByName(const std::string& name)
+{
+   for (auto& poiRecord : poiRecords_)
+   {
+      if (poiRecord->name_ == name)
+      {
+         return poiRecord;
+      }
+   }
+
+   return nullptr;
+}
+
+POIManager::POIManager() : p(std::make_unique<Impl>(this))
+{
+   // TODO THREADING?
+   try
+   {
+      p->InitializePOISettings();
+
+      // Read POI settings on startup
+      //main::Application::WaitForInitialization();
+      p->ReadPOISettings();
+   }
+   catch (const std::exception& ex)
+   {
+      logger_->error(ex.what());
+   }
+}
+
+POIManager::~POIManager()
+{
+   p->WritePOISettings();
+}
+
+size_t POIManager::poi_count()
+{
+   return p->poiRecords_.size();
+}
+
+// TODO deal with out of range/not found
+types::PointOfInterest POIManager::get_poi(size_t index)
+{
+   std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
+      p->poiRecords_[index];
+   return types::PointOfInterest(
+      poiRecord->name_, poiRecord->latitude_, poiRecord->longitude_);
+}
+
+types::PointOfInterest POIManager::get_poi(const std::string& name)
+{
+   std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
+      p->GetPOIByName(name);
+   return types::PointOfInterest(
+      poiRecord->name_, poiRecord->latitude_, poiRecord->longitude_);
+}
+
+void POIManager::set_poi(size_t index, const types::PointOfInterest& poi)
+{
+   std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
+      p->poiRecords_[index];
+   poiRecord->name_      = poi.name_;
+   poiRecord->latitude_  = poi.latitude_;
+   poiRecord->longitude_ = poi.longitude_;
+}
+
+void POIManager::set_poi(const std::string&            name,
+                         const types::PointOfInterest& poi)
+{
+   std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
+      p->GetPOIByName(name);
+   poiRecord->name_      = poi.name_;
+   poiRecord->latitude_  = poi.latitude_;
+   poiRecord->longitude_ = poi.longitude_;
+}
+
+void POIManager::add_poi(const types::PointOfInterest& poi)
+{
+   p->poiRecords_.emplace_back(std::make_shared<Impl::POIRecord>(
+      poi.name_, poi.latitude_, poi.longitude_));
+}
+
+void POIManager::move_poi(size_t from, size_t to)
+{
+   if (from >= p->poiRecords_.size() || to >= p->poiRecords_.size())
+   {
+      return;
+   }
+   std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
+      p->poiRecords_[from];
+
+   if (from == to)
+   {
+   }
+   else if (from < to)
+   {
+      for (size_t i = from; i < to; i++)
+      {
+         p->poiRecords_[i] = p->poiRecords_[i + 1];
+      }
+      p->poiRecords_[to] = poiRecord;
+   }
+   else
+   {
+      for (size_t i = from; i > to; i--)
+      {
+         p->poiRecords_[i] = p->poiRecords_[i - 1];
+      }
+      p->poiRecords_[to] = poiRecord;
+   }
+}
+
+std::shared_ptr<POIManager> POIManager::Instance()
+{
+   static std::weak_ptr<POIManager> poiManagerReference_ {};
+
+   std::shared_ptr<POIManager> poiManager = poiManagerReference_.lock();
+
+   if (poiManager == nullptr)
+   {
+      poiManager = std::make_shared<POIManager>();
+      poiManagerReference_ = poiManager;
+   }
+
+   return poiManager;
+}
+
+} // namespace manager
+} // namespace qt
+} // namespace scwx