From 71c5280bc6393669777147b5036dc510e74d93c4 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Sat, 17 Apr 2021 21:41:26 +0100 Subject: Second swing persistance Mostly functional JSON deserialising for most types. --- test/test-persistance.cpp | 328 +++++++++++++++------------------------------- 1 file changed, 108 insertions(+), 220 deletions(-) (limited to 'test/test-persistance.cpp') diff --git a/test/test-persistance.cpp b/test/test-persistance.cpp index 7d66675..b6bde3f 100644 --- a/test/test-persistance.cpp +++ b/test/test-persistance.cpp @@ -2,237 +2,97 @@ #include -#include +#include #include +#include #include -#include #include -#include -#include -#include -#include +#include +#include #include -struct PersistanceStore; -struct Selection; -using SelectionPtr = std::unique_ptr; -struct Selection { - virtual ~Selection() = default; - virtual void - operator()(float &) - { - throw std::runtime_error("Unexpected float"); - } - virtual void - operator()(bool &) - { - throw std::runtime_error("Unexpected bool"); - } - virtual void - operator()(const std::nullptr_t &) - { - throw std::runtime_error("Unexpected null"); - } - virtual void - operator()(std::string &) - { - throw std::runtime_error("Unexpected string"); - } - virtual void - BeginArray() - { - throw std::runtime_error("Unexpected array"); - } - virtual SelectionPtr - BeginObject() - { - throw std::runtime_error("Unexpected object"); - } - virtual SelectionPtr select(std::string) - { - throw std::runtime_error("Unexpected persist"); - } -}; - -template struct SelectionT : public Selection { - SelectionT(T & value) : v {value} { } - void - operator()(T & evalue) override - { - std::swap(v, evalue); - } - T & v; -}; - -template struct SelectionT> : public Selection { - SelectionT(glm::vec3 & value) : v {value} - { - CLOG(__PRETTY_FUNCTION__); - } - void - operator()(float & value) override - { - v[idx++] = value; - } - void - BeginArray() override - { - } - glm::vec3 & v; - glm::vec3::length_type idx {0}; -}; - -template struct SelectionT> : public Selection { - SelectionT(std::vector & value) : v {value} { } - void - operator()(T & value) override - { - v.push_back(value); - } - void - BeginArray() - { - } - std::vector & v; -}; - struct TestObject; -template struct MakeObjectByTypeName : public Selection { - MakeObjectByTypeName(Ptr & o) : o {o} { } - virtual void - operator()(std::string &) - { - o = std::make_unique(); // TODO shared_ptr - } - Ptr & o; -}; +namespace Persistanace { + struct JsonLoadPersistanceStore : public json::jsonParser { + explicit JsonLoadPersistanceStore(std::istream & in) : json::jsonParser {&in} { } -struct PersistanceStore { - // virtual bool persistType(const std::type_info &) = 0; - template - bool - persistValue(const std::string_view & key, T & value) - { - if (key == name) { - sel = std::make_unique>(std::ref(value)); - return false; - } - return true; - } - const std::string & name; - std::unique_ptr sel {}; -}; + Stack stk; -template struct SelectionObj : public Selection { - SelectionObj(Ptr & o) : v {o} { } + inline SelectionPtr & + current() + { + return stk.top(); + } - SelectionPtr - select(std::string mbr) override - { - if (mbr == "@typeid") { - return std::make_unique>(std::ref(v)); + template + void + loadState(std::unique_ptr & t) + { + stk.push(std::make_unique>>(std::ref(t))); + yy_push_state(0); + yylex(); } - else if (v) { - CLOG(mbr); - PersistanceStore ps {mbr}; - v->persist(ps); - return std::move(ps.sel); + void + BeginObject() override + { + stk.push(current()->BeginObject()); } - throw std::runtime_error("cannot select member of null object"); - } - - Ptr & v; -}; - -template struct SelectionT> : public Selection { - SelectionT(std::unique_ptr & o) : v {o} { } - SelectionPtr - BeginObject() override - { - CLOG(__PRETTY_FUNCTION__); - return std::make_unique>>(v); - } - std::unique_ptr & v; -}; - -struct Persistable { - virtual void persist(PersistanceStore & store) = 0; -}; - -struct JsonLoadPersistanceStore : public json::jsonParser { - JsonLoadPersistanceStore(std::istream & in) : json::jsonParser {&in} { } - - std::stack> stk; - std::unique_ptr selection; - - template - void - loadState(std::unique_ptr & t) - { - yy_push_state(0); - stk.push(std::make_unique>>(std::ref(t))); - yylex(); - } - void - BeginObject() override - { - CLOG(__FUNCTION__); - stk.push(stk.top()->BeginObject()); - } - void - BeginArray() override - { - CLOG(__FUNCTION__); - selection->BeginArray(); - } - void - PushBoolean(bool value) override - { - CLOG(__FUNCTION__); - (*selection)(value); - } - void - PushNumber(float value) override - { - CLOG(__FUNCTION__); - (*selection)(value); - } - void - PushNull() override - { - CLOG(__FUNCTION__); - (*selection)(nullptr); - } - void - PushText(std::string && value) override - { - CLOG(__FUNCTION__); - (*selection)(value); - } - void - PushKey(std::string && k) override - { - CLOG(__FUNCTION__); - selection = stk.top()->select(std::move(k)); - } - void - EndArray() override - { - CLOG(__FUNCTION__); - } - void - EndObject() override - { - CLOG(__FUNCTION__); - stk.pop(); - } -}; + void + BeginArray() override + { + current()->BeginArray(stk); + } + template + inline void + PushValue(T && value) + { + current()->beforeValue(stk); + (*current())(value); + stk.pop(); + } + void + PushBoolean(bool value) override + { + PushValue(value); + } + void + PushNumber(float value) override + { + PushValue(value); + } + void + PushNull() override + { + PushValue(nullptr); + } + void + PushText(std::string && value) override + { + PushValue(value); + } + void + PushKey(std::string && k) override + { + stk.push(current()->select(k)); + } + void + EndArray() override + { + stk.pop(); + } + void + EndObject() override + { + stk.pop(); + } + }; +} #define STORE_TYPE store.persistType(typeid(*this)) -#define STORE_MEMBER(mbr) store.persistValue(#mbr##sv, mbr) +#define STORE_MEMBER(mbr) store.persistValue(#mbr, mbr) -struct TestObject : public Persistable { +struct TestObject : public Persistanace::Persistable { TestObject() = default; float flt {}; @@ -240,12 +100,15 @@ struct TestObject : public Persistable { bool bl {}; glm::vec3 pos {}; std::vector flts; + std::vector poss; + std::vector>> nest; + std::unique_ptr ptr; void - persist(PersistanceStore & store) override + persist(Persistanace::PersistanceStore & store) override { - using namespace std::literals; - STORE_MEMBER(flt) && STORE_MEMBER(str) && STORE_MEMBER(bl) && STORE_MEMBER(pos) && STORE_MEMBER(flts); + STORE_MEMBER(flt) && STORE_MEMBER(str) && STORE_MEMBER(bl) && STORE_MEMBER(pos) && STORE_MEMBER(flts) + && STORE_MEMBER(poss) && STORE_MEMBER(nest) && STORE_MEMBER(ptr); } }; @@ -256,12 +119,20 @@ const std::string input(R"J({ "bl": true, "pos": [3.14, 6.28, 1.57], "flts": [3.14, 6.28, 1.57, 0, -1, -3.14], + "poss": [[3.14, 6.28, 1.57], [0, -1, -3.14]], + "nest": [[["a","b"],["c","d","e"]],[["f"]],[]], + "ptr": { + "@typeid": "TestObject", + "flt": 3.14, + "str": "Lovely string", + }, })J"); BOOST_AUTO_TEST_CASE(load_object) { + Persistanace::Persistable::addFactory("TestObject", std::make_unique); std::stringstream ss {input}; - JsonLoadPersistanceStore jlps {ss}; + Persistanace::JsonLoadPersistanceStore jlps {ss}; std::unique_ptr to; jlps.loadState(to); @@ -278,4 +149,21 @@ BOOST_AUTO_TEST_CASE(load_object) BOOST_CHECK_CLOSE(to->flts[3], 0, 0.01); BOOST_CHECK_CLOSE(to->flts[4], -1, 0.01); BOOST_CHECK_CLOSE(to->flts[5], -3.14, 0.01); + BOOST_REQUIRE_EQUAL(to->poss.size(), 2); + BOOST_CHECK_CLOSE(to->poss[0][0], 3.14, 0.01); + BOOST_CHECK_CLOSE(to->poss[0][1], 6.28, 0.01); + BOOST_CHECK_CLOSE(to->poss[0][2], 1.57, 0.01); + BOOST_CHECK_CLOSE(to->poss[1][0], 0, 0.01); + BOOST_CHECK_CLOSE(to->poss[1][1], -1, 0.01); + BOOST_CHECK_CLOSE(to->poss[1][2], -3.14, 0.01); + BOOST_REQUIRE_EQUAL(to->nest.size(), 3); + BOOST_REQUIRE_EQUAL(to->nest.at(0).size(), 2); + BOOST_REQUIRE_EQUAL(to->nest.at(0).at(0).size(), 2); + BOOST_REQUIRE_EQUAL(to->nest.at(0).at(1).size(), 3); + BOOST_REQUIRE_EQUAL(to->nest.at(1).size(), 1); + BOOST_REQUIRE_EQUAL(to->nest.at(1).at(0).size(), 1); + BOOST_REQUIRE_EQUAL(to->nest.at(2).size(), 0); + BOOST_REQUIRE(to->ptr); + BOOST_CHECK_CLOSE(to->ptr->flt, 3.14, 0.01); + BOOST_CHECK_EQUAL(to->ptr->str, "Lovely string"); } -- cgit v1.2.3