diff options
Diffstat (limited to 'include/jsoncons/json_visitor.hpp')
| -rw-r--r-- | include/jsoncons/json_visitor.hpp | 1560 |
1 files changed, 1560 insertions, 0 deletions
diff --git a/include/jsoncons/json_visitor.hpp b/include/jsoncons/json_visitor.hpp new file mode 100644 index 0000000..8be5900 --- /dev/null +++ b/include/jsoncons/json_visitor.hpp @@ -0,0 +1,1560 @@ +// 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_JSON_VISITOR_HPP +#define JSONCONS_JSON_VISITOR_HPP + +#include <iostream> +#include <string> +#include <utility> +#include <jsoncons/json_exception.hpp> +#include <jsoncons/bigint.hpp> +#include <jsoncons/ser_context.hpp> +#include <jsoncons/json_options.hpp> +#include <jsoncons/config/jsoncons_config.hpp> +#include <jsoncons/tag_type.hpp> +#include <jsoncons/byte_string.hpp> + +namespace jsoncons { + + template <class CharT> + class basic_json_visitor + { + public: + using char_type = CharT; + using char_traits_type = std::char_traits<char_type>; + + using string_view_type = jsoncons::basic_string_view<char_type,char_traits_type>; + + basic_json_visitor(basic_json_visitor&&) = default; + + basic_json_visitor& operator=(basic_json_visitor&&) = default; + + basic_json_visitor() = default; + + virtual ~basic_json_visitor() noexcept = default; + + void flush() + { + visit_flush(); + } + + bool begin_object(semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_begin_object(tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool begin_object(std::size_t length, + semantic_tag tag=semantic_tag::none, + const ser_context& context = ser_context()) + { + std::error_code ec; + bool more = visit_begin_object(length, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool end_object(const ser_context& context = ser_context()) + { + std::error_code ec; + bool more = visit_end_object(context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool begin_array(semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_begin_array(tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool begin_array(std::size_t length, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_begin_array(length, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool end_array(const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_end_array(context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool key(const string_view_type& name, const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_key(name, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool null_value(semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_null(tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool bool_value(bool value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_bool(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool string_value(const string_view_type& value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_string(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + template <class Source> + bool byte_string_value(const Source& b, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context(), + typename std::enable_if<type_traits::is_byte_sequence<Source>::value,int>::type = 0) + { + std::error_code ec; + bool more = visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + template <class Source> + bool byte_string_value(const Source& b, + uint64_t ext_tag, + const ser_context& context=ser_context(), + typename std::enable_if<type_traits::is_byte_sequence<Source>::value,int>::type = 0) + { + std::error_code ec; + bool more = visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool uint64_value(uint64_t value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_uint64(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool int64_value(int64_t value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_int64(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool half_value(uint16_t value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_half(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool double_value(double value, + semantic_tag tag = semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_double(value, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool begin_object(semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_begin_object(tag, context, ec); + } + + bool begin_object(std::size_t length, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_begin_object(length, tag, context, ec); + } + + bool end_object(const ser_context& context, std::error_code& ec) + { + return visit_end_object(context, ec); + } + + bool begin_array(semantic_tag tag, const ser_context& context, std::error_code& ec) + { + return visit_begin_array(tag, context, ec); + } + + bool begin_array(std::size_t length, semantic_tag tag, const ser_context& context, std::error_code& ec) + { + return visit_begin_array(length, tag, context, ec); + } + + bool end_array(const ser_context& context, std::error_code& ec) + { + return visit_end_array(context, ec); + } + + bool key(const string_view_type& name, const ser_context& context, std::error_code& ec) + { + return visit_key(name, context, ec); + } + + bool null_value(semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_null(tag, context, ec); + } + + bool bool_value(bool value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_bool(value, tag, context, ec); + } + + bool string_value(const string_view_type& value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_string(value, tag, context, ec); + } + + template <class Source> + bool byte_string_value(const Source& b, + semantic_tag tag, + const ser_context& context, + std::error_code& ec, + typename std::enable_if<type_traits::is_byte_sequence<Source>::value,int>::type = 0) + { + return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec); + } + + template <class Source> + bool byte_string_value(const Source& b, + uint64_t ext_tag, + const ser_context& context, + std::error_code& ec, + typename std::enable_if<type_traits::is_byte_sequence<Source>::value,int>::type = 0) + { + return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec); + } + + bool uint64_value(uint64_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_uint64(value, tag, context, ec); + } + + bool int64_value(int64_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_int64(value, tag, context, ec); + } + + bool half_value(uint16_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_half(value, tag, context, ec); + } + + bool double_value(double value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_double(value, tag, context, ec); + } + + template <class T> + bool typed_array(const jsoncons::span<T>& data, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_typed_array(data, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + template <class T> + bool typed_array(const jsoncons::span<T>& data, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_typed_array(data, tag, context, ec); + } + + bool typed_array(half_arg_t, const jsoncons::span<const uint16_t>& s, + semantic_tag tag = semantic_tag::none, + const ser_context& context = ser_context()) + { + std::error_code ec; + bool more = visit_typed_array(half_arg, s, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool typed_array(half_arg_t, const jsoncons::span<const uint16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_typed_array(half_arg, s, tag, context, ec); + } + + bool begin_multi_dim(const jsoncons::span<const size_t>& shape, + semantic_tag tag = semantic_tag::multi_dim_row_major, + const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_begin_multi_dim(shape, tag, context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool begin_multi_dim(const jsoncons::span<const size_t>& shape, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_begin_multi_dim(shape, tag, context, ec); + } + + bool end_multi_dim(const ser_context& context=ser_context()) + { + std::error_code ec; + bool more = visit_end_multi_dim(context, ec); + if (ec) + { + JSONCONS_THROW(ser_error(ec, context.line(), context.column())); + } + return more; + } + + bool end_multi_dim(const ser_context& context, + std::error_code& ec) + { + return visit_end_multi_dim(context, ec); + } + + #if !defined(JSONCONS_NO_DEPRECATED) + + JSONCONS_DEPRECATED_MSG("Instead, use byte_string_value(const Source&,semantic_tag=semantic_tag::none, const ser_context&=ser_context()") + bool byte_string_value(const uint8_t* p, std::size_t size, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + return byte_string_value(byte_string(p, size), tag, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use byte_string_value(const Source&, semantic_tag, const ser_context&, std::error_code&") + bool byte_string_value(const uint8_t* p, std::size_t size, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return byte_string_value(byte_string(p, size), tag, context, ec); + } + + JSONCONS_DEPRECATED_MSG("Instead, use key(const string_view_type&, const ser_context&=ser_context())") + bool name(const string_view_type& name, const ser_context& context=ser_context()) + { + return key(name, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use key(const string_view_type&, const ser_context&, std::error_code&)") + bool name(const string_view_type& name, const ser_context& context, std::error_code& ec) + { + return key(name, context, ec); + } + + JSONCONS_DEPRECATED_MSG("Instead, use byte_string_value(const byte_string_view&, semantic_tag=semantic_tag::none, const ser_context&=ser_context()") + bool byte_string_value(const byte_string_view& b, + byte_string_chars_format encoding_hint, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + switch (encoding_hint) + { + case byte_string_chars_format::base16: + tag = semantic_tag::base16; + break; + case byte_string_chars_format::base64: + tag = semantic_tag::base64; + break; + case byte_string_chars_format::base64url: + tag = semantic_tag::base64url; + break; + default: + break; + } + return byte_string_value(b, tag, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use byte_string_value(const byte_string_view&, semantic_tag=semantic_tag::none, const ser_context&=ser_context()") + bool byte_string_value(const uint8_t* p, std::size_t size, + byte_string_chars_format encoding_hint, + semantic_tag tag=semantic_tag::none, + const ser_context& context=ser_context()) + { + switch (encoding_hint) + { + case byte_string_chars_format::base16: + tag = semantic_tag::base16; + break; + case byte_string_chars_format::base64: + tag = semantic_tag::base64; + break; + case byte_string_chars_format::base64url: + tag = semantic_tag::base64url; + break; + default: + break; + } + return byte_string_value(byte_string(p, size), tag, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use string_value with semantic_tag::bigint") + bool big_integer_value(const string_view_type& value, const ser_context& context=ser_context()) + { + return string_value(value, semantic_tag::bigint, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use string_value with semantic_tag::bigdec") + bool big_decimal_value(const string_view_type& value, const ser_context& context=ser_context()) + { + return string_value(value, semantic_tag::bigdec, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use string_value with semantic_tag::datetime") + bool date_time_value(const string_view_type& value, const ser_context& context=ser_context()) + { + return string_value(value, semantic_tag::datetime, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use int64_value with semantic_tag::epoch_second") + bool timestamp_value(int64_t val, const ser_context& context=ser_context()) + { + return int64_value(val, semantic_tag::epoch_second, context); + } + + JSONCONS_DEPRECATED_MSG("Remove calls to this method, it doesn't do anything") + bool begin_document() + { + return true; + } + + JSONCONS_DEPRECATED_MSG("Instead, use flush() when serializing") + bool end_document() + { + flush(); + return true; + } + + JSONCONS_DEPRECATED_MSG("Remove calls to this method, it doesn't do anything") + void begin_json() + { + } + + JSONCONS_DEPRECATED_MSG("Instead, use flush() when serializing") + void end_json() + { + end_document(); + } + + JSONCONS_DEPRECATED_MSG("Instead, use key(const string_view_type&, const ser_context&=ser_context())") + void name(const char_type* p, std::size_t length, const ser_context& context) + { + name(string_view_type(p, length), context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use uint64_value(uint64_t, semantic_tag = semantic_tag::none, const ser_context&=ser_context())") + void integer_value(int64_t value) + { + int64_value(value); + } + + JSONCONS_DEPRECATED_MSG("Instead, use int64_value(int64_t, semantic_tag = semantic_tag::none, const ser_context&=ser_context())") + void integer_value(int64_t value, const ser_context& context) + { + int64_value(value,context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use uint64_value(uint64_t, semantic_tag = semantic_tag::none, const ser_context&=ser_context())") + void uinteger_value(uint64_t value) + { + uint64_value(value); + } + + JSONCONS_DEPRECATED_MSG("Instead, use uint64_value(uint64_t, semantic_tag = semantic_tag::none, const ser_context&=ser_context())") + void uinteger_value(uint64_t value, const ser_context& context) + { + uint64_value(value,context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use string_value with semantic_tag::bigint") + bool bignum_value(const string_view_type& value, const ser_context& context=ser_context()) + { + return string_value(value, semantic_tag::bigint, context); + } + + JSONCONS_DEPRECATED_MSG("Instead, use string_value with semantic_tag::bigdec") + bool decimal_value(const string_view_type& value, const ser_context& context=ser_context()) + { + return string_value(value, semantic_tag::bigdec, context); + } + + #endif + private: + + virtual void visit_flush() = 0; + + virtual bool visit_begin_object(semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_begin_object(std::size_t /*length*/, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_begin_object(tag, context, ec); + } + + virtual bool visit_end_object(const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_begin_array(semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_begin_array(std::size_t /*length*/, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_begin_array(tag, context, ec); + } + + virtual bool visit_end_array(const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_key(const string_view_type& name, + const ser_context& context, + std::error_code&) = 0; + + virtual bool visit_null(semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_bool(bool value, + semantic_tag tag, + const ser_context& context, + std::error_code&) = 0; + + virtual bool visit_string(const string_view_type& value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_byte_string(const byte_string_view& value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_byte_string(const byte_string_view& value, + uint64_t /* ext_tag */, + const ser_context& context, + std::error_code& ec) + { + return visit_byte_string(value, semantic_tag::none, context, ec); + } + + virtual bool visit_uint64(uint64_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_int64(int64_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_half(uint16_t value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + return visit_double(binary::decode_half(value), + tag, + context, + ec); + } + + virtual bool visit_double(double value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) = 0; + + virtual bool visit_typed_array(const jsoncons::span<const uint8_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag, context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = uint64_value(*p, semantic_tag::none, context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const uint16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag, context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = uint64_value(*p, semantic_tag::none, context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const uint32_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag, context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = uint64_value(*p, semantic_tag::none, context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const uint64_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag, context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = uint64_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const int8_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = int64_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const int16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = int64_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const int32_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = int64_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const int64_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = int64_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(half_arg_t, + const jsoncons::span<const uint16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag, context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = half_value(*p, semantic_tag::none, context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const float>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = double_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_typed_array(const jsoncons::span<const double>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = begin_array(s.size(), tag,context, ec); + for (auto p = s.begin(); more && p != s.end(); ++p) + { + more = double_value(*p,semantic_tag::none,context, ec); + } + if (more) + { + more = end_array(context, ec); + } + return more; + } + + virtual bool visit_begin_multi_dim(const jsoncons::span<const size_t>& shape, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) + { + bool more = visit_begin_array(2, tag, context, ec); + if (more) + { + more = visit_begin_array(shape.size(), tag, context, ec); + for (auto it = shape.begin(); more && it != shape.end(); ++it) + { + visit_uint64(*it, semantic_tag::none, context, ec); + } + if (more) + { + more = visit_end_array(context, ec); + } + } + return more; + } + + virtual bool visit_end_multi_dim(const ser_context& context, + std::error_code& ec) + { + return visit_end_array(context, ec); + } + }; + + template <class CharT> + class basic_default_json_visitor : public basic_json_visitor<CharT> + { + bool parse_more_; + std::error_code ec_; + public: + using typename basic_json_visitor<CharT>::string_view_type; + + basic_default_json_visitor(bool accept_more = true, + std::error_code ec = std::error_code()) + : parse_more_(accept_more), ec_(ec) + { + } + private: + void visit_flush() override + { + } + + bool visit_begin_object(semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_end_object(const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_begin_array(semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_end_array(const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_key(const string_view_type&, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_null(semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_string(const string_view_type&, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_byte_string(const byte_string_view&, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_uint64(uint64_t, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_int64(int64_t, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_half(uint16_t, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_double(double, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + + bool visit_bool(bool, semantic_tag, const ser_context&, std::error_code& ec) override + { + if (ec_) + { + ec = ec_; + } + return parse_more_; + } + }; + + template <class CharT> + class basic_json_tee_visitor : public basic_json_visitor<CharT> + { + public: + using typename basic_json_visitor<CharT>::char_type; + using typename basic_json_visitor<CharT>::string_view_type; + private: + basic_json_visitor<char_type>& destination0_; + basic_json_visitor<char_type>& destination1_; + + // noncopyable and nonmoveable + basic_json_tee_visitor(const basic_json_tee_visitor&) = delete; + basic_json_tee_visitor& operator=(const basic_json_tee_visitor&) = delete; + public: + basic_json_tee_visitor(basic_json_visitor<char_type>& destination0, + basic_json_visitor<char_type>& destination1) + : destination0_(destination0), destination1_(destination1) + { + } + + basic_json_visitor<char_type>& destination1() + { + return destination0_; + } + + basic_json_visitor<char_type>& destination2() + { + return destination1_; + } + + private: + void visit_flush() override + { + destination0_.flush(); + } + + bool visit_begin_object(semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.begin_object(tag, context, ec); + bool more1 = destination1_.begin_object(tag, context, ec); + + return more0 && more1; + } + + bool visit_begin_object(std::size_t length, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.begin_object(length, tag, context, ec); + bool more1 = destination1_.begin_object(length, tag, context, ec); + + return more0 && more1; + } + + bool visit_end_object(const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.end_object(context, ec); + bool more1 = destination1_.end_object(context, ec); + + return more0 && more1; + } + + bool visit_begin_array(semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.begin_array(tag, context, ec); + bool more1 = destination1_.begin_array(tag, context, ec); + + return more0 && more1; + } + + bool visit_begin_array(std::size_t length, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.begin_array(length, tag, context, ec); + bool more1 = destination1_.begin_array(length, tag, context, ec); + + return more0 && more1; + } + + bool visit_end_array(const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.end_array(context, ec); + bool more1 = destination1_.end_array(context, ec); + + return more0 && more1; + } + + bool visit_key(const string_view_type& name, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.key(name, context, ec); + bool more1 = destination1_.key(name, context, ec); + + return more0 && more1; + } + + bool visit_string(const string_view_type& value, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.string_value(value, tag, context, ec); + bool more1 = destination1_.string_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_byte_string(const byte_string_view& b, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.byte_string_value(b, tag, context, ec); + bool more1 = destination1_.byte_string_value(b, tag, context, ec); + + return more0 && more1; + } + + bool visit_uint64(uint64_t value, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.uint64_value(value, tag, context, ec); + bool more1 = destination1_.uint64_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_int64(int64_t value, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.int64_value(value, tag, context, ec); + bool more1 = destination1_.int64_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_half(uint16_t value, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.half_value(value, tag, context, ec); + bool more1 = destination1_.half_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_double(double value, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.double_value(value, tag, context, ec); + bool more1 = destination1_.double_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_bool(bool value, semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.bool_value(value, tag, context, ec); + bool more1 = destination1_.bool_value(value, tag, context, ec); + + return more0 && more1; + } + + bool visit_null(semantic_tag tag, const ser_context& context, std::error_code& ec) override + { + bool more0 = destination0_.null_value(tag, context, ec); + bool more1 = destination1_.null_value(tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const uint8_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const uint16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const uint32_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const uint64_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const int8_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const int16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const int32_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const int64_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(half_arg_t, + const jsoncons::span<const uint16_t>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(half_arg, s, tag, context, ec); + bool more1 = destination1_.typed_array(half_arg, s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const float>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_typed_array(const jsoncons::span<const double>& s, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.typed_array(s, tag, context, ec); + bool more1 = destination1_.typed_array(s, tag, context, ec); + + return more0 && more1; + } + + bool visit_begin_multi_dim(const jsoncons::span<const size_t>& shape, + semantic_tag tag, + const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.begin_multi_dim(shape, tag, context, ec); + bool more1 = destination1_.begin_multi_dim(shape, tag, context, ec); + + return more0 && more1; + } + + bool visit_end_multi_dim(const ser_context& context, + std::error_code& ec) override + { + bool more0 = destination0_.end_multi_dim(context, ec); + bool more1 = destination1_.end_multi_dim(context, ec); + + return more0 && more1; + } + + }; + + template <class CharT> + class basic_json_diagnostics_visitor : public basic_default_json_visitor<CharT> + { + public: + using stream_type = std::basic_ostream<CharT>; + using string_type = std::basic_string<CharT>; + + private: + using supertype = basic_default_json_visitor<CharT>; + using string_view_type = typename supertype::string_view_type; + + struct enabler {}; + + static constexpr CharT visit_begin_array_name[] = {'v','i','s','i','t','_','b','e','g','i','n','_','a','r','r','a','y', 0}; + static constexpr CharT visit_end_array_name[] = {'v','i','s','i','t','_','e','n','d','_','a','r','r','a','y', 0}; + static constexpr CharT visit_begin_object_name[] = {'v','i','s','i','t','_','b','e','g','i','n','_','o','b','j','e','c','t', 0}; + static constexpr CharT visit_end_object_name[] = {'v','i','s','i','t','_','e','n','d','_','o','b','j','e','c','t', 0}; + static constexpr CharT visit_key_name[] = {'v','i','s','i','t','_','k','e','y', 0}; + static constexpr CharT visit_string_name[] = {'v','i','s','i','t','_','s','t','r','i','n','g', 0}; + static constexpr CharT visit_byte_string_name[] = {'v','i','s','i','t','_','b','y','t','e','_','s','t','r','i','n','g', 0}; + static constexpr CharT visit_null_name[] = {'v','i','s','i','t','_','n','u','l','l', 0}; + static constexpr CharT visit_bool_name[] = {'v','i','s','i','t','_','b','o','o','l', 0}; + static constexpr CharT visit_uint64_name[] = {'v','i','s','i','t','_','u','i','n','t','6','4', 0}; + static constexpr CharT visit_int64_name[] = {'v','i','s','i','t','_','i','n','t','6','4', 0}; + static constexpr CharT visit_half_name[] = {'v','i','s','i','t','_','h','a','l','f', 0}; + static constexpr CharT visit_double_name[] = {'v','i','s','i','t','_','d','o','u','b','l','e', 0}; + + static constexpr CharT separator_ = ':'; + + stream_type& output_; + string_type indentation_; + long level_; + + public: + // If CharT is char, then enable the default constructor which binds to + // std::cout. + template <class U = enabler> + basic_json_diagnostics_visitor( + typename std::enable_if<std::is_same<CharT, char>::value, U>::type = enabler{}) + : basic_json_diagnostics_visitor(std::cout) + { + } + + // If CharT is wchar_t, then enable the default constructor which binds + // to std::wcout. + template <class U = enabler> + basic_json_diagnostics_visitor( + typename std::enable_if<std::is_same<CharT, wchar_t>::value, U>::type = enabler{}) + : basic_json_diagnostics_visitor(std::wcout) + { + } + + explicit basic_json_diagnostics_visitor( + stream_type& output, + string_type indentation = string_type()) + : output_(output), + indentation_(std::move(indentation)), + level_(0) + { + } + + private: + void indent() + { + for (long i=0; i<level_; ++i) + output_ << indentation_; + } + + bool visit_begin_object(semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_begin_object_name << std::endl; + ++level_; + return true; + } + + bool visit_begin_object(std::size_t length, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_begin_object_name << separator_ << length << std::endl; + ++level_; + return true; + } + + bool visit_end_object(const ser_context&, std::error_code&) override + { + --level_; + indent(); + output_ << visit_end_object_name << std::endl; + return true; + } + + bool visit_begin_array(semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_begin_array_name << std::endl; + ++level_; + return true; + } + + bool visit_begin_array(std::size_t length, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_begin_array_name << separator_ << length << std::endl; + ++level_; + return true; + } + + bool visit_end_array(const ser_context&, std::error_code&) override + { + --level_; + indent(); + output_ << visit_end_array_name << std::endl; + return true; + } + + bool visit_key(const string_view_type& s, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_key_name << separator_ << s << std::endl; + return true; + } + bool visit_string(const string_view_type& s, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_string_name << separator_ << s << std::endl; + return true; + } + bool visit_int64(int64_t val, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_int64_name << separator_ << val << std::endl; + return true; + } + bool visit_uint64(uint64_t val, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_uint64_name << separator_ << val << std::endl; + return true; + } + bool visit_bool(bool val, semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_bool_name << separator_ << val << std::endl; + return true; + } + bool visit_null(semantic_tag, const ser_context&, std::error_code&) override + { + indent(); + output_ << visit_null_name << std::endl; + return true; + } + }; + + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_begin_array_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_end_array_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_begin_object_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_end_object_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_key_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_string_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_byte_string_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_null_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_bool_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_uint64_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_int64_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_half_name[]; + template <class C> constexpr C basic_json_diagnostics_visitor<C>::visit_double_name[]; + + using json_visitor = basic_json_visitor<char>; + using wjson_visitor = basic_json_visitor<wchar_t>; + + using json_tee_visitor = basic_json_tee_visitor<char>; + using wjson_tee_visitor = basic_json_tee_visitor<wchar_t>; + + using default_json_visitor = basic_default_json_visitor<char>; + using wdefault_json_visitor = basic_default_json_visitor<wchar_t>; + + using json_diagnostics_visitor = basic_json_diagnostics_visitor<char>; + using wjson_diagnostics_visitor = basic_json_diagnostics_visitor<wchar_t>; + +#if !defined(JSONCONS_NO_DEPRECATED) +template<class CharT> +using basic_json_content_handler = basic_json_visitor<CharT>; + +JSONCONS_DEPRECATED_MSG("Instead, use json_visitor") typedef json_visitor json_content_handler; +JSONCONS_DEPRECATED_MSG("Instead, use wjson_visitor") typedef wjson_visitor wjson_content_handler; + +template<class CharT> +using basic_default_json_content_handler = basic_default_json_visitor<CharT>; + +JSONCONS_DEPRECATED_MSG("Instead, use default_json_visitor") typedef default_json_visitor default_json_content_handler; +JSONCONS_DEPRECATED_MSG("Instead, use default_wjson_visitor") typedef wdefault_json_visitor default_wjson_content_handler; +#endif + +} // namespace jsoncons + +#endif |