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

renamed all POI/point of intrest to marker

Browse source
This commit is contained in:
AdenKoperczak 2024-10-04 19:31:47 -04:00
parent cd16902635
commit 31940441ed
11 changed files with 153 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

188
scwx-qt/source/scwx/qt/manager/marker_manager.cpp
View file

@ -1,5 +1,5 @@
#include <scwx/qt/manager/poi_manager.hpp>
#include <scwx/qt/types/poi_types.hpp>
#include <scwx/qt/manager/marker_manager.hpp>
#include <scwx/qt/types/marker_types.hpp>
#include <scwx/qt/util/json.hpp>
#include <scwx/qt/main/application.hpp>
#include <scwx/util/logger.hpp>
@ -18,37 +18,37 @@ namespace qt
namespace manager
{
static const std::string logPrefix_ = "scwx::qt::manager::poi_manager";
static const std::string logPrefix_ = "scwx::qt::manager::marker_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
class MarkerManager::Impl
{
public:
class POIRecord;
class MarkerRecord;
explicit Impl(POIManager* self) : self_ {self} {}
explicit Impl(MarkerManager* self) : self_ {self} {}
~Impl() {}
std::string poiSettingsPath_ {};
std::vector<std::shared_ptr<POIRecord>> poiRecords_ {};
std::string markerSettingsPath_ {};
std::vector<std::shared_ptr<MarkerRecord>> markerRecords_ {};
POIManager* self_;
MarkerManager* self_;
void InitializePOISettings();
void ReadPOISettings();
void WritePOISettings();
std::shared_ptr<POIRecord> GetPOIByName(const std::string& name);
void InitializeMarkerSettings();
void ReadMarkerSettings();
void WriteMarkerSettings();
std::shared_ptr<MarkerRecord> GetMarkerByName(const std::string& name);
};
class POIManager::Impl::POIRecord
class MarkerManager::Impl::MarkerRecord
{
public:
POIRecord(std::string name, double latitude, double longitude) :
MarkerRecord(std::string name, double latitude, double longitude) :
name_ {name}, latitude_ {latitude}, longitude_ {longitude}
{
}
@ -59,17 +59,17 @@ public:
friend void tag_invoke(boost::json::value_from_tag,
boost::json::value& jv,
const std::shared_ptr<POIRecord>& record)
const std::shared_ptr<MarkerRecord>& record)
{
jv = {{kNameName_, record->name_},
{kLatitudeName_, record->latitude_},
{kLongitudeName_, record->longitude_}};
}
friend POIRecord tag_invoke(boost::json::value_to_tag<POIRecord>,
friend MarkerRecord tag_invoke(boost::json::value_to_tag<MarkerRecord>,
const boost::json::value& jv)
{
return POIRecord(
return MarkerRecord(
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_)));
@ -77,7 +77,7 @@ public:
};
void POIManager::Impl::InitializePOISettings()
void MarkerManager::Impl::InitializeMarkerSettings()
{
std::string appDataPath {
QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)
@ -92,81 +92,81 @@ void POIManager::Impl::InitializePOISettings()
}
}
poiSettingsPath_ = appDataPath + "/points_of_interest.json";
markerSettingsPath_ = appDataPath + "/location-markers.json";
}
void POIManager::Impl::ReadPOISettings()
void MarkerManager::Impl::ReadMarkerSettings()
{
logger_->info("Reading point of interest settings");
logger_->info("Reading location marker settings");
boost::json::value poiJson = nullptr;
boost::json::value markerJson = nullptr;
// Determine if poi settings exists
if (std::filesystem::exists(poiSettingsPath_))
// Determine if marker settings exists
if (std::filesystem::exists(markerSettingsPath_))
{
poiJson = util::json::ReadJsonFile(poiSettingsPath_);
markerJson = util::json::ReadJsonFile(markerSettingsPath_);
}
if (poiJson != nullptr && poiJson.is_array())
if (markerJson != nullptr && markerJson.is_array())
{
// For each poi entry
auto& poiArray = poiJson.as_array();
poiRecords_.reserve(poiArray.size());
for (auto& poiEntry : poiArray)
// For each marker entry
auto& markerArray = markerJson.as_array();
markerRecords_.reserve(markerArray.size());
for (auto& markerEntry : markerArray)
{
try
{
POIRecord record =
boost::json::value_to<POIRecord>(poiEntry);
MarkerRecord record =
boost::json::value_to<MarkerRecord>(markerEntry);
if (!record.name_.empty())
{
poiRecords_.emplace_back(std::make_shared<POIRecord>(
markerRecords_.emplace_back(std::make_shared<MarkerRecord>(
record.name_, record.latitude_, record.longitude_));
}
}
catch (const std::exception& ex)
{
logger_->warn("Invalid point of interest entry: {}", ex.what());
logger_->warn("Invalid location marker entry: {}", ex.what());
}
}
logger_->debug("{} point of interest entries", poiRecords_.size());
logger_->debug("{} location marker entries", markerRecords_.size());
}
}
void POIManager::Impl::WritePOISettings()
void MarkerManager::Impl::WriteMarkerSettings()
{
logger_->info("Saving point of interest settings");
logger_->info("Saving location marker settings");
auto poiJson = boost::json::value_from(poiRecords_);
util::json::WriteJsonFile(poiSettingsPath_, poiJson);
auto markerJson = boost::json::value_from(markerRecords_);
util::json::WriteJsonFile(markerSettingsPath_, markerJson);
}
std::shared_ptr<POIManager::Impl::POIRecord>
POIManager::Impl::GetPOIByName(const std::string& name)
std::shared_ptr<MarkerManager::Impl::MarkerRecord>
MarkerManager::Impl::GetMarkerByName(const std::string& name)
{
for (auto& poiRecord : poiRecords_)
for (auto& markerRecord : markerRecords_)
{
if (poiRecord->name_ == name)
if (markerRecord->name_ == name)
{
return poiRecord;
return markerRecord;
}
}
return nullptr;
}
POIManager::POIManager() : p(std::make_unique<Impl>(this))
MarkerManager::MarkerManager() : p(std::make_unique<Impl>(this))
{
// TODO THREADING?
try
{
p->InitializePOISettings();
p->InitializeMarkerSettings();
// Read POI settings on startup
// Read Marker settings on startup
//main::Application::WaitForInitialization();
p->ReadPOISettings();
p->ReadMarkerSettings();
}
catch (const std::exception& ex)
{
@ -174,66 +174,66 @@ POIManager::POIManager() : p(std::make_unique<Impl>(this))
}
}
POIManager::~POIManager()
MarkerManager::~MarkerManager()
{
p->WritePOISettings();
p->WriteMarkerSettings();
}
size_t POIManager::poi_count()
size_t MarkerManager::marker_count()
{
return p->poiRecords_.size();
return p->markerRecords_.size();
}
// TODO deal with out of range/not found
types::PointOfInterest POIManager::get_poi(size_t index)
types::MarkerInfo MarkerManager::get_marker(size_t index)
{
std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
p->poiRecords_[index];
return types::PointOfInterest(
poiRecord->name_, poiRecord->latitude_, poiRecord->longitude_);
std::shared_ptr<MarkerManager::Impl::MarkerRecord> markerRecord =
p->markerRecords_[index];
return types::MarkerInfo(
markerRecord->name_, markerRecord->latitude_, markerRecord->longitude_);
}
types::PointOfInterest POIManager::get_poi(const std::string& name)
types::MarkerInfo MarkerManager::get_marker(const std::string& name)
{
std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
p->GetPOIByName(name);
return types::PointOfInterest(
poiRecord->name_, poiRecord->latitude_, poiRecord->longitude_);
std::shared_ptr<MarkerManager::Impl::MarkerRecord> markerRecord =
p->GetMarkerByName(name);
return types::MarkerInfo(
markerRecord->name_, markerRecord->latitude_, markerRecord->longitude_);
}
void POIManager::set_poi(size_t index, const types::PointOfInterest& poi)
void MarkerManager::set_marker(size_t index, const types::MarkerInfo& marker)
{
std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
p->poiRecords_[index];
poiRecord->name_ = poi.name_;
poiRecord->latitude_ = poi.latitude_;
poiRecord->longitude_ = poi.longitude_;
std::shared_ptr<MarkerManager::Impl::MarkerRecord> markerRecord =
p->markerRecords_[index];
markerRecord->name_ = marker.name_;
markerRecord->latitude_ = marker.latitude_;
markerRecord->longitude_ = marker.longitude_;
}
void POIManager::set_poi(const std::string& name,
const types::PointOfInterest& poi)
void MarkerManager::set_marker(const std::string& name,
const types::MarkerInfo& marker)
{
std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
p->GetPOIByName(name);
poiRecord->name_ = poi.name_;
poiRecord->latitude_ = poi.latitude_;
poiRecord->longitude_ = poi.longitude_;
std::shared_ptr<MarkerManager::Impl::MarkerRecord> markerRecord =
p->GetMarkerByName(name);
markerRecord->name_ = marker.name_;
markerRecord->latitude_ = marker.latitude_;
markerRecord->longitude_ = marker.longitude_;
}
void POIManager::add_poi(const types::PointOfInterest& poi)
void MarkerManager::add_marker(const types::MarkerInfo& marker)
{
p->poiRecords_.emplace_back(std::make_shared<Impl::POIRecord>(
poi.name_, poi.latitude_, poi.longitude_));
p->markerRecords_.emplace_back(std::make_shared<Impl::MarkerRecord>(
marker.name_, marker.latitude_, marker.longitude_));
}
void POIManager::move_poi(size_t from, size_t to)
void MarkerManager::move_marker(size_t from, size_t to)
{
if (from >= p->poiRecords_.size() || to >= p->poiRecords_.size())
if (from >= p->markerRecords_.size() || to >= p->markerRecords_.size())
{
return;
}
std::shared_ptr<POIManager::Impl::POIRecord> poiRecord =
p->poiRecords_[from];
std::shared_ptr<MarkerManager::Impl::MarkerRecord> markerRecord =
p->markerRecords_[from];
if (from == to)
{
@ -242,33 +242,33 @@ void POIManager::move_poi(size_t from, size_t to)
{
for (size_t i = from; i < to; i++)
{
p->poiRecords_[i] = p->poiRecords_[i + 1];
p->markerRecords_[i] = p->markerRecords_[i + 1];
}
p->poiRecords_[to] = poiRecord;
p->markerRecords_[to] = markerRecord;
}
else
{
for (size_t i = from; i > to; i--)
{
p->poiRecords_[i] = p->poiRecords_[i - 1];
p->markerRecords_[i] = p->markerRecords_[i - 1];
}
p->poiRecords_[to] = poiRecord;
p->markerRecords_[to] = markerRecord;
}
}
std::shared_ptr<POIManager> POIManager::Instance()
std::shared_ptr<MarkerManager> MarkerManager::Instance()
{
static std::weak_ptr<POIManager> poiManagerReference_ {};
static std::weak_ptr<MarkerManager> markerManagerReference_ {};
std::shared_ptr<POIManager> poiManager = poiManagerReference_.lock();
std::shared_ptr<MarkerManager> markerManager = markerManagerReference_.lock();
if (poiManager == nullptr)
if (markerManager == nullptr)
{
poiManager = std::make_shared<POIManager>();
poiManagerReference_ = poiManager;
markerManager = std::make_shared<MarkerManager>();
markerManagerReference_ = markerManager;
}
return poiManager;
return markerManager;
}
} // namespace manager

24
scwx-qt/source/scwx/qt/manager/marker_manager.hpp
View file

@ -1,6 +1,6 @@
#pragma once
#include <scwx/qt/types/poi_types.hpp>
#include <scwx/qt/types/marker_types.hpp>
#include <string>
@ -13,23 +13,23 @@ namespace qt
namespace manager
{
class POIManager : public QObject
class MarkerManager : public QObject
{
Q_OBJECT
public:
explicit POIManager();
~POIManager();
explicit MarkerManager();
~MarkerManager();
size_t poi_count();
types::PointOfInterest get_poi(size_t index);
types::PointOfInterest get_poi(const std::string& name);
void set_poi(size_t index, const types::PointOfInterest& poi);
void set_poi(const std::string& name, const types::PointOfInterest& poi);
void add_poi(const types::PointOfInterest& poi);
void move_poi(size_t from, size_t to);
size_t marker_count();
types::MarkerInfo get_marker(size_t index);
types::MarkerInfo get_marker(const std::string& name);
void set_marker(size_t index, const types::MarkerInfo& marker);
void set_marker(const std::string& name, const types::MarkerInfo& marker);
void add_marker(const types::MarkerInfo& marker);
void move_marker(size_t from, size_t to);
static std::shared_ptr<POIManager> Instance();
static std::shared_ptr<MarkerManager> Instance();
private:
class Impl;