jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons_ext/cbor/cbor_cursor.hpp

@@ -0,0 +1,351 @@
+// 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_CBOR_CBOR_CURSOR_HPP
+#define JSONCONS_CBOR_CBOR_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/cbor/cbor_parser.hpp>
+
+namespace jsoncons { 
+namespace cbor {
+
+template<class Source=jsoncons::binary_stream_source,class Allocator=std::allocator<char>>
+class basic_cbor_cursor : public basic_staj_cursor<char>, private virtual ser_context
+{
+public:
+    using source_type = Source;
+    using char_type = char;
+    using allocator_type = Allocator;
+private:
+    basic_cbor_parser<Source,Allocator> parser_;
+    basic_staj_visitor<char_type> cursor_visitor_;
+    basic_json_visitor2_to_visitor_adaptor<char_type,Allocator> cursor_handler_adaptor_;
+    bool eof_;
+
+    // Noncopyable and nonmoveable
+    basic_cbor_cursor(const basic_cbor_cursor&) = delete;
+    basic_cbor_cursor& operator=(const basic_cbor_cursor&) = delete;
+
+public:
+    using string_view_type = string_view;
+
+    template <class Sourceable>
+    basic_cbor_cursor(Sourceable&& source,
+                      const cbor_decode_options& options = cbor_decode_options(),
+                      const Allocator& alloc = Allocator())
+        : parser_(std::forward<Sourceable>(source), options, alloc), 
+          cursor_visitor_(accept_all), 
+          cursor_handler_adaptor_(cursor_visitor_, alloc),
+          eof_(false)
+    {
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    // Constructors that set parse error codes
+
+    template <class Sourceable>
+    basic_cbor_cursor(Sourceable&& source, 
+                      std::error_code& ec)
+        : basic_cbor_cursor(std::allocator_arg, Allocator(),
+                            std::forward<Sourceable>(source), 
+                            cbor_decode_options(), 
+                            ec)
+    {
+    }
+
+    template <class Sourceable>
+    basic_cbor_cursor(Sourceable&& source, 
+                      const cbor_decode_options& options,
+                      std::error_code& ec)
+        : basic_cbor_cursor(std::allocator_arg, Allocator(),
+                            std::forward<Sourceable>(source), 
+                            options, 
+                            ec)
+    {
+    }
+
+    template <class Sourceable>
+    basic_cbor_cursor(std::allocator_arg_t, const Allocator& alloc, 
+                      Sourceable&& source,
+                      const cbor_decode_options& options,
+                      std::error_code& ec)
+       : parser_(std::forward<Sourceable>(source), options, alloc), 
+         cursor_visitor_(accept_all),
+         cursor_handler_adaptor_(cursor_visitor_, alloc),
+         eof_(false)
+    {
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    void reset()
+    {
+        parser_.reset();
+        cursor_visitor_.reset();
+        cursor_handler_adaptor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    template <class Sourceable>
+    void reset(Sourceable&& source)
+    {
+        parser_.reset(std::forward<Sourceable>(source));
+        cursor_visitor_.reset();
+        cursor_handler_adaptor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    void reset(std::error_code& ec)
+    {
+        parser_.reset();
+        cursor_visitor_.reset();
+        cursor_handler_adaptor_.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();
+        cursor_handler_adaptor_.reset();
+        eof_ = false;
+        if (!done())
+        {
+            next(ec);
+        }
+    }
+
+    bool done() const override
+    {
+        return parser_.done();
+    }
+
+    bool is_typed_array() const
+    {
+        return cursor_visitor_.is_typed_array();
+    }
+
+    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 (cursor_visitor_.dump(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_cbor_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_cbor_cursor(Sourceable&& source,
+                      std::function<bool(const staj_event&, const ser_context&)> filter,
+                      const cbor_decode_options& options = cbor_decode_options(),
+                      const Allocator& alloc = Allocator())
+       : parser_(std::forward<Sourceable>(source), options, alloc), 
+         cursor_visitor_(filter), 
+         cursor_handler_adaptor_(cursor_visitor_, alloc),
+         eof_(false)
+    {
+        if (!done())
+        {
+            next();
+        }
+    }
+
+    template <class Sourceable>
+    JSONCONS_DEPRECATED_MSG("Instead, use pipe syntax for filter")
+    basic_cbor_cursor(Sourceable&& source,
+                      std::function<bool(const staj_event&, const ser_context&)> filter,
+                      std::error_code& ec)
+        : basic_cbor_cursor(std::allocator_arg, Allocator(),
+                            std::forward<Sourceable>(source), filter, ec)
+    {
+    }
+
+    template <class Sourceable>
+    JSONCONS_DEPRECATED_MSG("Instead, use pipe syntax for filter")
+    basic_cbor_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),
+         cursor_handler_adaptor_(cursor_visitor_, alloc),
+         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)
+    {
+        if (cursor_visitor_.in_available())
+        {
+            cursor_visitor_.send_available(ec);
+        }
+        else
+        {
+            parser_.restart();
+            while (!parser_.stopped())
+            {
+                parser_.parse(cursor_handler_adaptor_, ec);
+                if (ec) return;
+            }
+        }
+    }
+
+    void read_next(basic_json_visitor<char_type>& visitor, std::error_code& ec)
+    {
+        {
+            struct resource_wrapper
+            {
+                basic_json_visitor2_to_visitor_adaptor<char_type,Allocator>& adaptor;
+                basic_json_visitor<char_type>& original;
+
+                resource_wrapper(basic_json_visitor2_to_visitor_adaptor<char_type,Allocator>& adaptor,
+                                 basic_json_visitor<char_type>& visitor)
+                    : adaptor(adaptor), original(adaptor.destination())
+                {
+                    adaptor.destination(visitor);
+                }
+
+                ~resource_wrapper()
+                {
+                    adaptor.destination(original);
+                }
+            } wrapper(cursor_handler_adaptor_, visitor);
+
+            parser_.restart();
+            while (!parser_.stopped())
+            {
+                parser_.parse(cursor_handler_adaptor_, ec);
+                if (ec)
+                {
+                    return;
+                }
+            }
+        }
+    }
+};
+
+using cbor_stream_cursor = basic_cbor_cursor<jsoncons::binary_stream_source>;
+using cbor_bytes_cursor = basic_cbor_cursor<jsoncons::bytes_source>;
+
+} // namespace cbor
+} // namespace jsoncons
+
+#endif
+

data/lib/jsoncons/jsoncons/include/jsoncons_ext/cbor/cbor_cursor2.hpp

@@ -0,0 +1,265 @@
+// 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_CBOR_CBOR_CURSOR2_HPP
+#define JSONCONS_CBOR_CBOR_CURSOR2_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_visitor2.hpp>
+#include <jsoncons/json_exception.hpp>
+#include <jsoncons/staj2_cursor.hpp>
+#include <jsoncons/source.hpp>
+#include <jsoncons_ext/cbor/cbor_parser.hpp>
+
+namespace jsoncons { 
+namespace cbor {
+
+    template<class Source=jsoncons::binary_stream_source,class Allocator=std::allocator<char>>
+    class basic_cbor_cursor2 : public basic_staj2_cursor<char>, private virtual ser_context
+    {
+    public:
+        using source_type = Source;
+        using char_type = char;
+        using allocator_type = Allocator;
+    private:
+        basic_cbor_parser<Source,Allocator> parser_;
+        basic_staj2_visitor<char_type> cursor_visitor_;
+        bool eof_;
+
+        // Noncopyable and nonmoveable
+        basic_cbor_cursor2(const basic_cbor_cursor2&) = delete;
+        basic_cbor_cursor2& operator=(const basic_cbor_cursor2&) = delete;
+
+    public:
+        using string_view_type = string_view;
+
+        template <class Sourceable>
+        basic_cbor_cursor2(Sourceable&& source,
+                          const cbor_decode_options& options = cbor_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_cbor_cursor2(Sourceable&& source, 
+                          std::error_code& ec)
+            : basic_cbor_cursor2(std::allocator_arg, Allocator(),
+                                std::forward<Sourceable>(source), 
+                                cbor_decode_options(), 
+                                ec)
+        {
+        }
+
+        template <class Sourceable>
+        basic_cbor_cursor2(Sourceable&& source, 
+                          const cbor_decode_options& options,
+                          std::error_code& ec)
+            : basic_cbor_cursor2(std::allocator_arg, Allocator(),
+                                std::forward<Sourceable>(source), 
+                                options, 
+                                ec)
+        {
+        }
+
+        template <class Sourceable>
+        basic_cbor_cursor2(std::allocator_arg_t, const Allocator& alloc, 
+                          Sourceable&& source,
+                          const cbor_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();
+        }
+
+        bool is_typed_array() const
+        {
+            return cursor_visitor_.is_typed_array();
+        }
+
+        const staj2_event& current() const override
+        {
+            return cursor_visitor_.event();
+        }
+
+        void read_to(basic_json_visitor2<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_visitor2<char_type>& visitor,
+                     std::error_code& ec) override
+        {
+            if (cursor_visitor_.dump(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
+        staj2_filter_view operator|(basic_cbor_cursor2& cursor, 
+                                   std::function<bool(const staj2_event&, const ser_context&)> pred)
+        {
+            return staj2_filter_view(cursor, pred);
+        }
+
+    private:
+        static bool accept_all(const staj2_event&, const ser_context&) 
+        {
+            return true;
+        }
+
+        void read_next(std::error_code& ec)
+        {
+            if (cursor_visitor_.in_available())
+            {
+                cursor_visitor_.send_available(ec);
+            }
+            else
+            {
+                parser_.restart();
+                while (!parser_.stopped())
+                {
+                    parser_.parse(cursor_visitor_, ec);
+                    if (ec) return;
+                }
+            }
+        }
+
+        void read_next(basic_json_visitor2<char_type>& visitor, std::error_code& ec)
+        {
+            parser_.restart();
+            while (!parser_.stopped())
+            {
+                parser_.parse(visitor, ec);
+                if (ec)
+                {
+                    return;
+                }
+            }
+        }
+    };
+
+    using cbor_stream_cursor2 = basic_cbor_cursor2<jsoncons::binary_stream_source>;
+    using cbor_bytes_cursor2 = basic_cbor_cursor2<jsoncons::bytes_source>;
+
+} // namespace cbor
+} // namespace jsoncons
+
+#endif
+

data/lib/jsoncons/jsoncons/include/jsoncons_ext/cbor/cbor_detail.hpp

@@ -0,0 +1,93 @@
+// 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_CBOR_CBOR_DETAIL_HPP
+#define JSONCONS_CBOR_CBOR_DETAIL_HPP
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <iterator> // std::forward_iterator_tag
+#include <limits> // std::numeric_limits
+#include <utility> // std::move
+#include <jsoncons/json.hpp>
+#include <jsoncons/json_visitor.hpp>
+#include <jsoncons/config/jsoncons_config.hpp>
+
+// 0x00..0x17 (0..23)
+#define JSONCONS_CBOR_0x00_0x17 \
+    0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x17
+
+#define JSONCONS_CBOR_ARRAY_TAGS \
+    0x40:case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:case 0x47:case 0x48:case 0x49:case 0x4a:case 0x4b:case 0x4c:case 0x4d:case 0x4e:case 0x4f:case 0x50:case 0x51:case 0x52:case 0x53:case 0x54:case 0x55:case 0x56:case 0x57    
+
+namespace jsoncons { namespace cbor { namespace detail {
+
+//const uint8_t cbor_array_tags_010_mask = 0b11100000;
+//const uint8_t cbor_array_tags_f_mask = 0b00010000;
+//const uint8_t cbor_array_tags_s_mask = 0b00001000;
+//const uint8_t cbor_array_tags_e_mask = 0b00000100;
+//const uint8_t cbor_array_tags_ll_mask = 0b00000011;
+
+const uint8_t cbor_array_tags_010_mask = 0xE0;
+const uint8_t cbor_array_tags_f_mask = 0x10;
+const uint8_t cbor_array_tags_s_mask = 0x08;
+const uint8_t cbor_array_tags_e_mask = 0x04;
+const uint8_t cbor_array_tags_ll_mask = 0x03;
+
+const uint8_t cbor_array_tags_010_shift = 5;
+const uint8_t cbor_array_tags_f_shift = 4;
+const uint8_t cbor_array_tags_s_shift = 3;
+const uint8_t cbor_array_tags_e_shift = 2;
+const uint8_t cbor_array_tags_ll_shift = 0;
+
+enum class cbor_major_type : uint8_t
+{
+    unsigned_integer = 0x00,
+    negative_integer = 0x01,
+    byte_string = 0x02,
+    text_string = 0x03,
+    array = 0x04,
+    map = 0x05,   
+    semantic_tag = 0x06,
+    simple = 0x7
+};
+
+namespace additional_info
+{
+    const uint8_t indefinite_length = 0x1f;
+}
+
+inline
+size_t min_length_for_stringref(uint64_t index)
+{
+    std::size_t n;
+    if (index <= 23)
+    {
+        n = 3;
+    }
+    else if (index <= 255)
+    {
+        n = 4;
+    }
+    else if (index <= 65535)
+    {
+        n = 5;
+    }
+    else if (index <= 4294967295)
+    {
+        n = 7;
+    }
+    else 
+    {
+        n = 11;
+    }
+    return n;
+}
+
+}}}
+
+#endif