Skip to content

J
json
Unverified Commit d5b21b05 by Niels Lohmann Committed by GitHub
Options

Merge pull request #1153 from theodelrieu/refactor/no_virtual_sax

Refactor/no virtual sax
parents 3ac2d81a 0cc3db4f
Showing with 452 additions and 227 deletions
Makefile
...@@ -21,7 +21,10 @@ SRCS = include/nlohmann/json.hpp \ ...@@ -21,7 +21,10 @@ SRCS = include/nlohmann/json.hpp \
include/nlohmann/detail/json_ref.hpp \ include/nlohmann/detail/json_ref.hpp \
include/nlohmann/detail/macro_scope.hpp \ include/nlohmann/detail/macro_scope.hpp \
include/nlohmann/detail/macro_unscope.hpp \ include/nlohmann/detail/macro_unscope.hpp \
include/nlohmann/detail/meta.hpp \ include/nlohmann/detail/meta/cpp_future.hpp \
include/nlohmann/detail/meta/detected.hpp \
include/nlohmann/detail/meta/type_traits.hpp \
include/nlohmann/detail/meta/void_t.hpp \
include/nlohmann/detail/output/binary_writer.hpp \ include/nlohmann/detail/output/binary_writer.hpp \
include/nlohmann/detail/output/output_adapters.hpp \ include/nlohmann/detail/output/output_adapters.hpp \
include/nlohmann/detail/output/serializer.hpp \ include/nlohmann/detail/output/serializer.hpp \
......
include/nlohmann/detail/conversions/from_json.hpp
...@@ -15,7 +15,8 @@ ...@@ -15,7 +15,8 @@
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
namespace nlohmann namespace nlohmann
......
include/nlohmann/detail/conversions/to_json.hpp
...@@ -8,7 +8,8 @@ ...@@ -8,7 +8,8 @@
#include <valarray> // valarray #include <valarray> // valarray
#include <vector> // vector #include <vector> // vector
#include <nlohmann/detail/meta.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
#include <nlohmann/detail/iterators/iteration_proxy.hpp> #include <nlohmann/detail/iterators/iteration_proxy.hpp>
......
include/nlohmann/detail/input/binary_reader.hpp
...@@ -17,6 +17,7 @@ ...@@ -17,6 +17,7 @@
#include <nlohmann/detail/input/json_sax.hpp> #include <nlohmann/detail/input/json_sax.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/is_sax.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
namespace nlohmann namespace nlohmann
...@@ -30,14 +31,14 @@ namespace detail ...@@ -30,14 +31,14 @@ namespace detail
/*! /*!
@brief deserialization of CBOR, MessagePack, and UBJSON values @brief deserialization of CBOR, MessagePack, and UBJSON values
*/ */
template<typename BasicJsonType> template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>
class binary_reader class binary_reader
{ {
using number_integer_t = typename BasicJsonType::number_integer_t; using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t; using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t; using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t; using string_t = typename BasicJsonType::string_t;
using json_sax_t = json_sax<BasicJsonType>; using json_sax_t = SAX;
public: public:
/*! /*!
...@@ -47,6 +48,7 @@ class binary_reader ...@@ -47,6 +48,7 @@ class binary_reader
*/ */
explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter)) explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
{ {
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
assert(ia); assert(ia);
} }
...@@ -321,7 +323,7 @@ class binary_reader ...@@ -321,7 +323,7 @@ class binary_reader
} }
case 0x9F: // array (indefinite length) case 0x9F: // array (indefinite length)
return get_cbor_array(json_sax_t::no_limit); return get_cbor_array(std::size_t(-1));
// map (0x00..0x17 pairs of data items follow) // map (0x00..0x17 pairs of data items follow)
case 0xA0: case 0xA0:
...@@ -375,7 +377,7 @@ class binary_reader ...@@ -375,7 +377,7 @@ class binary_reader
} }
case 0xBF: // map (indefinite length) case 0xBF: // map (indefinite length)
return get_cbor_object(json_sax_t::no_limit); return get_cbor_object(std::size_t(-1));
case 0xF4: // false case 0xF4: // false
return sax->boolean(false); return sax->boolean(false);
...@@ -1020,7 +1022,7 @@ class binary_reader ...@@ -1020,7 +1022,7 @@ class binary_reader
} }
/*! /*!
@param[in] len the length of the array or json_sax_t::no_limit for an @param[in] len the length of the array or std::size_t(-1) for an
array of indefinite size array of indefinite size
@return whether array creation completed @return whether array creation completed
*/ */
...@@ -1031,7 +1033,7 @@ class binary_reader ...@@ -1031,7 +1033,7 @@ class binary_reader
return false; return false;
} }
if (len != json_sax_t::no_limit) if (len != std::size_t(-1))
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
if (JSON_UNLIKELY(not parse_cbor_internal())) if (JSON_UNLIKELY(not parse_cbor_internal()))
...@@ -1054,7 +1056,7 @@ class binary_reader ...@@ -1054,7 +1056,7 @@ class binary_reader
} }
/*! /*!
@param[in] len the length of the object or json_sax_t::no_limit for an @param[in] len the length of the object or std::size_t(-1) for an
object of indefinite size object of indefinite size
@return whether object creation completed @return whether object creation completed
*/ */
...@@ -1066,7 +1068,7 @@ class binary_reader ...@@ -1066,7 +1068,7 @@ class binary_reader
} }
string_t key; string_t key;
if (len != json_sax_t::no_limit) if (len != std::size_t(-1))
{ {
for (std::size_t i = 0; i < len; ++i) for (std::size_t i = 0; i < len; ++i)
{ {
...@@ -1558,7 +1560,7 @@ class binary_reader ...@@ -1558,7 +1560,7 @@ class binary_reader
} }
else else
{ {
if (JSON_UNLIKELY(not sax->start_array())) if (JSON_UNLIKELY(not sax->start_array(-1)))
{ {
return false; return false;
} }
...@@ -1628,7 +1630,7 @@ class binary_reader ...@@ -1628,7 +1630,7 @@ class binary_reader
} }
else else
{ {
if (JSON_UNLIKELY(not sax->start_object())) if (JSON_UNLIKELY(not sax->start_object(-1)))
{ {
return false; return false;
} }
......
include/nlohmann/detail/input/parser.hpp
...@@ -9,6 +9,7 @@ ...@@ -9,6 +9,7 @@
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/is_sax.hpp>
#include <nlohmann/detail/input/input_adapters.hpp> #include <nlohmann/detail/input/input_adapters.hpp>
#include <nlohmann/detail/input/json_sax.hpp> #include <nlohmann/detail/input/json_sax.hpp>
#include <nlohmann/detail/input/lexer.hpp> #include <nlohmann/detail/input/lexer.hpp>
...@@ -54,8 +55,6 @@ class parser ...@@ -54,8 +55,6 @@ class parser
value value
}; };
using json_sax_t = json_sax<BasicJsonType>;
using parser_callback_t = using parser_callback_t =
std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>; std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
...@@ -144,8 +143,10 @@ class parser ...@@ -144,8 +143,10 @@ class parser
return sax_parse(&sax_acceptor, strict); return sax_parse(&sax_acceptor, strict);
} }
bool sax_parse(json_sax_t* sax, const bool strict = true) template <typename SAX>
bool sax_parse(SAX* sax, const bool strict = true)
{ {
(void)detail::is_sax_static_asserts<SAX, BasicJsonType>{};
const bool result = sax_parse_internal(sax); const bool result = sax_parse_internal(sax);
// strict mode: next byte must be EOF // strict mode: next byte must be EOF
...@@ -160,7 +161,8 @@ class parser ...@@ -160,7 +161,8 @@ class parser
} }
private: private:
bool sax_parse_internal(json_sax_t* sax) template <typename SAX>
bool sax_parse_internal(SAX* sax)
{ {
// stack to remember the hieararchy of structured values we are parsing // stack to remember the hieararchy of structured values we are parsing
// true = array; false = object // true = array; false = object
...@@ -177,7 +179,7 @@ class parser ...@@ -177,7 +179,7 @@ class parser
{ {
case token_type::begin_object: case token_type::begin_object:
{ {
if (JSON_UNLIKELY(not sax->start_object())) if (JSON_UNLIKELY(not sax->start_object(-1)))
{ {
return false; return false;
} }
...@@ -225,7 +227,7 @@ class parser ...@@ -225,7 +227,7 @@ class parser
case token_type::begin_array: case token_type::begin_array:
{ {
if (JSON_UNLIKELY(not sax->start_array())) if (JSON_UNLIKELY(not sax->start_array(-1)))
{ {
return false; return false;
} }
......
include/nlohmann/detail/iterators/iter_impl.hpp
...@@ -8,7 +8,7 @@ ...@@ -8,7 +8,7 @@
#include <nlohmann/detail/iterators/internal_iterator.hpp> #include <nlohmann/detail/iterators/internal_iterator.hpp>
#include <nlohmann/detail/iterators/primitive_iterator.hpp> #include <nlohmann/detail/iterators/primitive_iterator.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
namespace nlohmann namespace nlohmann
......
include/nlohmann/detail/meta/cpp_future.hpp 0 → 100644
#pragma once
#include <ciso646> // not
#include <cstddef> // size_t
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
namespace nlohmann
{
namespace detail
{
// alias templates to reduce boilerplate
template<bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template<typename T>
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
// implementation of C++14 index_sequence and affiliates
// source: https://stackoverflow.com/a/32223343
template<std::size_t... Ints>
struct index_sequence
{
using type = index_sequence;
using value_type = std::size_t;
static constexpr std::size_t size() noexcept
{
return sizeof...(Ints);
}
};
template<class Sequence1, class Sequence2>
struct merge_and_renumber;
template<std::size_t... I1, std::size_t... I2>
struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
: index_sequence < I1..., (sizeof...(I1) + I2)... > {};
template<std::size_t N>
struct make_index_sequence
: merge_and_renumber < typename make_index_sequence < N / 2 >::type,
typename make_index_sequence < N - N / 2 >::type > {};
template<> struct make_index_sequence<0> : index_sequence<> {};
template<> struct make_index_sequence<1> : index_sequence<0> {};
template<typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
/*
Implementation of two C++17 constructs: conjunction, negation. This is needed
to avoid evaluating all the traits in a condition
For example: not std::is_same<void, T>::value and has_value_type<T>::value
will not compile when T = void (on MSVC at least). Whereas
conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will
stop evaluating if negation<...>::value == false
Please note that those constructs must be used with caution, since symbols can
become very long quickly (which can slow down compilation and cause MSVC
internal compiler errors). Only use it when you have to (see example ahead).
*/
template<class...> struct conjunction : std::true_type {};
template<class B1> struct conjunction<B1> : B1 {};
template<class B1, class... Bn>
struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
template<class B> struct negation : std::integral_constant<bool, not B::value> {};
// dispatch utility (taken from ranges-v3)
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
template<> struct priority_tag<0> {};
// taken from ranges-v3
template<typename T>
struct static_const
{
static constexpr T value{};
};
template<typename T>
constexpr T static_const<T>::value;
}
}
include/nlohmann/detail/meta/detected.hpp 0 → 100644
#pragma once
#include <type_traits>
#include <nlohmann/detail/meta/void_t.hpp>
// http://en.cppreference.com/w/cpp/experimental/is_detected
namespace nlohmann
{
namespace detail
{
struct nonesuch
{
nonesuch() = delete;
~nonesuch() = delete;
nonesuch(nonesuch const&) = delete;
void operator=(nonesuch const&) = delete;
};
template <class Default,
class AlwaysVoid,
template <class...> class Op,
class... Args>
struct detector
{
using value_t = std::false_type;
using type = Default;
};
template <class Default, template <class...> class Op, class... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
{
using value_t = std::true_type;
using type = Op<Args...>;
};
template <template <class...> class Op, class... Args>
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
template <template <class...> class Op, class... Args>
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
template <class Default, template <class...> class Op, class... Args>
using detected_or = detector<Default, void, Op, Args...>;
template <class Default, template <class...> class Op, class... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
template <class Expected, template <class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
template <class To, template <class...> class Op, class... Args>
using is_detected_convertible =
std::is_convertible<detected_t<Op, Args...>, To>;
}
}
include/nlohmann/detail/meta/is_sax.hpp 0 → 100644
#pragma once
#include <cstdint> // size_t
#include <utility> // declval
#include <nlohmann/detail/meta/detected.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
namespace nlohmann
{
namespace detail
{
template <typename T>
using null_function_t = decltype(std::declval<T&>().null());
template <typename T>
using boolean_function_t =
decltype(std::declval<T&>().boolean(std::declval<bool>()));
template <typename T, typename Integer>
using number_integer_function_t =
decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
template <typename T, typename Unsigned>
using number_unsigned_function_t =
decltype(std::declval<T &>().number_unsigned(std::declval<Unsigned>()));
template <typename T, typename Float, typename String>
using number_float_function_t = decltype(std::declval<T &>().number_float(
std::declval<Float>(), std::declval<const String &>()));
template <typename T, typename String>
using string_function_t =
decltype(std::declval<T &>().string(std::declval<String &>()));
template <typename T>
using start_object_function_t =
decltype(std::declval<T &>().start_object(std::declval<std::size_t>()));
template <typename T, typename String>
using key_function_t =
decltype(std::declval<T &>().key(std::declval<String &>()));
template <typename T>
using end_object_function_t = decltype(std::declval<T &>().end_object());
template <typename T>
using start_array_function_t =
decltype(std::declval<T &>().start_array(std::declval<std::size_t>()));
template <typename T>
using end_array_function_t = decltype(std::declval<T &>().end_array());
template <typename T, typename Exception>
using parse_error_function_t = decltype(std::declval<T &>().parse_error(
std::declval<std::size_t>(), std::declval<const std::string &>(),
std::declval<const Exception &>()));
template <typename SAX, typename BasicJsonType>
struct is_sax
{
private:
static_assert(is_basic_json<BasicJsonType>::value,
"BasicJsonType must be of type basic_json<...>");
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
using exception_t = typename BasicJsonType::exception;
public:
static constexpr bool value =
is_detected_exact<bool, null_function_t, SAX>::value &&
is_detected_exact<bool, boolean_function_t, SAX>::value &&
is_detected_exact<bool, number_integer_function_t, SAX,
number_integer_t>::value &&
is_detected_exact<bool, number_unsigned_function_t, SAX,
number_unsigned_t>::value &&
is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
string_t>::value &&
is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
is_detected_exact<bool, start_object_function_t, SAX>::value &&
is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
is_detected_exact<bool, end_object_function_t, SAX>::value &&
is_detected_exact<bool, start_array_function_t, SAX>::value &&
is_detected_exact<bool, end_array_function_t, SAX>::value &&
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
};
template <typename SAX, typename BasicJsonType>
struct is_sax_static_asserts
{
private:
static_assert(is_basic_json<BasicJsonType>::value,
"BasicJsonType must be of type basic_json<...>");
using number_integer_t = typename BasicJsonType::number_integer_t;
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
using number_float_t = typename BasicJsonType::number_float_t;
using string_t = typename BasicJsonType::string_t;
using exception_t = typename BasicJsonType::exception;
public:
static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
"Missing/invalid function: bool null()");
static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
"Missing/invalid function: bool boolean(bool)");
static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
"Missing/invalid function: bool boolean(bool)");
static_assert(
is_detected_exact<bool, number_integer_function_t, SAX,
number_integer_t>::value,
"Missing/invalid function: bool number_integer(number_integer_t)");
static_assert(
is_detected_exact<bool, number_unsigned_function_t, SAX,
number_unsigned_t>::value,
"Missing/invalid function: bool number_unsigned(number_unsigned_t)");
static_assert(is_detected_exact<bool, number_float_function_t, SAX,
number_float_t, string_t>::value,
"Missing/invalid function: bool number_float(number_float_t, const string_t&)");
static_assert(
is_detected_exact<bool, string_function_t, SAX, string_t>::value,
"Missing/invalid function: bool string(string_t&)");
static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
"Missing/invalid function: bool start_object(std::size_t)");
static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
"Missing/invalid function: bool key(string_t&)");
static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
"Missing/invalid function: bool end_object()");
static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
"Missing/invalid function: bool start_array(std::size_t)");
static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
"Missing/invalid function: bool end_array()");
static_assert(
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
"Missing/invalid function: bool parse_error(std::size_t, const "
"std::string&, const exception&)");
};
}
}
include/nlohmann/detail/meta.hpp → include/nlohmann/detail/meta/type_traits.hpp
#pragma once #pragma once
#include <ciso646> // not #include <ciso646> // not
#include <cstddef> // size_t
#include <limits> // numeric_limits #include <limits> // numeric_limits
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
#include <utility> // declval #include <utility> // declval
#include <nlohmann/json_fwd.hpp> #include <nlohmann/json_fwd.hpp>
#include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
namespace nlohmann namespace nlohmann
...@@ -30,68 +30,6 @@ template<typename> struct is_basic_json : std::false_type {}; ...@@ -30,68 +30,6 @@ template<typename> struct is_basic_json : std::false_type {};
NLOHMANN_BASIC_JSON_TPL_DECLARATION NLOHMANN_BASIC_JSON_TPL_DECLARATION
struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {}; struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
// alias templates to reduce boilerplate
template<bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template<typename T>
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
// implementation of C++14 index_sequence and affiliates
// source: https://stackoverflow.com/a/32223343
template<std::size_t... Ints>
struct index_sequence
{
using type = index_sequence;
using value_type = std::size_t;
static constexpr std::size_t size() noexcept
{
return sizeof...(Ints);
}
};
template<class Sequence1, class Sequence2>
struct merge_and_renumber;
template<std::size_t... I1, std::size_t... I2>
struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
: index_sequence < I1..., (sizeof...(I1) + I2)... > {};
template<std::size_t N>
struct make_index_sequence
: merge_and_renumber < typename make_index_sequence < N / 2 >::type,
typename make_index_sequence < N - N / 2 >::type > {};
template<> struct make_index_sequence<0> : index_sequence<> {};
template<> struct make_index_sequence<1> : index_sequence<0> {};
template<typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
/*
Implementation of two C++17 constructs: conjunction, negation. This is needed
to avoid evaluating all the traits in a condition
For example: not std::is_same<void, T>::value and has_value_type<T>::value
will not compile when T = void (on MSVC at least). Whereas
conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will
stop evaluating if negation<...>::value == false
Please note that those constructs must be used with caution, since symbols can
become very long quickly (which can slow down compilation and cause MSVC
internal compiler errors). Only use it when you have to (see example ahead).
*/
template<class...> struct conjunction : std::true_type {};
template<class B1> struct conjunction<B1> : B1 {};
template<class B1, class... Bn>
struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
template<class B> struct negation : std::integral_constant<bool, not B::value> {};
// dispatch utility (taken from ranges-v3)
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
template<> struct priority_tag<0> {};
//////////////////////// ////////////////////////
// has_/is_ functions // // has_/is_ functions //
//////////////////////// ////////////////////////
...@@ -264,15 +202,5 @@ struct is_compatible_type ...@@ -264,15 +202,5 @@ struct is_compatible_type
is_compatible_complete_type<BasicJsonType, CompatibleType>> is_compatible_complete_type<BasicJsonType, CompatibleType>>
{ {
}; };
// taken from ranges-v3
template<typename T>
struct static_const
{
static constexpr T value{};
};
template<typename T>
constexpr T static_const<T>::value;
} }
} }
include/nlohmann/detail/meta/void_t.hpp 0 → 100644
#pragma once
namespace nlohmann
{
namespace detail
{
template <typename...>
using void_t = void;
}
}
include/nlohmann/detail/output/serializer.hpp
...@@ -16,7 +16,7 @@ ...@@ -16,7 +16,7 @@
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/conversions/to_chars.hpp> #include <nlohmann/detail/conversions/to_chars.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/output/output_adapters.hpp> #include <nlohmann/detail/output/output_adapters.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
......
include/nlohmann/json.hpp
...@@ -48,7 +48,8 @@ SOFTWARE. ...@@ -48,7 +48,8 @@ SOFTWARE.
#include <nlohmann/json_fwd.hpp> #include <nlohmann/json_fwd.hpp>
#include <nlohmann/detail/macro_scope.hpp> #include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta.hpp> #include <nlohmann/detail/meta/cpp_future.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
#include <nlohmann/detail/exceptions.hpp> #include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/value_t.hpp> #include <nlohmann/detail/value_t.hpp>
#include <nlohmann/detail/conversions/from_json.hpp> #include <nlohmann/detail/conversions/from_json.hpp>
...@@ -170,7 +171,7 @@ class basic_json ...@@ -170,7 +171,7 @@ class basic_json
friend class ::nlohmann::detail::iter_impl; friend class ::nlohmann::detail::iter_impl;
template<typename BasicJsonType, typename CharType> template<typename BasicJsonType, typename CharType>
friend class ::nlohmann::detail::binary_writer; friend class ::nlohmann::detail::binary_writer;
template<typename BasicJsonType> template<typename BasicJsonType, typename SAX>
friend class ::nlohmann::detail::binary_reader; friend class ::nlohmann::detail::binary_reader;
template<typename BasicJsonType> template<typename BasicJsonType>
friend class ::nlohmann::detail::json_sax_dom_parser; friend class ::nlohmann::detail::json_sax_dom_parser;
...@@ -211,6 +212,7 @@ class basic_json ...@@ -211,6 +212,7 @@ class basic_json
using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>; using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
using input_format_t = detail::input_format_t; using input_format_t = detail::input_format_t;
using json_sax_t = json_sax<basic_json>;
//////////////// ////////////////
// exceptions // // exceptions //
...@@ -1112,8 +1114,6 @@ class basic_json ...@@ -1112,8 +1114,6 @@ class basic_json
*/ */
using parser_callback_t = typename parser::parser_callback_t; using parser_callback_t = typename parser::parser_callback_t;
using json_sax_t = typename parser::json_sax_t;
////////////////// //////////////////
// constructors // // constructors //
////////////////// //////////////////
...@@ -6013,7 +6013,8 @@ class basic_json ...@@ -6013,7 +6013,8 @@ class basic_json
return parser(i).accept(true); return parser(i).accept(true);
} }
static bool sax_parse(detail::input_adapter&& i, json_sax_t* sax, template <typename SAX>
static bool sax_parse(detail::input_adapter&& i, SAX* sax,
input_format_t format = input_format_t::json, input_format_t format = input_format_t::json,
const bool strict = true) const bool strict = true)
{ {
...@@ -6023,7 +6024,7 @@ class basic_json ...@@ -6023,7 +6024,7 @@ class basic_json
case input_format_t::json: case input_format_t::json:
return parser(std::move(i)).sax_parse(sax, strict); return parser(std::move(i)).sax_parse(sax, strict);
default: default:
return binary_reader(std::move(i)).sax_parse(format, sax, strict); return detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
} }
} }
...@@ -6096,11 +6097,11 @@ class basic_json ...@@ -6096,11 +6097,11 @@ class basic_json
return parser(detail::input_adapter(first, last)).accept(true); return parser(detail::input_adapter(first, last)).accept(true);
} }
template<class IteratorType, typename std::enable_if< template<class IteratorType, class SAX, typename std::enable_if<
std::is_base_of< std::is_base_of<
std::random_access_iterator_tag, std::random_access_iterator_tag,
typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0> typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
static bool sax_parse(IteratorType first, IteratorType last, json_sax_t* sax) static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)
{ {
return parser(detail::input_adapter(first, last)).sax_parse(sax); return parser(detail::input_adapter(first, last)).sax_parse(sax);
} }
......
test/src/unit-cbor.cpp
...@@ -34,68 +34,68 @@ using nlohmann::json; ...@@ -34,68 +34,68 @@ using nlohmann::json;
#include <fstream> #include <fstream>
class SaxCountdown : public nlohmann::json::json_sax_t class SaxCountdown
{ {
public: public:
explicit SaxCountdown(const int count) : events_left(count) explicit SaxCountdown(const int count) : events_left(count)
{} {}
bool null() override bool null()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool boolean(bool) override bool boolean(bool)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_integer(json::number_integer_t) override bool number_integer(json::number_integer_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_unsigned(json::number_unsigned_t) override bool number_unsigned(json::number_unsigned_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_float(json::number_float_t, const std::string&) override bool number_float(json::number_float_t, const std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool string(std::string&) override bool string(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_object(std::size_t) override bool start_object(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool key(std::string&) override bool key(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_object() override bool end_object()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_array(std::size_t) override bool start_array(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_array() override bool end_array()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool parse_error(std::size_t, const std::string&, const json::exception&) override bool parse_error(std::size_t, const std::string&, const json::exception&)
{ {
return false; return false;
} }
......
test/src/unit-class_parser.cpp
...@@ -35,48 +35,48 @@ using nlohmann::json; ...@@ -35,48 +35,48 @@ using nlohmann::json;
#include <valarray> #include <valarray>
class SaxEventLogger : public nlohmann::json::json_sax_t class SaxEventLogger
{ {
public: public:
bool null() override bool null()
{ {
events.push_back("null()"); events.push_back("null()");
return true; return true;
} }
bool boolean(bool val) override bool boolean(bool val)
{ {
events.push_back(val ? "boolean(true)" : "boolean(false)"); events.push_back(val ? "boolean(true)" : "boolean(false)");
return true; return true;
} }
bool number_integer(json::number_integer_t val) override bool number_integer(json::number_integer_t val)
{ {
events.push_back("number_integer(" + std::to_string(val) + ")"); events.push_back("number_integer(" + std::to_string(val) + ")");
return true; return true;
} }
bool number_unsigned(json::number_unsigned_t val) override bool number_unsigned(json::number_unsigned_t val)
{ {
events.push_back("number_unsigned(" + std::to_string(val) + ")"); events.push_back("number_unsigned(" + std::to_string(val) + ")");
return true; return true;
} }
bool number_float(json::number_float_t, const std::string& s) override bool number_float(json::number_float_t, const std::string& s)
{ {
events.push_back("number_float(" + s + ")"); events.push_back("number_float(" + s + ")");
return true; return true;
} }
bool string(std::string& val) override bool string(std::string& val)
{ {
events.push_back("string(" + val + ")"); events.push_back("string(" + val + ")");
return true; return true;
} }
bool start_object(std::size_t elements) override bool start_object(std::size_t elements)
{ {
if (elements == no_limit) if (elements == std::size_t(-1))
{ {
events.push_back("start_object()"); events.push_back("start_object()");
} }
...@@ -87,21 +87,21 @@ class SaxEventLogger : public nlohmann::json::json_sax_t ...@@ -87,21 +87,21 @@ class SaxEventLogger : public nlohmann::json::json_sax_t
return true; return true;
} }
bool key(std::string& val) override bool key(std::string& val)
{ {
events.push_back("key(" + val + ")"); events.push_back("key(" + val + ")");
return true; return true;
} }
bool end_object() override bool end_object()
{ {
events.push_back("end_object()"); events.push_back("end_object()");
return true; return true;
} }
bool start_array(std::size_t elements) override bool start_array(std::size_t elements)
{ {
if (elements == no_limit) if (elements == std::size_t(-1))
{ {
events.push_back("start_array()"); events.push_back("start_array()");
} }
...@@ -112,13 +112,13 @@ class SaxEventLogger : public nlohmann::json::json_sax_t ...@@ -112,13 +112,13 @@ class SaxEventLogger : public nlohmann::json::json_sax_t
return true; return true;
} }
bool end_array() override bool end_array()
{ {
events.push_back("end_array()"); events.push_back("end_array()");
return true; return true;
} }
bool parse_error(std::size_t position, const std::string&, const json::exception&) override bool parse_error(std::size_t position, const std::string&, const json::exception&)
{ {
errored = true; errored = true;
events.push_back("parse_error(" + std::to_string(position) + ")"); events.push_back("parse_error(" + std::to_string(position) + ")");
......
test/src/unit-deserialization.cpp
...@@ -35,45 +35,45 @@ using nlohmann::json; ...@@ -35,45 +35,45 @@ using nlohmann::json;
#include <iostream> #include <iostream>
#include <valarray> #include <valarray>
struct SaxEventLogger : public nlohmann::json::json_sax_t struct SaxEventLogger
{ {
bool null() override bool null()
{ {
events.push_back("null()"); events.push_back("null()");
return true; return true;
} }
bool boolean(bool val) override bool boolean(bool val)
{ {
events.push_back(val ? "boolean(true)" : "boolean(false)"); events.push_back(val ? "boolean(true)" : "boolean(false)");
return true; return true;
} }
bool number_integer(json::number_integer_t val) override bool number_integer(json::number_integer_t val)
{ {
events.push_back("number_integer(" + std::to_string(val) + ")"); events.push_back("number_integer(" + std::to_string(val) + ")");
return true; return true;
} }
bool number_unsigned(json::number_unsigned_t val) override bool number_unsigned(json::number_unsigned_t val)
{ {
events.push_back("number_unsigned(" + std::to_string(val) + ")"); events.push_back("number_unsigned(" + std::to_string(val) + ")");
return true; return true;
} }
bool number_float(json::number_float_t, const std::string& s) override bool number_float(json::number_float_t, const std::string& s)
{ {
events.push_back("number_float(" + s + ")"); events.push_back("number_float(" + s + ")");
return true; return true;
} }
bool string(std::string& val) override bool string(std::string& val)
{ {
events.push_back("string(" + val + ")"); events.push_back("string(" + val + ")");
return true; return true;
} }
bool start_object(std::size_t elements) override bool start_object(std::size_t elements)
{ {
if (elements == std::size_t(-1)) if (elements == std::size_t(-1))
{ {
...@@ -86,19 +86,19 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t ...@@ -86,19 +86,19 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t
return true; return true;
} }
bool key(std::string& val) override bool key(std::string& val)
{ {
events.push_back("key(" + val + ")"); events.push_back("key(" + val + ")");
return true; return true;
} }
bool end_object()override bool end_object()
{ {
events.push_back("end_object()"); events.push_back("end_object()");
return true; return true;
} }
bool start_array(std::size_t elements) override bool start_array(std::size_t elements)
{ {
if (elements == std::size_t(-1)) if (elements == std::size_t(-1))
{ {
...@@ -111,13 +111,13 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t ...@@ -111,13 +111,13 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t
return true; return true;
} }
bool end_array() override bool end_array()
{ {
events.push_back("end_array()"); events.push_back("end_array()");
return true; return true;
} }
bool parse_error(std::size_t position, const std::string&, const json::exception&) override bool parse_error(std::size_t position, const std::string&, const json::exception&)
{ {
events.push_back("parse_error(" + std::to_string(position) + ")"); events.push_back("parse_error(" + std::to_string(position) + ")");
return false; return false;
...@@ -128,9 +128,9 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t ...@@ -128,9 +128,9 @@ struct SaxEventLogger : public nlohmann::json::json_sax_t
struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger
{ {
bool start_object(std::size_t elements) override bool start_object(std::size_t elements)
{ {
if (elements == no_limit) if (elements == -1)
{ {
events.push_back("start_object()"); events.push_back("start_object()");
} }
...@@ -144,7 +144,7 @@ struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger ...@@ -144,7 +144,7 @@ struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger
struct SaxEventLoggerExitAfterKey : public SaxEventLogger struct SaxEventLoggerExitAfterKey : public SaxEventLogger
{ {
bool key(std::string& val) override bool key(std::string& val)
{ {
events.push_back("key(" + val + ")"); events.push_back("key(" + val + ")");
return false; return false;
...@@ -153,9 +153,9 @@ struct SaxEventLoggerExitAfterKey : public SaxEventLogger ...@@ -153,9 +153,9 @@ struct SaxEventLoggerExitAfterKey : public SaxEventLogger
struct SaxEventLoggerExitAfterStartArray : public SaxEventLogger struct SaxEventLoggerExitAfterStartArray : public SaxEventLogger
{ {
bool start_array(std::size_t elements) override bool start_array(std::size_t elements)
{ {
if (elements == no_limit) if (elements == -1)
{ {
events.push_back("start_array()"); events.push_back("start_array()");
} }
......
test/src/unit-inspection.cpp
...@@ -317,8 +317,8 @@ TEST_CASE("object inspection") ...@@ -317,8 +317,8 @@ TEST_CASE("object inspection")
SECTION("round trips") SECTION("round trips")
{ {
for (const auto& s : for (const auto& s :
{"3.141592653589793", "1000000000000000010E5" {"3.141592653589793", "1000000000000000010E5"
}) })
{ {
json j1 = json::parse(s); json j1 = json::parse(s);
std::string s1 = j1.dump(); std::string s1 = j1.dump();
......
test/src/unit-msgpack.cpp
...@@ -34,68 +34,68 @@ using nlohmann::json; ...@@ -34,68 +34,68 @@ using nlohmann::json;
#include <fstream> #include <fstream>
class SaxCountdown : public nlohmann::json::json_sax_t class SaxCountdown
{ {
public: public:
explicit SaxCountdown(const int count) : events_left(count) explicit SaxCountdown(const int count) : events_left(count)
{} {}
bool null() override bool null()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool boolean(bool) override bool boolean(bool)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_integer(json::number_integer_t) override bool number_integer(json::number_integer_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_unsigned(json::number_unsigned_t) override bool number_unsigned(json::number_unsigned_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_float(json::number_float_t, const std::string&) override bool number_float(json::number_float_t, const std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool string(std::string&) override bool string(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_object(std::size_t) override bool start_object(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool key(std::string&) override bool key(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_object() override bool end_object()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_array(std::size_t) override bool start_array(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_array() override bool end_array()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool parse_error(std::size_t, const std::string&, const json::exception&) override bool parse_error(std::size_t, const std::string&, const json::exception&)
{ {
return false; return false;
} }
......
test/src/unit-ubjson.cpp
...@@ -34,68 +34,68 @@ using nlohmann::json; ...@@ -34,68 +34,68 @@ using nlohmann::json;
#include <fstream> #include <fstream>
class SaxCountdown : public nlohmann::json::json_sax_t class SaxCountdown
{ {
public: public:
explicit SaxCountdown(const int count) : events_left(count) explicit SaxCountdown(const int count) : events_left(count)
{} {}
bool null() override bool null()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool boolean(bool) override bool boolean(bool)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_integer(json::number_integer_t) override bool number_integer(json::number_integer_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_unsigned(json::number_unsigned_t) override bool number_unsigned(json::number_unsigned_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool number_float(json::number_float_t, const std::string&) override bool number_float(json::number_float_t, const std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool string(std::string&) override bool string(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_object(std::size_t) override bool start_object(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool key(std::string&) override bool key(std::string&)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_object() override bool end_object()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool start_array(std::size_t) override bool start_array(std::size_t)
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool end_array() override bool end_array()
{ {
return events_left-- > 0; return events_left-- > 0;
} }
bool parse_error(std::size_t, const std::string&, const json::exception&) override bool parse_error(std::size_t, const std::string&, const json::exception&)
{ {
return false; return false;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment