jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons/value_converter.hpp

@@ -0,0 +1,340 @@
+// Copyright 2020 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_CONVERTER_HPP
+#define JSONCONS_CONVERTER_HPP
+
+#include <system_error> // std::error_code
+#include <jsoncons/traits_extension.hpp>
+#include <jsoncons/byte_string.hpp>
+#include <jsoncons/json_type.hpp>
+#include <jsoncons/conv_error.hpp>
+#include <jsoncons/detail/write_number.hpp> // from_integer
+#include <jsoncons/tag_type.hpp>
+
+namespace jsoncons {
+
+    template <class From, class Into, class Enable = void>
+    class value_converter
+    {
+    };
+
+    template <class Into>
+    class value_converter_base
+    {
+    public:
+        using allocator_type = typename std::conditional<traits_extension::has_allocator_type<Into>::value, typename Into::allocator_type, std::allocator<char>>::type;
+    private:
+        allocator_type alloc_;
+
+    public:
+        value_converter_base(const allocator_type& alloc = allocator_type())
+            : alloc_(alloc)
+        {
+        }
+
+        allocator_type get_allocator() const noexcept
+        {
+            return alloc_;
+        }
+    };
+
+    // From any byte sequence, Into string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_byte_sequence<From>::value && !traits_extension::is_string_or_string_view<From>::value &&
+            traits_extension::is_string<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        template <class CharT = typename Into::value_type>
+        typename std::enable_if<traits_extension::is_narrow_character<CharT>::value,Into>::type
+        convert(const From& value, semantic_tag tag, std::error_code&)
+        {
+            Into s(this->get_allocator());
+            switch (tag)
+            {
+                case semantic_tag::base64:
+                    encode_base64(value.begin(), value.end(), s);
+                    break;
+                case semantic_tag::base16:
+                    encode_base16(value.begin(), value.end(), s);
+                    break;
+                default:
+                    encode_base64url(value.begin(), value.end(), s);
+                    break;
+            }
+            return s;
+        }
+        template <class CharT = typename Into::value_type>
+        typename std::enable_if<traits_extension::is_wide_character<CharT>::value,Into>::type
+        convert(const From& value, semantic_tag tag, std::error_code& ec)
+        {
+            std::string s;
+            switch (tag)
+            {
+                case semantic_tag::base64:
+                    encode_base64(value.begin(), value.end(), s);
+                    break;
+                case semantic_tag::base16:
+                    encode_base16(value.begin(), value.end(), s);
+                    break;
+                default:
+                    encode_base64url(value.begin(), value.end(), s);
+                    break;
+            }
+
+            Into ws(this->get_allocator());
+            auto retval = unicode_traits::convert(s.data(), s.size(), ws);
+            if (retval.ec != unicode_traits::conv_errc())
+            {
+                ec = conv_errc::not_wide_char;
+            }
+
+            return ws;
+        }
+    };
+
+    // From byte string, Into byte string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_byte_sequence<From>::value && 
+            !traits_extension::is_string_or_string_view<From>::value &&
+            !traits_extension::is_string_or_string_view<Into>::value && 
+            traits_extension::is_back_insertable_byte_container<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(const From& value, semantic_tag, std::error_code&)
+        {
+            Into s(value.begin(),value.end(),this->get_allocator());
+            return s;
+        }
+    };
+    
+    // From string or string_view, Into string, same character type
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_string_or_string_view<From>::value &&
+            traits_extension::is_string<Into>::value && 
+            std::is_same<typename From::value_type,typename Into::value_type>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(const From& value, semantic_tag, std::error_code&)
+        {
+            return Into(value.begin(),value.end(),this->get_allocator());
+        }
+    };
+
+    // From string or string_view, Into string, different character type
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_string_or_string_view<From>::value &&
+            traits_extension::is_string<Into>::value && 
+            !std::is_same<typename From::value_type,typename Into::value_type>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(const From& value, semantic_tag, std::error_code& ec)
+        {
+            Into ws(this->get_allocator());
+            auto retval = unicode_traits::convert(value.data(), value.size(), ws);
+            if (retval.ec != unicode_traits::conv_errc())
+            {
+                ec = conv_errc::not_wide_char;
+            }
+
+            return ws;
+        }
+    };
+
+    // From string, Into byte_string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_char_sequence<From>::value &&
+            !traits_extension::is_string_or_string_view<Into>::value && 
+            traits_extension::is_back_insertable_byte_container<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        template <class CharT = typename From::value_type>
+        typename std::enable_if<traits_extension::is_narrow_character<CharT>::value,Into>::type
+        convert(const From& value, semantic_tag tag, std::error_code& ec)
+        {
+            Into bytes(this->get_allocator());
+            switch (tag)
+            {
+                case semantic_tag::base16:
+                {
+                    auto res = decode_base16(value.begin(), value.end(), bytes);
+                    if (res.ec != conv_errc::success)
+                    {
+                        ec = conv_errc::not_byte_string;
+                    }
+                    break;
+                }
+                case semantic_tag::base64:
+                {
+                    decode_base64(value.begin(), value.end(), bytes);
+                    break;
+                }
+                case semantic_tag::base64url:
+                {
+                    decode_base64url(value.begin(), value.end(), bytes);
+                    break;
+                }
+                default:
+                {
+                    ec = conv_errc::not_byte_string;
+                    break;
+                }
+            }
+            return bytes;
+        }
+
+        template <class CharT = typename From::value_type>
+        typename std::enable_if<traits_extension::is_wide_character<CharT>::value,Into>::type
+        convert(const From& value, semantic_tag tag, std::error_code& ec)
+        {
+            Into bytes(this->get_allocator());
+
+            std::string s(this->get_allocator());
+            auto retval = unicode_traits::convert(value.data(), value.size(), s);
+            if (retval.ec != unicode_traits::conv_errc())
+            {
+                ec = conv_errc::not_wide_char;
+            }
+            switch (tag)
+            {
+                case semantic_tag::base16:
+                {
+                    auto res = decode_base16(s.begin(), s.end(), bytes);
+                    if (res.ec != conv_errc::success)
+                    {
+                        ec = conv_errc::not_byte_string;
+                    }
+                    break;
+                }
+                case semantic_tag::base64:
+                {
+                    decode_base64(s.begin(), s.end(), bytes);
+                    break;
+                }
+                case semantic_tag::base64url:
+                {
+                    decode_base64url(s.begin(), s.end(), bytes);
+                    break;
+                }
+                default:
+                {
+                    ec = conv_errc::not_byte_string;
+                    break;
+                }
+            }
+            return bytes;
+        }
+    };
+
+    // From integer, Into string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_integer<From>::value &&
+            traits_extension::is_string<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(From value, semantic_tag, std::error_code&)
+        {
+            Into s(this->get_allocator());
+            jsoncons::detail::from_integer(value, s);
+            return s;
+        }
+    };
+
+    // From integer, Into string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<std::is_floating_point<From>::value &&
+            traits_extension::is_string<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(From value, semantic_tag, std::error_code&)
+        {
+            Into s(this->get_allocator());
+            jsoncons::detail::write_double f{float_chars_format::general,0};
+            f(value, s);
+            return s;
+        }
+    };
+
+    // From half, Into string
+    template <class Into>
+    class value_converter<half_arg_t, Into,
+        typename std::enable_if<traits_extension::is_string<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+
+        Into convert(uint16_t value, semantic_tag, std::error_code&)
+        {
+            Into s(this->get_allocator());
+            jsoncons::detail::write_double f{float_chars_format::general,0};
+            double x = binary::decode_half(value);
+            f(x, s);
+            return s;
+        }
+    };
+
+    // From bool, Into string
+    template <class From, class Into>
+    class value_converter<From, Into, 
+        typename std::enable_if<traits_extension::is_bool<From>::value &&
+            traits_extension::is_string<Into>::value>::type> : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+        using char_type = typename Into::value_type;
+
+        JSONCONS_CPP14_CONSTEXPR 
+        Into convert(From value, semantic_tag, std::error_code&)
+        {
+            constexpr const char_type* true_constant = JSONCONS_CSTRING_CONSTANT(char_type,"true"); 
+            constexpr const char_type* false_constant = JSONCONS_CSTRING_CONSTANT(char_type,"false"); 
+
+            return value ? Into(true_constant,4) : Into(false_constant,5);
+        }
+    };
+
+    // From null, Into string
+    template <class Into>
+    class value_converter<null_type, Into, void>  : value_converter_base<Into>
+    {
+    public:
+        using allocator_type = typename value_converter_base<Into>::allocator_type;
+        using char_type = typename Into::value_type;
+
+        JSONCONS_CPP14_CONSTEXPR 
+        Into convert(semantic_tag, std::error_code&)
+        {
+            constexpr const char_type* null_constant = JSONCONS_CSTRING_CONSTANT(char_type,"null"); 
+
+            return Into(null_constant,4);
+        }
+    };
+
+} // namespace jsoncons
+
+#endif
+

data/lib/jsoncons/jsoncons/include/jsoncons_ext/bson/bson.hpp

@@ -0,0 +1,23 @@
+// Copyright 2013 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_BSON_BSON_HPP
+#define JSONCONS_BSON_BSON_HPP
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <type_traits> // std::enable_if
+#include <istream> // std::basic_istream
+#include <jsoncons/json.hpp>
+#include <jsoncons/config/jsoncons_config.hpp>
+#include <jsoncons_ext/bson/bson_encoder.hpp>
+#include <jsoncons_ext/bson/bson_reader.hpp>
+#include <jsoncons_ext/bson/bson_cursor.hpp>
+#include <jsoncons_ext/bson/encode_bson.hpp>
+#include <jsoncons_ext/bson/decode_bson.hpp>
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons_ext/bson/bson_cursor.hpp

@@ -0,0 +1,320 @@
+// Copyright 2018 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_BSON_BSON_CURSOR_HPP
+#define JSONCONS_BSON_BSON_CURSOR_HPP
+
+#include <memory> // std::allocator
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <system_error>
+#include <ios>
+#include <istream> // std::basic_istream
+#include <jsoncons/byte_string.hpp>
+#include <jsoncons/config/jsoncons_config.hpp>
+#include <jsoncons/json_visitor.hpp>
+#include <jsoncons/json_exception.hpp>
+#include <jsoncons/staj_cursor.hpp>
+#include <jsoncons/source.hpp>
+#include <jsoncons_ext/bson/bson_parser.hpp>
+
+namespace jsoncons { 
+namespace bson {
+
+template<class Source=jsoncons::binary_stream_source,class Allocator=std::allocator<char>>
+class basic_bson_cursor : public basic_staj_cursor<char>, private virtual ser_context
+{
+    using super_type = basic_staj_cursor<char>;
+public:
+    using source_type = Source;
+    using char_type = char;
+    using allocator_type = Allocator;
+private:
+    basic_bson_parser<Source,Allocator> parser_;
+    basic_staj_visitor<char_type> cursor_visitor_;
+    bool eof_;
+
+    // Noncopyable and nonmoveable
+    basic_bson_cursor(const basic_bson_cursor&) = delete;
+    basic_bson_cursor& operator=(const basic_bson_cursor&) = delete;
+
+public:
+    using string_view_type = string_view;
+
+    template <class Sourceable>
+    basic_bson_cursor(Sourceable&& source,
+                      const bson_decode_options& options = bson_decode_options(),
+                      const Allocator& alloc = Allocator())
+        : parser_(std::forward<Sourceable>(source), options, alloc), 
+          cursor_visitor_(accept_all),
+          eof_(false)
+    {
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    // Constructors that set parse error codes
+
+    template <class Sourceable>
+    basic_bson_cursor(Sourceable&& source,
+                      std::error_code& ec)
+        : basic_bson_cursor(std::allocator_arg, Allocator(),
+                            std::forward<Sourceable>(source), 
+                            bson_decode_options(), 
+                            ec)
+    {
+    }
+
+    template <class Sourceable>
+    basic_bson_cursor(Sourceable&& source,
+                      const bson_decode_options& options,
+                      std::error_code& ec)
+        : basic_bson_cursor(std::allocator_arg, Allocator(),
+                            std::forward<Sourceable>(source), 
+                            options, 
+                            ec)
+    {
+    }
+
+    template <class Sourceable>
+    basic_bson_cursor(std::allocator_arg_t, const Allocator& alloc, 
+                      Sourceable&& source,
+                      const bson_decode_options& options,
+                      std::error_code& ec)
+       : parser_(std::forward<Sourceable>(source), options, alloc),
+         cursor_visitor_(accept_all),
+         eof_(false)
+    {
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    void reset()
+    {
+        parser_.reset();
+        cursor_visitor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    template <class Sourceable>
+    void reset(Sourceable&& source)
+    {
+        parser_.reset(std::forward<Sourceable>(source));
+        cursor_visitor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    void reset(std::error_code& ec)
+    {
+        parser_.reset();
+        cursor_visitor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    template <class Sourceable>
+    void reset(Sourceable&& source, std::error_code& ec)
+    {
+        parser_.reset(std::forward<Sourceable>(source));
+        cursor_visitor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    bool done() const override
+    {
+        return parser_.done();
+    }
+
+    void array_expected(std::error_code& ec) override
+    {
+        if (cursor_visitor_.event().event_type() == staj_event_type::begin_object)
+        {
+            parser_.array_expected(cursor_visitor_, ec);
+        }
+        else
+        { 
+            super_type::array_expected(ec);
+        }
+    }
+
+    const staj_event& current() const override
+    {
+        return cursor_visitor_.event();
+    }
+
+    void read_to(basic_json_visitor<char_type>& visitor) override
+    {
+        std::error_code ec;
+        read_to(visitor, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column()));
+        }
+    }
+
+    void read_to(basic_json_visitor<char_type>& visitor,
+                std::error_code& ec) override
+    {
+        if (send_json_event(cursor_visitor_.event(), visitor, *this, ec))
+        {
+            read_next(visitor, ec);
+        }
+    }
+
+    void next() override
+    {
+        std::error_code ec;
+        next(ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column()));
+        }
+    }
+
+    void next(std::error_code& ec) override
+    {
+        read_next(ec);
+    }
+
+    const ser_context& context() const override
+    {
+        return *this;
+    }
+
+    bool eof() const
+    {
+        return eof_;
+    }
+
+    std::size_t line() const override
+    {
+        return parser_.line();
+    }
+
+    std::size_t column() const override
+    {
+        return parser_.column();
+    }
+
+    friend
+    staj_filter_view operator|(basic_bson_cursor& cursor, 
+                               std::function<bool(const staj_event&, const ser_context&)> pred)
+    {
+        return staj_filter_view(cursor, pred);
+    }
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+
+    template <class Sourceable>
+    JSONCONS_DEPRECATED_MSG("Instead, use pipe syntax for filter")
+    basic_bson_cursor(Sourceable&& source,
+                      std::function<bool(const staj_event&, const ser_context&)> filter,
+                      std::error_code& ec)
+       : basic_bson_cursor(std::allocator_arg, Allocator(), 
+                           std::forward<Sourceable>(source), filter, ec)
+    {
+    }
+
+    template <class Sourceable>
+    JSONCONS_DEPRECATED_MSG("Instead, use pipe syntax for filter")
+    basic_bson_cursor(Sourceable&& source,
+                      std::function<bool(const staj_event&, const ser_context&)> filter,
+                      const bson_decode_options& options = bson_decode_options(),
+                      const Allocator& alloc = Allocator())
+       : parser_(std::forward<Sourceable>(source), options, alloc), 
+         cursor_visitor_(filter), 
+         eof_(false)
+    {
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    template <class Sourceable>
+    JSONCONS_DEPRECATED_MSG("Instead, use pipe syntax for filter")
+    basic_bson_cursor(std::allocator_arg_t, const Allocator& alloc, 
+                      Sourceable&& source,
+                      std::function<bool(const staj_event&, const ser_context&)> filter, 
+                      std::error_code& ec)
+       : parser_(std::forward<Sourceable>(source),alloc), 
+         cursor_visitor_(filter),
+         eof_(false)
+    {
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    JSONCONS_DEPRECATED_MSG("Instead, use read_to(basic_json_visitor<char_type>&)")
+    void read(basic_json_visitor<char_type>& visitor)
+    {
+        read_to(visitor);
+    }
+
+    JSONCONS_DEPRECATED_MSG("Instead, use read_to(basic_json_visitor<char_type>&, std::error_code&)")
+    void read(basic_json_visitor<char_type>& visitor,
+                 std::error_code& ec) 
+    {
+        read_to(visitor, ec);
+    }
+#endif
+private:
+    static bool accept_all(const staj_event&, const ser_context&) 
+    {
+        return true;
+    }
+
+    void read_next(std::error_code& ec)
+    {
+        parser_.restart();
+        while (!parser_.stopped())
+        {
+            parser_.parse(cursor_visitor_, ec);
+            if (ec) return;
+        }
+    }
+
+    void read_next(basic_json_visitor<char_type>& visitor, std::error_code& ec)
+    {
+        parser_.restart();
+        while (!parser_.stopped())
+        {
+            parser_.parse(visitor, ec);
+            if (ec) return;
+        }
+    }
+};
+
+using bson_stream_cursor = basic_bson_cursor<jsoncons::binary_stream_source>;
+using bson_bytes_cursor = basic_bson_cursor<jsoncons::bytes_source>;
+
+} // namespace bson
+} // namespace jsoncons
+
+#endif
+