Fixed several bugs, enabled boost::optional support for stringification.

Author: 5cript

parse/jsd.h

@@ -11,5 +11,6 @@
 #include "jsd_atomic.h"
 #include "jsd_fusion_adapted_struct.h"
 #include "jsd_object.h"
+#include "jsd_optional.h"
 
 #endif

stringify/jss.h

@@ -13,10 +13,8 @@
 #include "jss_forward_list.h"
 #include "jss_iterator.h"
 #include "jss_array.h"
-#include "jss_struct.h"
 #include "jss_tuple.h"
 #include "jss_object.h"
-#include "jss_initializer_list.h"
 #include "jss_convenience.h"
 #include "jss_queue.h"
 #include "jss_stack.h"
@@ -29,6 +27,7 @@
 #include "jss_atomic.h"
 #include "jss_smart_ptr.h"
 #include "jss_check.h"
+#include "jss_optional.h"
 
 #include "jss_undefine.h"
 

stringify/jss_array.h

@@ -2,8 +2,8 @@
 #define JSS_ARRAY_H_INCLUDED
 
 #include "jss_core.h"
-#include "jss_struct.h"
 #include "jss_iterator.h"
+#include "jss_optional.h"
 #include <array>
 
 namespace JSON
@@ -14,14 +14,16 @@ namespace JSON
     {
         options.ignore_name = true;
         WRITE_ARRAY_START(stream);
-        if (!values.empty())
+        bool first = true;
+        for (auto const& i : values)
         {
-            for (auto i = values.begin(); i != values.end() - 1; ++i)
+            if (Internal::is_optional_set(i))
             {
-                stringify(stream, {}, *i, options);
-                stream << options.delimiter;
+                if (!first)
+                    stream << options.delimiter;
+                stringify(stream, {}, i, options);
+                first = false;
             }
-            stream << values.back();
         }
         WRITE_ARRAY_END(stream);
         return stream;

stringify/jss_bidirectional.h

@@ -13,7 +13,7 @@ namespace JSON
     std::ostream& stringify (std::ostream& stream, std::string const& name, ContainerT <T> values, StringificationOptions const& options = DEFAULT_OPTIONS,
                              typename std::enable_if<has_bidirectional_iterator<T, ContainerT>::value>::type* = nullptr)
     {
-        Internal::stringify_i(stream, name, values, [](ContainerT <T> const& c){ auto end = c.end(); end--; return end;  });
+        Internal::stringify_i(stream, name, values, options);
         return stream;
     }
 }

stringify/jss_container.h

@@ -4,31 +4,32 @@
 #include "jss_core.h"
 #include "jss_object.h"
 #include "jss_check.h"
+#include "jss_optional.h"
 #include <functional>
 
 namespace JSON { namespace Internal
 {
     template <typename T, template <typename, class = std::allocator <T> > class ContainerT,
               typename FuncT = std::function <typename ContainerT<T>::const_iterator(ContainerT<T> const&)>,
               class = typename std::enable_if<Internal::can_stringify<typename ContainerT<T>::value_type>::value>::type >
-    inline std::ostream& stringify_i(std::ostream& stream, std::string const& name, ContainerT <T> const& values, FuncT end_iter, StringificationOptions const& options = DEFAULT_OPTIONS)
+    inline std::ostream& stringify_i(std::ostream& stream, std::string const& name, ContainerT <T> const& values, StringificationOptions const& options = DEFAULT_OPTIONS)
     {
         using namespace Internal;
 
         WRITE_ARRAY_START(stream);
-        if (!values.empty())
+        auto noNameOption = options;
+        noNameOption.ignore_name = true;
+
+        bool first = true;
+        for (auto const& i : values)
         {
-            auto end = end_iter(values);
-            APPLY_IO_MANIPULATERS(stream);
-            auto noNameOption = options;
-            noNameOption.ignore_name = true;
-            auto i = values.begin();
-            for (; i != end; ++i)
+            if (Internal::is_optional_set(i))
             {
-                stringify(stream, {}, *i, noNameOption);
-                stream << options.delimiter;
+                if (!first)
+                    stream << options.delimiter;
+                stringify(stream, {}, i, noNameOption);
+                first = false;
             }
-            stringify(stream, {}, *i, noNameOption);
         }
         WRITE_ARRAY_END(stream);
         return stream;

stringify/jss_core.h

@@ -25,7 +25,6 @@ namespace JSON
     constexpr auto TemplateRecursionMaximum = 8;
 
     #define CLASS_STRINGIFY_FUNCTION_NAME stringify
-    #define APPLY_IO_MANIPULATERS(STREAM) options.io_options.apply(STREAM)
 
     #define WRITE_NAME(STREAM)                          \
     if (!options.ignore_name && options.in_object)      \

stringify/jss_forward.h

@@ -13,7 +13,7 @@ namespace JSON
     std::ostream& stringify(std::ostream& stream, std::string const& name, ContainerT <T> const& values, StringificationOptions const& options = DEFAULT_OPTIONS,
                                typename std::enable_if<has_forward_iterator<T, ContainerT>::value>::type* = nullptr)
     {
-        Internal::stringify_i(stream, name, values, [](ContainerT <T> const& c){ auto b = c.cbegin(); std::advance(b, std::distance(b, c.cend()) - 1); return b; }, options);
+        Internal::stringify_i(stream, name, values, options);
         return stream;
     }
 }

stringify/jss_forward_list.h

@@ -1,7 +1,7 @@
 #ifndef JSS_FORWARD_LIST_H_INCLUDED
 #define JSS_FORWARD_LIST_H_INCLUDED
 
-#include "jss_forward.h"
 #include <forward_list>
+#include "jss_forward.h"
 
 #endif // JSS_FORWARD_LIST_H_INCLUDED

stringify/jss_fundamental.cpp

@@ -4,15 +4,13 @@ namespace JSON
 {
     std::ostream& stringify(std::ostream& stream, std::string const& name, char value, StringificationOptions const& options)
     {
-        APPLY_IO_MANIPULATERS(stream);
         WRITE_NAME(stream);
         stream << "\"" << value << "\"";
         return stream;
     }
 
     std::ostream& stringify(std::ostream& stream, std::string const& name, wchar_t value, StringificationOptions const& options)
     {
-        APPLY_IO_MANIPULATERS(stream);
         WRITE_NAME(stream);
         stream << "\"" << value << "\"";
         return stream;

stringify/jss_fundamental.h

@@ -13,7 +13,6 @@ namespace JSON
                                               || std::is_enum<T>::value         >::type >
     std::ostream& stringify(std::ostream& stream, std::string const& name, T value, StringificationOptions const& options = DEFAULT_OPTIONS)
     {
-        APPLY_IO_MANIPULATERS(stream);
         WRITE_NAME(stream);
         stream << value;
         return stream;