jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons/staj_iterator.hpp

@@ -0,0 +1,449 @@
+// 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_STAJ_ITERATOR_HPP
+#define JSONCONS_STAJ_ITERATOR_HPP
+
+#include <new> // placement new
+#include <memory>
+#include <string>
+#include <stdexcept>
+#include <system_error>
+#include <ios>
+#include <iterator> // std::input_iterator_tag
+#include <jsoncons/json_exception.hpp>
+#include <jsoncons/staj_cursor.hpp>
+#include <jsoncons/basic_json.hpp>
+#include <jsoncons/decode_traits.hpp>
+
+namespace jsoncons {
+
+    template <class T, class Json>
+    class staj_array_view;
+
+    template<class T, class Json>
+    class staj_array_iterator
+    {
+        using char_type = typename Json::char_type;
+
+        staj_array_view<T, Json>* view_;
+        std::exception_ptr eptr_;
+
+    public:
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        using pointer = T*;
+        using reference = T&;
+        using iterator_category = std::input_iterator_tag;
+
+        staj_array_iterator() noexcept
+            : view_(nullptr)
+        {
+        }
+
+        staj_array_iterator(staj_array_view<T, Json>& view)
+            : view_(std::addressof(view))
+        {
+            if (view_->cursor_->current().event_type() == staj_event_type::begin_array)
+            {
+                next();
+            }
+            else
+            {
+                view_->cursor_ = nullptr;
+            }
+        }
+
+        staj_array_iterator(staj_array_view<T, Json>& view,
+                            std::error_code& ec)
+            : view_(std::addressof(view))
+        {
+            if (view_->cursor_->current().event_type() == staj_event_type::begin_array)
+            {
+                next(ec);
+                if (ec) {view_ = nullptr;}
+            }
+            else
+            {
+                view_ = nullptr;
+            }
+        }
+
+        ~staj_array_iterator() noexcept
+        {
+        }
+
+        bool has_value() const
+        {
+            return !eptr_;
+        }
+
+        const T& operator*() const
+        {
+            if (eptr_)
+            {
+                 std::rethrow_exception(eptr_);
+            }
+            else
+            {
+                return *view_->value_;
+            }
+        }
+
+        const T* operator->() const
+        {
+            if (eptr_)
+            {
+                 std::rethrow_exception(eptr_);
+            }
+            else
+            {
+                return view_->value_.operator->();
+            }
+        }
+
+        staj_array_iterator& operator++()
+        {
+            next();
+            return *this;
+        }
+
+        staj_array_iterator& increment(std::error_code& ec)
+        {
+            next(ec);
+            if (ec) {view_ = nullptr;}
+            return *this;
+        }
+
+        staj_array_iterator operator++(int) // postfix increment
+        {
+            staj_array_iterator temp(*this);
+            next();
+            return temp;
+        }
+
+        friend bool operator==(const staj_array_iterator& a, const staj_array_iterator& b)
+        {
+            return (!a.view_ && !b.view_)
+                || (!a.view_ && b.done())
+                || (!b.view_ && a.done());
+        }
+
+        friend bool operator!=(const staj_array_iterator& a, const staj_array_iterator& b)
+        {
+            return !(a == b);
+        }
+
+    private:
+
+        bool done() const
+        {
+            return view_->cursor_->done() || view_->cursor_->current().event_type() == staj_event_type::end_array;
+        }
+
+        void next()
+        {
+            std::error_code ec;
+            next(ec);
+            if (ec)
+            {
+                JSONCONS_THROW(ser_error(ec, view_->cursor_->context().line(), view_->cursor_->context().column()));
+            }
+        }
+
+        void next(std::error_code& ec)
+        {
+            using char_type = typename Json::char_type;
+
+            if (!done())
+            {
+                view_->cursor_->next(ec);
+                if (ec)
+                {
+                    return;
+                }
+                if (!done())
+                {
+                    eptr_ = std::exception_ptr();
+                    JSONCONS_TRY
+                    {
+                        view_->value_ = decode_traits<T,char_type>::decode(*view_->cursor_, view_->decoder_, ec);
+                    }
+                    JSONCONS_CATCH(const conv_error&)
+                    {
+                        eptr_ = std::current_exception();
+                    }
+                }
+            }
+        }
+    };
+
+    template <class Key,class Json,class T=Json>
+    class staj_object_view;
+
+    template <class Key, class T, class Json>
+    class staj_object_iterator
+    {
+        using char_type = typename Json::char_type;
+
+        staj_object_view<Key, T, Json>* view_;
+        std::exception_ptr eptr_;
+    public:
+        using key_type = std::basic_string<char_type>;
+        using value_type = std::pair<key_type,T>;
+        using difference_type = std::ptrdiff_t;
+        using pointer = value_type*;
+        using reference = value_type&;
+        using iterator_category = std::input_iterator_tag;
+
+    public:
+
+        staj_object_iterator() noexcept
+            : view_(nullptr)
+        {
+        }
+
+        staj_object_iterator(staj_object_view<Key, T, Json>& view)
+            : view_(std::addressof(view))
+        {
+            if (view_->cursor_->current().event_type() == staj_event_type::begin_object)
+            {
+                next();
+            }
+            else
+            {
+                view_ = nullptr;
+            }
+        }
+
+        staj_object_iterator(staj_object_view<Key, T, Json>& view, 
+                             std::error_code& ec)
+            : view_(std::addressof(view))
+        {
+            if (view_->cursor_->current().event_type() == staj_event_type::begin_object)
+            {
+                next(ec);
+                if (ec) {view_ = nullptr;}
+            }
+            else
+            {
+                view_ = nullptr;
+            }
+        }
+
+        ~staj_object_iterator() noexcept
+        {
+        }
+
+        bool has_value() const
+        {
+            return !eptr_;
+        }
+
+        const value_type& operator*() const
+        {
+            if (eptr_)
+            {
+                 std::rethrow_exception(eptr_);
+            }
+            else
+            {
+                return *view_->key_value_;
+            }
+        }
+
+        const value_type* operator->() const
+        {
+            if (eptr_)
+            {
+                 std::rethrow_exception(eptr_);
+            }
+            else
+            {
+                return view_->key_value_.operator->();
+            }
+        }
+
+        staj_object_iterator& operator++()
+        {
+            next();
+            return *this;
+        }
+
+        staj_object_iterator& increment(std::error_code& ec)
+        {
+            next(ec);
+            if (ec)
+            {
+                view_ = nullptr;
+            }
+            return *this;
+        }
+
+        staj_object_iterator operator++(int) // postfix increment
+        {
+            staj_object_iterator temp(*this);
+            next();
+            return temp;
+        }
+
+        friend bool operator==(const staj_object_iterator& a, const staj_object_iterator& b)
+        {
+            return (!a.view_ && !b.view_)
+                   || (!a.view_ && b.done())
+                   || (!b.view_ && a.done());
+        }
+
+        friend bool operator!=(const staj_object_iterator& a, const staj_object_iterator& b)
+        {
+            return !(a == b);
+        }
+
+    private:
+
+        bool done() const
+        {
+            return view_->cursor_->done() || view_->cursor_->current().event_type() == staj_event_type::end_object;
+        }
+
+        void next()
+        {
+            std::error_code ec;
+            next(ec);
+            if (ec)
+            {
+                JSONCONS_THROW(ser_error(ec, view_->cursor_->context().line(), view_->cursor_->context().column()));
+            }
+        }
+
+        void next(std::error_code& ec)
+        {
+            using char_type = typename Json::char_type;
+
+            view_->cursor_->next(ec);
+            if (ec)
+            {
+                return;
+            }
+            if (!done())
+            {
+                JSONCONS_ASSERT(view_->cursor_->current().event_type() == staj_event_type::key);
+                auto key = view_->cursor_->current(). template get<key_type>();
+                view_->cursor_->next(ec);
+                if (ec)
+                {
+                    return;
+                }
+                if (!done())
+                {
+                    eptr_ = std::exception_ptr();
+                    JSONCONS_TRY
+                    {
+                        view_->key_value_ = value_type(std::move(key),decode_traits<T,char_type>::decode(*view_->cursor_, view_->decoder_, ec));
+                    }
+                    JSONCONS_CATCH(const conv_error&)
+                    {
+                        eptr_ = std::current_exception();
+                    }
+                }
+            }
+        }
+    };
+
+    // staj_array_view
+
+    template <class T, class Json>
+    class staj_array_view
+    {
+        friend class staj_array_iterator<T, Json>;
+    public:
+        using char_type = typename Json::char_type;
+        using iterator = staj_array_iterator<T, Json>;
+    private:
+        basic_staj_cursor<char_type>* cursor_;
+        json_decoder<Json> decoder_;
+        jsoncons::optional<T> value_;
+    public:
+        staj_array_view(basic_staj_cursor<char_type>& cursor) 
+            : cursor_(std::addressof(cursor))
+        {
+        }
+
+        iterator begin()
+        {
+            return staj_array_iterator<T, Json>(*this);
+        }
+
+        iterator end()
+        {
+            return staj_array_iterator<T, Json>();
+        }
+    };
+
+    // staj_object_view
+
+    template <class Key, class T, class Json>
+    class staj_object_view
+    {
+        friend class staj_object_iterator<Key,T,Json>;
+    public:
+        using char_type = typename Json::char_type;
+        using iterator = staj_object_iterator<Key,T,Json>;
+        using key_type = std::basic_string<char_type>;
+        using value_type = std::pair<key_type,T>;
+    private:
+        basic_staj_cursor<char_type>* cursor_;
+        json_decoder<Json> decoder_;
+        jsoncons::optional<value_type> key_value_;
+    public:
+        staj_object_view(basic_staj_cursor<char_type>& cursor) 
+            : cursor_(std::addressof(cursor))
+        {
+        }
+
+        iterator begin()
+        {
+            return staj_object_iterator<Key,T,Json>(*this);
+        }
+
+        iterator end()
+        {
+            return staj_object_iterator<Key,T,Json>();
+        }
+    };
+
+    template <class T, class CharT, class Json=typename std::conditional<traits_extension::is_basic_json<T>::value,T,basic_json<CharT>>::type>
+    staj_array_view<T, Json> staj_array(basic_staj_cursor<CharT>& cursor)
+    {
+        return staj_array_view<T, Json>(cursor);
+    }
+
+    template <class Key, class T, class CharT, class Json=typename std::conditional<traits_extension::is_basic_json<T>::value,T,basic_json<CharT>>::type>
+    staj_object_view<Key, T, Json> staj_object(basic_staj_cursor<CharT>& cursor)
+    {
+        return staj_object_view<Key, T, Json>(cursor);
+    }
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+    template <class T, class CharT, class Json=typename std::conditional<traits_extension::is_basic_json<T>::value,T,basic_json<CharT>>::type>
+    JSONCONS_DEPRECATED_MSG("Instead, use staj_array()")
+    staj_array_view<T, Json> make_array_iterator(basic_staj_cursor<CharT>& cursor)
+    {
+        return staj_array_view<T, Json>(cursor);
+    }
+
+    template <class T, class CharT, class Json=typename std::conditional<traits_extension::is_basic_json<T>::value,T,basic_json<CharT>>::type>
+    JSONCONS_DEPRECATED_MSG("Instead, use staj_object()")
+    staj_object_view<std::basic_string<CharT>, T, Json> make_object_iterator(basic_staj_cursor<CharT>& cursor)
+    {
+        return staj_object_view<std::basic_string<CharT>, T, Json>(cursor);
+    }
+#endif
+
+} // namespace jsoncons
+
+#endif
+

data/lib/jsoncons/jsoncons/include/jsoncons/tag_type.hpp

@@ -0,0 +1,245 @@
+// Copyright 2019 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_TAG_TYPE_HPP
+#define JSONCONS_TAG_TYPE_HPP
+
+#include <ostream>
+#include <jsoncons/config/jsoncons_config.hpp>
+
+namespace jsoncons {
+
+struct null_type
+{
+    explicit null_type() = default; 
+};
+
+struct temp_allocator_arg_t
+{
+    explicit temp_allocator_arg_t() = default; 
+};
+
+constexpr temp_allocator_arg_t temp_allocator_arg{};
+
+struct result_allocator_arg_t
+{
+    explicit result_allocator_arg_t() = default; 
+};
+
+constexpr result_allocator_arg_t result_allocator_arg{};
+
+struct half_arg_t
+{
+    explicit half_arg_t() = default; 
+};
+
+constexpr half_arg_t half_arg{};
+
+struct json_array_arg_t
+{
+    explicit json_array_arg_t() = default; 
+};
+
+constexpr json_array_arg_t json_array_arg{};
+
+struct json_object_arg_t
+{
+    explicit json_object_arg_t() = default; 
+};
+
+constexpr json_object_arg_t json_object_arg{};
+
+struct byte_string_arg_t
+{
+    explicit byte_string_arg_t() = default; 
+};
+
+constexpr byte_string_arg_t byte_string_arg{};
+
+struct json_const_pointer_arg_t
+{
+    explicit json_const_pointer_arg_t() = default; 
+};
+
+constexpr json_const_pointer_arg_t json_const_pointer_arg{};
+ 
+enum class semantic_tag : uint8_t 
+{
+    none = 0,
+    undefined = 0x01,
+    datetime = 0x02,
+    epoch_second = 0x03,
+    epoch_milli = 0x04,
+    epoch_nano = 0x05,
+    bigint = 0x06,
+    bigdec = 0x07,
+    bigfloat = 0x08,
+    float128 = 0x09,
+    base16 = 0x1a,
+    base64 = 0x1b,
+    base64url = 0x1c,
+    uri = 0x0d,
+    clamped = 0x0e,
+    multi_dim_row_major = 0x0f,
+    multi_dim_column_major = 0x10,
+    ext = 0x11,
+    id = 0x12,
+    regex = 0x13,
+    code = 0x14
+#if !defined(JSONCONS_NO_DEPRECATED)
+    , big_integer = bigint
+    , big_decimal = bigdec
+    , big_float = bigfloat
+    , date_time = datetime
+    , timestamp = epoch_second
+#endif
+};
+
+template <class CharT>
+std::basic_ostream<CharT>& operator<<(std::basic_ostream<CharT>& os, semantic_tag tag)
+{
+    static constexpr const CharT* na_name = JSONCONS_CSTRING_CONSTANT(CharT, "n/a");
+    static constexpr const CharT* undefined_name = JSONCONS_CSTRING_CONSTANT(CharT, "undefined");
+    static constexpr const CharT* datetime_name = JSONCONS_CSTRING_CONSTANT(CharT, "datetime");
+    static constexpr const CharT* epoch_second_name = JSONCONS_CSTRING_CONSTANT(CharT, "epoch-second");
+    static constexpr const CharT* epoch_milli_name = JSONCONS_CSTRING_CONSTANT(CharT, "epoch-milli");
+    static constexpr const CharT* epoch_nano_name = JSONCONS_CSTRING_CONSTANT(CharT, "epoch-nano");
+    static constexpr const CharT* bigint_name = JSONCONS_CSTRING_CONSTANT(CharT, "bigint");
+    static constexpr const CharT* bigdec_name = JSONCONS_CSTRING_CONSTANT(CharT, "bigdec");
+    static constexpr const CharT* bigfloat_name = JSONCONS_CSTRING_CONSTANT(CharT, "bigfloat");
+    static constexpr const CharT* base16_name = JSONCONS_CSTRING_CONSTANT(CharT, "base16");
+    static constexpr const CharT* base64_name = JSONCONS_CSTRING_CONSTANT(CharT, "base64");
+    static constexpr const CharT* base64url_name = JSONCONS_CSTRING_CONSTANT(CharT, "base64url");
+    static constexpr const CharT* uri_name = JSONCONS_CSTRING_CONSTANT(CharT, "uri");
+    static constexpr const CharT* clamped_name = JSONCONS_CSTRING_CONSTANT(CharT, "clamped");
+    static constexpr const CharT* multi_dim_row_major_name = JSONCONS_CSTRING_CONSTANT(CharT, "multi-dim-row-major");
+    static constexpr const CharT* multi_dim_column_major_name = JSONCONS_CSTRING_CONSTANT(CharT, "multi-dim-column-major");
+    static constexpr const CharT* ext_name = JSONCONS_CSTRING_CONSTANT(CharT, "ext");
+    static constexpr const CharT* id_name = JSONCONS_CSTRING_CONSTANT(CharT, "id");
+    static constexpr const CharT*  float128_name = JSONCONS_CSTRING_CONSTANT(CharT, "float128");
+    static constexpr const CharT*  regex_name = JSONCONS_CSTRING_CONSTANT(CharT, "regex");
+    static constexpr const CharT*  code_name = JSONCONS_CSTRING_CONSTANT(CharT, "code");
+
+    switch (tag)
+    {
+        case semantic_tag::none:
+        {
+            os << na_name;
+            break;
+        }
+        case semantic_tag::undefined:
+        {
+            os << undefined_name;
+            break;
+        }
+        case semantic_tag::datetime:
+        {
+            os << datetime_name;
+            break;
+        }
+        case semantic_tag::epoch_second:
+        {
+            os << epoch_second_name;
+            break;
+        }
+        case semantic_tag::epoch_milli:
+        {
+            os << epoch_milli_name;
+            break;
+        }
+        case semantic_tag::epoch_nano:
+        {
+            os << epoch_nano_name;
+            break;
+        }
+        case semantic_tag::bigint:
+        {
+            os << bigint_name;
+            break;
+        }
+        case semantic_tag::bigdec:
+        {
+            os << bigdec_name;
+            break;
+        }
+        case semantic_tag::bigfloat:
+        {
+            os << bigfloat_name;
+            break;
+        }
+        case semantic_tag::float128:
+        {
+            os << float128_name;
+            break;
+        }
+        case semantic_tag::base16:
+        {
+            os << base16_name;
+            break;
+        }
+        case semantic_tag::base64:
+        {
+            os << base64_name;
+            break;
+        }
+        case semantic_tag::base64url:
+        {
+            os << base64url_name;
+            break;
+        }
+        case semantic_tag::uri:
+        {
+            os << uri_name;
+            break;
+        }
+        case semantic_tag::clamped:
+        {
+            os << clamped_name;
+            break;
+        }
+        case semantic_tag::multi_dim_row_major:
+        {
+            os << multi_dim_row_major_name;
+            break;
+        }
+        case semantic_tag::multi_dim_column_major:
+        {
+            os << multi_dim_column_major_name;
+            break;
+        }
+        case semantic_tag::ext:
+        {
+            os << ext_name;
+            break;
+        }
+        case semantic_tag::id:
+        {
+            os << id_name;
+            break;
+        }
+        case semantic_tag::regex:
+        {
+            os << regex_name;
+            break;
+        }
+        case semantic_tag::code:
+        {
+            os << code_name;
+            break;
+        }
+    }
+    return os;
+}
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+    JSONCONS_DEPRECATED_MSG("Instead, use semantic_tag") typedef semantic_tag semantic_tag_type;
+    JSONCONS_DEPRECATED_MSG("Instead, use byte_string_arg_t") typedef byte_string_arg_t bstr_arg_t;
+    constexpr byte_string_arg_t bstr_arg{};
+#endif
+
+}
+
+#endif