more WIP savemanager

13 files changed, 198 insertions, 40 deletions

diff --git a/src/crepe/DB.cpp b/src/crepe/DB.cpp
index b8448a7..b188637 100644
--- a/src/crepe/DB.cpp
+++ b/src/crepe/DB.cpp
@@ -7,7 +7,7 @@
 using namespace std;
 using namespace crepe;
 
-DB::DB(const char * path) {
+DB::DB(const string & path) {
 	dbg_trace();
 	int ret;
 
@@ -18,7 +18,7 @@ DB::DB(const char * path) {
 	this->db = { db, [] (libdb::DB * db) { db->close(db, 0); } };
 
 	// load or create database file
-	if ((ret = this->db->open(this->db.get(), NULL, path, NULL, libdb::DB_BTREE, DB_CREATE, 0)) != 0) {
+	if ((ret = this->db->open(this->db.get(), NULL, path.c_str(), NULL, libdb::DB_BTREE, DB_CREATE, 0)) != 0) {
 		throw nullptr;
 	}
 
diff --git a/src/crepe/DB.h b/src/crepe/DB.h
index 010ef42..c331f95 100644
--- a/src/crepe/DB.h
+++ b/src/crepe/DB.h
@@ -14,7 +14,7 @@ namespace crepe {
 
 class DB {
 public:
-	DB(const char * path);
+	DB(const std::string & path);
 	virtual ~DB() = default;
 
 public:
diff --git a/src/crepe/ValueBroker.h b/src/crepe/ValueBroker.h
index 9d30a2e..c3359a1 100644
--- a/src/crepe/ValueBroker.h
+++ b/src/crepe/ValueBroker.h
@@ -10,14 +10,13 @@ public:
 	virtual void set(const T &);
 	virtual const T & get();
 
-	typedef std::function<void(T & value, const T & target)> setter_t;
-	typedef std::function<const T & (T & value)> getter_t;
+	typedef std::function<void(const T & target)> setter_t;
+	typedef std::function<const T & ()> getter_t;
 private:
-	T & value;
 	setter_t setter;
 	getter_t getter;
 public:
-	ValueBroker(T &, const setter_t &, const getter_t &);
+	ValueBroker(const setter_t &, const getter_t &);
 	ValueBroker(T &);
 };
 
diff --git a/src/crepe/ValueBroker.hpp b/src/crepe/ValueBroker.hpp
index ef31c17..61f7f6c 100644
--- a/src/crepe/ValueBroker.hpp
+++ b/src/crepe/ValueBroker.hpp
@@ -8,19 +8,17 @@ namespace crepe {
 
 template <typename T>
 ValueBroker<T>::ValueBroker(T & value) :
-	value(value),
-	setter([] (T & value, const T & target) {
+	setter([&value] (const T & target) {
 		value = std::move(target);
 	}),
-	getter([] (T & value) -> const int & {
+	getter([&value] () -> const int & {
 		return value;
 	})
 	{
 }
 
 template <typename T>
-ValueBroker<T>::ValueBroker(T & value, const setter_t & setter, const getter_t & getter) :
-	value(value),
+ValueBroker<T>::ValueBroker(const setter_t & setter, const getter_t & getter) :
 	setter(setter),
 	getter(getter)
 	{
@@ -28,12 +26,12 @@ ValueBroker<T>::ValueBroker(T & value, const setter_t & setter, const getter_t &
 
 template <typename T>
 const T & ValueBroker<T>::get() {
-	return this->getter(this->value);
+	return this->getter();
 }
 
 template <typename T>
 void ValueBroker<T>::set(const T & value) {
-	this->setter(this->value, value);
+	this->setter(value);
 }
 
 }
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 97bc6b1..abc96ab 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -30,5 +30,4 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	AssetManager.h 
 	AssetManager.hpp
 	SaveManager.h
-	SaveManager.hpp
 )
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 8a7f268..aef4d54 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -35,6 +35,11 @@ public:
 		 */
 		bool color = true;
 	} log;
+
+	//! Save manager
+	struct {
+		std::string location = "save.crepe.db";
+	} savemgr;
 };
 
 } // namespace crepe::api
diff --git a/src/crepe/api/SaveManager.cpp b/src/crepe/api/SaveManager.cpp
index 83ff0fa..87e634b 100644
--- a/src/crepe/api/SaveManager.cpp
+++ b/src/crepe/api/SaveManager.cpp
@@ -1,15 +1,80 @@
 #include "../DB.h"
-#include "util/log.h"
+#include "../util/log.h"
 
+#include "Config.h"
+#include "ValueBroker.h"
 #include "SaveManager.h"
 
 using namespace std;
 using namespace crepe;
 using namespace crepe::api;
 
+template <>
+string SaveManager::serialize(const string & value) {
+	return value;
+}
+template <typename T>
+string SaveManager::serialize(const T & value) {
+	return to_string(value);
+}
+template string SaveManager::serialize(const uint8_t &);
+template string SaveManager::serialize(const int8_t &);
+template string SaveManager::serialize(const uint16_t &);
+template string SaveManager::serialize(const int16_t &);
+template string SaveManager::serialize(const uint32_t &);
+template string SaveManager::serialize(const int32_t &);
+template string SaveManager::serialize(const uint64_t &);
+template string SaveManager::serialize(const int64_t &);
+template string SaveManager::serialize(const float &);
+template string SaveManager::serialize(const double &);
+
+template <>
+uint64_t SaveManager::deserialize(const string & value) {
+	try {
+		return stoul(value);
+	} catch (std::invalid_argument &) {
+		return 0;
+	}
+}
+template <>
+int64_t SaveManager::deserialize(const string & value) {
+	try {
+		return stol(value);
+	} catch (std::invalid_argument &) {
+		return 0;
+	}
+}
+template <>
+float SaveManager::deserialize(const string & value) {
+	try {
+		return stof(value);
+	} catch (std::invalid_argument &) {
+		return 0;
+	}
+	return stof(value);
+}
+template <>
+double SaveManager::deserialize(const string & value) {
+	try {
+		return stod(value);
+	} catch (std::invalid_argument &) {
+		return 0;
+	}
+}
+template <>
+string SaveManager::deserialize(const string & value) {
+	return value;
+}
+
+template <> uint8_t SaveManager::deserialize(const string & value) { return deserialize<uint64_t>(value); }
+template <> int8_t SaveManager::deserialize(const string & value) { return deserialize<int64_t>(value); }
+template <> uint16_t SaveManager::deserialize(const string & value) { return deserialize<uint64_t>(value); }
+template <> int16_t SaveManager::deserialize(const string & value) { return deserialize<int64_t>(value); }
+template <> uint32_t SaveManager::deserialize(const string & value) { return deserialize<uint64_t>(value); }
+template <> int32_t SaveManager::deserialize(const string & value) { return deserialize<int64_t>(value); }
+
 SaveManager::SaveManager() {
 	dbg_trace();
-	this->db = make_unique<DB>("./save.crepe.db");
 }
 
 SaveManager & SaveManager::get_instance() {
@@ -18,3 +83,78 @@ SaveManager & SaveManager::get_instance() {
 	return instance;
 }
 
+DB & SaveManager::get_db() {
+	Config & cfg = Config::get_instance();
+	// TODO: make this path relative to XDG_DATA_HOME on Linux and whatever the
+	// default equivalent is on Windows using some third party library
+	static DB db(cfg.savemgr.location);
+	return db;
+}
+
+bool SaveManager::has(const string & key) {
+	DB & db = this->get_db();
+	return db.has(key);
+}
+
+template <>
+void SaveManager::set(const string & key, const string & value) {
+	DB & db = this->get_db();
+	db.set(key, value);
+}
+template <typename T>
+void SaveManager::set(const string & key, const T & value) {
+	DB & db = this->get_db();
+	db.set(key, std::to_string(value));
+}
+template void SaveManager::set(const string &, const uint8_t &);
+template void SaveManager::set(const string &, const int8_t &);
+template void SaveManager::set(const string &, const uint16_t &);
+template void SaveManager::set(const string &, const int16_t &);
+template void SaveManager::set(const string &, const uint32_t &);
+template void SaveManager::set(const string &, const int32_t &);
+template void SaveManager::set(const string &, const uint64_t &);
+template void SaveManager::set(const string &, const int64_t &);
+template void SaveManager::set(const string &, const float &);
+template void SaveManager::set(const string &, const double &);
+
+template <typename T>
+ValueBroker<T> SaveManager::get(const string & key, const T & default_value) {
+	if (!this->has(key))
+		this->set<T>(key, default_value);
+	return this->get<T>(key);
+}
+template ValueBroker<uint8_t> SaveManager::get(const string &, const uint8_t &);
+template ValueBroker<int8_t> SaveManager::get(const string &, const int8_t &);
+template ValueBroker<uint16_t> SaveManager::get(const string &, const uint16_t &);
+template ValueBroker<int16_t> SaveManager::get(const string &, const int16_t &);
+template ValueBroker<uint32_t> SaveManager::get(const string &, const uint32_t &);
+template ValueBroker<int32_t> SaveManager::get(const string &, const int32_t &);
+template ValueBroker<uint64_t> SaveManager::get(const string &, const uint64_t &);
+template ValueBroker<int64_t> SaveManager::get(const string &, const int64_t &);
+template ValueBroker<float> SaveManager::get(const string &, const float &);
+template ValueBroker<double> SaveManager::get(const string &, const double &);
+template ValueBroker<string> SaveManager::get(const string &, const string &);
+
+template <typename T>
+ValueBroker<T> SaveManager::get(const string & key) {
+	T value;
+	return {
+		[this, key] (const T & target) { this->set<T>(key, target); },
+		[this, key, value] () mutable -> const T & {
+			value = this->deserialize<T>(this->get_db().get(key));
+			return value;
+		},
+	};
+}
+template ValueBroker<uint8_t> SaveManager::get(const string &);
+template ValueBroker<int8_t> SaveManager::get(const string &);
+template ValueBroker<uint16_t> SaveManager::get(const string &);
+template ValueBroker<int16_t> SaveManager::get(const string &);
+template ValueBroker<uint32_t> SaveManager::get(const string &);
+template ValueBroker<int32_t> SaveManager::get(const string &);
+template ValueBroker<uint64_t> SaveManager::get(const string &);
+template ValueBroker<int64_t> SaveManager::get(const string &);
+template ValueBroker<float> SaveManager::get(const string &);
+template ValueBroker<double> SaveManager::get(const string &);
+template ValueBroker<string> SaveManager::get(const string &);
+
diff --git a/src/crepe/api/SaveManager.h b/src/crepe/api/SaveManager.h
index 110735d..a1f239d 100644
--- a/src/crepe/api/SaveManager.h
+++ b/src/crepe/api/SaveManager.h
@@ -14,23 +14,30 @@ class SaveManager {
 public:
 	//! Get a reference to a value and initialize it with a value if it does not yet exist
 	template <typename T>
-	ValueBroker<T> & get(const char * key, const T & default_value);
+	ValueBroker<T> get(const std::string & key, const T & default_value);
 
 	//! Get a reference to a value
 	template <typename T>
-	ValueBroker<T> & get(const char * key);
+	ValueBroker<T> get(const std::string & key);
 
 	//! Set a value directly
 	template <typename T>
-	void set(const char * key, const T & value);
+	void set(const std::string & key, const T & value);
 
 	//! Check if the save file has a value for this \c key
-	bool has(const char * key);
+	bool has(const std::string & key);
 
 private:
 	SaveManager();
 	virtual ~SaveManager() = default;
 
+private:
+	template <typename T>
+	std::string serialize(const T &);
+
+	template <typename T>
+	T deserialize(const std::string &);
+
 public:
 	// singleton
 	static SaveManager & get_instance();
@@ -40,9 +47,8 @@ public:
 	SaveManager & operator = (SaveManager &&) = delete;
 
 private:
-	std::unique_ptr<DB> db = nullptr;
+	static DB & get_db();
 };
 
 }
 
-#include "SaveManager.hpp"
diff --git a/src/crepe/api/SaveManager.hpp b/src/crepe/api/SaveManager.hpp
deleted file mode 100644
index 44f58ed..0000000
--- a/src/crepe/api/SaveManager.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-#include "SaveManager.h"
-
diff --git a/src/crepe/util/Proxy.h b/src/crepe/util/Proxy.h
index f8eb1f2..89cb3c3 100644
--- a/src/crepe/util/Proxy.h
+++ b/src/crepe/util/Proxy.h
@@ -11,10 +11,10 @@ public:
 	operator const T & () const;
 
 public:
-	Proxy(ValueBroker<T> &);
+	Proxy(ValueBroker<T>);
 
 private:
-	ValueBroker<T> & broker;
+	ValueBroker<T> broker;
 };
 
 }
diff --git a/src/crepe/util/Proxy.hpp b/src/crepe/util/Proxy.hpp
index 5738d9c..c2cae93 100644
--- a/src/crepe/util/Proxy.hpp
+++ b/src/crepe/util/Proxy.hpp
@@ -5,7 +5,7 @@
 namespace crepe::util {
 
 template <typename T>
-Proxy<T>::Proxy(ValueBroker<T> & broker) : broker(broker) { }
+Proxy<T>::Proxy(ValueBroker<T> broker) : broker(broker) { }
 
 template <typename T>
 Proxy<T> & Proxy<T>::operator = (const T & val) {
diff --git a/src/example/proxy.cpp b/src/example/proxy.cpp
index 7c2cb8d..0be4fac 100644
--- a/src/example/proxy.cpp
+++ b/src/example/proxy.cpp
@@ -23,14 +23,13 @@ int main() {
 	int real_value = 0;
 
 	ValueBroker<int> broker {
-		real_value,
-		[] (int & value, const int & target) {
-			dbg_logf("set %s to %s", to_string(value).c_str(), to_string(target).c_str());
-			value = target;
+		[&real_value] (const int & target) {
+			dbg_logf("set %s to %s", to_string(real_value).c_str(), to_string(target).c_str());
+			real_value = target;
 		},
-		[] (int & value) -> const int & {
-			dbg_logf("get %s", to_string(value).c_str());
-			return value;
+		[&real_value] () -> const int & {
+			dbg_logf("get %s", to_string(real_value).c_str());
+			return real_value;
 		},
 	};
 
diff --git a/src/example/savemgr.cpp b/src/example/savemgr.cpp
index 2c03e3a..6d011e5 100644
--- a/src/example/savemgr.cpp
+++ b/src/example/savemgr.cpp
@@ -7,23 +7,39 @@
 #include <crepe/util/log.h>
 #include <crepe/util/Proxy.h>
 #include <crepe/api/SaveManager.h>
+#include <crepe/api/Config.h>
 
 using namespace crepe;
 using namespace crepe::api;
 using namespace crepe::util;
 
+// unrelated setup code
+int _ = [] () {
+	// make sure all log messages get printed
+	auto & cfg = Config::get_instance();
+	cfg.log.level = util::LogLevel::TRACE;
+
+	return 0; // satisfy compiler
+} ();
+
 int main() {
 	const char * key = "mygame.test";
 
 	SaveManager & mgr = SaveManager::get_instance();
 
-	ValueBroker<unsigned int> & prop = mgr.get<unsigned int>(key, 0);
-	Proxy<unsigned int> val          = mgr.get<unsigned int>(key, 0);
+	dbg_logf("has key = %s", mgr.has(key) ? "true" : "false");
+	ValueBroker<int> prop = mgr.get<int>(key, 0);
+	Proxy<int> val        = mgr.get<int>(key, 0);
 
+	dbg_logf("val = %d", mgr.get<int>(key).get());
 	prop.set(1);
+	dbg_logf("val = %d", mgr.get<int>(key).get());
 	val = 2;
-	mgr.set<unsigned int>(key, 3);
+	dbg_logf("val = %d", mgr.get<int>(key).get());
+	mgr.set<int>(key, 3);
+	dbg_logf("val = %d", mgr.get<int>(key).get());
 
+	dbg_logf("has key = %s", mgr.has(key) ? "true" : "false");
 	assert(true == mgr.has(key));
 
 	return 0;