Added polymorphy capabilities using RTTI for unique_ptrs.

5cript · 5cript · commit 4ab4d8a3447a · 2016-07-28T15:58:42.000+02:00
diff --git a/parse/jsd.h b/parse/jsd.h
@@ -13,6 +13,7 @@
 #include "jsd_optional.h"
 #include "jsd_fusion_adapted_struct.h"
 #include "jsd_object.h"
-#include "jsd_renamed.h"
+#include "jsd_renamed.h"
+#include "jsd_unique_ptr.h"
 
 #endif
diff --git a/parse/jsd_core.h b/parse/jsd_core.h
@@ -82,7 +82,15 @@ namespace JSON
 		case (InvalidPathHandlingBehaviour::THROW):			\
 			throw exc;											\
 	}
-	// MAKRO END
+	// MAKRO END
+
+	inline std::string member_name(std::string const& base_name, std::string const& name)
+	{
+	    if (base_name.empty())
+            return "";
+        else
+            return base_name + "." + name;
+	}
 }
 
 #endif
diff --git a/parse/jsd_fusion_adapted_struct.h b/parse/jsd_fusion_adapted_struct.h
@@ -69,7 +69,7 @@ namespace JSON
     template <typename Derived>
     struct Parsable
     {
-        void parse(std::string const& name, PropertyTree const& tree, ParsingOptions const& options = DEFAULT_PARSER_OPTIONS)
+        void parse(std::string const& name, PropertyTree const& tree, ParsingOptions const& options = {})
         {
             AdaptedParser<Derived> parser;
             parser(*static_cast <Derived*> (this), name, tree, options);
diff --git a/parse/jsd_unique_ptr.h b/parse/jsd_unique_ptr.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include "jsd_core.h"
+#include "../utility/polymorphy.h"
+
+#include <type_traits>
+#include <memory>
+
+namespace JSON
+{
+    namespace internal
+    {
+        template <typename T, bool ClassType, bool Enabler>
+        struct type_dependent_retriever
+        {
+        };
+
+        template <typename T>
+        struct type_dependent_retriever <T, true, true>
+        {
+            static void get(T& value, std::string const& name, PropertyTree const& object, ParsingOptions const& options)
+            {
+                value.reset(new T{});
+                value->parse(name, object, options);
+            }
+        };
+
+        template <typename T>
+        struct type_dependent_retriever <T, false, true>
+        {
+            static void get(T& value, std::string const& name, PropertyTree const& object, ParsingOptions const& options)
+            {
+                value.reset(new T{});
+                GET_VALUE(T, name, *value, {});
+            }
+        };
+
+        template <typename T>
+        struct type_dependent_retriever <T, true, false>
+        {
+            static void get(T& value, std::string const& name, PropertyTree const& object, ParsingOptions const& options)
+            {
+                using polydecl_type = polydecls <typename T::element_type>;
+
+                auto type_name = object.tree.get_optional <std::string> (name + ".__cxx_type");
+                if (!type_name)
+                    throw std::runtime_error ("object is declared polymorphic, but does not come with a type definition __cxx_type");
+                polydecl_type::smart_pointer_get(value, type_name.get(), name, object, options);
+            }
+        };
+
+        template <typename T>
+        struct type_dependent_retriever <T, false, false>
+        {
+            static void get(T& value, std::string const& name, PropertyTree const& object, ParsingOptions const& options)
+            {
+                // static_assert(false, "Not a class but polymorphic? you did something wrong!");
+                // poly, but not a class
+            }
+        };
+    }
+
+    template <typename T, typename Deleter>
+    void parse(std::unique_ptr <T, Deleter>& value, std::string const& name,
+               PropertyTree const& object, ParsingOptions const& options = {})
+    {
+        using polydecl_type = polydecls <T>;
+
+        internal::type_dependent_retriever <typename std::decay<decltype(value)>::type,
+                                            std::is_class <T>::value,
+                                            std::is_same <typename polydecl_type::type, no_poly>::value>::get(value,
+                                                                                                              name,
+                                                                                                              object,
+                                                                                                              options);
+    }
+}
diff --git a/stringify/jss_core.h b/stringify/jss_core.h
@@ -42,7 +42,47 @@ namespace JSON
     STREAM << "}"
 
     #define WRITE_ARRAY_END(STREAM)                     \
-    STREAM << "]"
+    STREAM << "]"
+
+    inline std::ostream& stringify_object_start(std::ostream& stream, std::string const& name, StringificationOptions const& options)
+    {
+        WRITE_OBJECT_START(stream);
+        return stream;
+    }
+    inline std::ostream& stringify_object_end(std::ostream& stream)
+    {
+        WRITE_OBJECT_END(stream);
+        return stream;
+    }
+
+    class object_scope
+    {
+    public:
+        object_scope(std::ostream& stream, std::string const& name, StringificationOptions& options)
+            : stream_(stream)
+            , options_(options)
+        {
+            options_.in_object = true;
+            stringify_object_start(stream_, name, options);
+        }
+
+        ~object_scope()
+        {
+            stringify_object_end(stream_);
+            options_.in_object = false;
+        }
+
+        object_scope& operator=(object_scope const&) = delete;
+        object_scope& operator=(object_scope&&) = delete;
+        object_scope(object_scope const&) = delete;
+        object_scope(object_scope&&) = delete;
+
+    private:
+        std::ostream& stream_;
+        StringificationOptions& options_;
+    };
+
+    #define JSON_OBJECT_STRINGIFY(stream, options) object_scope(stream, options) _json_os__;
 }
 
 #endif // JSS_CORE_H_INCLUDED
diff --git a/stringify/jss_fusion_adapted_struct.h b/stringify/jss_fusion_adapted_struct.h
@@ -4,12 +4,15 @@
 #include "jss_core.h"
 
 #ifndef JSS_OBJECT_H_INCLUDED
-#include "jss_object.h"
+#   include "jss_object.h"
 #endif
 
-#include "jss_optional.h"
+#include "jss_optional.h"
+#include "../utility/polymorphy.h"
+
+#include <iostream>
+#include <type_traits>
 
-#include <iostream>
 #include <boost/fusion/mpl.hpp>
 #include <boost/fusion/adapted.hpp>
 #include <boost/fusion/include/at.hpp>
@@ -19,8 +22,41 @@
 #include <boost/fusion/include/size.hpp>
 
 namespace JSON
-{
-    template <typename T>
+{
+    namespace internal
+    {
+        template <typename Base, typename Derived, bool Enable = !std::is_same <Base, Derived>::value>
+        struct Polify
+        {
+        };
+
+        template <typename Base, typename Derived>
+        struct Polify <Base, Derived, false>
+        {
+            template <typename... List>
+            static void exec(List&...)
+            {
+                // not enabled
+            }
+        };
+
+        template <typename Base, typename Derived>
+        struct Polify <Base, Derived, true>
+        {
+            static void exec(std::ostream& stream, bool& first, Derived const& object)
+            {
+                using polydecl_type = polydecls <Base>;
+                if (std::is_same <typename polydecl_type::type, no_poly>::value == false)
+                {
+                    // leave polymorphy mark behind
+                    stream << "\"__cxx_type\": \"" << polydecl_type::identify_type(&object) << "\"";
+                    first = false;
+                }
+            }
+        };
+    }
+
+    template <typename T, typename Base = T>
     class AdaptedStringifier
     {
     public:
@@ -36,7 +72,8 @@ namespace JSON
 
             bool first = true;
 
-            stream << '{';
+            stream << '{';
+            internal::Polify <Base, T>::exec(stream, first, object);
             boost::mpl::for_each<range> (std::bind<void>(_helper(boost::fusion::result_of::size<T>::type::value), std::placeholders::_1, std::ref(stream), std::ref(first), std::ref(object), std::ref(options)));
             stream << '}';
             return stream;
@@ -70,8 +107,16 @@ namespace JSON
         {
             options.in_object = true;
             options.ignore_name = false;
-            AdaptedStringifier<Derived> stringifier;
+            AdaptedStringifier <Derived> stringifier;
             return stringifier(stream, *static_cast <Derived const*> (this), options);
+        }
+        template <typename Base>
+        std::ostream& stringify(std::ostream& stream, StringificationOptions options) const
+        {
+            options.in_object = true;
+            options.ignore_name = false;
+            AdaptedStringifier <Derived, Base> stringifier;
+            return stringifier(stream, *static_cast <Derived const*> (this), options);
         }
         virtual ~Stringifiable() = default;
     };
diff --git a/stringify/jss_optional.h b/stringify/jss_optional.h
@@ -1,9 +1,9 @@
 #ifndef JSS_OPTIONAL_H_INCLUDED
 #define JSS_OPTIONAL_H_INCLUDED
 
-#include "tmp_util/fundamental/eval_if.hpp"
-#include "tmp_util/fundamental/is_same.hpp"
-#include "tmp_util/fundamental/null_type.hpp"
+#include "../utility/tmp_util/fundamental/eval_if.hpp"
+#include "../utility/tmp_util/fundamental/is_same.hpp"
+#include "../utility/tmp_util/fundamental/null_type.hpp"
 
 // really want to swap with std::optional
 #include <boost/optional.hpp>
diff --git a/stringify/jss_unique_ptr.h b/stringify/jss_unique_ptr.h
@@ -1,18 +1,68 @@
 #ifndef JSS_UNIQUE_PTR_H_INCLUDED
 #define JSS_UNIQUE_PTR_H_INCLUDED
 
-#include "jss_core.h"
+#include "jss_core.h"
+#include "../utility/polymorphy.h"
+
 #include <memory>
 
 namespace JSON
-{
-    template <typename T,
-              typename = typename std::enable_if <Internal::can_stringify<T>::value>::type >
-    std::ostream& stringify(std::ostream& stream, const std::string& name, std::unique_ptr<T> const& value, StringificationOptions const& options = DEFAULT_OPTIONS)
+{
+    namespace internal
+    {
+        template <typename T, bool IsClass, bool IsPolymorphic>
+        struct stringify_call_chooser
+        {
+        };
+
+        template <typename T>
+        struct stringify_call_chooser <T, true, false>
+        {
+            static void exec(std::ostream& stream, const std::string& name, T const& value, StringificationOptions const& options)
+            {
+                value->stringify(stream, options);
+            }
+        };
+
+        template <typename T>
+        struct stringify_call_chooser <T, true, true>
+        {
+            static void exec(std::ostream& stream, const std::string& name, T const& value, StringificationOptions const& options)
+            {
+                //value->stringify(stream, options);
+                polydecls <typename T::element_type>::smart_pointer_set(value, stream, options);
+            }
+        };
+
+        template <typename T, bool IsPolymorphic>
+        struct stringify_call_chooser <T, false, IsPolymorphic>
+        {
+            static void exec(std::ostream& stream, const std::string& name, T const& value, StringificationOptions const& options)
+            {
+                stringify(stream, name, *value, options);
+            }
+        };
+    }
+
+    template <typename T, typename Deleter,
+              typename = typename std::enable_if <
+                Internal::can_stringify<T>::value ||
+                !std::is_same <typename polydecls <T>::type, no_poly>::value
+              >::type >
+    std::ostream& stringify(std::ostream& stream, const std::string& name, std::unique_ptr<T, Deleter> const& value, StringificationOptions const& options = {})
     {
         if (!value)
-            throw UniquePtrNullptrException{};
-        return stringify(stream, name, *value, options);
+            throw UniquePtrNullptrException{};
+
+        if (options.in_object && !options.ignore_name)
+            WRITE_NAME(stream);
+
+        internal::stringify_call_chooser <
+            typename std::decay<decltype(value)>::type,
+            std::is_class <T>::value,
+            !std::is_same <typename polydecls <T>::type, no_poly>::value
+        >::exec(stream, name, value, options);
+        return stream;
     }
 }
 
diff --git a/utility/polymorphy.h b/utility/polymorphy.h

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ namespace JSON`
`69`	`69`	`template <typename Derived>`
`70`	`70`	`struct Parsable`
`71`	`71`	`{`
`72`		`- void parse(std::string const& name, PropertyTree const& tree, ParsingOptions const& options = DEFAULT_PARSER_OPTIONS)`
	`72`	`+ void parse(std::string const& name, PropertyTree const& tree, ParsingOptions const& options = {})`
`73`	`73`	`{`
`74`	`74`	`AdaptedParser<Derived> parser;`
`75`	`75`	`parser(static_cast <Derived> (this), name, tree, options);`