jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons/encode_json.hpp

@@ -0,0 +1,315 @@
+// Copyright 2017 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_ENCODE_JSON_HPP
+#define JSONCONS_ENCODE_JSON_HPP
+
+#include <iostream>
+#include <string>
+#include <tuple>
+#include <memory>
+#include <istream> // std::basic_istream
+#include <jsoncons/encode_traits.hpp>
+#include <jsoncons/json_cursor.hpp>
+
+namespace jsoncons {
+
+    // to string
+
+    template <class T, class Container>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json(const T& val,
+                Container& s, 
+                const basic_json_encode_options<typename Container::value_type>& options = 
+                    basic_json_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+
+        basic_compact_json_encoder<char_type, jsoncons::string_sink<Container>> encoder(s, options);
+        val.dump(encoder);
+    }
+
+    template <class T, class Container>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json(const T& val,
+                Container& s, 
+                const basic_json_encode_options<typename Container::value_type>& options = basic_json_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+
+        basic_compact_json_encoder<char_type, jsoncons::string_sink<Container>> encoder(s, options);
+        encode_json(val, encoder);
+    }
+
+    // to stream
+
+    template <class T, class CharT>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value>::type
+    encode_json(const T& val,
+                std::basic_ostream<CharT>& os, 
+                const basic_json_encode_options<CharT>& options = basic_json_encode_options<CharT>())
+    {
+        basic_compact_json_encoder<CharT> encoder(os, options);
+        val.dump(encoder);
+    }
+
+    template <class T, class CharT>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value>::type
+    encode_json(const T& val,
+                std::basic_ostream<CharT>& os, 
+                const basic_json_encode_options<CharT>& options = basic_json_encode_options<CharT>())
+    {
+        basic_compact_json_encoder<CharT> encoder(os, options);
+        encode_json(val, encoder);
+    }
+
+    // encode_json_pretty
+
+    template <class T, class Container>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json_pretty(const T& val,
+                       Container& s, 
+                       const basic_json_encode_options<typename Container::value_type>& options = basic_json_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+
+        basic_json_encoder<char_type,jsoncons::string_sink<Container>> encoder(s, options);
+        val.dump(encoder);
+    }
+
+    template <class T, class Container>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json_pretty(const T& val,
+                       Container& s, 
+                       const basic_json_encode_options<typename Container::value_type>& options = basic_json_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+        basic_json_encoder<char_type,jsoncons::string_sink<Container>> encoder(s, options);
+        encode_json(val, encoder);
+    }
+
+    template <class T, class CharT>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value>::type
+    encode_json_pretty(const T& val,
+                       std::basic_ostream<CharT>& os, 
+                       const basic_json_encode_options<CharT>& options = basic_json_encode_options<CharT>())
+    {
+        basic_json_encoder<CharT> encoder(os, options);
+        val.dump(encoder);
+    }
+
+    template <class T, class CharT>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value>::type
+    encode_json_pretty(const T& val,
+                       std::basic_ostream<CharT>& os, 
+                       const basic_json_encode_options<CharT>& options = basic_json_encode_options<CharT>())
+    {
+        basic_json_encoder<CharT> encoder(os, options);
+        encode_json(val, encoder);
+    }
+
+    template <class T, class CharT>
+    void encode_json(const T& val, basic_json_visitor<CharT>& encoder)
+    {
+        std::error_code ec;
+        encode_traits<T,CharT>::encode(val, encoder, basic_json<CharT>(), ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+        encoder.flush();
+    }
+
+    template <class T, class Container, class TempAllocator>
+    void encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                     const T& val, 
+                     Container& s, 
+                     indenting line_indent = indenting::no_indent)
+    {
+        encode_json(temp_allocator_arg, temp_alloc, val, s, basic_json_encode_options<typename Container::value_type>(), line_indent);
+    }
+
+// legacy
+
+    template <class T, class Container>
+    void encode_json(const T& val, Container& s, indenting line_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            encode_json_pretty(val,s);
+        }
+        else
+        {
+            encode_json(val,s);
+        }
+    }
+
+    template <class T, class Container>
+    void encode_json(const T& val,
+                     Container& s, 
+                     const basic_json_encode_options<typename Container::value_type>& options, 
+                     indenting line_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            encode_json_pretty(val,s,options);
+        }
+        else
+        {
+            encode_json(val,s,options);
+        }
+    }
+
+    template <class T, class CharT>
+    void encode_json(const T& val,
+                     std::basic_ostream<CharT>& os, 
+                     indenting line_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            encode_json_pretty(val, os);
+        }
+        else
+        {
+            encode_json(val, os);
+        }
+    }
+
+    template <class T, class CharT>
+    void encode_json(const T& val,
+                     std::basic_ostream<CharT>& os, 
+                     const basic_json_encode_options<CharT>& options, 
+                     indenting line_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            encode_json_pretty(val, os, options);
+        }
+        else
+        {
+            encode_json(val, os, options);
+        }
+    }
+
+//end legacy
+
+    template <class T, class Container, class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                const T& val,
+                Container& s, 
+                const basic_json_encode_options<typename Container::value_type>& options, 
+                indenting line_indent = indenting::no_indent)
+    {
+        using char_type = typename Container::value_type;
+        if (line_indent == indenting::indent)
+        {
+            basic_json_encoder<char_type,jsoncons::string_sink<Container>,TempAllocator> encoder(s, options, temp_alloc);
+            val.dump(encoder);
+        }
+        else
+        {
+            basic_compact_json_encoder<char_type, jsoncons::string_sink<Container>,TempAllocator> encoder(s, options, temp_alloc);
+            val.dump(encoder);
+        }
+    }
+
+    template <class T, class Container, class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type
+    encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                const T& val,
+                Container& s,
+                const basic_json_encode_options<typename Container::value_type>& options, 
+                indenting line_indent)
+    { 
+        using char_type = typename Container::value_type;
+        if (line_indent == indenting::indent)
+        {
+            basic_json_encoder<char_type,jsoncons::string_sink<Container>,TempAllocator> encoder(s, options, temp_alloc);
+            encode_json(temp_allocator_arg, temp_alloc, val, encoder);
+        }
+        else
+        {
+            basic_compact_json_encoder<char_type,jsoncons::string_sink<Container>,TempAllocator> encoder(s, options, temp_alloc);
+            encode_json(temp_allocator_arg, temp_alloc, val, encoder);
+        }
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    void encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                     const T& val, 
+                     std::basic_ostream<CharT>& os, 
+                     indenting line_indent = indenting::no_indent)
+    {
+        encode_json(temp_allocator_arg, temp_alloc, val, os, basic_json_encode_options<CharT>(), line_indent);
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value>::type
+    encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                const T& val,
+                std::basic_ostream<CharT>& os, 
+                const basic_json_encode_options<CharT>& options, 
+                indenting line_indent = indenting::no_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            basic_json_encoder<CharT,jsoncons::stream_sink<CharT>,TempAllocator> encoder(os, options, temp_alloc);
+            val.dump(encoder);
+        }
+        else
+        {
+            basic_compact_json_encoder<CharT,jsoncons::stream_sink<CharT>,TempAllocator> encoder(os, options, temp_alloc);
+            val.dump(encoder);
+        }
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value>::type
+    encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                const T& val,
+                std::basic_ostream<CharT>& os, 
+                const basic_json_encode_options<CharT>& options, 
+                indenting line_indent)
+    {
+        if (line_indent == indenting::indent)
+        {
+            basic_json_encoder<CharT> encoder(os, options);
+            encode_json(temp_allocator_arg, temp_alloc, val, encoder);
+        }
+        else
+        {
+            basic_compact_json_encoder<CharT> encoder(os, options);
+            encode_json(temp_allocator_arg, temp_alloc, val, encoder);
+        }
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value>::type
+    encode_json(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+                const T& val,
+                basic_json_visitor<CharT>& encoder)
+    {
+        std::error_code ec;
+        basic_json<CharT,sorted_policy,TempAllocator> proto(temp_alloc);
+        encode_traits<T,CharT>::encode(val, encoder, proto, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+        encoder.flush();
+    }
+
+} // jsoncons
+
+#endif
+

data/lib/jsoncons/jsoncons/include/jsoncons/encode_traits.hpp

@@ -0,0 +1,378 @@
+// Copyright 2017 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_ENCODE_TRAITS_HPP
+#define JSONCONS_ENCODE_TRAITS_HPP
+
+#include <string>
+#include <tuple>
+#include <array>
+#include <memory>
+#include <type_traits> // std::enable_if, std::true_type, std::false_type
+#include <jsoncons/json_visitor.hpp>
+#include <jsoncons/json_decoder.hpp>
+#include <jsoncons/json_options.hpp>
+#include <jsoncons/json_encoder.hpp>
+#include <jsoncons/json_type_traits.hpp>
+#include <jsoncons/conv_error.hpp>
+
+namespace jsoncons {
+
+    // encode_traits
+
+    template <class T, class CharT, class Enable = void>
+    struct encode_traits
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder,
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encode(std::integral_constant<bool, traits_extension::is_stateless<typename Json::allocator_type>::value>(),
+                      val, encoder, proto, ec);
+        }
+    private:
+        template <class Json>
+        static void encode(std::true_type,
+                           const T& val, 
+                           basic_json_visitor<CharT>& encoder,
+                           const Json& /*proto*/, 
+                           std::error_code& ec)
+        {
+            auto j = json_type_traits<Json,T>::to_json(val);
+            j.dump(encoder, ec);
+        }
+        template <class Json>
+        static void encode(std::false_type, 
+                           const T& val, 
+                           basic_json_visitor<CharT>& encoder,
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            auto j = json_type_traits<Json,T>::to_json(val, proto.get_allocator());
+            j.dump(encoder, ec);
+        }
+    };
+
+    // specializations
+
+    // bool
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_bool<T>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            encoder.bool_value(val,semantic_tag::none,ser_context(),ec);
+        }
+    };
+
+    // uint
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_u8_u16_u32_or_u64<T>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            encoder.uint64_value(val,semantic_tag::none,ser_context(),ec);
+        }
+    };
+
+    // int
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_i8_i16_i32_or_i64<T>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            encoder.int64_value(val,semantic_tag::none,ser_context(),ec);
+        }
+    };
+
+    // float or double
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_float_or_double<T>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            encoder.double_value(val,semantic_tag::none,ser_context(),ec);
+        }
+    };
+
+    // string
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_string<T>::value &&
+                                std::is_same<typename T::value_type,CharT>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            encoder.string_value(val,semantic_tag::none,ser_context(),ec);
+        }
+    };
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<traits_extension::is_string<T>::value &&
+                                !std::is_same<typename T::value_type,CharT>::value 
+    >::type>
+    {
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&, 
+                           std::error_code& ec)
+        {
+            std::basic_string<CharT> s;
+            unicode_traits::convert(val.data(), val.size(), s);
+            encoder.string_value(s,semantic_tag::none,ser_context(),ec);
+        }
+    };
+
+    // std::pair
+
+    template <class T1, class T2, class CharT>
+    struct encode_traits<std::pair<T1, T2>, CharT>
+    {
+        using value_type = std::pair<T1, T2>;
+
+        template <class Json>
+        static void encode(const value_type& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encoder.begin_array(2,semantic_tag::none,ser_context(),ec);
+            if (ec) return;
+            encode_traits<T1,CharT>::encode(val.first, encoder, proto, ec);
+            if (ec) return;
+            encode_traits<T2,CharT>::encode(val.second, encoder, proto, ec);
+            if (ec) return;
+            encoder.end_array(ser_context(),ec);
+        }
+    };
+
+    // std::tuple
+
+    namespace detail
+    {
+        template<size_t Pos, std::size_t Size, class Json, class Tuple>
+        struct json_serialize_tuple_helper
+        {
+            using char_type = typename Json::char_type;
+            using element_type = typename std::tuple_element<Size-Pos, Tuple>::type;
+            using next = json_serialize_tuple_helper<Pos-1, Size, Json, Tuple>;
+
+            static void encode(const Tuple& tuple,
+                               basic_json_visitor<char_type>& encoder, 
+                               const Json& proto, 
+                               std::error_code& ec)
+            {
+                encode_traits<element_type,char_type>::encode(std::get<Size-Pos>(tuple), encoder, proto, ec);
+                if (ec) return;
+                next::encode(tuple, encoder, proto, ec);
+            }
+        };
+
+        template<size_t Size, class Json, class Tuple>
+        struct json_serialize_tuple_helper<0, Size, Json, Tuple>
+        {
+            using char_type = typename Json::char_type;
+            static void encode(const Tuple&,
+                               basic_json_visitor<char_type>&, 
+                               const Json&, 
+                               std::error_code&)
+            {
+            }
+        };
+    } // namespace detail
+
+
+    template <class CharT, typename... E>
+    struct encode_traits<std::tuple<E...>, CharT>
+    {
+        using value_type = std::tuple<E...>;
+        static constexpr std::size_t size = sizeof...(E);
+
+        template <class Json>
+        static void encode(const value_type& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            using helper = jsoncons::detail::json_serialize_tuple_helper<size, size, Json, std::tuple<E...>>;
+            encoder.begin_array(size,semantic_tag::none,ser_context(),ec);
+            if (ec) return;
+            helper::encode(val, encoder, proto, ec);
+            if (ec) return;
+            encoder.end_array(ser_context(),ec);
+        }
+    };
+
+    // vector like
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<!is_json_type_traits_declared<T>::value && 
+                 traits_extension::is_list_like<T>::value &&
+                 !traits_extension::is_typed_array<T>::value 
+    >::type>
+    {
+        using value_type = typename T::value_type;
+
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encoder.begin_array(val.size(),semantic_tag::none,ser_context(),ec);
+            if (ec) return;
+            for (auto it = std::begin(val); it != std::end(val); ++it)
+            {
+                encode_traits<value_type,CharT>::encode(*it, encoder, proto, ec);
+                if (ec) return;
+            }
+            encoder.end_array(ser_context(), ec);
+        }
+    };
+
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<!is_json_type_traits_declared<T>::value && 
+                 traits_extension::is_list_like<T>::value &&
+                 traits_extension::is_typed_array<T>::value 
+    >::type>
+    {
+        using value_type = typename T::value_type;
+
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json&,
+                           std::error_code& ec)
+        {
+            encoder.typed_array(jsoncons::span<const value_type>(val), semantic_tag::none, ser_context(), ec);
+        }
+    };
+
+    // std::array
+
+    template <class T, class CharT, std::size_t N>
+    struct encode_traits<std::array<T,N>,CharT>
+    {
+        using value_type = typename std::array<T,N>::value_type;
+
+        template <class Json>
+        static void encode(const std::array<T, N>& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encoder.begin_array(val.size(),semantic_tag::none,ser_context(),ec);
+            if (ec) return;
+            for (auto it = std::begin(val); it != std::end(val); ++it)
+            {
+                encode_traits<value_type,CharT>::encode(*it, encoder, proto, ec);
+                if (ec) return;
+            }
+            encoder.end_array(ser_context(),ec);
+        }
+    };
+
+    // map like
+
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<!is_json_type_traits_declared<T>::value && 
+                                traits_extension::is_map_like<T>::value &&
+                                traits_extension::is_constructible_from_const_pointer_and_size<typename T::key_type>::value
+    >::type>
+    {
+        using mapped_type = typename T::mapped_type;
+        using value_type = typename T::value_type;
+        using key_type = typename T::key_type;
+
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encoder.begin_object(val.size(), semantic_tag::none, ser_context(), ec);
+            if (ec) return;
+            for (auto it = std::begin(val); it != std::end(val); ++it)
+            {
+                encoder.key(it->first);
+                encode_traits<mapped_type,CharT>::encode(it->second, encoder, proto, ec);
+                if (ec) return;
+            }
+            encoder.end_object(ser_context(), ec);
+            if (ec) return;
+        }
+    };
+
+    template <class T, class CharT>
+    struct encode_traits<T,CharT,
+        typename std::enable_if<!is_json_type_traits_declared<T>::value && 
+                                traits_extension::is_map_like<T>::value &&
+                                std::is_integral<typename T::key_type>::value
+    >::type>
+    {
+        using mapped_type = typename T::mapped_type;
+        using value_type = typename T::value_type;
+        using key_type = typename T::key_type;
+
+        template <class Json>
+        static void encode(const T& val, 
+                           basic_json_visitor<CharT>& encoder, 
+                           const Json& proto, 
+                           std::error_code& ec)
+        {
+            encoder.begin_object(val.size(), semantic_tag::none, ser_context(), ec);
+            if (ec) return;
+            for (auto it = std::begin(val); it != std::end(val); ++it)
+            {
+                std::basic_string<typename Json::char_type> s;
+                jsoncons::detail::from_integer(it->first,s);
+                encoder.key(s);
+                encode_traits<mapped_type,CharT>::encode(it->second, encoder, proto, ec);
+                if (ec) return;
+            }
+            encoder.end_object(ser_context(), ec);
+            if (ec) return;
+        }
+    };
+
+} // jsoncons
+
+#endif
+