diff options
Diffstat (limited to 'lib')
-rw-r--r-- | lib/jsonParse.impl.cpp | 23 | ||||
-rw-r--r-- | lib/jsonParse.ll | 2 | ||||
-rw-r--r-- | lib/persistance.cpp | 74 | ||||
-rw-r--r-- | lib/persistance.h | 201 |
4 files changed, 290 insertions, 10 deletions
diff --git a/lib/jsonParse.impl.cpp b/lib/jsonParse.impl.cpp index 27e73b4..3ed8e62 100644 --- a/lib/jsonParse.impl.cpp +++ b/lib/jsonParse.impl.cpp @@ -1,4 +1,7 @@ #include "jsonParse.h" +#include <cstdlib> +#include <stdexcept> +#include <string> void json::jsonParser::LexerError(const char * msg) @@ -16,24 +19,24 @@ void json::jsonParser::appendEscape(unsigned long cp, std::string & str) { if (cp <= 0x7F) { - str += cp; + str += (char)cp; } else if (cp <= 0x7FF) { - str += (cp >> 6) + 192; - str += (cp & 63) + 128; + str += char((cp >> 6) + 192); + str += char((cp & 63) + 128); } else if (0xd800 <= cp && cp <= 0xdfff) { throw std::range_error("Invalid UTF-8 sequence"); } else if (cp <= 0xFFFF) { - str += (cp >> 12) + 224; - str += ((cp >> 6) & 63) + 128; - str += (cp & 63) + 128; + str += char((cp >> 12) + 224); + str += char(((cp >> 6) & 63) + 128); + str += char((cp & 63) + 128); } else if (cp <= 0x10FFFF) { - str += (cp >> 18) + 240; - str += ((cp >> 12) & 63) + 128; - str += ((cp >> 6) & 63) + 128; - str += (cp & 63) + 128; + str += char((cp >> 18) + 240); + str += char(((cp >> 12) & 63) + 128); + str += char(((cp >> 6) & 63) + 128); + str += char((cp & 63) + 128); } } diff --git a/lib/jsonParse.ll b/lib/jsonParse.ll index 0fc27e9..7e0b8ca 100644 --- a/lib/jsonParse.ll +++ b/lib/jsonParse.ll @@ -9,6 +9,8 @@ %{ #include <string> +#include <utility> +class jsonBaseFlexLexer; #include "jsonParse.h" #pragma GCC diagnostic ignored "-Wsign-compare" #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" diff --git a/lib/persistance.cpp b/lib/persistance.cpp new file mode 100644 index 0000000..7539b44 --- /dev/null +++ b/lib/persistance.cpp @@ -0,0 +1,74 @@ +#include "persistance.h" +#include <map> + +namespace Persistanace { + using NamedTypeFactories = std::map<std::string_view, std::function<std::unique_ptr<Persistable>()>>; + static NamedTypeFactories namedTypeFactories; + + void + Persistable::addFactory(const std::string_view t, std::function<std::unique_ptr<Persistable>()> f) + { + namedTypeFactories.emplace(t, std::move(f)); + } + + std::unique_ptr<Persistable> + Persistable::callFactory(const std::string_view t) + { + return namedTypeFactories.at(t)(); + } + + void + Selection::operator()(float &) + { + throw std::runtime_error("Unexpected float"); + } + + void + Selection::operator()(bool &) + { + throw std::runtime_error("Unexpected bool"); + } + + void + Selection::operator()(const std::nullptr_t &) + { + throw std::runtime_error("Unexpected null"); + } + + void + Selection::operator()(std::string &) + { + throw std::runtime_error("Unexpected string"); + } + + void + Selection::BeginArray(Stack &) + { + throw std::runtime_error("Unexpected array"); + } + + SelectionPtr + Selection::BeginObject() + { + throw std::runtime_error("Unexpected object"); + } + + void + Selection::beforeValue(Stack &) + { + throw std::runtime_error("Unexpected value"); + } + + SelectionPtr + Selection::select(const std::string &) + { + throw std::runtime_error("Unexpected persist"); + } + + static_assert(!SelectionT<float>::ArrayLike); + static_assert(!SelectionT<bool>::ArrayLike); + static_assert(!SelectionT<std::string>::ArrayLike); + static_assert(SelectionT<std::vector<float>>::ArrayLike); + static_assert(SelectionT<glm::vec3>::ArrayLike); + static_assert(SelectionT<std::vector<glm::vec3>>::ArrayLike); +} diff --git a/lib/persistance.h b/lib/persistance.h new file mode 100644 index 0000000..75222e0 --- /dev/null +++ b/lib/persistance.h @@ -0,0 +1,201 @@ +#ifndef PERSISTANCE_H +#define PERSISTANCE_H + +#include <functional> +#include <glm/glm.hpp> +#include <iosfwd> +#include <memory> +#include <special_members.hpp> +#include <stack> +#include <stdexcept> +#include <string> +#include <string_view> +#include <utility> +#include <vector> + +namespace glm { + template<glm::length_t L, typename T, glm::qualifier Q> struct vec; +} + +namespace Persistanace { + struct Selection; + using SelectionPtr = std::unique_ptr<Selection>; + using Stack = std::stack<SelectionPtr>; + + struct Selection { + Selection() = default; + virtual ~Selection() = default; + DEFAULT_MOVE_COPY(Selection); + + virtual void operator()(float &); + virtual void operator()(bool &); + virtual void operator()(const std::nullptr_t &); + virtual void operator()(std::string &); + virtual void BeginArray(Stack &); + virtual SelectionPtr BeginObject(); + virtual void beforeValue(Stack &); + virtual SelectionPtr select(const std::string &); + }; + + template<typename T> struct SelectionT : public Selection { + explicit SelectionT(T & value) : v {value} { } + + void + beforeValue(Stack &) override + { + } + + void + operator()(T & evalue) override + { + std::swap(v, evalue); + } + + static constexpr bool ArrayLike {false}; + T & v; + }; + + struct PersistanceStore { + // virtual bool persistType(const std::type_info &) = 0; + template<typename T> + bool + persistValue(const std::string_view & key, T & value) + { + if (key == name) { + sel = std::make_unique<SelectionT<T>>(std::ref(value)); + return false; + } + return true; + } + const std::string & name; + SelectionPtr sel {}; + }; + + template<glm::length_t L, typename T, glm::qualifier Q> struct SelectionT<glm::vec<L, T, Q>> : public Selection { + explicit SelectionT(glm::vec<L, float, Q> & value) : v {value} { } + + void + BeginArray(Stack &) override + { + } + + void + beforeValue(Stack & stk) override + { + stk.push(std::make_unique<SelectionT<T>>(std::ref(v[idx++]))); + } + + static constexpr bool ArrayLike {true}; + glm::vec<L, T, Q> & v; + glm::length_t idx {0}; + }; + + template<typename T> struct SelectionT<std::vector<T>> : public Selection { + explicit SelectionT(std::vector<T> & value) : v {value} { } + + void + BeginArray(Stack &) override + { + } + + void + beforeValue(Stack & stk) override + { + stk.push(std::make_unique<SelectionT<T>>(std::ref(v.emplace_back()))); + } + + static constexpr bool ArrayLike {true}; + std::vector<T> & v; + }; + + template<typename T> + concept ArrayLike = SelectionT<T>::ArrayLike; + + template<ArrayLike T> struct SelectionT<std::vector<T>> : public Selection { + explicit SelectionT(std::vector<T> & value) : v {value} { } + + void + BeginArray(Stack & stk) override + { + stk.push(std::make_unique<SelectionT<T>>(std::ref(v.emplace_back()))); + } + + static constexpr bool ArrayLike {true}; + std::vector<T> & v; + }; + + struct Persistable { + Persistable() = default; + virtual ~Persistable() = default; + DEFAULT_MOVE_COPY(Persistable); + + virtual void persist(PersistanceStore & store) = 0; + + static void addFactory(const std::string_view, std::function<std::unique_ptr<Persistable>()>); + static std::unique_ptr<Persistable> callFactory(const std::string_view); + }; + + template<typename T> struct SelectionT<std::unique_ptr<T>> : public Selection { + using Ptr = std::unique_ptr<T>; + struct SelectionObj : public Selection { + struct MakeObjectByTypeName : public Selection { + explicit MakeObjectByTypeName(Ptr & o) : o {o} { } + + void + beforeValue(Stack &) override + { + } + + void + operator()(std::string & type) override + { + auto no = Persistable::callFactory(type); + if (dynamic_cast<T *>(no.get())) { + o.reset(static_cast<T *>(no.release())); + } + } + + Ptr & o; + }; + + explicit SelectionObj(Ptr & o) : v {o} { } + + SelectionPtr + select(const std::string & mbr) override + { + using namespace std::literals; + if (mbr == "@typeid"sv) { + if (v) { + throw std::runtime_error("cannot set object type after creation"); + } + return std::make_unique<MakeObjectByTypeName>(std::ref(v)); + } + else { + if (!v) { + if constexpr (!std::is_abstract_v<T>) { + v = std::make_unique<T>(); + } + throw std::runtime_error("cannot select member of null object"); + } + PersistanceStore ps {mbr}; + v->persist(ps); + return std::move(ps.sel); + } + } + + Ptr & v; + }; + + explicit SelectionT(std::unique_ptr<T> & o) : v {o} { } + + SelectionPtr + BeginObject() override + { + return std::make_unique<SelectionObj>(v); + } + + std::unique_ptr<T> & v; + }; +} + +#endif |