forked from etc/pineapple-src
4752 lines
167 KiB
C++
4752 lines
167 KiB
C++
|
/*
|
||
|
__ _____ _____ _____
|
||
|
__| | __| | | | JSON for Modern C++
|
||
|
| | |__ | | | | | | version 3.10.5
|
||
|
|_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||
|
|
||
|
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
|
||
|
SPDX-License-Identifier: MIT
|
||
|
Copyright (c) 2013-2022 Niels Lohmann <http://nlohmann.me>.
|
||
|
|
||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
|
of this software and associated documentation files (the "Software"), to deal
|
||
|
in the Software without restriction, including without limitation the rights
|
||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
copies of the Software, and to permit persons to whom the Software is
|
||
|
furnished to do so, subject to the following conditions:
|
||
|
|
||
|
The above copyright notice and this permission notice shall be included in all
|
||
|
copies or substantial portions of the Software.
|
||
|
|
||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
|
SOFTWARE.
|
||
|
*/
|
||
|
|
||
|
/****************************************************************************\
|
||
|
* Note on documentation: The source files contain links to the online *
|
||
|
* documentation of the public API at https://json.nlohmann.me. This URL *
|
||
|
* contains the most recent documentation and should also be applicable to *
|
||
|
* previous versions; documentation for deprecated functions is not *
|
||
|
* removed, but marked deprecated. See "Generate documentation" section in *
|
||
|
* file doc/README.md. *
|
||
|
\****************************************************************************/
|
||
|
|
||
|
#ifndef INCLUDE_NLOHMANN_JSON_HPP_
|
||
|
#define INCLUDE_NLOHMANN_JSON_HPP_
|
||
|
|
||
|
#define NLOHMANN_JSON_VERSION_MAJOR 3
|
||
|
#define NLOHMANN_JSON_VERSION_MINOR 10
|
||
|
#define NLOHMANN_JSON_VERSION_PATCH 5
|
||
|
|
||
|
#include <algorithm> // all_of, find, for_each
|
||
|
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
|
||
|
#include <functional> // hash, less
|
||
|
#include <initializer_list> // initializer_list
|
||
|
#ifndef JSON_NO_IO
|
||
|
#include <iosfwd> // istream, ostream
|
||
|
#endif // JSON_NO_IO
|
||
|
#include <iterator> // random_access_iterator_tag
|
||
|
#include <memory> // unique_ptr
|
||
|
#include <numeric> // accumulate
|
||
|
#include <string> // string, stoi, to_string
|
||
|
#include <utility> // declval, forward, move, pair, swap
|
||
|
#include <vector> // vector
|
||
|
|
||
|
#include <nlohmann/adl_serializer.hpp>
|
||
|
#include <nlohmann/byte_container_with_subtype.hpp>
|
||
|
#include <nlohmann/detail/conversions/from_json.hpp>
|
||
|
#include <nlohmann/detail/conversions/to_json.hpp>
|
||
|
#include <nlohmann/detail/exceptions.hpp>
|
||
|
#include <nlohmann/detail/hash.hpp>
|
||
|
#include <nlohmann/detail/input/binary_reader.hpp>
|
||
|
#include <nlohmann/detail/input/input_adapters.hpp>
|
||
|
#include <nlohmann/detail/input/lexer.hpp>
|
||
|
#include <nlohmann/detail/input/parser.hpp>
|
||
|
#include <nlohmann/detail/iterators/internal_iterator.hpp>
|
||
|
#include <nlohmann/detail/iterators/iter_impl.hpp>
|
||
|
#include <nlohmann/detail/iterators/iteration_proxy.hpp>
|
||
|
#include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
|
||
|
#include <nlohmann/detail/iterators/primitive_iterator.hpp>
|
||
|
#include <nlohmann/detail/json_pointer.hpp>
|
||
|
#include <nlohmann/detail/json_ref.hpp>
|
||
|
#include <nlohmann/detail/macro_scope.hpp>
|
||
|
#include <nlohmann/detail/string_escape.hpp>
|
||
|
#include <nlohmann/detail/meta/cpp_future.hpp>
|
||
|
#include <nlohmann/detail/meta/type_traits.hpp>
|
||
|
#include <nlohmann/detail/output/binary_writer.hpp>
|
||
|
#include <nlohmann/detail/output/output_adapters.hpp>
|
||
|
#include <nlohmann/detail/output/serializer.hpp>
|
||
|
#include <nlohmann/detail/value_t.hpp>
|
||
|
#include <nlohmann/json_fwd.hpp>
|
||
|
#include <nlohmann/ordered_map.hpp>
|
||
|
|
||
|
#if defined(JSON_HAS_CPP_17)
|
||
|
#include <string_view>
|
||
|
#endif
|
||
|
|
||
|
/*!
|
||
|
@brief namespace for Niels Lohmann
|
||
|
@see https://github.com/nlohmann
|
||
|
@since version 1.0.0
|
||
|
*/
|
||
|
namespace nlohmann
|
||
|
{
|
||
|
|
||
|
/*!
|
||
|
@brief a class to store JSON values
|
||
|
|
||
|
@internal
|
||
|
@invariant The member variables @a m_value and @a m_type have the following
|
||
|
relationship:
|
||
|
- If `m_type == value_t::object`, then `m_value.object != nullptr`.
|
||
|
- If `m_type == value_t::array`, then `m_value.array != nullptr`.
|
||
|
- If `m_type == value_t::string`, then `m_value.string != nullptr`.
|
||
|
The invariants are checked by member function assert_invariant().
|
||
|
|
||
|
@note ObjectType trick from https://stackoverflow.com/a/9860911
|
||
|
@endinternal
|
||
|
|
||
|
@since version 1.0.0
|
||
|
|
||
|
@nosubgrouping
|
||
|
*/
|
||
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||
|
class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
|
||
|
{
|
||
|
private:
|
||
|
template<detail::value_t> friend struct detail::external_constructor;
|
||
|
friend ::nlohmann::json_pointer<basic_json>;
|
||
|
|
||
|
template<typename BasicJsonType, typename InputType>
|
||
|
friend class ::nlohmann::detail::parser;
|
||
|
friend ::nlohmann::detail::serializer<basic_json>;
|
||
|
template<typename BasicJsonType>
|
||
|
friend class ::nlohmann::detail::iter_impl;
|
||
|
template<typename BasicJsonType, typename CharType>
|
||
|
friend class ::nlohmann::detail::binary_writer;
|
||
|
template<typename BasicJsonType, typename InputType, typename SAX>
|
||
|
friend class ::nlohmann::detail::binary_reader;
|
||
|
template<typename BasicJsonType>
|
||
|
friend class ::nlohmann::detail::json_sax_dom_parser;
|
||
|
template<typename BasicJsonType>
|
||
|
friend class ::nlohmann::detail::json_sax_dom_callback_parser;
|
||
|
friend class ::nlohmann::detail::exception;
|
||
|
|
||
|
/// workaround type for MSVC
|
||
|
using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
|
||
|
|
||
|
JSON_PRIVATE_UNLESS_TESTED:
|
||
|
// convenience aliases for types residing in namespace detail;
|
||
|
using lexer = ::nlohmann::detail::lexer_base<basic_json>;
|
||
|
|
||
|
template<typename InputAdapterType>
|
||
|
static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
|
||
|
InputAdapterType adapter,
|
||
|
detail::parser_callback_t<basic_json>cb = nullptr,
|
||
|
const bool allow_exceptions = true,
|
||
|
const bool ignore_comments = false
|
||
|
)
|
||
|
{
|
||
|
return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
|
||
|
std::move(cb), allow_exceptions, ignore_comments);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
|
||
|
template<typename BasicJsonType>
|
||
|
using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
|
||
|
template<typename BasicJsonType>
|
||
|
using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
|
||
|
template<typename Iterator>
|
||
|
using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
|
||
|
template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
|
||
|
|
||
|
template<typename CharType>
|
||
|
using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
|
||
|
|
||
|
template<typename InputType>
|
||
|
using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
|
||
|
template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
|
||
|
|
||
|
JSON_PRIVATE_UNLESS_TESTED:
|
||
|
using serializer = ::nlohmann::detail::serializer<basic_json>;
|
||
|
|
||
|
public:
|
||
|
using value_t = detail::value_t;
|
||
|
/// JSON Pointer, see @ref nlohmann::json_pointer
|
||
|
using json_pointer = ::nlohmann::json_pointer<basic_json>;
|
||
|
template<typename T, typename SFINAE>
|
||
|
using json_serializer = JSONSerializer<T, SFINAE>;
|
||
|
/// how to treat decoding errors
|
||
|
using error_handler_t = detail::error_handler_t;
|
||
|
/// how to treat CBOR tags
|
||
|
using cbor_tag_handler_t = detail::cbor_tag_handler_t;
|
||
|
/// helper type for initializer lists of basic_json values
|
||
|
using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
|
||
|
|
||
|
using input_format_t = detail::input_format_t;
|
||
|
/// SAX interface type, see @ref nlohmann::json_sax
|
||
|
using json_sax_t = json_sax<basic_json>;
|
||
|
|
||
|
////////////////
|
||
|
// exceptions //
|
||
|
////////////////
|
||
|
|
||
|
/// @name exceptions
|
||
|
/// Classes to implement user-defined exceptions.
|
||
|
/// @{
|
||
|
|
||
|
using exception = detail::exception;
|
||
|
using parse_error = detail::parse_error;
|
||
|
using invalid_iterator = detail::invalid_iterator;
|
||
|
using type_error = detail::type_error;
|
||
|
using out_of_range = detail::out_of_range;
|
||
|
using other_error = detail::other_error;
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
/////////////////////
|
||
|
// container types //
|
||
|
/////////////////////
|
||
|
|
||
|
/// @name container types
|
||
|
/// The canonic container types to use @ref basic_json like any other STL
|
||
|
/// container.
|
||
|
/// @{
|
||
|
|
||
|
/// the type of elements in a basic_json container
|
||
|
using value_type = basic_json;
|
||
|
|
||
|
/// the type of an element reference
|
||
|
using reference = value_type&;
|
||
|
/// the type of an element const reference
|
||
|
using const_reference = const value_type&;
|
||
|
|
||
|
/// a type to represent differences between iterators
|
||
|
using difference_type = std::ptrdiff_t;
|
||
|
/// a type to represent container sizes
|
||
|
using size_type = std::size_t;
|
||
|
|
||
|
/// the allocator type
|
||
|
using allocator_type = AllocatorType<basic_json>;
|
||
|
|
||
|
/// the type of an element pointer
|
||
|
using pointer = typename std::allocator_traits<allocator_type>::pointer;
|
||
|
/// the type of an element const pointer
|
||
|
using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
|
||
|
|
||
|
/// an iterator for a basic_json container
|
||
|
using iterator = iter_impl<basic_json>;
|
||
|
/// a const iterator for a basic_json container
|
||
|
using const_iterator = iter_impl<const basic_json>;
|
||
|
/// a reverse iterator for a basic_json container
|
||
|
using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
|
||
|
/// a const reverse iterator for a basic_json container
|
||
|
using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
/// @brief returns the allocator associated with the container
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
|
||
|
static allocator_type get_allocator()
|
||
|
{
|
||
|
return allocator_type();
|
||
|
}
|
||
|
|
||
|
/// @brief returns version information on the library
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/meta/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json meta()
|
||
|
{
|
||
|
basic_json result;
|
||
|
|
||
|
result["copyright"] = "(C) 2013-2022 Niels Lohmann";
|
||
|
result["name"] = "JSON for Modern C++";
|
||
|
result["url"] = "https://github.com/nlohmann/json";
|
||
|
result["version"]["string"] =
|
||
|
std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
|
||
|
std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
|
||
|
std::to_string(NLOHMANN_JSON_VERSION_PATCH);
|
||
|
result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
|
||
|
result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
|
||
|
result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
|
||
|
|
||
|
#ifdef _WIN32
|
||
|
result["platform"] = "win32";
|
||
|
#elif defined __linux__
|
||
|
result["platform"] = "linux";
|
||
|
#elif defined __APPLE__
|
||
|
result["platform"] = "apple";
|
||
|
#elif defined __unix__
|
||
|
result["platform"] = "unix";
|
||
|
#else
|
||
|
result["platform"] = "unknown";
|
||
|
#endif
|
||
|
|
||
|
#if defined(__ICC) || defined(__INTEL_COMPILER)
|
||
|
result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
|
||
|
#elif defined(__clang__)
|
||
|
result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
|
||
|
#elif defined(__GNUC__) || defined(__GNUG__)
|
||
|
result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
|
||
|
#elif defined(__HP_cc) || defined(__HP_aCC)
|
||
|
result["compiler"] = "hp"
|
||
|
#elif defined(__IBMCPP__)
|
||
|
result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
|
||
|
#elif defined(_MSC_VER)
|
||
|
result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
|
||
|
#elif defined(__PGI)
|
||
|
result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
|
||
|
#elif defined(__SUNPRO_CC)
|
||
|
result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
|
||
|
#else
|
||
|
result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
|
||
|
#endif
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
result["compiler"]["c++"] = std::to_string(__cplusplus);
|
||
|
#else
|
||
|
result["compiler"]["c++"] = "unknown";
|
||
|
#endif
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////
|
||
|
// JSON value data types //
|
||
|
///////////////////////////
|
||
|
|
||
|
/// @name JSON value data types
|
||
|
/// The data types to store a JSON value. These types are derived from
|
||
|
/// the template arguments passed to class @ref basic_json.
|
||
|
/// @{
|
||
|
|
||
|
/// @brief object key comparator type
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
|
||
|
#if defined(JSON_HAS_CPP_14)
|
||
|
// Use transparent comparator if possible, combined with perfect forwarding
|
||
|
// on find() and count() calls prevents unnecessary string construction.
|
||
|
using object_comparator_t = std::less<>;
|
||
|
#else
|
||
|
using object_comparator_t = std::less<StringType>;
|
||
|
#endif
|
||
|
|
||
|
/// @brief a type for an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/object_t/
|
||
|
using object_t = ObjectType<StringType,
|
||
|
basic_json,
|
||
|
object_comparator_t,
|
||
|
AllocatorType<std::pair<const StringType,
|
||
|
basic_json>>>;
|
||
|
|
||
|
/// @brief a type for an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/array_t/
|
||
|
using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
|
||
|
|
||
|
/// @brief a type for a string
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/string_t/
|
||
|
using string_t = StringType;
|
||
|
|
||
|
/// @brief a type for a boolean
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
|
||
|
using boolean_t = BooleanType;
|
||
|
|
||
|
/// @brief a type for a number (integer)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
|
||
|
using number_integer_t = NumberIntegerType;
|
||
|
|
||
|
/// @brief a type for a number (unsigned)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
|
||
|
using number_unsigned_t = NumberUnsignedType;
|
||
|
|
||
|
/// @brief a type for a number (floating-point)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
|
||
|
using number_float_t = NumberFloatType;
|
||
|
|
||
|
/// @brief a type for a packed binary type
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/binary_t/
|
||
|
using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
private:
|
||
|
|
||
|
/// helper for exception-safe object creation
|
||
|
template<typename T, typename... Args>
|
||
|
JSON_HEDLEY_RETURNS_NON_NULL
|
||
|
static T* create(Args&& ... args)
|
||
|
{
|
||
|
AllocatorType<T> alloc;
|
||
|
using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
|
||
|
|
||
|
auto deleter = [&](T * obj)
|
||
|
{
|
||
|
AllocatorTraits::deallocate(alloc, obj, 1);
|
||
|
};
|
||
|
std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
|
||
|
AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
|
||
|
JSON_ASSERT(obj != nullptr);
|
||
|
return obj.release();
|
||
|
}
|
||
|
|
||
|
////////////////////////
|
||
|
// JSON value storage //
|
||
|
////////////////////////
|
||
|
|
||
|
JSON_PRIVATE_UNLESS_TESTED:
|
||
|
/*!
|
||
|
@brief a JSON value
|
||
|
|
||
|
The actual storage for a JSON value of the @ref basic_json class. This
|
||
|
union combines the different storage types for the JSON value types
|
||
|
defined in @ref value_t.
|
||
|
|
||
|
JSON type | value_t type | used type
|
||
|
--------- | --------------- | ------------------------
|
||
|
object | object | pointer to @ref object_t
|
||
|
array | array | pointer to @ref array_t
|
||
|
string | string | pointer to @ref string_t
|
||
|
boolean | boolean | @ref boolean_t
|
||
|
number | number_integer | @ref number_integer_t
|
||
|
number | number_unsigned | @ref number_unsigned_t
|
||
|
number | number_float | @ref number_float_t
|
||
|
binary | binary | pointer to @ref binary_t
|
||
|
null | null | *no value is stored*
|
||
|
|
||
|
@note Variable-length types (objects, arrays, and strings) are stored as
|
||
|
pointers. The size of the union should not exceed 64 bits if the default
|
||
|
value types are used.
|
||
|
|
||
|
@since version 1.0.0
|
||
|
*/
|
||
|
union json_value
|
||
|
{
|
||
|
/// object (stored with pointer to save storage)
|
||
|
object_t* object;
|
||
|
/// array (stored with pointer to save storage)
|
||
|
array_t* array;
|
||
|
/// string (stored with pointer to save storage)
|
||
|
string_t* string;
|
||
|
/// binary (stored with pointer to save storage)
|
||
|
binary_t* binary;
|
||
|
/// boolean
|
||
|
boolean_t boolean;
|
||
|
/// number (integer)
|
||
|
number_integer_t number_integer;
|
||
|
/// number (unsigned integer)
|
||
|
number_unsigned_t number_unsigned;
|
||
|
/// number (floating-point)
|
||
|
number_float_t number_float;
|
||
|
|
||
|
/// default constructor (for null values)
|
||
|
json_value() = default;
|
||
|
/// constructor for booleans
|
||
|
json_value(boolean_t v) noexcept : boolean(v) {}
|
||
|
/// constructor for numbers (integer)
|
||
|
json_value(number_integer_t v) noexcept : number_integer(v) {}
|
||
|
/// constructor for numbers (unsigned)
|
||
|
json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
|
||
|
/// constructor for numbers (floating-point)
|
||
|
json_value(number_float_t v) noexcept : number_float(v) {}
|
||
|
/// constructor for empty values of a given type
|
||
|
json_value(value_t t)
|
||
|
{
|
||
|
switch (t)
|
||
|
{
|
||
|
case value_t::object:
|
||
|
{
|
||
|
object = create<object_t>();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
array = create<array_t>();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
{
|
||
|
string = create<string_t>("");
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
binary = create<binary_t>();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::boolean:
|
||
|
{
|
||
|
boolean = static_cast<boolean_t>(false);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_integer:
|
||
|
{
|
||
|
number_integer = static_cast<number_integer_t>(0);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
{
|
||
|
number_unsigned = static_cast<number_unsigned_t>(0);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_float:
|
||
|
{
|
||
|
number_float = static_cast<number_float_t>(0.0);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
{
|
||
|
object = nullptr; // silence warning, see #821
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
object = nullptr; // silence warning, see #821
|
||
|
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
|
||
|
{
|
||
|
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.10.5", basic_json())); // LCOV_EXCL_LINE
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// constructor for strings
|
||
|
json_value(const string_t& value) : string(create<string_t>(value)) {}
|
||
|
|
||
|
/// constructor for rvalue strings
|
||
|
json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
|
||
|
|
||
|
/// constructor for objects
|
||
|
json_value(const object_t& value) : object(create<object_t>(value)) {}
|
||
|
|
||
|
/// constructor for rvalue objects
|
||
|
json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
|
||
|
|
||
|
/// constructor for arrays
|
||
|
json_value(const array_t& value) : array(create<array_t>(value)) {}
|
||
|
|
||
|
/// constructor for rvalue arrays
|
||
|
json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
|
||
|
|
||
|
/// constructor for binary arrays
|
||
|
json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
|
||
|
|
||
|
/// constructor for rvalue binary arrays
|
||
|
json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
|
||
|
|
||
|
/// constructor for binary arrays (internal type)
|
||
|
json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
|
||
|
|
||
|
/// constructor for rvalue binary arrays (internal type)
|
||
|
json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
|
||
|
|
||
|
void destroy(value_t t)
|
||
|
{
|
||
|
if (t == value_t::array || t == value_t::object)
|
||
|
{
|
||
|
// flatten the current json_value to a heap-allocated stack
|
||
|
std::vector<basic_json> stack;
|
||
|
|
||
|
// move the top-level items to stack
|
||
|
if (t == value_t::array)
|
||
|
{
|
||
|
stack.reserve(array->size());
|
||
|
std::move(array->begin(), array->end(), std::back_inserter(stack));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
stack.reserve(object->size());
|
||
|
for (auto&& it : *object)
|
||
|
{
|
||
|
stack.push_back(std::move(it.second));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
while (!stack.empty())
|
||
|
{
|
||
|
// move the last item to local variable to be processed
|
||
|
basic_json current_item(std::move(stack.back()));
|
||
|
stack.pop_back();
|
||
|
|
||
|
// if current_item is array/object, move
|
||
|
// its children to the stack to be processed later
|
||
|
if (current_item.is_array())
|
||
|
{
|
||
|
std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
|
||
|
|
||
|
current_item.m_value.array->clear();
|
||
|
}
|
||
|
else if (current_item.is_object())
|
||
|
{
|
||
|
for (auto&& it : *current_item.m_value.object)
|
||
|
{
|
||
|
stack.push_back(std::move(it.second));
|
||
|
}
|
||
|
|
||
|
current_item.m_value.object->clear();
|
||
|
}
|
||
|
|
||
|
// it's now safe that current_item get destructed
|
||
|
// since it doesn't have any children
|
||
|
}
|
||
|
}
|
||
|
|
||
|
switch (t)
|
||
|
{
|
||
|
case value_t::object:
|
||
|
{
|
||
|
AllocatorType<object_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
AllocatorType<array_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
{
|
||
|
AllocatorType<string_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
AllocatorType<binary_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
|
||
|
private:
|
||
|
/*!
|
||
|
@brief checks the class invariants
|
||
|
|
||
|
This function asserts the class invariants. It needs to be called at the
|
||
|
end of every constructor to make sure that created objects respect the
|
||
|
invariant. Furthermore, it has to be called each time the type of a JSON
|
||
|
value is changed, because the invariant expresses a relationship between
|
||
|
@a m_type and @a m_value.
|
||
|
|
||
|
Furthermore, the parent relation is checked for arrays and objects: If
|
||
|
@a check_parents true and the value is an array or object, then the
|
||
|
container's elements must have the current value as parent.
|
||
|
|
||
|
@param[in] check_parents whether the parent relation should be checked.
|
||
|
The value is true by default and should only be set to false
|
||
|
during destruction of objects when the invariant does not
|
||
|
need to hold.
|
||
|
*/
|
||
|
void assert_invariant(bool check_parents = true) const noexcept
|
||
|
{
|
||
|
JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
|
||
|
JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
|
||
|
JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
|
||
|
JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
|
||
|
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
JSON_TRY
|
||
|
{
|
||
|
// cppcheck-suppress assertWithSideEffect
|
||
|
JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
|
||
|
{
|
||
|
return j.m_parent == this;
|
||
|
}));
|
||
|
}
|
||
|
JSON_CATCH(...) {} // LCOV_EXCL_LINE
|
||
|
#endif
|
||
|
static_cast<void>(check_parents);
|
||
|
}
|
||
|
|
||
|
void set_parents()
|
||
|
{
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::array:
|
||
|
{
|
||
|
for (auto& element : *m_value.array)
|
||
|
{
|
||
|
element.m_parent = this;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
for (auto& element : *m_value.object)
|
||
|
{
|
||
|
element.second.m_parent = this;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::string:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
|
||
|
{
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
|
||
|
{
|
||
|
(it + i)->m_parent = this;
|
||
|
}
|
||
|
#else
|
||
|
static_cast<void>(count_set_parents);
|
||
|
#endif
|
||
|
return it;
|
||
|
}
|
||
|
|
||
|
reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
|
||
|
{
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
if (old_capacity != static_cast<std::size_t>(-1))
|
||
|
{
|
||
|
// see https://github.com/nlohmann/json/issues/2838
|
||
|
JSON_ASSERT(type() == value_t::array);
|
||
|
if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
|
||
|
{
|
||
|
// capacity has changed: update all parents
|
||
|
set_parents();
|
||
|
return j;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// ordered_json uses a vector internally, so pointers could have
|
||
|
// been invalidated; see https://github.com/nlohmann/json/issues/2962
|
||
|
#ifdef JSON_HEDLEY_MSVC_VERSION
|
||
|
#pragma warning(push )
|
||
|
#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
|
||
|
#endif
|
||
|
if (detail::is_ordered_map<object_t>::value)
|
||
|
{
|
||
|
set_parents();
|
||
|
return j;
|
||
|
}
|
||
|
#ifdef JSON_HEDLEY_MSVC_VERSION
|
||
|
#pragma warning( pop )
|
||
|
#endif
|
||
|
|
||
|
j.m_parent = this;
|
||
|
#else
|
||
|
static_cast<void>(j);
|
||
|
static_cast<void>(old_capacity);
|
||
|
#endif
|
||
|
return j;
|
||
|
}
|
||
|
|
||
|
public:
|
||
|
//////////////////////////
|
||
|
// JSON parser callback //
|
||
|
//////////////////////////
|
||
|
|
||
|
/// @brief parser event types
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
|
||
|
using parse_event_t = detail::parse_event_t;
|
||
|
|
||
|
/// @brief per-element parser callback type
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
|
||
|
using parser_callback_t = detail::parser_callback_t<basic_json>;
|
||
|
|
||
|
//////////////////
|
||
|
// constructors //
|
||
|
//////////////////
|
||
|
|
||
|
/// @name constructors and destructors
|
||
|
/// Constructors of class @ref basic_json, copy/move constructor, copy
|
||
|
/// assignment, static functions creating objects, and the destructor.
|
||
|
/// @{
|
||
|
|
||
|
/// @brief create an empty value with a given type
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(const value_t v)
|
||
|
: m_type(v), m_value(v)
|
||
|
{
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief create a null object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(std::nullptr_t = nullptr) noexcept
|
||
|
: basic_json(value_t::null)
|
||
|
{
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from compatible types
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
template < typename CompatibleType,
|
||
|
typename U = detail::uncvref_t<CompatibleType>,
|
||
|
detail::enable_if_t <
|
||
|
!detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
|
||
|
basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
|
||
|
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
|
||
|
std::forward<CompatibleType>(val))))
|
||
|
{
|
||
|
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an existing one
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
template < typename BasicJsonType,
|
||
|
detail::enable_if_t <
|
||
|
detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
|
||
|
basic_json(const BasicJsonType& val)
|
||
|
{
|
||
|
using other_boolean_t = typename BasicJsonType::boolean_t;
|
||
|
using other_number_float_t = typename BasicJsonType::number_float_t;
|
||
|
using other_number_integer_t = typename BasicJsonType::number_integer_t;
|
||
|
using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
||
|
using other_string_t = typename BasicJsonType::string_t;
|
||
|
using other_object_t = typename BasicJsonType::object_t;
|
||
|
using other_array_t = typename BasicJsonType::array_t;
|
||
|
using other_binary_t = typename BasicJsonType::binary_t;
|
||
|
|
||
|
switch (val.type())
|
||
|
{
|
||
|
case value_t::boolean:
|
||
|
JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
|
||
|
break;
|
||
|
case value_t::number_float:
|
||
|
JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
|
||
|
break;
|
||
|
case value_t::number_integer:
|
||
|
JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
|
||
|
break;
|
||
|
case value_t::number_unsigned:
|
||
|
JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
|
||
|
break;
|
||
|
case value_t::string:
|
||
|
JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
|
||
|
break;
|
||
|
case value_t::object:
|
||
|
JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
|
||
|
break;
|
||
|
case value_t::array:
|
||
|
JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
|
||
|
break;
|
||
|
case value_t::binary:
|
||
|
JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
|
||
|
break;
|
||
|
case value_t::null:
|
||
|
*this = nullptr;
|
||
|
break;
|
||
|
case value_t::discarded:
|
||
|
m_type = value_t::discarded;
|
||
|
break;
|
||
|
default: // LCOV_EXCL_LINE
|
||
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
||
|
}
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief create a container (array or object) from an initializer list
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(initializer_list_t init,
|
||
|
bool type_deduction = true,
|
||
|
value_t manual_type = value_t::array)
|
||
|
{
|
||
|
// check if each element is an array with two elements whose first
|
||
|
// element is a string
|
||
|
bool is_an_object = std::all_of(init.begin(), init.end(),
|
||
|
[](const detail::json_ref<basic_json>& element_ref)
|
||
|
{
|
||
|
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
|
||
|
});
|
||
|
|
||
|
// adjust type if type deduction is not wanted
|
||
|
if (!type_deduction)
|
||
|
{
|
||
|
// if array is wanted, do not create an object though possible
|
||
|
if (manual_type == value_t::array)
|
||
|
{
|
||
|
is_an_object = false;
|
||
|
}
|
||
|
|
||
|
// if object is wanted but impossible, throw an exception
|
||
|
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (is_an_object)
|
||
|
{
|
||
|
// the initializer list is a list of pairs -> create object
|
||
|
m_type = value_t::object;
|
||
|
m_value = value_t::object;
|
||
|
|
||
|
for (auto& element_ref : init)
|
||
|
{
|
||
|
auto element = element_ref.moved_or_copied();
|
||
|
m_value.object->emplace(
|
||
|
std::move(*((*element.m_value.array)[0].m_value.string)),
|
||
|
std::move((*element.m_value.array)[1]));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// the initializer list describes an array -> create array
|
||
|
m_type = value_t::array;
|
||
|
m_value.array = create<array_t>(init.begin(), init.end());
|
||
|
}
|
||
|
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create a binary array (without subtype)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json binary(const typename binary_t::container_type& init)
|
||
|
{
|
||
|
auto res = basic_json();
|
||
|
res.m_type = value_t::binary;
|
||
|
res.m_value = init;
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create a binary array (with subtype)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
|
||
|
{
|
||
|
auto res = basic_json();
|
||
|
res.m_type = value_t::binary;
|
||
|
res.m_value = binary_t(init, subtype);
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create a binary array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json binary(typename binary_t::container_type&& init)
|
||
|
{
|
||
|
auto res = basic_json();
|
||
|
res.m_type = value_t::binary;
|
||
|
res.m_value = std::move(init);
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create a binary array (with subtype)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
|
||
|
{
|
||
|
auto res = basic_json();
|
||
|
res.m_type = value_t::binary;
|
||
|
res.m_value = binary_t(std::move(init), subtype);
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create an array from an initializer list
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/array/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json array(initializer_list_t init = {})
|
||
|
{
|
||
|
return basic_json(init, false, value_t::array);
|
||
|
}
|
||
|
|
||
|
/// @brief explicitly create an object from an initializer list
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/object/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json object(initializer_list_t init = {})
|
||
|
{
|
||
|
return basic_json(init, false, value_t::object);
|
||
|
}
|
||
|
|
||
|
/// @brief construct an array with count copies of given value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(size_type cnt, const basic_json& val)
|
||
|
: m_type(value_t::array)
|
||
|
{
|
||
|
m_value.array = create<array_t>(cnt, val);
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief construct a JSON container given an iterator range
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
template < class InputIT, typename std::enable_if <
|
||
|
std::is_same<InputIT, typename basic_json_t::iterator>::value ||
|
||
|
std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
|
||
|
basic_json(InputIT first, InputIT last)
|
||
|
{
|
||
|
JSON_ASSERT(first.m_object != nullptr);
|
||
|
JSON_ASSERT(last.m_object != nullptr);
|
||
|
|
||
|
// make sure iterator fits the current value
|
||
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", basic_json()));
|
||
|
}
|
||
|
|
||
|
// copy type from first iterator
|
||
|
m_type = first.m_object->m_type;
|
||
|
|
||
|
// check if iterator range is complete for primitive values
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_float:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::string:
|
||
|
{
|
||
|
if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
|
||
|
|| !last.m_it.primitive_iterator.is_end()))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(204, "iterators out of range", *first.m_object));
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::object:
|
||
|
case value_t::array:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::number_integer:
|
||
|
{
|
||
|
m_value.number_integer = first.m_object->m_value.number_integer;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
{
|
||
|
m_value.number_unsigned = first.m_object->m_value.number_unsigned;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_float:
|
||
|
{
|
||
|
m_value.number_float = first.m_object->m_value.number_float;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::boolean:
|
||
|
{
|
||
|
m_value.boolean = first.m_object->m_value.boolean;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
{
|
||
|
m_value = *first.m_object->m_value.string;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
m_value.object = create<object_t>(first.m_it.object_iterator,
|
||
|
last.m_it.object_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
m_value.array = create<array_t>(first.m_it.array_iterator,
|
||
|
last.m_it.array_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
m_value = *first.m_object->m_value.binary;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
|
||
|
}
|
||
|
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
|
||
|
///////////////////////////////////////
|
||
|
// other constructors and destructor //
|
||
|
///////////////////////////////////////
|
||
|
|
||
|
template<typename JsonRef,
|
||
|
detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
|
||
|
std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
|
||
|
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
|
||
|
|
||
|
/// @brief copy constructor
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(const basic_json& other)
|
||
|
: m_type(other.m_type)
|
||
|
{
|
||
|
// check of passed value is valid
|
||
|
other.assert_invariant();
|
||
|
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::object:
|
||
|
{
|
||
|
m_value = *other.m_value.object;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
m_value = *other.m_value.array;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
{
|
||
|
m_value = *other.m_value.string;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::boolean:
|
||
|
{
|
||
|
m_value = other.m_value.boolean;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_integer:
|
||
|
{
|
||
|
m_value = other.m_value.number_integer;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
{
|
||
|
m_value = other.m_value.number_unsigned;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_float:
|
||
|
{
|
||
|
m_value = other.m_value.number_float;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
m_value = *other.m_value.binary;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief move constructor
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
||
|
basic_json(basic_json&& other) noexcept
|
||
|
: m_type(std::move(other.m_type)),
|
||
|
m_value(std::move(other.m_value))
|
||
|
{
|
||
|
// check that passed value is valid
|
||
|
other.assert_invariant(false);
|
||
|
|
||
|
// invalidate payload
|
||
|
other.m_type = value_t::null;
|
||
|
other.m_value = {};
|
||
|
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief copy assignment
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator=/
|
||
|
basic_json& operator=(basic_json other) noexcept (
|
||
|
std::is_nothrow_move_constructible<value_t>::value&&
|
||
|
std::is_nothrow_move_assignable<value_t>::value&&
|
||
|
std::is_nothrow_move_constructible<json_value>::value&&
|
||
|
std::is_nothrow_move_assignable<json_value>::value
|
||
|
)
|
||
|
{
|
||
|
// check that passed value is valid
|
||
|
other.assert_invariant();
|
||
|
|
||
|
using std::swap;
|
||
|
swap(m_type, other.m_type);
|
||
|
swap(m_value, other.m_value);
|
||
|
|
||
|
set_parents();
|
||
|
assert_invariant();
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/// @brief destructor
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
|
||
|
~basic_json() noexcept
|
||
|
{
|
||
|
assert_invariant(false);
|
||
|
m_value.destroy(m_type);
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
public:
|
||
|
///////////////////////
|
||
|
// object inspection //
|
||
|
///////////////////////
|
||
|
|
||
|
/// @name object inspection
|
||
|
/// Functions to inspect the type of a JSON value.
|
||
|
/// @{
|
||
|
|
||
|
/// @brief serialization
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/dump/
|
||
|
string_t dump(const int indent = -1,
|
||
|
const char indent_char = ' ',
|
||
|
const bool ensure_ascii = false,
|
||
|
const error_handler_t error_handler = error_handler_t::strict) const
|
||
|
{
|
||
|
string_t result;
|
||
|
serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
|
||
|
|
||
|
if (indent >= 0)
|
||
|
{
|
||
|
s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
s.dump(*this, false, ensure_ascii, 0);
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief return the type of the JSON value (explicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/type/
|
||
|
constexpr value_t type() const noexcept
|
||
|
{
|
||
|
return m_type;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether type is primitive
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
|
||
|
constexpr bool is_primitive() const noexcept
|
||
|
{
|
||
|
return is_null() || is_string() || is_boolean() || is_number() || is_binary();
|
||
|
}
|
||
|
|
||
|
/// @brief return whether type is structured
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_structured/
|
||
|
constexpr bool is_structured() const noexcept
|
||
|
{
|
||
|
return is_array() || is_object();
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is null
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_null/
|
||
|
constexpr bool is_null() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::null;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is a boolean
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
|
||
|
constexpr bool is_boolean() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::boolean;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is a number
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number/
|
||
|
constexpr bool is_number() const noexcept
|
||
|
{
|
||
|
return is_number_integer() || is_number_float();
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is an integer number
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
|
||
|
constexpr bool is_number_integer() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is an unsigned integer number
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
|
||
|
constexpr bool is_number_unsigned() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::number_unsigned;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is a floating-point number
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
|
||
|
constexpr bool is_number_float() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::number_float;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_object/
|
||
|
constexpr bool is_object() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::object;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_array/
|
||
|
constexpr bool is_array() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::array;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is a string
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_string/
|
||
|
constexpr bool is_string() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::string;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is a binary array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_binary/
|
||
|
constexpr bool is_binary() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::binary;
|
||
|
}
|
||
|
|
||
|
/// @brief return whether value is discarded
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
|
||
|
constexpr bool is_discarded() const noexcept
|
||
|
{
|
||
|
return m_type == value_t::discarded;
|
||
|
}
|
||
|
|
||
|
/// @brief return the type of the JSON value (implicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
|
||
|
constexpr operator value_t() const noexcept
|
||
|
{
|
||
|
return m_type;
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
private:
|
||
|
//////////////////
|
||
|
// value access //
|
||
|
//////////////////
|
||
|
|
||
|
/// get a boolean (explicit)
|
||
|
boolean_t get_impl(boolean_t* /*unused*/) const
|
||
|
{
|
||
|
if (JSON_HEDLEY_LIKELY(is_boolean()))
|
||
|
{
|
||
|
return m_value.boolean;
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (object)
|
||
|
object_t* get_impl_ptr(object_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_object() ? m_value.object : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (object)
|
||
|
constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_object() ? m_value.object : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (array)
|
||
|
array_t* get_impl_ptr(array_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_array() ? m_value.array : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (array)
|
||
|
constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_array() ? m_value.array : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (string)
|
||
|
string_t* get_impl_ptr(string_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_string() ? m_value.string : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (string)
|
||
|
constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_string() ? m_value.string : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (boolean)
|
||
|
boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_boolean() ? &m_value.boolean : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (boolean)
|
||
|
constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_boolean() ? &m_value.boolean : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (integer number)
|
||
|
number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_number_integer() ? &m_value.number_integer : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (integer number)
|
||
|
constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_number_integer() ? &m_value.number_integer : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (unsigned number)
|
||
|
number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (unsigned number)
|
||
|
constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (floating-point number)
|
||
|
number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_number_float() ? &m_value.number_float : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (floating-point number)
|
||
|
constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_number_float() ? &m_value.number_float : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (binary)
|
||
|
binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
|
||
|
{
|
||
|
return is_binary() ? m_value.binary : nullptr;
|
||
|
}
|
||
|
|
||
|
/// get a pointer to the value (binary)
|
||
|
constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
|
||
|
{
|
||
|
return is_binary() ? m_value.binary : nullptr;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief helper function to implement get_ref()
|
||
|
|
||
|
This function helps to implement get_ref() without code duplication for
|
||
|
const and non-const overloads
|
||
|
|
||
|
@tparam ThisType will be deduced as `basic_json` or `const basic_json`
|
||
|
|
||
|
@throw type_error.303 if ReferenceType does not match underlying value
|
||
|
type of the current JSON
|
||
|
*/
|
||
|
template<typename ReferenceType, typename ThisType>
|
||
|
static ReferenceType get_ref_impl(ThisType& obj)
|
||
|
{
|
||
|
// delegate the call to get_ptr<>()
|
||
|
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
|
||
|
|
||
|
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
|
||
|
{
|
||
|
return *ptr;
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
|
||
|
}
|
||
|
|
||
|
public:
|
||
|
/// @name value access
|
||
|
/// Direct access to the stored value of a JSON value.
|
||
|
/// @{
|
||
|
|
||
|
/// @brief get a pointer value (implicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
|
||
|
template<typename PointerType, typename std::enable_if<
|
||
|
std::is_pointer<PointerType>::value, int>::type = 0>
|
||
|
auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
|
||
|
{
|
||
|
// delegate the call to get_impl_ptr<>()
|
||
|
return get_impl_ptr(static_cast<PointerType>(nullptr));
|
||
|
}
|
||
|
|
||
|
/// @brief get a pointer value (implicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
|
||
|
template < typename PointerType, typename std::enable_if <
|
||
|
std::is_pointer<PointerType>::value&&
|
||
|
std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
|
||
|
constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
|
||
|
{
|
||
|
// delegate the call to get_impl_ptr<>() const
|
||
|
return get_impl_ptr(static_cast<PointerType>(nullptr));
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
/*!
|
||
|
@brief get a value (explicit)
|
||
|
|
||
|
Explicit type conversion between the JSON value and a compatible value
|
||
|
which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
|
||
|
and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
|
||
|
The value is converted by calling the @ref json_serializer<ValueType>
|
||
|
`from_json()` method.
|
||
|
|
||
|
The function is equivalent to executing
|
||
|
@code {.cpp}
|
||
|
ValueType ret;
|
||
|
JSONSerializer<ValueType>::from_json(*this, ret);
|
||
|
return ret;
|
||
|
@endcode
|
||
|
|
||
|
This overloads is chosen if:
|
||
|
- @a ValueType is not @ref basic_json,
|
||
|
- @ref json_serializer<ValueType> has a `from_json()` method of the form
|
||
|
`void from_json(const basic_json&, ValueType&)`, and
|
||
|
- @ref json_serializer<ValueType> does not have a `from_json()` method of
|
||
|
the form `ValueType from_json(const basic_json&)`
|
||
|
|
||
|
@tparam ValueType the returned value type
|
||
|
|
||
|
@return copy of the JSON value, converted to @a ValueType
|
||
|
|
||
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws
|
||
|
|
||
|
@liveexample{The example below shows several conversions from JSON values
|
||
|
to other types. There a few things to note: (1) Floating-point numbers can
|
||
|
be converted to integers\, (2) A JSON array can be converted to a standard
|
||
|
`std::vector<short>`\, (3) A JSON object can be converted to C++
|
||
|
associative containers such as `std::unordered_map<std::string\,
|
||
|
json>`.,get__ValueType_const}
|
||
|
|
||
|
@since version 2.1.0
|
||
|
*/
|
||
|
template < typename ValueType,
|
||
|
detail::enable_if_t <
|
||
|
detail::is_default_constructible<ValueType>::value&&
|
||
|
detail::has_from_json<basic_json_t, ValueType>::value,
|
||
|
int > = 0 >
|
||
|
ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
|
||
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
|
||
|
{
|
||
|
auto ret = ValueType();
|
||
|
JSONSerializer<ValueType>::from_json(*this, ret);
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get a value (explicit); special case
|
||
|
|
||
|
Explicit type conversion between the JSON value and a compatible value
|
||
|
which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
|
||
|
and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
|
||
|
The value is converted by calling the @ref json_serializer<ValueType>
|
||
|
`from_json()` method.
|
||
|
|
||
|
The function is equivalent to executing
|
||
|
@code {.cpp}
|
||
|
return JSONSerializer<ValueType>::from_json(*this);
|
||
|
@endcode
|
||
|
|
||
|
This overloads is chosen if:
|
||
|
- @a ValueType is not @ref basic_json and
|
||
|
- @ref json_serializer<ValueType> has a `from_json()` method of the form
|
||
|
`ValueType from_json(const basic_json&)`
|
||
|
|
||
|
@note If @ref json_serializer<ValueType> has both overloads of
|
||
|
`from_json()`, this one is chosen.
|
||
|
|
||
|
@tparam ValueType the returned value type
|
||
|
|
||
|
@return copy of the JSON value, converted to @a ValueType
|
||
|
|
||
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws
|
||
|
|
||
|
@since version 2.1.0
|
||
|
*/
|
||
|
template < typename ValueType,
|
||
|
detail::enable_if_t <
|
||
|
detail::has_non_default_from_json<basic_json_t, ValueType>::value,
|
||
|
int > = 0 >
|
||
|
ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
|
||
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
|
||
|
{
|
||
|
return JSONSerializer<ValueType>::from_json(*this);
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get special-case overload
|
||
|
|
||
|
This overloads converts the current @ref basic_json in a different
|
||
|
@ref basic_json type
|
||
|
|
||
|
@tparam BasicJsonType == @ref basic_json
|
||
|
|
||
|
@return a copy of *this, converted into @a BasicJsonType
|
||
|
|
||
|
@complexity Depending on the implementation of the called `from_json()`
|
||
|
method.
|
||
|
|
||
|
@since version 3.2.0
|
||
|
*/
|
||
|
template < typename BasicJsonType,
|
||
|
detail::enable_if_t <
|
||
|
detail::is_basic_json<BasicJsonType>::value,
|
||
|
int > = 0 >
|
||
|
BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
|
||
|
{
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get special-case overload
|
||
|
|
||
|
This overloads avoids a lot of template boilerplate, it can be seen as the
|
||
|
identity method
|
||
|
|
||
|
@tparam BasicJsonType == @ref basic_json
|
||
|
|
||
|
@return a copy of *this
|
||
|
|
||
|
@complexity Constant.
|
||
|
|
||
|
@since version 2.1.0
|
||
|
*/
|
||
|
template<typename BasicJsonType,
|
||
|
detail::enable_if_t<
|
||
|
std::is_same<BasicJsonType, basic_json_t>::value,
|
||
|
int> = 0>
|
||
|
basic_json get_impl(detail::priority_tag<3> /*unused*/) const
|
||
|
{
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get a pointer value (explicit)
|
||
|
@copydoc get()
|
||
|
*/
|
||
|
template<typename PointerType,
|
||
|
detail::enable_if_t<
|
||
|
std::is_pointer<PointerType>::value,
|
||
|
int> = 0>
|
||
|
constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
|
||
|
-> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
|
||
|
{
|
||
|
// delegate the call to get_ptr
|
||
|
return get_ptr<PointerType>();
|
||
|
}
|
||
|
|
||
|
public:
|
||
|
/*!
|
||
|
@brief get a (pointer) value (explicit)
|
||
|
|
||
|
Performs explicit type conversion between the JSON value and a compatible value if required.
|
||
|
|
||
|
- If the requested type is a pointer to the internally stored JSON value that pointer is returned.
|
||
|
No copies are made.
|
||
|
|
||
|
- If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
|
||
|
from the current @ref basic_json.
|
||
|
|
||
|
- Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
|
||
|
method.
|
||
|
|
||
|
@tparam ValueTypeCV the provided value type
|
||
|
@tparam ValueType the returned value type
|
||
|
|
||
|
@return copy of the JSON value, converted to @tparam ValueType if necessary
|
||
|
|
||
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
|
||
|
|
||
|
@since version 2.1.0
|
||
|
*/
|
||
|
template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
|
||
|
#if defined(JSON_HAS_CPP_14)
|
||
|
constexpr
|
||
|
#endif
|
||
|
auto get() const noexcept(
|
||
|
noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
|
||
|
-> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
|
||
|
{
|
||
|
// we cannot static_assert on ValueTypeCV being non-const, because
|
||
|
// there is support for get<const basic_json_t>(), which is why we
|
||
|
// still need the uncvref
|
||
|
static_assert(!std::is_reference<ValueTypeCV>::value,
|
||
|
"get() cannot be used with reference types, you might want to use get_ref()");
|
||
|
return get_impl<ValueType>(detail::priority_tag<4> {});
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get a pointer value (explicit)
|
||
|
|
||
|
Explicit pointer access to the internally stored JSON value. No copies are
|
||
|
made.
|
||
|
|
||
|
@warning The pointer becomes invalid if the underlying JSON object
|
||
|
changes.
|
||
|
|
||
|
@tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
|
||
|
object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
|
||
|
@ref number_unsigned_t, or @ref number_float_t.
|
||
|
|
||
|
@return pointer to the internally stored JSON value if the requested
|
||
|
pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
|
||
|
|
||
|
@complexity Constant.
|
||
|
|
||
|
@liveexample{The example below shows how pointers to internal values of a
|
||
|
JSON value can be requested. Note that no type conversions are made and a
|
||
|
`nullptr` is returned if the value and the requested pointer type does not
|
||
|
match.,get__PointerType}
|
||
|
|
||
|
@sa see @ref get_ptr() for explicit pointer-member access
|
||
|
|
||
|
@since version 1.0.0
|
||
|
*/
|
||
|
template<typename PointerType, typename std::enable_if<
|
||
|
std::is_pointer<PointerType>::value, int>::type = 0>
|
||
|
auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
|
||
|
{
|
||
|
// delegate the call to get_ptr
|
||
|
return get_ptr<PointerType>();
|
||
|
}
|
||
|
|
||
|
/// @brief get a value (explicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_to/
|
||
|
template < typename ValueType,
|
||
|
detail::enable_if_t <
|
||
|
!detail::is_basic_json<ValueType>::value&&
|
||
|
detail::has_from_json<basic_json_t, ValueType>::value,
|
||
|
int > = 0 >
|
||
|
ValueType & get_to(ValueType& v) const noexcept(noexcept(
|
||
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
|
||
|
{
|
||
|
JSONSerializer<ValueType>::from_json(*this, v);
|
||
|
return v;
|
||
|
}
|
||
|
|
||
|
// specialization to allow calling get_to with a basic_json value
|
||
|
// see https://github.com/nlohmann/json/issues/2175
|
||
|
template<typename ValueType,
|
||
|
detail::enable_if_t <
|
||
|
detail::is_basic_json<ValueType>::value,
|
||
|
int> = 0>
|
||
|
ValueType & get_to(ValueType& v) const
|
||
|
{
|
||
|
v = *this;
|
||
|
return v;
|
||
|
}
|
||
|
|
||
|
template <
|
||
|
typename T, std::size_t N,
|
||
|
typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||
|
detail::enable_if_t <
|
||
|
detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
|
||
|
Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||
|
noexcept(noexcept(JSONSerializer<Array>::from_json(
|
||
|
std::declval<const basic_json_t&>(), v)))
|
||
|
{
|
||
|
JSONSerializer<Array>::from_json(*this, v);
|
||
|
return v;
|
||
|
}
|
||
|
|
||
|
/// @brief get a reference value (implicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
|
||
|
template<typename ReferenceType, typename std::enable_if<
|
||
|
std::is_reference<ReferenceType>::value, int>::type = 0>
|
||
|
ReferenceType get_ref()
|
||
|
{
|
||
|
// delegate call to get_ref_impl
|
||
|
return get_ref_impl<ReferenceType>(*this);
|
||
|
}
|
||
|
|
||
|
/// @brief get a reference value (implicit)
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
|
||
|
template < typename ReferenceType, typename std::enable_if <
|
||
|
std::is_reference<ReferenceType>::value&&
|
||
|
std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
|
||
|
ReferenceType get_ref() const
|
||
|
{
|
||
|
// delegate call to get_ref_impl
|
||
|
return get_ref_impl<ReferenceType>(*this);
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
@brief get a value (implicit)
|
||
|
|
||
|
Implicit type conversion between the JSON value and a compatible value.
|
||
|
The call is realized by calling @ref get() const.
|
||
|
|
||
|
@tparam ValueType non-pointer type compatible to the JSON value, for
|
||
|
instance `int` for JSON integer numbers, `bool` for JSON booleans, or
|
||
|
`std::vector` types for JSON arrays. The character type of @ref string_t
|
||
|
as well as an initializer list of this type is excluded to avoid
|
||
|
ambiguities as these types implicitly convert to `std::string`.
|
||
|
|
||
|
@return copy of the JSON value, converted to type @a ValueType
|
||
|
|
||
|
@throw type_error.302 in case passed type @a ValueType is incompatible
|
||
|
to the JSON value type (e.g., the JSON value is of type boolean, but a
|
||
|
string is requested); see example below
|
||
|
|
||
|
@complexity Linear in the size of the JSON value.
|
||
|
|
||
|
@liveexample{The example below shows several conversions from JSON values
|
||
|
to other types. There a few things to note: (1) Floating-point numbers can
|
||
|
be converted to integers\, (2) A JSON array can be converted to a standard
|
||
|
`std::vector<short>`\, (3) A JSON object can be converted to C++
|
||
|
associative containers such as `std::unordered_map<std::string\,
|
||
|
json>`.,operator__ValueType}
|
||
|
|
||
|
@since version 1.0.0
|
||
|
*/
|
||
|
template < typename ValueType, typename std::enable_if <
|
||
|
detail::conjunction <
|
||
|
detail::negation<std::is_pointer<ValueType>>,
|
||
|
detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
|
||
|
detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
|
||
|
detail::negation<detail::is_basic_json<ValueType>>,
|
||
|
detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
|
||
|
|
||
|
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
|
||
|
detail::negation<std::is_same<ValueType, std::string_view>>,
|
||
|
#endif
|
||
|
detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
|
||
|
>::value, int >::type = 0 >
|
||
|
JSON_EXPLICIT operator ValueType() const
|
||
|
{
|
||
|
// delegate the call to get<>() const
|
||
|
return get<ValueType>();
|
||
|
}
|
||
|
|
||
|
/// @brief get a binary value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
|
||
|
binary_t& get_binary()
|
||
|
{
|
||
|
if (!is_binary())
|
||
|
{
|
||
|
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
return *get_ptr<binary_t*>();
|
||
|
}
|
||
|
|
||
|
/// @brief get a binary value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
|
||
|
const binary_t& get_binary() const
|
||
|
{
|
||
|
if (!is_binary())
|
||
|
{
|
||
|
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
return *get_ptr<const binary_t*>();
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
////////////////////
|
||
|
// element access //
|
||
|
////////////////////
|
||
|
|
||
|
/// @name element access
|
||
|
/// Access to the JSON value.
|
||
|
/// @{
|
||
|
|
||
|
/// @brief access specified array element with bounds checking
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
reference at(size_type idx)
|
||
|
{
|
||
|
// at only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
JSON_TRY
|
||
|
{
|
||
|
return set_parent(m_value.array->at(idx));
|
||
|
}
|
||
|
JSON_CATCH (std::out_of_range&)
|
||
|
{
|
||
|
// create better exception explanation
|
||
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief access specified array element with bounds checking
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
const_reference at(size_type idx) const
|
||
|
{
|
||
|
// at only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
JSON_TRY
|
||
|
{
|
||
|
return m_value.array->at(idx);
|
||
|
}
|
||
|
JSON_CATCH (std::out_of_range&)
|
||
|
{
|
||
|
// create better exception explanation
|
||
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element with bounds checking
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
reference at(const typename object_t::key_type& key)
|
||
|
{
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
JSON_TRY
|
||
|
{
|
||
|
return set_parent(m_value.object->at(key));
|
||
|
}
|
||
|
JSON_CATCH (std::out_of_range&)
|
||
|
{
|
||
|
// create better exception explanation
|
||
|
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element with bounds checking
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
const_reference at(const typename object_t::key_type& key) const
|
||
|
{
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
JSON_TRY
|
||
|
{
|
||
|
return m_value.object->at(key);
|
||
|
}
|
||
|
JSON_CATCH (std::out_of_range&)
|
||
|
{
|
||
|
// create better exception explanation
|
||
|
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief access specified array element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
reference operator[](size_type idx)
|
||
|
{
|
||
|
// implicitly convert null value to an empty array
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::array;
|
||
|
m_value.array = create<array_t>();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// operator[] only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
// fill up array with null values if given idx is outside range
|
||
|
if (idx >= m_value.array->size())
|
||
|
{
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
// remember array size & capacity before resizing
|
||
|
const auto old_size = m_value.array->size();
|
||
|
const auto old_capacity = m_value.array->capacity();
|
||
|
#endif
|
||
|
m_value.array->resize(idx + 1);
|
||
|
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
|
||
|
{
|
||
|
// capacity has changed: update all parents
|
||
|
set_parents();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// set parent for values added above
|
||
|
set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
|
||
|
}
|
||
|
#endif
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
return m_value.array->operator[](idx);
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified array element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
const_reference operator[](size_type idx) const
|
||
|
{
|
||
|
// const operator[] only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
return m_value.array->operator[](idx);
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
reference operator[](const typename object_t::key_type& key)
|
||
|
{
|
||
|
// implicitly convert null value to an empty object
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::object;
|
||
|
m_value.object = create<object_t>();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// operator[] only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
return set_parent(m_value.object->operator[](key));
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
const_reference operator[](const typename object_t::key_type& key) const
|
||
|
{
|
||
|
// const operator[] only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
|
||
|
return m_value.object->find(key)->second;
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_NON_NULL(2)
|
||
|
reference operator[](T* key)
|
||
|
{
|
||
|
// implicitly convert null to object
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::object;
|
||
|
m_value = value_t::object;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
return set_parent(m_value.object->operator[](key));
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_NON_NULL(2)
|
||
|
const_reference operator[](T* key) const
|
||
|
{
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
|
||
|
return m_value.object->find(key)->second;
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element with default value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
||
|
/// using std::is_convertible in a std::enable_if will fail when using explicit conversions
|
||
|
template < class ValueType, typename std::enable_if <
|
||
|
detail::is_getable<basic_json_t, ValueType>::value
|
||
|
&& !std::is_same<value_t, ValueType>::value, int >::type = 0 >
|
||
|
ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
|
||
|
{
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
// if key is found, return value and given default value otherwise
|
||
|
const auto it = find(key);
|
||
|
if (it != end())
|
||
|
{
|
||
|
return it->template get<ValueType>();
|
||
|
}
|
||
|
|
||
|
return default_value;
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element with default value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
||
|
/// overload for a default value of type const char*
|
||
|
string_t value(const typename object_t::key_type& key, const char* default_value) const
|
||
|
{
|
||
|
return value(key, string_t(default_value));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element via JSON Pointer with default value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
||
|
template<class ValueType, typename std::enable_if<
|
||
|
detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
|
||
|
ValueType value(const json_pointer& ptr, const ValueType& default_value) const
|
||
|
{
|
||
|
// at only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
// if pointer resolves a value, return it or use default value
|
||
|
JSON_TRY
|
||
|
{
|
||
|
return ptr.get_checked(this).template get<ValueType>();
|
||
|
}
|
||
|
JSON_INTERNAL_CATCH (out_of_range&)
|
||
|
{
|
||
|
return default_value;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief access specified object element via JSON Pointer with default value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
||
|
/// overload for a default value of type const char*
|
||
|
JSON_HEDLEY_NON_NULL(3)
|
||
|
string_t value(const json_pointer& ptr, const char* default_value) const
|
||
|
{
|
||
|
return value(ptr, string_t(default_value));
|
||
|
}
|
||
|
|
||
|
/// @brief access the first element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/front/
|
||
|
reference front()
|
||
|
{
|
||
|
return *begin();
|
||
|
}
|
||
|
|
||
|
/// @brief access the first element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/front/
|
||
|
const_reference front() const
|
||
|
{
|
||
|
return *cbegin();
|
||
|
}
|
||
|
|
||
|
/// @brief access the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/back/
|
||
|
reference back()
|
||
|
{
|
||
|
auto tmp = end();
|
||
|
--tmp;
|
||
|
return *tmp;
|
||
|
}
|
||
|
|
||
|
/// @brief access the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/back/
|
||
|
const_reference back() const
|
||
|
{
|
||
|
auto tmp = cend();
|
||
|
--tmp;
|
||
|
return *tmp;
|
||
|
}
|
||
|
|
||
|
/// @brief remove element given an iterator
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
||
|
template < class IteratorType, typename std::enable_if <
|
||
|
std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
|
||
|
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
|
||
|
= 0 >
|
||
|
IteratorType erase(IteratorType pos)
|
||
|
{
|
||
|
// make sure iterator fits the current value
|
||
|
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
IteratorType result = end();
|
||
|
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_float:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::string:
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(205, "iterator out of range", *this));
|
||
|
}
|
||
|
|
||
|
if (is_string())
|
||
|
{
|
||
|
AllocatorType<string_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
|
||
|
m_value.string = nullptr;
|
||
|
}
|
||
|
else if (is_binary())
|
||
|
{
|
||
|
AllocatorType<binary_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
|
||
|
m_value.binary = nullptr;
|
||
|
}
|
||
|
|
||
|
m_type = value_t::null;
|
||
|
assert_invariant();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief remove elements given an iterator range
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
||
|
template < class IteratorType, typename std::enable_if <
|
||
|
std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
|
||
|
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
|
||
|
= 0 >
|
||
|
IteratorType erase(IteratorType first, IteratorType last)
|
||
|
{
|
||
|
// make sure iterator fits the current value
|
||
|
if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
IteratorType result = end();
|
||
|
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_float:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::string:
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
|
||
|
|| !last.m_it.primitive_iterator.is_end()))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
|
||
|
}
|
||
|
|
||
|
if (is_string())
|
||
|
{
|
||
|
AllocatorType<string_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
|
||
|
m_value.string = nullptr;
|
||
|
}
|
||
|
else if (is_binary())
|
||
|
{
|
||
|
AllocatorType<binary_t> alloc;
|
||
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
|
||
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
|
||
|
m_value.binary = nullptr;
|
||
|
}
|
||
|
|
||
|
m_type = value_t::null;
|
||
|
assert_invariant();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
|
||
|
last.m_it.object_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
|
||
|
last.m_it.array_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief remove element from a JSON object given a key
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
||
|
size_type erase(const typename object_t::key_type& key)
|
||
|
{
|
||
|
// this erase only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
return m_value.object->erase(key);
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief remove element from a JSON array given an index
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
||
|
void erase(const size_type idx)
|
||
|
{
|
||
|
// this erase only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
if (JSON_HEDLEY_UNLIKELY(idx >= size()))
|
||
|
{
|
||
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
||
|
}
|
||
|
|
||
|
m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
////////////
|
||
|
// lookup //
|
||
|
////////////
|
||
|
|
||
|
/// @name lookup
|
||
|
/// @{
|
||
|
|
||
|
/// @brief find an element in a JSON object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/find/
|
||
|
template<typename KeyT>
|
||
|
iterator find(KeyT&& key)
|
||
|
{
|
||
|
auto result = end();
|
||
|
|
||
|
if (is_object())
|
||
|
{
|
||
|
result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief find an element in a JSON object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/find/
|
||
|
template<typename KeyT>
|
||
|
const_iterator find(KeyT&& key) const
|
||
|
{
|
||
|
auto result = cend();
|
||
|
|
||
|
if (is_object())
|
||
|
{
|
||
|
result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief returns the number of occurrences of a key in a JSON object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/count/
|
||
|
template<typename KeyT>
|
||
|
size_type count(KeyT&& key) const
|
||
|
{
|
||
|
// return 0 for all nonobject types
|
||
|
return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
|
||
|
}
|
||
|
|
||
|
/// @brief check the existence of an element in a JSON object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/contains/
|
||
|
template < typename KeyT, typename std::enable_if <
|
||
|
!std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
|
||
|
bool contains(KeyT && key) const
|
||
|
{
|
||
|
return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
|
||
|
}
|
||
|
|
||
|
/// @brief check the existence of an element in a JSON object given a JSON pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/contains/
|
||
|
bool contains(const json_pointer& ptr) const
|
||
|
{
|
||
|
return ptr.contains(this);
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
///////////////
|
||
|
// iterators //
|
||
|
///////////////
|
||
|
|
||
|
/// @name iterators
|
||
|
/// @{
|
||
|
|
||
|
/// @brief returns an iterator to the first element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/begin/
|
||
|
iterator begin() noexcept
|
||
|
{
|
||
|
iterator result(this);
|
||
|
result.set_begin();
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to the first element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/begin/
|
||
|
const_iterator begin() const noexcept
|
||
|
{
|
||
|
return cbegin();
|
||
|
}
|
||
|
|
||
|
/// @brief returns a const iterator to the first element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/cbegin/
|
||
|
const_iterator cbegin() const noexcept
|
||
|
{
|
||
|
const_iterator result(this);
|
||
|
result.set_begin();
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to one past the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/end/
|
||
|
iterator end() noexcept
|
||
|
{
|
||
|
iterator result(this);
|
||
|
result.set_end();
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to one past the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/end/
|
||
|
const_iterator end() const noexcept
|
||
|
{
|
||
|
return cend();
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to one past the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/cend/
|
||
|
const_iterator cend() const noexcept
|
||
|
{
|
||
|
const_iterator result(this);
|
||
|
result.set_end();
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to the reverse-beginning
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
|
||
|
reverse_iterator rbegin() noexcept
|
||
|
{
|
||
|
return reverse_iterator(end());
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to the reverse-beginning
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
|
||
|
const_reverse_iterator rbegin() const noexcept
|
||
|
{
|
||
|
return crbegin();
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to the reverse-end
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/rend/
|
||
|
reverse_iterator rend() noexcept
|
||
|
{
|
||
|
return reverse_iterator(begin());
|
||
|
}
|
||
|
|
||
|
/// @brief returns an iterator to the reverse-end
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/rend/
|
||
|
const_reverse_iterator rend() const noexcept
|
||
|
{
|
||
|
return crend();
|
||
|
}
|
||
|
|
||
|
/// @brief returns a const reverse iterator to the last element
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/crbegin/
|
||
|
const_reverse_iterator crbegin() const noexcept
|
||
|
{
|
||
|
return const_reverse_iterator(cend());
|
||
|
}
|
||
|
|
||
|
/// @brief returns a const reverse iterator to one before the first
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/crend/
|
||
|
const_reverse_iterator crend() const noexcept
|
||
|
{
|
||
|
return const_reverse_iterator(cbegin());
|
||
|
}
|
||
|
|
||
|
public:
|
||
|
/// @brief wrapper to access iterator member functions in range-based for
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
||
|
/// @deprecated This function is deprecated since 3.1.0 and will be removed in
|
||
|
/// version 4.0.0 of the library. Please use @ref items() instead;
|
||
|
/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
|
||
|
static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
|
||
|
{
|
||
|
return ref.items();
|
||
|
}
|
||
|
|
||
|
/// @brief wrapper to access iterator member functions in range-based for
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
||
|
/// @deprecated This function is deprecated since 3.1.0 and will be removed in
|
||
|
/// version 4.0.0 of the library. Please use @ref items() instead;
|
||
|
/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
|
||
|
static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
|
||
|
{
|
||
|
return ref.items();
|
||
|
}
|
||
|
|
||
|
/// @brief helper to access iterator member functions in range-based for
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
||
|
iteration_proxy<iterator> items() noexcept
|
||
|
{
|
||
|
return iteration_proxy<iterator>(*this);
|
||
|
}
|
||
|
|
||
|
/// @brief helper to access iterator member functions in range-based for
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
||
|
iteration_proxy<const_iterator> items() const noexcept
|
||
|
{
|
||
|
return iteration_proxy<const_iterator>(*this);
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
//////////////
|
||
|
// capacity //
|
||
|
//////////////
|
||
|
|
||
|
/// @name capacity
|
||
|
/// @{
|
||
|
|
||
|
/// @brief checks whether the container is empty.
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/empty/
|
||
|
bool empty() const noexcept
|
||
|
{
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::null:
|
||
|
{
|
||
|
// null values are empty
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
// delegate call to array_t::empty()
|
||
|
return m_value.array->empty();
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
// delegate call to object_t::empty()
|
||
|
return m_value.object->empty();
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
// all other types are nonempty
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief returns the number of elements
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/size/
|
||
|
size_type size() const noexcept
|
||
|
{
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::null:
|
||
|
{
|
||
|
// null values are empty
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
// delegate call to array_t::size()
|
||
|
return m_value.array->size();
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
// delegate call to object_t::size()
|
||
|
return m_value.object->size();
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
// all other types have size 1
|
||
|
return 1;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief returns the maximum possible number of elements
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/max_size/
|
||
|
size_type max_size() const noexcept
|
||
|
{
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::array:
|
||
|
{
|
||
|
// delegate call to array_t::max_size()
|
||
|
return m_value.array->max_size();
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
// delegate call to object_t::max_size()
|
||
|
return m_value.object->max_size();
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::string:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
// all other types have max_size() == size()
|
||
|
return size();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
///////////////
|
||
|
// modifiers //
|
||
|
///////////////
|
||
|
|
||
|
/// @name modifiers
|
||
|
/// @{
|
||
|
|
||
|
/// @brief clears the contents
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/clear/
|
||
|
void clear() noexcept
|
||
|
{
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::number_integer:
|
||
|
{
|
||
|
m_value.number_integer = 0;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
{
|
||
|
m_value.number_unsigned = 0;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::number_float:
|
||
|
{
|
||
|
m_value.number_float = 0.0;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::boolean:
|
||
|
{
|
||
|
m_value.boolean = false;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::string:
|
||
|
{
|
||
|
m_value.string->clear();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::binary:
|
||
|
{
|
||
|
m_value.binary->clear();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
m_value.array->clear();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
m_value.object->clear();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
||
|
void push_back(basic_json&& val)
|
||
|
{
|
||
|
// push_back only works for null objects or arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// transform null object into an array
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::array;
|
||
|
m_value = value_t::array;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// add element to array (move semantics)
|
||
|
const auto old_capacity = m_value.array->capacity();
|
||
|
m_value.array->push_back(std::move(val));
|
||
|
set_parent(m_value.array->back(), old_capacity);
|
||
|
// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
||
|
reference operator+=(basic_json&& val)
|
||
|
{
|
||
|
push_back(std::move(val));
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
||
|
void push_back(const basic_json& val)
|
||
|
{
|
||
|
// push_back only works for null objects or arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// transform null object into an array
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::array;
|
||
|
m_value = value_t::array;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// add element to array
|
||
|
const auto old_capacity = m_value.array->capacity();
|
||
|
m_value.array->push_back(val);
|
||
|
set_parent(m_value.array->back(), old_capacity);
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
||
|
reference operator+=(const basic_json& val)
|
||
|
{
|
||
|
push_back(val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
||
|
void push_back(const typename object_t::value_type& val)
|
||
|
{
|
||
|
// push_back only works for null objects or objects
|
||
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// transform null object into an object
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::object;
|
||
|
m_value = value_t::object;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// add element to object
|
||
|
auto res = m_value.object->insert(val);
|
||
|
set_parent(res.first->second);
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
||
|
reference operator+=(const typename object_t::value_type& val)
|
||
|
{
|
||
|
push_back(val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
||
|
void push_back(initializer_list_t init)
|
||
|
{
|
||
|
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
|
||
|
{
|
||
|
basic_json&& key = init.begin()->moved_or_copied();
|
||
|
push_back(typename object_t::value_type(
|
||
|
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
push_back(basic_json(init));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
||
|
reference operator+=(initializer_list_t init)
|
||
|
{
|
||
|
push_back(init);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
|
||
|
template<class... Args>
|
||
|
reference emplace_back(Args&& ... args)
|
||
|
{
|
||
|
// emplace_back only works for null objects or arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// transform null object into an array
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::array;
|
||
|
m_value = value_t::array;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// add element to array (perfect forwarding)
|
||
|
const auto old_capacity = m_value.array->capacity();
|
||
|
m_value.array->emplace_back(std::forward<Args>(args)...);
|
||
|
return set_parent(m_value.array->back(), old_capacity);
|
||
|
}
|
||
|
|
||
|
/// @brief add an object to an object if key does not exist
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/emplace/
|
||
|
template<class... Args>
|
||
|
std::pair<iterator, bool> emplace(Args&& ... args)
|
||
|
{
|
||
|
// emplace only works for null objects or arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// transform null object into an object
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::object;
|
||
|
m_value = value_t::object;
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
// add element to array (perfect forwarding)
|
||
|
auto res = m_value.object->emplace(std::forward<Args>(args)...);
|
||
|
set_parent(res.first->second);
|
||
|
|
||
|
// create result iterator and set iterator to the result of emplace
|
||
|
auto it = begin();
|
||
|
it.m_it.object_iterator = res.first;
|
||
|
|
||
|
// return pair of iterator and boolean
|
||
|
return {it, res.second};
|
||
|
}
|
||
|
|
||
|
/// Helper for insertion of an iterator
|
||
|
/// @note: This uses std::distance to support GCC 4.8,
|
||
|
/// see https://github.com/nlohmann/json/pull/1257
|
||
|
template<typename... Args>
|
||
|
iterator insert_iterator(const_iterator pos, Args&& ... args)
|
||
|
{
|
||
|
iterator result(this);
|
||
|
JSON_ASSERT(m_value.array != nullptr);
|
||
|
|
||
|
auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
|
||
|
m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
|
||
|
result.m_it.array_iterator = m_value.array->begin() + insert_pos;
|
||
|
|
||
|
// This could have been written as:
|
||
|
// result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
|
||
|
// but the return value of insert is missing in GCC 4.8, so it is written this way instead.
|
||
|
|
||
|
set_parents();
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief inserts element into array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
iterator insert(const_iterator pos, const basic_json& val)
|
||
|
{
|
||
|
// insert only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
// check if iterator pos fits to this JSON value
|
||
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
// insert to array and return iterator
|
||
|
return insert_iterator(pos, val);
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief inserts element into array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
iterator insert(const_iterator pos, basic_json&& val)
|
||
|
{
|
||
|
return insert(pos, val);
|
||
|
}
|
||
|
|
||
|
/// @brief inserts copies of element into array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
|
||
|
{
|
||
|
// insert only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
// check if iterator pos fits to this JSON value
|
||
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
// insert to array and return iterator
|
||
|
return insert_iterator(pos, cnt, val);
|
||
|
}
|
||
|
|
||
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
/// @brief inserts range of elements into array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
|
||
|
{
|
||
|
// insert only works for arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// check if iterator pos fits to this JSON value
|
||
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
// check if range iterators belong to the same JSON object
|
||
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
||
|
}
|
||
|
|
||
|
if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", *this));
|
||
|
}
|
||
|
|
||
|
// insert to array and return iterator
|
||
|
return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
|
||
|
}
|
||
|
|
||
|
/// @brief inserts elements from initializer list into array
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
iterator insert(const_iterator pos, initializer_list_t ilist)
|
||
|
{
|
||
|
// insert only works for arrays
|
||
|
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// check if iterator pos fits to this JSON value
|
||
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
||
|
}
|
||
|
|
||
|
// insert to array and return iterator
|
||
|
return insert_iterator(pos, ilist.begin(), ilist.end());
|
||
|
}
|
||
|
|
||
|
/// @brief inserts range of elements into object
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
||
|
void insert(const_iterator first, const_iterator last)
|
||
|
{
|
||
|
// insert only works for objects
|
||
|
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// check if range iterators belong to the same JSON object
|
||
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
||
|
}
|
||
|
|
||
|
// passed iterators must belong to objects
|
||
|
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", *this));
|
||
|
}
|
||
|
|
||
|
m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
|
||
|
}
|
||
|
|
||
|
/// @brief updates a JSON object from another object, overwriting existing keys
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/update/
|
||
|
void update(const_reference j, bool merge_objects = false)
|
||
|
{
|
||
|
update(j.begin(), j.end(), merge_objects);
|
||
|
}
|
||
|
|
||
|
/// @brief updates a JSON object from another object, overwriting existing keys
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/update/
|
||
|
void update(const_iterator first, const_iterator last, bool merge_objects = false)
|
||
|
{
|
||
|
// implicitly convert null value to an empty object
|
||
|
if (is_null())
|
||
|
{
|
||
|
m_type = value_t::object;
|
||
|
m_value.object = create<object_t>();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
|
||
|
// check if range iterators belong to the same JSON object
|
||
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
||
|
{
|
||
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
||
|
}
|
||
|
|
||
|
// passed iterators must belong to objects
|
||
|
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
|
||
|
{
|
||
|
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(first.m_object->type_name()), *first.m_object));
|
||
|
}
|
||
|
|
||
|
for (auto it = first; it != last; ++it)
|
||
|
{
|
||
|
if (merge_objects && it.value().is_object())
|
||
|
{
|
||
|
auto it2 = m_value.object->find(it.key());
|
||
|
if (it2 != m_value.object->end())
|
||
|
{
|
||
|
it2->second.update(it.value(), true);
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
m_value.object->operator[](it.key()) = it.value();
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
m_value.object->operator[](it.key()).m_parent = this;
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(reference other) noexcept (
|
||
|
std::is_nothrow_move_constructible<value_t>::value&&
|
||
|
std::is_nothrow_move_assignable<value_t>::value&&
|
||
|
std::is_nothrow_move_constructible<json_value>::value&&
|
||
|
std::is_nothrow_move_assignable<json_value>::value
|
||
|
)
|
||
|
{
|
||
|
std::swap(m_type, other.m_type);
|
||
|
std::swap(m_value, other.m_value);
|
||
|
|
||
|
set_parents();
|
||
|
other.set_parents();
|
||
|
assert_invariant();
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
friend void swap(reference left, reference right) noexcept (
|
||
|
std::is_nothrow_move_constructible<value_t>::value&&
|
||
|
std::is_nothrow_move_assignable<value_t>::value&&
|
||
|
std::is_nothrow_move_constructible<json_value>::value&&
|
||
|
std::is_nothrow_move_assignable<json_value>::value
|
||
|
)
|
||
|
{
|
||
|
left.swap(right);
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(array_t& other) // NOLINT(bugprone-exception-escape)
|
||
|
{
|
||
|
// swap only works for arrays
|
||
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
||
|
{
|
||
|
std::swap(*(m_value.array), other);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(object_t& other) // NOLINT(bugprone-exception-escape)
|
||
|
{
|
||
|
// swap only works for objects
|
||
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
||
|
{
|
||
|
std::swap(*(m_value.object), other);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(string_t& other) // NOLINT(bugprone-exception-escape)
|
||
|
{
|
||
|
// swap only works for strings
|
||
|
if (JSON_HEDLEY_LIKELY(is_string()))
|
||
|
{
|
||
|
std::swap(*(m_value.string), other);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
|
||
|
{
|
||
|
// swap only works for strings
|
||
|
if (JSON_HEDLEY_LIKELY(is_binary()))
|
||
|
{
|
||
|
std::swap(*(m_value.binary), other);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @brief exchanges the values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
||
|
void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
|
||
|
{
|
||
|
// swap only works for strings
|
||
|
if (JSON_HEDLEY_LIKELY(is_binary()))
|
||
|
{
|
||
|
std::swap(*(m_value.binary), other);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
public:
|
||
|
//////////////////////////////////////////
|
||
|
// lexicographical comparison operators //
|
||
|
//////////////////////////////////////////
|
||
|
|
||
|
/// @name lexicographical comparison operators
|
||
|
/// @{
|
||
|
|
||
|
/// @brief comparison: equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
||
|
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
#ifdef __GNUC__
|
||
|
#pragma GCC diagnostic push
|
||
|
#pragma GCC diagnostic ignored "-Wfloat-equal"
|
||
|
#endif
|
||
|
const auto lhs_type = lhs.type();
|
||
|
const auto rhs_type = rhs.type();
|
||
|
|
||
|
if (lhs_type == rhs_type)
|
||
|
{
|
||
|
switch (lhs_type)
|
||
|
{
|
||
|
case value_t::array:
|
||
|
return *lhs.m_value.array == *rhs.m_value.array;
|
||
|
|
||
|
case value_t::object:
|
||
|
return *lhs.m_value.object == *rhs.m_value.object;
|
||
|
|
||
|
case value_t::null:
|
||
|
return true;
|
||
|
|
||
|
case value_t::string:
|
||
|
return *lhs.m_value.string == *rhs.m_value.string;
|
||
|
|
||
|
case value_t::boolean:
|
||
|
return lhs.m_value.boolean == rhs.m_value.boolean;
|
||
|
|
||
|
case value_t::number_integer:
|
||
|
return lhs.m_value.number_integer == rhs.m_value.number_integer;
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
|
||
|
|
||
|
case value_t::number_float:
|
||
|
return lhs.m_value.number_float == rhs.m_value.number_float;
|
||
|
|
||
|
case value_t::binary:
|
||
|
return *lhs.m_value.binary == *rhs.m_value.binary;
|
||
|
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
|
||
|
{
|
||
|
return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
|
||
|
{
|
||
|
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
|
||
|
{
|
||
|
return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
|
||
|
{
|
||
|
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
|
||
|
{
|
||
|
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
|
||
|
{
|
||
|
return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
#ifdef __GNUC__
|
||
|
#pragma GCC diagnostic pop
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs == basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) == rhs;
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: not equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
||
|
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return !(lhs == rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: not equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs != basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: not equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) != rhs;
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
||
|
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
const auto lhs_type = lhs.type();
|
||
|
const auto rhs_type = rhs.type();
|
||
|
|
||
|
if (lhs_type == rhs_type)
|
||
|
{
|
||
|
switch (lhs_type)
|
||
|
{
|
||
|
case value_t::array:
|
||
|
// note parentheses are necessary, see
|
||
|
// https://github.com/nlohmann/json/issues/1530
|
||
|
return (*lhs.m_value.array) < (*rhs.m_value.array);
|
||
|
|
||
|
case value_t::object:
|
||
|
return (*lhs.m_value.object) < (*rhs.m_value.object);
|
||
|
|
||
|
case value_t::null:
|
||
|
return false;
|
||
|
|
||
|
case value_t::string:
|
||
|
return (*lhs.m_value.string) < (*rhs.m_value.string);
|
||
|
|
||
|
case value_t::boolean:
|
||
|
return (lhs.m_value.boolean) < (rhs.m_value.boolean);
|
||
|
|
||
|
case value_t::number_integer:
|
||
|
return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
|
||
|
|
||
|
case value_t::number_unsigned:
|
||
|
return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
|
||
|
|
||
|
case value_t::number_float:
|
||
|
return (lhs.m_value.number_float) < (rhs.m_value.number_float);
|
||
|
|
||
|
case value_t::binary:
|
||
|
return (*lhs.m_value.binary) < (*rhs.m_value.binary);
|
||
|
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
|
||
|
{
|
||
|
return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
|
||
|
{
|
||
|
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
|
||
|
{
|
||
|
return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
|
||
|
{
|
||
|
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
|
||
|
{
|
||
|
return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
|
||
|
}
|
||
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
|
||
|
{
|
||
|
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
|
||
|
}
|
||
|
|
||
|
// We only reach this line if we cannot compare values. In that case,
|
||
|
// we compare types. Note we have to call the operator explicitly,
|
||
|
// because MSVC has problems otherwise.
|
||
|
return operator<(lhs_type, rhs_type);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs < basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) < rhs;
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
||
|
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return !(rhs < lhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs <= basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: less than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) <= rhs;
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
||
|
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return !(lhs <= rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs > basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) > rhs;
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
||
|
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return !(lhs < rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
|
||
|
{
|
||
|
return lhs >= basic_json(rhs);
|
||
|
}
|
||
|
|
||
|
/// @brief comparison: greater than or equal
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
||
|
template<typename ScalarType, typename std::enable_if<
|
||
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
||
|
friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
|
||
|
{
|
||
|
return basic_json(lhs) >= rhs;
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
///////////////////
|
||
|
// serialization //
|
||
|
///////////////////
|
||
|
|
||
|
/// @name serialization
|
||
|
/// @{
|
||
|
#ifndef JSON_NO_IO
|
||
|
/// @brief serialize to stream
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
|
||
|
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
|
||
|
{
|
||
|
// read width member and use it as indentation parameter if nonzero
|
||
|
const bool pretty_print = o.width() > 0;
|
||
|
const auto indentation = pretty_print ? o.width() : 0;
|
||
|
|
||
|
// reset width to 0 for subsequent calls to this stream
|
||
|
o.width(0);
|
||
|
|
||
|
// do the actual serialization
|
||
|
serializer s(detail::output_adapter<char>(o), o.fill());
|
||
|
s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
|
||
|
return o;
|
||
|
}
|
||
|
|
||
|
/// @brief serialize to stream
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
|
||
|
/// @deprecated This function is deprecated since 3.0.0 and will be removed in
|
||
|
/// version 4.0.0 of the library. Please use
|
||
|
/// operator<<(std::ostream&, const basic_json&) instead; that is,
|
||
|
/// replace calls like `j >> o;` with `o << j;`.
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
|
||
|
friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
|
||
|
{
|
||
|
return o << j;
|
||
|
}
|
||
|
#endif // JSON_NO_IO
|
||
|
/// @}
|
||
|
|
||
|
|
||
|
/////////////////////
|
||
|
// deserialization //
|
||
|
/////////////////////
|
||
|
|
||
|
/// @name deserialization
|
||
|
/// @{
|
||
|
|
||
|
/// @brief deserialize from a compatible input
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/parse/
|
||
|
template<typename InputType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json parse(InputType&& i,
|
||
|
const parser_callback_t cb = nullptr,
|
||
|
const bool allow_exceptions = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
basic_json result;
|
||
|
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief deserialize from a pair of character iterators
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/parse/
|
||
|
template<typename IteratorType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json parse(IteratorType first,
|
||
|
IteratorType last,
|
||
|
const parser_callback_t cb = nullptr,
|
||
|
const bool allow_exceptions = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
basic_json result;
|
||
|
parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
|
||
|
static basic_json parse(detail::span_input_adapter&& i,
|
||
|
const parser_callback_t cb = nullptr,
|
||
|
const bool allow_exceptions = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
basic_json result;
|
||
|
parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief check if the input is valid JSON
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/accept/
|
||
|
template<typename InputType>
|
||
|
static bool accept(InputType&& i,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
|
||
|
}
|
||
|
|
||
|
/// @brief check if the input is valid JSON
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/accept/
|
||
|
template<typename IteratorType>
|
||
|
static bool accept(IteratorType first, IteratorType last,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
|
||
|
}
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
|
||
|
static bool accept(detail::span_input_adapter&& i,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
return parser(i.get(), nullptr, false, ignore_comments).accept(true);
|
||
|
}
|
||
|
|
||
|
/// @brief generate SAX events
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
||
|
template <typename InputType, typename SAX>
|
||
|
JSON_HEDLEY_NON_NULL(2)
|
||
|
static bool sax_parse(InputType&& i, SAX* sax,
|
||
|
input_format_t format = input_format_t::json,
|
||
|
const bool strict = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
||
|
return format == input_format_t::json
|
||
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
||
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
||
|
}
|
||
|
|
||
|
/// @brief generate SAX events
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
||
|
template<class IteratorType, class SAX>
|
||
|
JSON_HEDLEY_NON_NULL(3)
|
||
|
static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
|
||
|
input_format_t format = input_format_t::json,
|
||
|
const bool strict = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
||
|
return format == input_format_t::json
|
||
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
||
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
||
|
}
|
||
|
|
||
|
/// @brief generate SAX events
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
||
|
/// @deprecated This function is deprecated since 3.8.0 and will be removed in
|
||
|
/// version 4.0.0 of the library. Please use
|
||
|
/// sax_parse(ptr, ptr + len) instead.
|
||
|
template <typename SAX>
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
|
||
|
JSON_HEDLEY_NON_NULL(2)
|
||
|
static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
|
||
|
input_format_t format = input_format_t::json,
|
||
|
const bool strict = true,
|
||
|
const bool ignore_comments = false)
|
||
|
{
|
||
|
auto ia = i.get();
|
||
|
return format == input_format_t::json
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
||
|
}
|
||
|
#ifndef JSON_NO_IO
|
||
|
/// @brief deserialize from stream
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
|
||
|
/// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
|
||
|
/// version 4.0.0 of the library. Please use
|
||
|
/// operator>>(std::istream&, basic_json&) instead; that is,
|
||
|
/// replace calls like `j << i;` with `i >> j;`.
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
|
||
|
friend std::istream& operator<<(basic_json& j, std::istream& i)
|
||
|
{
|
||
|
return operator>>(i, j);
|
||
|
}
|
||
|
|
||
|
/// @brief deserialize from stream
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
|
||
|
friend std::istream& operator>>(std::istream& i, basic_json& j)
|
||
|
{
|
||
|
parser(detail::input_adapter(i)).parse(false, j);
|
||
|
return i;
|
||
|
}
|
||
|
#endif // JSON_NO_IO
|
||
|
/// @}
|
||
|
|
||
|
///////////////////////////
|
||
|
// convenience functions //
|
||
|
///////////////////////////
|
||
|
|
||
|
/// @brief return the type as string
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/type_name/
|
||
|
JSON_HEDLEY_RETURNS_NON_NULL
|
||
|
const char* type_name() const noexcept
|
||
|
{
|
||
|
switch (m_type)
|
||
|
{
|
||
|
case value_t::null:
|
||
|
return "null";
|
||
|
case value_t::object:
|
||
|
return "object";
|
||
|
case value_t::array:
|
||
|
return "array";
|
||
|
case value_t::string:
|
||
|
return "string";
|
||
|
case value_t::boolean:
|
||
|
return "boolean";
|
||
|
case value_t::binary:
|
||
|
return "binary";
|
||
|
case value_t::discarded:
|
||
|
return "discarded";
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
default:
|
||
|
return "number";
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
JSON_PRIVATE_UNLESS_TESTED:
|
||
|
//////////////////////
|
||
|
// member variables //
|
||
|
//////////////////////
|
||
|
|
||
|
/// the type of the current element
|
||
|
value_t m_type = value_t::null;
|
||
|
|
||
|
/// the value of the current element
|
||
|
json_value m_value = {};
|
||
|
|
||
|
#if JSON_DIAGNOSTICS
|
||
|
/// a pointer to a parent value (for debugging purposes)
|
||
|
basic_json* m_parent = nullptr;
|
||
|
#endif
|
||
|
|
||
|
//////////////////////////////////////////
|
||
|
// binary serialization/deserialization //
|
||
|
//////////////////////////////////////////
|
||
|
|
||
|
/// @name binary serialization/deserialization support
|
||
|
/// @{
|
||
|
|
||
|
public:
|
||
|
/// @brief create a CBOR serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
||
|
static std::vector<std::uint8_t> to_cbor(const basic_json& j)
|
||
|
{
|
||
|
std::vector<std::uint8_t> result;
|
||
|
to_cbor(j, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief create a CBOR serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
||
|
static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
||
|
{
|
||
|
binary_writer<std::uint8_t>(o).write_cbor(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a CBOR serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
||
|
static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
|
||
|
{
|
||
|
binary_writer<char>(o).write_cbor(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a MessagePack serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
||
|
static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
|
||
|
{
|
||
|
std::vector<std::uint8_t> result;
|
||
|
to_msgpack(j, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief create a MessagePack serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
||
|
static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
||
|
{
|
||
|
binary_writer<std::uint8_t>(o).write_msgpack(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a MessagePack serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
||
|
static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
|
||
|
{
|
||
|
binary_writer<char>(o).write_msgpack(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a UBJSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
||
|
static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
|
||
|
const bool use_size = false,
|
||
|
const bool use_type = false)
|
||
|
{
|
||
|
std::vector<std::uint8_t> result;
|
||
|
to_ubjson(j, result, use_size, use_type);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief create a UBJSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
||
|
static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
|
||
|
const bool use_size = false, const bool use_type = false)
|
||
|
{
|
||
|
binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
|
||
|
}
|
||
|
|
||
|
/// @brief create a UBJSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
||
|
static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
|
||
|
const bool use_size = false, const bool use_type = false)
|
||
|
{
|
||
|
binary_writer<char>(o).write_ubjson(j, use_size, use_type);
|
||
|
}
|
||
|
|
||
|
/// @brief create a BSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
||
|
static std::vector<std::uint8_t> to_bson(const basic_json& j)
|
||
|
{
|
||
|
std::vector<std::uint8_t> result;
|
||
|
to_bson(j, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief create a BSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
||
|
static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
||
|
{
|
||
|
binary_writer<std::uint8_t>(o).write_bson(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a BSON serialization of a given JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
||
|
static void to_bson(const basic_json& j, detail::output_adapter<char> o)
|
||
|
{
|
||
|
binary_writer<char>(o).write_bson(j);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in CBOR format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
|
||
|
template<typename InputType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_cbor(InputType&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true,
|
||
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in CBOR format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
|
||
|
template<typename IteratorType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_cbor(IteratorType first, IteratorType last,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true,
|
||
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
|
||
|
static basic_json from_cbor(const T* ptr, std::size_t len,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true,
|
||
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
||
|
{
|
||
|
return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
|
||
|
}
|
||
|
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
|
||
|
static basic_json from_cbor(detail::span_input_adapter&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true,
|
||
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = i.get();
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in MessagePack format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
|
||
|
template<typename InputType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_msgpack(InputType&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in MessagePack format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
|
||
|
template<typename IteratorType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_msgpack(IteratorType first, IteratorType last,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
|
||
|
static basic_json from_msgpack(const T* ptr, std::size_t len,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
|
||
|
}
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
|
||
|
static basic_json from_msgpack(detail::span_input_adapter&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = i.get();
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in UBJSON format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
|
||
|
template<typename InputType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_ubjson(InputType&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in UBJSON format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
|
||
|
template<typename IteratorType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_ubjson(IteratorType first, IteratorType last,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
|
||
|
static basic_json from_ubjson(const T* ptr, std::size_t len,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
|
||
|
}
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
|
||
|
static basic_json from_ubjson(detail::span_input_adapter&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = i.get();
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in BSON format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
|
||
|
template<typename InputType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_bson(InputType&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
/// @brief create a JSON value from an input in BSON format
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
|
||
|
template<typename IteratorType>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json from_bson(IteratorType first, IteratorType last,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
|
||
|
template<typename T>
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
|
||
|
static basic_json from_bson(const T* ptr, std::size_t len,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
return from_bson(ptr, ptr + len, strict, allow_exceptions);
|
||
|
}
|
||
|
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
|
||
|
static basic_json from_bson(detail::span_input_adapter&& i,
|
||
|
const bool strict = true,
|
||
|
const bool allow_exceptions = true)
|
||
|
{
|
||
|
basic_json result;
|
||
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
||
|
auto ia = i.get();
|
||
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
||
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
||
|
return res ? result : basic_json(value_t::discarded);
|
||
|
}
|
||
|
/// @}
|
||
|
|
||
|
//////////////////////////
|
||
|
// JSON Pointer support //
|
||
|
//////////////////////////
|
||
|
|
||
|
/// @name JSON Pointer functions
|
||
|
/// @{
|
||
|
|
||
|
/// @brief access specified element via JSON Pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
reference operator[](const json_pointer& ptr)
|
||
|
{
|
||
|
return ptr.get_unchecked(this);
|
||
|
}
|
||
|
|
||
|
/// @brief access specified element via JSON Pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
||
|
const_reference operator[](const json_pointer& ptr) const
|
||
|
{
|
||
|
return ptr.get_unchecked(this);
|
||
|
}
|
||
|
|
||
|
/// @brief access specified element via JSON Pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
reference at(const json_pointer& ptr)
|
||
|
{
|
||
|
return ptr.get_checked(this);
|
||
|
}
|
||
|
|
||
|
/// @brief access specified element via JSON Pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
||
|
const_reference at(const json_pointer& ptr) const
|
||
|
{
|
||
|
return ptr.get_checked(this);
|
||
|
}
|
||
|
|
||
|
/// @brief return flattened JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/flatten/
|
||
|
basic_json flatten() const
|
||
|
{
|
||
|
basic_json result(value_t::object);
|
||
|
json_pointer::flatten("", *this, result);
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief unflatten a previously flattened JSON value
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/unflatten/
|
||
|
basic_json unflatten() const
|
||
|
{
|
||
|
return json_pointer::unflatten(*this);
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
//////////////////////////
|
||
|
// JSON Patch functions //
|
||
|
//////////////////////////
|
||
|
|
||
|
/// @name JSON Patch functions
|
||
|
/// @{
|
||
|
|
||
|
/// @brief applies a JSON patch
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/patch/
|
||
|
basic_json patch(const basic_json& json_patch) const
|
||
|
{
|
||
|
// make a working copy to apply the patch to
|
||
|
basic_json result = *this;
|
||
|
|
||
|
// the valid JSON Patch operations
|
||
|
enum class patch_operations {add, remove, replace, move, copy, test, invalid};
|
||
|
|
||
|
const auto get_op = [](const std::string & op)
|
||
|
{
|
||
|
if (op == "add")
|
||
|
{
|
||
|
return patch_operations::add;
|
||
|
}
|
||
|
if (op == "remove")
|
||
|
{
|
||
|
return patch_operations::remove;
|
||
|
}
|
||
|
if (op == "replace")
|
||
|
{
|
||
|
return patch_operations::replace;
|
||
|
}
|
||
|
if (op == "move")
|
||
|
{
|
||
|
return patch_operations::move;
|
||
|
}
|
||
|
if (op == "copy")
|
||
|
{
|
||
|
return patch_operations::copy;
|
||
|
}
|
||
|
if (op == "test")
|
||
|
{
|
||
|
return patch_operations::test;
|
||
|
}
|
||
|
|
||
|
return patch_operations::invalid;
|
||
|
};
|
||
|
|
||
|
// wrapper for "add" operation; add value at ptr
|
||
|
const auto operation_add = [&result](json_pointer & ptr, basic_json val)
|
||
|
{
|
||
|
// adding to the root of the target document means replacing it
|
||
|
if (ptr.empty())
|
||
|
{
|
||
|
result = val;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// make sure the top element of the pointer exists
|
||
|
json_pointer top_pointer = ptr.top();
|
||
|
if (top_pointer != ptr)
|
||
|
{
|
||
|
result.at(top_pointer);
|
||
|
}
|
||
|
|
||
|
// get reference to parent of JSON pointer ptr
|
||
|
const auto last_path = ptr.back();
|
||
|
ptr.pop_back();
|
||
|
basic_json& parent = result[ptr];
|
||
|
|
||
|
switch (parent.m_type)
|
||
|
{
|
||
|
case value_t::null:
|
||
|
case value_t::object:
|
||
|
{
|
||
|
// use operator[] to add value
|
||
|
parent[last_path] = val;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::array:
|
||
|
{
|
||
|
if (last_path == "-")
|
||
|
{
|
||
|
// special case: append to back
|
||
|
parent.push_back(val);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
const auto idx = json_pointer::array_index(last_path);
|
||
|
if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
|
||
|
{
|
||
|
// avoid undefined behavior
|
||
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", parent));
|
||
|
}
|
||
|
|
||
|
// default case: insert add offset
|
||
|
parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// if there exists a parent it cannot be primitive
|
||
|
case value_t::string: // LCOV_EXCL_LINE
|
||
|
case value_t::boolean: // LCOV_EXCL_LINE
|
||
|
case value_t::number_integer: // LCOV_EXCL_LINE
|
||
|
case value_t::number_unsigned: // LCOV_EXCL_LINE
|
||
|
case value_t::number_float: // LCOV_EXCL_LINE
|
||
|
case value_t::binary: // LCOV_EXCL_LINE
|
||
|
case value_t::discarded: // LCOV_EXCL_LINE
|
||
|
default: // LCOV_EXCL_LINE
|
||
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// wrapper for "remove" operation; remove value at ptr
|
||
|
const auto operation_remove = [this, &result](json_pointer & ptr)
|
||
|
{
|
||
|
// get reference to parent of JSON pointer ptr
|
||
|
const auto last_path = ptr.back();
|
||
|
ptr.pop_back();
|
||
|
basic_json& parent = result.at(ptr);
|
||
|
|
||
|
// remove child
|
||
|
if (parent.is_object())
|
||
|
{
|
||
|
// perform range check
|
||
|
auto it = parent.find(last_path);
|
||
|
if (JSON_HEDLEY_LIKELY(it != parent.end()))
|
||
|
{
|
||
|
parent.erase(it);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", *this));
|
||
|
}
|
||
|
}
|
||
|
else if (parent.is_array())
|
||
|
{
|
||
|
// note erase performs range check
|
||
|
parent.erase(json_pointer::array_index(last_path));
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// type check: top level value must be an array
|
||
|
if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
|
||
|
{
|
||
|
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", json_patch));
|
||
|
}
|
||
|
|
||
|
// iterate and apply the operations
|
||
|
for (const auto& val : json_patch)
|
||
|
{
|
||
|
// wrapper to get a value for an operation
|
||
|
const auto get_value = [&val](const std::string & op,
|
||
|
const std::string & member,
|
||
|
bool string_type) -> basic_json &
|
||
|
{
|
||
|
// find value
|
||
|
auto it = val.m_value.object->find(member);
|
||
|
|
||
|
// context-sensitive error message
|
||
|
const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
|
||
|
|
||
|
// check if desired value is present
|
||
|
if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
|
||
|
{
|
||
|
// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
|
||
|
JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", val));
|
||
|
}
|
||
|
|
||
|
// check if result is of type string
|
||
|
if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
|
||
|
{
|
||
|
// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
|
||
|
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", val));
|
||
|
}
|
||
|
|
||
|
// no error: return value
|
||
|
return it->second;
|
||
|
};
|
||
|
|
||
|
// type check: every element of the array must be an object
|
||
|
if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
|
||
|
{
|
||
|
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", val));
|
||
|
}
|
||
|
|
||
|
// collect mandatory members
|
||
|
const auto op = get_value("op", "op", true).template get<std::string>();
|
||
|
const auto path = get_value(op, "path", true).template get<std::string>();
|
||
|
json_pointer ptr(path);
|
||
|
|
||
|
switch (get_op(op))
|
||
|
{
|
||
|
case patch_operations::add:
|
||
|
{
|
||
|
operation_add(ptr, get_value("add", "value", false));
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::remove:
|
||
|
{
|
||
|
operation_remove(ptr);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::replace:
|
||
|
{
|
||
|
// the "path" location must exist - use at()
|
||
|
result.at(ptr) = get_value("replace", "value", false);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::move:
|
||
|
{
|
||
|
const auto from_path = get_value("move", "from", true).template get<std::string>();
|
||
|
json_pointer from_ptr(from_path);
|
||
|
|
||
|
// the "from" location must exist - use at()
|
||
|
basic_json v = result.at(from_ptr);
|
||
|
|
||
|
// The move operation is functionally identical to a
|
||
|
// "remove" operation on the "from" location, followed
|
||
|
// immediately by an "add" operation at the target
|
||
|
// location with the value that was just removed.
|
||
|
operation_remove(from_ptr);
|
||
|
operation_add(ptr, v);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::copy:
|
||
|
{
|
||
|
const auto from_path = get_value("copy", "from", true).template get<std::string>();
|
||
|
const json_pointer from_ptr(from_path);
|
||
|
|
||
|
// the "from" location must exist - use at()
|
||
|
basic_json v = result.at(from_ptr);
|
||
|
|
||
|
// The copy is functionally identical to an "add"
|
||
|
// operation at the target location using the value
|
||
|
// specified in the "from" member.
|
||
|
operation_add(ptr, v);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::test:
|
||
|
{
|
||
|
bool success = false;
|
||
|
JSON_TRY
|
||
|
{
|
||
|
// check if "value" matches the one at "path"
|
||
|
// the "path" location must exist - use at()
|
||
|
success = (result.at(ptr) == get_value("test", "value", false));
|
||
|
}
|
||
|
JSON_INTERNAL_CATCH (out_of_range&)
|
||
|
{
|
||
|
// ignore out of range errors: success remains false
|
||
|
}
|
||
|
|
||
|
// throw an exception if test fails
|
||
|
if (JSON_HEDLEY_UNLIKELY(!success))
|
||
|
{
|
||
|
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), val));
|
||
|
}
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case patch_operations::invalid:
|
||
|
default:
|
||
|
{
|
||
|
// op must be "add", "remove", "replace", "move", "copy", or
|
||
|
// "test"
|
||
|
JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", val));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @brief creates a diff as a JSON patch
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/diff/
|
||
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
||
|
static basic_json diff(const basic_json& source, const basic_json& target,
|
||
|
const std::string& path = "")
|
||
|
{
|
||
|
// the patch
|
||
|
basic_json result(value_t::array);
|
||
|
|
||
|
// if the values are the same, return empty patch
|
||
|
if (source == target)
|
||
|
{
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
if (source.type() != target.type())
|
||
|
{
|
||
|
// different types: replace value
|
||
|
result.push_back(
|
||
|
{
|
||
|
{"op", "replace"}, {"path", path}, {"value", target}
|
||
|
});
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
switch (source.type())
|
||
|
{
|
||
|
case value_t::array:
|
||
|
{
|
||
|
// first pass: traverse common elements
|
||
|
std::size_t i = 0;
|
||
|
while (i < source.size() && i < target.size())
|
||
|
{
|
||
|
// recursive call to compare array values at index i
|
||
|
auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
|
||
|
result.insert(result.end(), temp_diff.begin(), temp_diff.end());
|
||
|
++i;
|
||
|
}
|
||
|
|
||
|
// We now reached the end of at least one array
|
||
|
// in a second pass, traverse the remaining elements
|
||
|
|
||
|
// remove my remaining elements
|
||
|
const auto end_index = static_cast<difference_type>(result.size());
|
||
|
while (i < source.size())
|
||
|
{
|
||
|
// add operations in reverse order to avoid invalid
|
||
|
// indices
|
||
|
result.insert(result.begin() + end_index, object(
|
||
|
{
|
||
|
{"op", "remove"},
|
||
|
{"path", path + "/" + std::to_string(i)}
|
||
|
}));
|
||
|
++i;
|
||
|
}
|
||
|
|
||
|
// add other remaining elements
|
||
|
while (i < target.size())
|
||
|
{
|
||
|
result.push_back(
|
||
|
{
|
||
|
{"op", "add"},
|
||
|
{"path", path + "/-"},
|
||
|
{"value", target[i]}
|
||
|
});
|
||
|
++i;
|
||
|
}
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::object:
|
||
|
{
|
||
|
// first pass: traverse this object's elements
|
||
|
for (auto it = source.cbegin(); it != source.cend(); ++it)
|
||
|
{
|
||
|
// escape the key name to be used in a JSON patch
|
||
|
const auto path_key = path + "/" + detail::escape(it.key());
|
||
|
|
||
|
if (target.find(it.key()) != target.end())
|
||
|
{
|
||
|
// recursive call to compare object values at key it
|
||
|
auto temp_diff = diff(it.value(), target[it.key()], path_key);
|
||
|
result.insert(result.end(), temp_diff.begin(), temp_diff.end());
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// found a key that is not in o -> remove it
|
||
|
result.push_back(object(
|
||
|
{
|
||
|
{"op", "remove"}, {"path", path_key}
|
||
|
}));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// second pass: traverse other object's elements
|
||
|
for (auto it = target.cbegin(); it != target.cend(); ++it)
|
||
|
{
|
||
|
if (source.find(it.key()) == source.end())
|
||
|
{
|
||
|
// found a key that is not in this -> add it
|
||
|
const auto path_key = path + "/" + detail::escape(it.key());
|
||
|
result.push_back(
|
||
|
{
|
||
|
{"op", "add"}, {"path", path_key},
|
||
|
{"value", it.value()}
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case value_t::null:
|
||
|
case value_t::string:
|
||
|
case value_t::boolean:
|
||
|
case value_t::number_integer:
|
||
|
case value_t::number_unsigned:
|
||
|
case value_t::number_float:
|
||
|
case value_t::binary:
|
||
|
case value_t::discarded:
|
||
|
default:
|
||
|
{
|
||
|
// both primitive type: replace value
|
||
|
result.push_back(
|
||
|
{
|
||
|
{"op", "replace"}, {"path", path}, {"value", target}
|
||
|
});
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
|
||
|
////////////////////////////////
|
||
|
// JSON Merge Patch functions //
|
||
|
////////////////////////////////
|
||
|
|
||
|
/// @name JSON Merge Patch functions
|
||
|
/// @{
|
||
|
|
||
|
/// @brief applies a JSON Merge Patch
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
|
||
|
void merge_patch(const basic_json& apply_patch)
|
||
|
{
|
||
|
if (apply_patch.is_object())
|
||
|
{
|
||
|
if (!is_object())
|
||
|
{
|
||
|
*this = object();
|
||
|
}
|
||
|
for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
|
||
|
{
|
||
|
if (it.value().is_null())
|
||
|
{
|
||
|
erase(it.key());
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
operator[](it.key()).merge_patch(it.value());
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
*this = apply_patch;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// @}
|
||
|
};
|
||
|
|
||
|
/// @brief user-defined to_string function for JSON values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/to_string/
|
||
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||
|
std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
|
||
|
{
|
||
|
return j.dump();
|
||
|
}
|
||
|
|
||
|
} // namespace nlohmann
|
||
|
|
||
|
///////////////////////
|
||
|
// nonmember support //
|
||
|
///////////////////////
|
||
|
|
||
|
namespace std // NOLINT(cert-dcl58-cpp)
|
||
|
{
|
||
|
|
||
|
/// @brief hash value for JSON objects
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
|
||
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||
|
struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>
|
||
|
{
|
||
|
std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
|
||
|
{
|
||
|
return nlohmann::detail::hash(j);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// specialization for std::less<value_t>
|
||
|
template<>
|
||
|
struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
|
||
|
{
|
||
|
/*!
|
||
|
@brief compare two value_t enum values
|
||
|
@since version 3.0.0
|
||
|
*/
|
||
|
bool operator()(nlohmann::detail::value_t lhs,
|
||
|
nlohmann::detail::value_t rhs) const noexcept
|
||
|
{
|
||
|
return nlohmann::detail::operator<(lhs, rhs);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// C++20 prohibit function specialization in the std namespace.
|
||
|
#ifndef JSON_HAS_CPP_20
|
||
|
|
||
|
/// @brief exchanges the values of two JSON objects
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
|
||
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||
|
inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name)
|
||
|
is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&& // NOLINT(misc-redundant-expression)
|
||
|
is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
|
||
|
{
|
||
|
j1.swap(j2);
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
} // namespace std
|
||
|
|
||
|
/// @brief user-defined string literal for JSON values
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
|
||
|
JSON_HEDLEY_NON_NULL(1)
|
||
|
inline nlohmann::json operator "" _json(const char* s, std::size_t n)
|
||
|
{
|
||
|
return nlohmann::json::parse(s, s + n);
|
||
|
}
|
||
|
|
||
|
/// @brief user-defined string literal for JSON pointer
|
||
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
|
||
|
JSON_HEDLEY_NON_NULL(1)
|
||
|
inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
|
||
|
{
|
||
|
return nlohmann::json::json_pointer(std::string(s, n));
|
||
|
}
|
||
|
|
||
|
#include <nlohmann/detail/macro_unscope.hpp>
|
||
|
|
||
|
#endif // INCLUDE_NLOHMANN_JSON_HPP_
|