Changed file extension for all header files to hpp

Author: 5cript

stringify/container_traits.hpp

@@ -0,0 +1,27 @@
+#ifndef CONTAINER_TRAITS_H_INCLUDED
+#define CONTAINER_TRAITS_H_INCLUDED
+
+// and iterator traits :D
+
+#include <iterator>
+#include <type_traits>
+
+template <typename T, template <typename, class = std::allocator <T> > class ContainerT>
+struct has_random_access_iterator : std::is_same <
+    typename std::iterator_traits<typename ContainerT<T>::iterator>::iterator_category
+    , std::random_access_iterator_tag>
+{};
+
+template <typename T, template <typename, class = std::allocator <T> > class ContainerT>
+struct has_bidirectional_iterator : std::is_same <
+    typename std::iterator_traits<typename ContainerT<T>::iterator>::iterator_category
+    , std::bidirectional_iterator_tag>
+{};
+
+template <typename T, template <typename, class = std::allocator <T> > class ContainerT>
+struct has_forward_iterator : std::is_same <
+    typename std::iterator_traits<typename ContainerT<T>::iterator>::iterator_category
+    , std::forward_iterator_tag>
+{};
+
+#endif // CONTAINER_TRAITS_H_INCLUDED

stringify/integer_of_size.hpp

@@ -0,0 +1,38 @@
+#ifndef INTEGER_OF_SIZE_H_INCLUDED
+#define INTEGER_OF_SIZE_H_INCLUDED
+
+#include <cstdint>
+
+template <unsigned s>
+struct int_of_size
+{
+    typedef int type;
+};
+
+template <unsigned s>
+struct uint_of_size
+{
+    typedef int type;
+};
+
+#define __I_OF_SIZE(SIZE, TYPE)     \
+template <>                         \
+struct int_of_size<(SIZE)>          \
+{                                   \
+    typedef TYPE type;              \
+};                                  \
+                                    \
+template <>                         \
+struct uint_of_size<(SIZE)>         \
+{                                   \
+    typedef u##TYPE type;           \
+};
+// END OF MAKRO
+
+
+__I_OF_SIZE(sizeof(int8_t), int8_t)
+__I_OF_SIZE(sizeof(int16_t), int16_t)
+__I_OF_SIZE(sizeof(int32_t), int32_t)
+__I_OF_SIZE(sizeof(int64_t), int64_t)
+
+#endif // INTEGER_OF_SIZE_H_INCLUDED

stringify/iterator_traits.hpp

@@ -0,0 +1,26 @@
+#ifndef JSS_ITERATOR_TRAITS_H_INCLUDED
+#define JSS_ITERATOR_TRAITS_H_INCLUDED
+
+#include <iterator>
+#include <type_traits>
+
+template <typename T>
+struct is_random_access_iterator : std::is_same <
+    typename std::iterator_traits<T>::iterator_category
+    , std::random_access_iterator_tag>
+{};
+
+template <typename T>
+struct is_bidirectional_iterator : std::is_same <
+    typename std::iterator_traits<T>::iterator_category
+    , std::bidirectional_iterator_tag>
+{};
+
+template <typename T>
+struct is_forward_iterator : std::is_same <
+    typename std::iterator_traits<T>::iterator_category
+    , std::forward_iterator_tag>
+{};
+
+
+#endif // ITERATOR_TRAITS_H_INCLUDED

stringify/jss.hpp

@@ -0,0 +1,38 @@
+#ifndef JSS_H_INCLUDED
+#define JSS_H_INCLUDED
+
+// Do not include this file! include only those headers that you need
+// + jss_undefine
+
+#include "jss_core.hpp"
+#include "jss_fundamental.hpp"
+#include "jss_string.hpp"
+#include "jss_list.hpp"
+#include "jss_vector.hpp"
+#include "jss_deque.hpp"
+#include "jss_forward_list.hpp"
+#include "jss_iterator.hpp"
+#include "jss_array.hpp"
+#include "jss_tuple.hpp"
+#include "jss_object.hpp"
+#include "jss_convenience.hpp"
+#include "jss_queue.hpp"
+#include "jss_stack.hpp"
+#include "jss_bitset.hpp"
+#include "jss_pointer.hpp"
+#include "jss_pair.hpp"
+#include "jss_valarray.hpp"
+#include "jss_map.hpp"
+#include "jss_unordered_map.hpp"
+#include "jss_set.hpp"
+#include "jss_atomic.hpp"
+#include "jss_unique_ptr.hpp"
+#include "jss_shared_ptr.hpp"
+#include "jss_weak_ptr.hpp"
+#include "jss_check.hpp"
+#include "jss_optional.hpp"
+#include "jss_renamed.hpp"
+
+// #include "jss_undefine.hpp"
+
+#endif // JSS_H_INCLUDED

stringify/jss_array.hpp

@@ -0,0 +1,33 @@
+#ifndef JSS_ARRAY_H_INCLUDED
+#define JSS_ARRAY_H_INCLUDED
+
+#include "jss_core.hpp"
+#include "jss_iterator.hpp"
+#include "jss_optional.hpp"
+#include <array>
+
+namespace JSON
+{
+    template <typename T, std::size_t N,
+              typename = typename std::enable_if <Internal::can_stringify<T>::value>::type >
+    std::ostream& stringify(std::ostream& stream, std::string const& name, std::array<T, N> const& values, StringificationOptions options = DEFAULT_OPTIONS)
+    {
+        WRITE_ARRAY_START(stream);
+        options.ignore_name = true;
+        bool first = true;
+        for (auto const& i : values)
+        {
+            if (Internal::is_optional_set(i))
+            {
+                if (!first)
+                    stream << options.delimiter;
+                stringify(stream, {}, i, options);
+                first = false;
+            }
+        }
+        WRITE_ARRAY_END(stream);
+        return stream;
+    }
+}
+
+#endif // JSS_ARRAY_H_INCLUDED

stringify/jss_atomic.hpp

@@ -0,0 +1,18 @@
+#ifndef JSS_ATOMIC_H_INCLUDED
+#define JSS_ATOMIC_H_INCLUDED
+
+#include "jss_core.hpp"
+#include <atomic>
+
+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::atomic<T> const& value, StringificationOptions const& options)
+    {
+        stringify(stream, name, value.load(), options);
+        return stream;
+    }
+}
+
+#endif // JSS_ATOMIC_H_INCLUDED

stringify/jss_bidirectional.hpp

@@ -0,0 +1,21 @@
+#ifndef JSS_BIDIRECTIONAL_H_INCLUDED
+#define JSS_BIDIRECTIONAL_H_INCLUDED
+
+#include "jss_core.hpp"
+#include "container_traits.hpp"
+#include "jss_object.hpp"
+#include "jss_container.hpp"
+
+namespace JSON
+{
+    template <typename T, template <typename, class = std::allocator <T> > class ContainerT,
+              class = typename std::enable_if<Internal::can_stringify<typename ContainerT<T>::value_type>::value>::type >
+    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, options);
+        return stream;
+    }
+}
+
+#endif // JSS_BIDIRECTIONAL_H_INCLUDED

stringify/jss_bitset.hpp

@@ -0,0 +1,34 @@
+#ifndef JSS_BITSET_H_INCLUDED
+#define JSS_BITSET_H_INCLUDED
+
+#include "jss_core.hpp"
+#include <bitset>
+#include <iostream>
+
+namespace JSON
+{
+    template <size_t Size, size_t TemplateRecursionMax = TemplateRecursionMaximum>
+    std::ostream& stringify (std::ostream& stream, std::string const& name, std::bitset<Size> const& values, StringificationOptions const& options = DEFAULT_OPTIONS)
+    {
+        WRITE_ARRAY_START(stream);
+        for (unsigned i = 0; i < Size - 1; ++i)
+        {
+            stream << values[i];
+            stream << options.delimiter;
+        }
+        stream << values[Size - 1];
+        WRITE_ARRAY_END(stream);
+        return stream;
+    }
+
+    template <size_t Size>
+    std::ostream& stringify (std::ostream& stream, std::string const& name, std::bitset<Size> const& values, StringificationOptions const& options = DEFAULT_OPTIONS,
+                                typename std::enable_if <Size==0>::type* = nullptr)
+    {
+        WRITE_ARRAY_START(stream);
+        WRITE_ARRAY_END(stream);
+        return stream;
+    }
+}
+
+#endif // JSS_BITSET_H_INCLUDED

stringify/jss_check.hpp

@@ -0,0 +1,44 @@
+#ifndef JSS_CHECK_H_INCLUDED
+#define JSS_CHECK_H_INCLUDED
+
+#include "jss_core.hpp"
+#include <sstream>
+#include <utility>
+
+namespace JSON { namespace Internal {
+
+    class StreamMock : public std::ostream {};
+    static StreamMock _smock;
+
+    template <typename T>
+    class can_stringify_1
+    {
+        template<typename U>
+        static char check(...);
+        template<typename U>
+        static char (&check(decltype(stringify(std::declval<std::ostream&>(), std::declval<std::string const>(), std::declval<U>(), std::declval<StringificationOptions const>()))))[2];
+        public:
+        static const bool value = sizeof(check<T> (_smock)) == 2;
+    };
+
+    template <typename T>
+    class can_stringify_2
+    {
+        template<typename U>
+        static char check(...);
+        template<typename U>
+        static char (&check(decltype(stringify(std::declval<std::ostream&>(), std::declval<std::string const>(), std::declval<U>(), std::declval<StringificationOptions>()))))[2];
+        public:
+        static const bool value = sizeof(check<T> (_smock)) == 2;
+    };
+
+    template <typename T>
+    struct can_stringify
+    {
+        static const bool value = can_stringify_1<T>::value || can_stringify_2<T>::value;
+    };
+
+}
+}
+
+#endif // JSS_CHECK_H_INCLUDED

stringify/jss_container.hpp

@@ -0,0 +1,40 @@
+#ifndef JSS_CONTAINER_H_INCLUDED
+#define JSS_CONTAINER_H_INCLUDED
+
+#include "jss_core.hpp"
+#include "jss_object.hpp"
+#include "jss_check.hpp"
+#include "jss_optional.hpp"
+#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, StringificationOptions const& options = DEFAULT_OPTIONS)
+    {
+        using namespace Internal;
+
+        WRITE_ARRAY_START(stream);
+        auto noNameOption = options;
+        noNameOption.ignore_name = true;
+
+        bool first = true;
+        for (auto const& i : values)
+        {
+            if (Internal::is_optional_set(i))
+            {
+                if (!first)
+                    stream << options.delimiter;
+                stringify(stream, {}, i, noNameOption);
+                first = false;
+            }
+        }
+        WRITE_ARRAY_END(stream);
+        return stream;
+    }
+} // Internal
+} // JSON
+
+#endif // JSS_CONTAINER_H_INCLUDED

stringify/jss_convenience.hpp

@@ -0,0 +1,30 @@
+#ifndef JSS_CONVENIENCE_H_INCLUDED
+#define JSS_CONVENIENCE_H_INCLUDED
+
+#include "jss_core.hpp"
+#include "jss_check.hpp"
+
+
+namespace JSON
+{
+    template <typename T>
+    std::ostream& try_stringify(std::ostream& stream, std::string const& name, T const& obj, StringificationOptions const& options = DEFAULT_OPTIONS,
+                                   typename std::enable_if <Internal::can_stringify<T>::value, void>::type* = nullptr)
+    {
+        stringify(stream, name, obj, options);
+        return stream;
+    }
+
+    template <typename T>
+    std::ostream& try_stringify(std::ostream& stream, std::string const&, T const&, StringificationOptions const& = DEFAULT_OPTIONS,
+                                 typename std::enable_if <!Internal::can_stringify<T>::value, int>::type* = nullptr)
+    {
+        static_assert (Internal::can_stringify<T>::value, "the object you try to convert is not convertible to JSON");
+        return stream;
+    }
+}
+
+#define json_serialize(NAME, STREAM) JSON::try_stringify(STREAM, #NAME, NAME)
+#define json_serialize_opt(NAME, STREAM, OPTIONS) JSON::try_stringify(STREAM, #NAME, NAME, OPTIONS)
+
+#endif // JSS_CONVENIENCE_H_INCLUDED