mirror of
https://github.com/nlohmann/json
synced 2025-01-15 03:30:04 +00:00
♻️ move diagnostic code in header
This commit is contained in:
Niels Lohmann
parent
43cd5c8a4d
commit
e160749003
@ -13,6 +13,7 @@
|
||||
#include <valarray> // valarray
|
||||
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
#include <nlohmann/detail/meta/cpp_future.hpp>
|
||||
#include <nlohmann/detail/meta/type_traits.hpp>
|
||||
@ -27,7 +28,7 @@ void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be null, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
n = nullptr;
|
||||
}
|
||||
@ -58,7 +59,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be number, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -67,7 +68,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be boolean, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
|
||||
}
|
||||
@ -77,7 +78,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be string, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
|
||||
}
|
||||
@ -93,7 +94,7 @@ void from_json(const BasicJsonType& j, ConstructibleStringType& s)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be string, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
|
||||
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
|
||||
@ -133,7 +134,7 @@ void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
l.clear();
|
||||
std::transform(j.rbegin(), j.rend(),
|
||||
@ -150,7 +151,7 @@ void from_json(const BasicJsonType& j, std::valarray<T>& l)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
l.resize(j.size());
|
||||
std::transform(j.begin(), j.end(), std::begin(l),
|
||||
@ -241,8 +242,7 @@ void())
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " +
|
||||
std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
|
||||
from_json_array_impl(j, arr, priority_tag<3> {});
|
||||
@ -253,7 +253,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be binary, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
|
||||
bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
|
||||
@ -265,7 +265,7 @@ void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be object, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
|
||||
ConstructibleObjectType ret;
|
||||
@ -319,7 +319,7 @@ void from_json(const BasicJsonType& j, ArithmeticType& val)
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be number, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -348,14 +348,14 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>&
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
m.clear();
|
||||
for (const auto& p : j)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(p.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
|
||||
}
|
||||
@ -368,14 +368,14 @@ void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyE
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
m.clear();
|
||||
for (const auto& p : j)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(302, j.diagnostics() + "type must be array, but is " + std::string(p.type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
|
||||
}
|
||||
|
||||
85
include/nlohmann/detail/diagnostics_t.hpp
Normal file
85
include/nlohmann/detail/diagnostics_t.hpp
Normal file
@ -0,0 +1,85 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <nlohmann/detail/value_t.hpp>
|
||||
|
||||
namespace nlohmann
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template<typename BasicJsonType>
|
||||
class diagnostics_t
|
||||
{
|
||||
public:
|
||||
diagnostics_t() noexcept = default;
|
||||
diagnostics_t(const BasicJsonType& j) noexcept
|
||||
: m_j(&j)
|
||||
{}
|
||||
|
||||
std::string diagnostics() const
|
||||
{
|
||||
#if JSON_DIAGNOSTICS
|
||||
if (m_j == nullptr)
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
std::vector<std::string> tokens;
|
||||
for (const auto* current = m_j; current->m_parent != nullptr; current = current->m_parent)
|
||||
{
|
||||
switch (current->m_parent->type())
|
||||
{
|
||||
case value_t::array:
|
||||
{
|
||||
for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
|
||||
{
|
||||
if (current->m_parent->m_value.array->operator[](i) == *current)
|
||||
{
|
||||
tokens.emplace_back(std::to_string(i));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case value_t::object:
|
||||
{
|
||||
for (const auto& element : *current->m_parent->m_value.object)
|
||||
{
|
||||
if (element.second == *current)
|
||||
{
|
||||
tokens.emplace_back(element.first.c_str());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (tokens.empty())
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
|
||||
[](const std::string & a, const std::string & b)
|
||||
{
|
||||
return a + "/" + b;
|
||||
}) + ") ";
|
||||
#else
|
||||
return "";
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
const BasicJsonType* m_j = static_cast<const BasicJsonType*>(nullptr);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace nlohmann
|
||||
@ -4,6 +4,7 @@
|
||||
#include <stdexcept> // runtime_error
|
||||
#include <string> // to_string
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/input/position_t.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
|
||||
@ -127,18 +128,20 @@ class parse_error : public exception
|
||||
@param[in] what_arg the explanatory string
|
||||
@return parse_error object
|
||||
*/
|
||||
static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static parse_error create(int id_, const position_t& pos, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("parse_error", id_) + "parse error" +
|
||||
position_string(pos) + ": " + what_arg;
|
||||
position_string(pos) + ": " + diagnostics.diagnostics() + what_arg;
|
||||
return parse_error(id_, pos.chars_read_total, w.c_str());
|
||||
}
|
||||
|
||||
static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("parse_error", id_) + "parse error" +
|
||||
(byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
|
||||
": " + what_arg;
|
||||
": " + diagnostics.diagnostics() + what_arg;
|
||||
return parse_error(id_, byte_, w.c_str());
|
||||
}
|
||||
|
||||
@ -204,9 +207,10 @@ caught.,invalid_iterator}
|
||||
class invalid_iterator : public exception
|
||||
{
|
||||
public:
|
||||
static invalid_iterator create(int id_, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static invalid_iterator create(int id_, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("invalid_iterator", id_) + what_arg;
|
||||
std::string w = exception::name("invalid_iterator", id_) + diagnostics.diagnostics() + what_arg;
|
||||
return invalid_iterator(id_, w.c_str());
|
||||
}
|
||||
|
||||
@ -258,9 +262,10 @@ caught.,type_error}
|
||||
class type_error : public exception
|
||||
{
|
||||
public:
|
||||
static type_error create(int id_, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static type_error create(int id_, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("type_error", id_) + what_arg;
|
||||
std::string w = exception::name("type_error", id_) + diagnostics.diagnostics() + what_arg;
|
||||
return type_error(id_, w.c_str());
|
||||
}
|
||||
|
||||
@ -305,9 +310,10 @@ caught.,out_of_range}
|
||||
class out_of_range : public exception
|
||||
{
|
||||
public:
|
||||
static out_of_range create(int id_, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static out_of_range create(int id_, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("out_of_range", id_) + what_arg;
|
||||
std::string w = exception::name("out_of_range", id_) + diagnostics.diagnostics() + what_arg;
|
||||
return out_of_range(id_, w.c_str());
|
||||
}
|
||||
|
||||
@ -343,9 +349,10 @@ caught.,other_error}
|
||||
class other_error : public exception
|
||||
{
|
||||
public:
|
||||
static other_error create(int id_, const std::string& what_arg)
|
||||
template<typename BasicJsonType>
|
||||
static other_error create(int id_, const std::string& what_arg, const detail::diagnostics_t<BasicJsonType>& diagnostics)
|
||||
{
|
||||
std::string w = exception::name("other_error", id_) + what_arg;
|
||||
std::string w = exception::name("other_error", id_) + diagnostics.diagnostics() + what_arg;
|
||||
return other_error(id_, w.c_str());
|
||||
}
|
||||
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
#include <utility> // make_pair, move
|
||||
#include <vector> // vector
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/input/input_adapters.hpp>
|
||||
#include <nlohmann/detail/input/json_sax.hpp>
|
||||
@ -64,6 +65,7 @@ class binary_reader
|
||||
using json_sax_t = SAX;
|
||||
using char_type = typename InputAdapterType::char_type;
|
||||
using char_int_type = typename std::char_traits<char_type>::int_type;
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
public:
|
||||
/*!
|
||||
@ -137,7 +139,7 @@ class binary_reader
|
||||
if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
|
||||
{
|
||||
return sax->parse_error(chars_read, get_token_string(),
|
||||
parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
|
||||
parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -213,7 +215,7 @@ class binary_reader
|
||||
if (JSON_HEDLEY_UNLIKELY(len < 1))
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string"), diagnostics_t()));
|
||||
}
|
||||
|
||||
return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
|
||||
@ -234,7 +236,7 @@ class binary_reader
|
||||
if (JSON_HEDLEY_UNLIKELY(len < 0))
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary"), diagnostics_t()));
|
||||
}
|
||||
|
||||
// All BSON binary values have a subtype
|
||||
@ -316,7 +318,7 @@ class binary_reader
|
||||
{
|
||||
std::array<char, 3> cr{{}};
|
||||
(std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
|
||||
return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
|
||||
return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data()), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -716,7 +718,7 @@ class binary_reader
|
||||
case cbor_tag_handler_t::error:
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), diagnostics_t()));
|
||||
}
|
||||
|
||||
case cbor_tag_handler_t::ignore:
|
||||
@ -831,7 +833,7 @@ class binary_reader
|
||||
default: // anything else (0xFF is handled inside the other types)
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -926,7 +928,7 @@ class binary_reader
|
||||
default:
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1025,7 +1027,7 @@ class binary_reader
|
||||
default:
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1492,7 +1494,7 @@ class binary_reader
|
||||
default: // anything else
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1574,7 +1576,7 @@ class binary_reader
|
||||
default:
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1824,7 +1826,7 @@ class binary_reader
|
||||
|
||||
default:
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1894,7 +1896,7 @@ class binary_reader
|
||||
default:
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1932,7 +1934,7 @@ class binary_reader
|
||||
return false;
|
||||
}
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size"), diagnostics_t()));
|
||||
}
|
||||
|
||||
return get_ubjson_size_value(result.first);
|
||||
@ -2022,7 +2024,7 @@ class binary_reader
|
||||
if (JSON_HEDLEY_UNLIKELY(current > 127))
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char"), diagnostics_t()));
|
||||
}
|
||||
string_t s(1, static_cast<typename string_t::value_type>(current));
|
||||
return sax->string(s);
|
||||
@ -2043,7 +2045,7 @@ class binary_reader
|
||||
default: // anything else
|
||||
{
|
||||
auto last_token = get_token_string();
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
|
||||
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2221,7 +2223,7 @@ class binary_reader
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
|
||||
{
|
||||
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
|
||||
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), diagnostics_t()));
|
||||
}
|
||||
|
||||
switch (result_number)
|
||||
@ -2233,7 +2235,7 @@ class binary_reader
|
||||
case token_type::value_float:
|
||||
return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
|
||||
default:
|
||||
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
|
||||
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -2389,7 +2391,7 @@ class binary_reader
|
||||
if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
|
||||
{
|
||||
return sax->parse_error(chars_read, "<end of file>",
|
||||
parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
|
||||
parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), diagnostics_t()));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
#include <utility> // move
|
||||
#include <vector> // vector
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
|
||||
@ -154,6 +155,7 @@ class json_sax_dom_parser
|
||||
using number_float_t = typename BasicJsonType::number_float_t;
|
||||
using string_t = typename BasicJsonType::string_t;
|
||||
using binary_t = typename BasicJsonType::binary_t;
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
/*!
|
||||
@param[in, out] r reference to a JSON value that is manipulated while
|
||||
@ -219,8 +221,7 @@ class json_sax_dom_parser
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(408, ref_stack.back()->diagnostics() +
|
||||
"excessive object size: " + std::to_string(len)));
|
||||
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), diagnostics_t(*ref_stack.back())));
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -245,8 +246,7 @@ class json_sax_dom_parser
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(408, ref_stack.back()->diagnostics() +
|
||||
"excessive array size: " + std::to_string(len)));
|
||||
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), diagnostics_t(*ref_stack.back())));
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -336,6 +336,7 @@ class json_sax_dom_callback_parser
|
||||
using binary_t = typename BasicJsonType::binary_t;
|
||||
using parser_callback_t = typename BasicJsonType::parser_callback_t;
|
||||
using parse_event_t = typename BasicJsonType::parse_event_t;
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
json_sax_dom_callback_parser(BasicJsonType& r,
|
||||
const parser_callback_t cb,
|
||||
@ -406,7 +407,7 @@ class json_sax_dom_callback_parser
|
||||
// check object limit
|
||||
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(408, ref_stack.back()->diagnostics() + "excessive object size: " + std::to_string(len)));
|
||||
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), diagnostics_t(*ref_stack.back())));
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -469,7 +470,7 @@ class json_sax_dom_callback_parser
|
||||
// check array limit
|
||||
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(408, ref_stack.back()->diagnostics() + "excessive array size: " + std::to_string(len)));
|
||||
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), diagnostics_t(*ref_stack.back())));
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#include <vector> // vector
|
||||
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/input/input_adapters.hpp>
|
||||
#include <nlohmann/detail/input/json_sax.hpp>
|
||||
#include <nlohmann/detail/input/lexer.hpp>
|
||||
@ -57,6 +58,7 @@ class parser
|
||||
using string_t = typename BasicJsonType::string_t;
|
||||
using lexer_t = lexer<BasicJsonType, InputAdapterType>;
|
||||
using token_type = typename lexer_t::token_type;
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
public:
|
||||
/// a parser reading from an input adapter
|
||||
@ -96,7 +98,7 @@ class parser
|
||||
sdp.parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::end_of_input, "value")));
|
||||
exception_message(token_type::end_of_input, "value"), diagnostics_t()));
|
||||
}
|
||||
|
||||
// in case of an error, return discarded value
|
||||
@ -125,7 +127,7 @@ class parser
|
||||
sdp.parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::end_of_input, "value")));
|
||||
exception_message(token_type::end_of_input, "value"), diagnostics_t()));
|
||||
}
|
||||
|
||||
// in case of an error, return discarded value
|
||||
@ -162,7 +164,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::end_of_input, "value")));
|
||||
exception_message(token_type::end_of_input, "value"), diagnostics_t()));
|
||||
}
|
||||
|
||||
return result;
|
||||
@ -209,7 +211,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::value_string, "object key")));
|
||||
exception_message(token_type::value_string, "object key"), diagnostics_t()));
|
||||
}
|
||||
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
||||
{
|
||||
@ -222,7 +224,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::name_separator, "object separator")));
|
||||
exception_message(token_type::name_separator, "object separator"), diagnostics_t()));
|
||||
}
|
||||
|
||||
// remember we are now inside an object
|
||||
@ -265,7 +267,7 @@ class parser
|
||||
{
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
|
||||
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'", diagnostics_t()));
|
||||
}
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
|
||||
@ -336,7 +338,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::uninitialized, "value")));
|
||||
exception_message(token_type::uninitialized, "value"), diagnostics_t()));
|
||||
}
|
||||
|
||||
default: // the last token was unexpected
|
||||
@ -344,7 +346,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::literal_or_value, "value")));
|
||||
exception_message(token_type::literal_or_value, "value"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -391,7 +393,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::end_array, "array")));
|
||||
exception_message(token_type::end_array, "array"), diagnostics_t()));
|
||||
}
|
||||
else // object
|
||||
{
|
||||
@ -404,7 +406,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::value_string, "object key")));
|
||||
exception_message(token_type::value_string, "object key"), diagnostics_t()));
|
||||
}
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
||||
@ -418,7 +420,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::name_separator, "object separator")));
|
||||
exception_message(token_type::name_separator, "object separator"), diagnostics_t()));
|
||||
}
|
||||
|
||||
// parse values
|
||||
@ -447,7 +449,7 @@ class parser
|
||||
return sax->parse_error(m_lexer.get_position(),
|
||||
m_lexer.get_token_string(),
|
||||
parse_error::create(101, m_lexer.get_position(),
|
||||
exception_message(token_type::end_object, "object")));
|
||||
exception_message(token_type::end_object, "object"), diagnostics_t()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
|
||||
#include <type_traits> // conditional, is_const, remove_const
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/iterators/internal_iterator.hpp>
|
||||
#include <nlohmann/detail/iterators/primitive_iterator.hpp>
|
||||
@ -51,6 +52,7 @@ class iter_impl
|
||||
// make sure BasicJsonType is basic_json or const basic_json
|
||||
static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
|
||||
"iter_impl only accepts (const) basic_json");
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
public:
|
||||
|
||||
@ -257,7 +259,7 @@ class iter_impl
|
||||
}
|
||||
|
||||
case value_t::null:
|
||||
JSON_THROW(invalid_iterator::create(214, m_object->diagnostics() + "cannot get value"));
|
||||
JSON_THROW(invalid_iterator::create(214, "cannot get value", diagnostics_t(*m_object)));
|
||||
|
||||
default:
|
||||
{
|
||||
@ -266,7 +268,7 @@ class iter_impl
|
||||
return *m_object;
|
||||
}
|
||||
|
||||
JSON_THROW(invalid_iterator::create(214, m_object->diagnostics() + "cannot get value"));
|
||||
JSON_THROW(invalid_iterator::create(214, "cannot get value", diagnostics_t(*m_object)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -300,7 +302,7 @@ class iter_impl
|
||||
return m_object;
|
||||
}
|
||||
|
||||
JSON_THROW(invalid_iterator::create(214, m_object->diagnostics() + "cannot get value"));
|
||||
JSON_THROW(invalid_iterator::create(214, "cannot get value", diagnostics_t(*m_object)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -401,7 +403,7 @@ class iter_impl
|
||||
// if objects are not the same, the comparison is undefined
|
||||
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(212, m_object->diagnostics() + "cannot compare iterators of different containers"));
|
||||
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", diagnostics_t(*m_object)));
|
||||
}
|
||||
|
||||
JSON_ASSERT(m_object != nullptr);
|
||||
@ -438,7 +440,7 @@ class iter_impl
|
||||
// if objects are not the same, the comparison is undefined
|
||||
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(212, m_object->diagnostics() + "cannot compare iterators of different containers"));
|
||||
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", diagnostics_t(*m_object)));
|
||||
}
|
||||
|
||||
JSON_ASSERT(m_object != nullptr);
|
||||
@ -446,7 +448,7 @@ class iter_impl
|
||||
switch (m_object->m_type)
|
||||
{
|
||||
case value_t::object:
|
||||
JSON_THROW(invalid_iterator::create(213, m_object->diagnostics() + "cannot compare order of object iterators"));
|
||||
JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", diagnostics_t(*m_object)));
|
||||
|
||||
case value_t::array:
|
||||
return (m_it.array_iterator < other.m_it.array_iterator);
|
||||
@ -494,7 +496,7 @@ class iter_impl
|
||||
switch (m_object->m_type)
|
||||
{
|
||||
case value_t::object:
|
||||
JSON_THROW(invalid_iterator::create(209, m_object->diagnostics() + "cannot use offsets with object iterators"));
|
||||
JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", diagnostics_t(*m_object)));
|
||||
|
||||
case value_t::array:
|
||||
{
|
||||
@ -565,7 +567,7 @@ class iter_impl
|
||||
switch (m_object->m_type)
|
||||
{
|
||||
case value_t::object:
|
||||
JSON_THROW(invalid_iterator::create(209, m_object->diagnostics() + "cannot use offsets with object iterators"));
|
||||
JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", diagnostics_t(*m_object)));
|
||||
|
||||
case value_t::array:
|
||||
return m_it.array_iterator - other.m_it.array_iterator;
|
||||
@ -586,13 +588,13 @@ class iter_impl
|
||||
switch (m_object->m_type)
|
||||
{
|
||||
case value_t::object:
|
||||
JSON_THROW(invalid_iterator::create(208, m_object->diagnostics() + "cannot use operator[] for object iterators"));
|
||||
JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", diagnostics_t(*m_object)));
|
||||
|
||||
case value_t::array:
|
||||
return *std::next(m_it.array_iterator, n);
|
||||
|
||||
case value_t::null:
|
||||
JSON_THROW(invalid_iterator::create(214, m_object->diagnostics() + "cannot get value"));
|
||||
JSON_THROW(invalid_iterator::create(214, "cannot get value", diagnostics_t(*m_object)));
|
||||
|
||||
default:
|
||||
{
|
||||
@ -601,7 +603,7 @@ class iter_impl
|
||||
return *m_object;
|
||||
}
|
||||
|
||||
JSON_THROW(invalid_iterator::create(214, m_object->diagnostics() + "cannot get value"));
|
||||
JSON_THROW(invalid_iterator::create(214, "cannot get value", diagnostics_t(*m_object)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -619,7 +621,7 @@ class iter_impl
|
||||
return m_it.object_iterator->first;
|
||||
}
|
||||
|
||||
JSON_THROW(invalid_iterator::create(207, m_object->diagnostics() + "cannot use key() for non-object iterators"));
|
||||
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", diagnostics_t(*m_object)));
|
||||
}
|
||||
|
||||
/*!
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#include <utility> // move
|
||||
#include <vector> // vector
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
#include <nlohmann/detail/value_t.hpp>
|
||||
@ -21,6 +22,8 @@ class json_pointer
|
||||
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||||
friend class basic_json;
|
||||
|
||||
using diagnostics_t = detail::diagnostics_t<BasicJsonType>;
|
||||
|
||||
public:
|
||||
/*!
|
||||
@brief create JSON pointer
|
||||
@ -247,7 +250,7 @@ class json_pointer
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(empty()))
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", diagnostics_t()));
|
||||
}
|
||||
|
||||
reference_tokens.pop_back();
|
||||
@ -271,7 +274,7 @@ class json_pointer
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(empty()))
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", diagnostics_t()));
|
||||
}
|
||||
|
||||
return reference_tokens.back();
|
||||
@ -337,15 +340,13 @@ class json_pointer
|
||||
// error condition (cf. RFC 6901, Sect. 4)
|
||||
if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
|
||||
{
|
||||
JSON_THROW(detail::parse_error::create(106, 0,
|
||||
"array index '" + s +
|
||||
"' must not begin with '0'"));
|
||||
JSON_THROW(detail::parse_error::create(106, 0, "array index '" + s + "' must not begin with '0'", diagnostics_t()));
|
||||
}
|
||||
|
||||
// error condition (cf. RFC 6901, Sect. 4)
|
||||
if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
|
||||
{
|
||||
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
|
||||
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number", diagnostics_t()));
|
||||
}
|
||||
|
||||
std::size_t processed_chars = 0;
|
||||
@ -356,20 +357,20 @@ class json_pointer
|
||||
}
|
||||
JSON_CATCH(std::out_of_range&)
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", diagnostics_t()));
|
||||
}
|
||||
|
||||
// check if the string was completely read
|
||||
if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", diagnostics_t()));
|
||||
}
|
||||
|
||||
// only triggered on special platforms (like 32bit), see also
|
||||
// https://github.com/nlohmann/json/pull/2203
|
||||
if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
|
||||
JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type", diagnostics_t())); // LCOV_EXCL_LINE
|
||||
}
|
||||
|
||||
return static_cast<size_type>(res);
|
||||
@ -380,7 +381,7 @@ class json_pointer
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(empty()))
|
||||
{
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
|
||||
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", diagnostics_t()));
|
||||
}
|
||||
|
||||
json_pointer result = *this;
|
||||
@ -443,7 +444,7 @@ class json_pointer
|
||||
single value; that is, with an empty list of reference tokens.
|
||||
*/
|
||||
default:
|
||||
JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
|
||||
JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", diagnostics_t(j)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -515,7 +516,7 @@ class json_pointer
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", diagnostics_t(*ptr)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -548,7 +549,7 @@ class json_pointer
|
||||
// "-" always fails the range check
|
||||
JSON_THROW(detail::out_of_range::create(402,
|
||||
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
|
||||
") is out of range"));
|
||||
") is out of range", diagnostics_t(*ptr)));
|
||||
}
|
||||
|
||||
// note: at performs range check
|
||||
@ -557,7 +558,7 @@ class json_pointer
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", diagnostics_t(*ptr)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -595,9 +596,7 @@ class json_pointer
|
||||
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
|
||||
{
|
||||
// "-" cannot be used for const access
|
||||
JSON_THROW(detail::out_of_range::create(402,
|
||||
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
|
||||
") is out of range"));
|
||||
JSON_THROW(detail::out_of_range::create(402, "array index '-' (" + std::to_string(ptr->m_value.array->size()) + ") is out of range", diagnostics_t(*ptr)));
|
||||
}
|
||||
|
||||
// use unchecked array access
|
||||
@ -606,7 +605,7 @@ class json_pointer
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", diagnostics_t(*ptr)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -639,7 +638,7 @@ class json_pointer
|
||||
// "-" always fails the range check
|
||||
JSON_THROW(detail::out_of_range::create(402,
|
||||
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
|
||||
") is out of range"));
|
||||
") is out of range", diagnostics_t(*ptr)));
|
||||
}
|
||||
|
||||
// note: at performs range check
|
||||
@ -648,7 +647,7 @@ class json_pointer
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
|
||||
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", diagnostics_t(*ptr)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -752,9 +751,7 @@ class json_pointer
|
||||
// check if nonempty reference string begins with slash
|
||||
if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
|
||||
{
|
||||
JSON_THROW(detail::parse_error::create(107, 1,
|
||||
"JSON pointer must be empty or begin with '/' - was: '" +
|
||||
reference_string + "'"));
|
||||
JSON_THROW(detail::parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'", diagnostics_t()));
|
||||
}
|
||||
|
||||
// extract the reference tokens:
|
||||
@ -789,7 +786,7 @@ class json_pointer
|
||||
(reference_token[pos + 1] != '0' &&
|
||||
reference_token[pos + 1] != '1')))
|
||||
{
|
||||
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
|
||||
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", diagnostics_t()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -916,7 +913,7 @@ class json_pointer
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
|
||||
{
|
||||
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
|
||||
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", diagnostics_t(value)));
|
||||
}
|
||||
|
||||
BasicJsonType result;
|
||||
@ -926,7 +923,7 @@ class json_pointer
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
|
||||
{
|
||||
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
|
||||
JSON_THROW(detail::type_error::create(315, "values in object must be primitive", diagnostics_t(element)));
|
||||
}
|
||||
|
||||
// assign value to reference pointed to by JSON pointer; Note that if
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#include <string> // string
|
||||
#include <cmath> // isnan, isinf
|
||||
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/input/binary_reader.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
#include <nlohmann/detail/output/output_adapters.hpp>
|
||||
@ -57,7 +58,7 @@ class binary_writer
|
||||
|
||||
default:
|
||||
{
|
||||
JSON_THROW(type_error::create(317, j.diagnostics() + "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), detail::diagnostics_t<BasicJsonType>(j)));;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -906,8 +907,7 @@ class binary_writer
|
||||
const auto it = name.find(static_cast<typename string_t::value_type>(0));
|
||||
if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(409, j.diagnostics() +
|
||||
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
|
||||
JSON_THROW(out_of_range::create(409, "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")", detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
|
||||
return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
|
||||
@ -1031,7 +1031,7 @@ class binary_writer
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(out_of_range::create(407, j.diagnostics() + "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64"));
|
||||
JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64", detail::diagnostics_t<BasicJsonType>(j)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
#include <utility> // move
|
||||
|
||||
#include <nlohmann/detail/conversions/to_chars.hpp>
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/macro_scope.hpp>
|
||||
#include <nlohmann/detail/meta/cpp_future.hpp>
|
||||
@ -499,7 +500,7 @@ class serializer
|
||||
{
|
||||
std::string sn(3, '\0');
|
||||
(std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
|
||||
JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
|
||||
JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn, detail::diagnostics_t<BasicJsonType>()));
|
||||
}
|
||||
|
||||
case error_handler_t::ignore:
|
||||
@ -593,7 +594,7 @@ class serializer
|
||||
{
|
||||
std::string sn(3, '\0');
|
||||
(std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
|
||||
JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
|
||||
JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn, detail::diagnostics_t<BasicJsonType>()));
|
||||
}
|
||||
|
||||
case error_handler_t::ignore:
|
||||
|
||||
@ -51,6 +51,7 @@ SOFTWARE.
|
||||
#include <nlohmann/detail/conversions/from_json.hpp>
|
||||
#include <nlohmann/detail/conversions/to_json.hpp>
|
||||
#include <nlohmann/detail/exceptions.hpp>
|
||||
#include <nlohmann/detail/diagnostics_t.hpp>
|
||||
#include <nlohmann/detail/hash.hpp>
|
||||
#include <nlohmann/detail/input/binary_reader.hpp>
|
||||
#include <nlohmann/detail/input/input_adapters.hpp>
|
||||
@ -189,10 +190,15 @@ class basic_json
|
||||
friend class ::nlohmann::detail::json_sax_dom_parser;
|
||||
template<typename BasicJsonType>
|
||||
friend class ::nlohmann::detail::json_sax_dom_callback_parser;
|
||||
template<typename BasicJsonType>
|
||||
friend class ::nlohmann::detail::diagnostics_t;
|
||||
|
||||
/// workaround type for MSVC
|
||||
using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
|
||||
|
||||
/// shortcut
|
||||
using diagnostics_t = ::nlohmann::detail::diagnostics_t<basic_json>;
|
||||
|
||||
JSON_PRIVATE_UNLESS_TESTED:
|
||||
// convenience aliases for types residing in namespace detail;
|
||||
using lexer = ::nlohmann::detail::lexer_base<basic_json>;
|
||||
@ -1060,7 +1066,7 @@ class basic_json
|
||||
object = nullptr; // silence warning, see #821
|
||||
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
|
||||
{
|
||||
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
|
||||
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1", diagnostics_t())); // LCOV_EXCL_LINE
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -1629,7 +1635,7 @@ class basic_json
|
||||
// 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"));
|
||||
JSON_THROW(type_error::create(301, "cannot create object from initializer list", diagnostics_t()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1950,7 +1956,7 @@ class basic_json
|
||||
// make sure iterator fits the current value
|
||||
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(201, diagnostics() + "iterators are not compatible"));
|
||||
JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", diagnostics_t()));
|
||||
}
|
||||
|
||||
// copy type from first iterator
|
||||
@ -1968,7 +1974,7 @@ class basic_json
|
||||
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"));
|
||||
JSON_THROW(invalid_iterator::create(204, "iterators out of range", diagnostics_t()));
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -2042,8 +2048,7 @@ class basic_json
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
|
||||
std::string(first.m_object->type_name())));
|
||||
JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), diagnostics_t()));
|
||||
}
|
||||
|
||||
assert_invariant();
|
||||
@ -2763,60 +2768,6 @@ class basic_json
|
||||
|
||||
/// @}
|
||||
|
||||
std::string diagnostics() const
|
||||
{
|
||||
#if JSON_DIAGNOSTICS
|
||||
std::vector<std::string> tokens;
|
||||
for (const basic_json* current = this; current->m_parent != nullptr; current = current->m_parent)
|
||||
{
|
||||
switch (current->m_parent->type())
|
||||
{
|
||||
case value_t::array:
|
||||
{
|
||||
for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
|
||||
{
|
||||
if (current->m_parent->m_value.array->operator[](i) == *current)
|
||||
{
|
||||
tokens.emplace_back(std::to_string(i));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case value_t::object:
|
||||
{
|
||||
for (const auto& element : *current->m_parent->m_value.object)
|
||||
{
|
||||
if (element.second == *current)
|
||||
{
|
||||
tokens.emplace_back(element.first.c_str());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (tokens.empty())
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
|
||||
[](const std::string & a, const std::string & b)
|
||||
{
|
||||
return a + "/" + b;
|
||||
}) + ") ";
|
||||
#else
|
||||
return "";
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
//////////////////
|
||||
// value access //
|
||||
@ -2830,7 +2781,7 @@ class basic_json
|
||||
return m_value.boolean;
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(302, diagnostics() + "type must be boolean, but is " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/// get a pointer to the value (object)
|
||||
@ -2951,7 +2902,7 @@ class basic_json
|
||||
return *ptr;
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(303, obj.diagnostics() + "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
|
||||
JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), diagnostics_t(obj)));
|
||||
}
|
||||
|
||||
public:
|
||||
@ -3379,7 +3330,7 @@ class basic_json
|
||||
{
|
||||
if (!is_binary())
|
||||
{
|
||||
JSON_THROW(type_error::create(302, diagnostics() + "type must be binary, but is " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
return *get_ptr<binary_t*>();
|
||||
@ -3390,7 +3341,7 @@ class basic_json
|
||||
{
|
||||
if (!is_binary())
|
||||
{
|
||||
JSON_THROW(type_error::create(302, diagnostics() + "type must be binary, but is " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
return *get_ptr<const binary_t*>();
|
||||
@ -3451,12 +3402,12 @@ class basic_json
|
||||
JSON_CATCH (std::out_of_range&)
|
||||
{
|
||||
// create better exception explanation
|
||||
JSON_THROW(out_of_range::create(401, diagnostics() + "array index " + std::to_string(idx) + " is out of range"));
|
||||
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(304, diagnostics() + "cannot use at() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -3498,12 +3449,12 @@ class basic_json
|
||||
JSON_CATCH (std::out_of_range&)
|
||||
{
|
||||
// create better exception explanation
|
||||
JSON_THROW(out_of_range::create(401, diagnostics() + "array index " + std::to_string(idx) + " is out of range"));
|
||||
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(304, diagnostics() + "cannot use at() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -3555,12 +3506,12 @@ class basic_json
|
||||
JSON_CATCH (std::out_of_range&)
|
||||
{
|
||||
// create better exception explanation
|
||||
JSON_THROW(out_of_range::create(403, diagnostics() + "key '" + key + "' not found"));
|
||||
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(304, diagnostics() + "cannot use at() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -3606,12 +3557,12 @@ class basic_json
|
||||
JSON_CATCH (std::out_of_range&)
|
||||
{
|
||||
// create better exception explanation
|
||||
JSON_THROW(out_of_range::create(403, diagnostics() + "key '" + key + "' not found"));
|
||||
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(304, diagnostics() + "cannot use at() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -3675,7 +3626,7 @@ class basic_json
|
||||
return m_value.array->operator[](idx);
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a numeric argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3705,7 +3656,7 @@ class basic_json
|
||||
return m_value.array->operator[](idx);
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a numeric argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3757,7 +3708,7 @@ class basic_json
|
||||
#endif
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a string argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3799,7 +3750,7 @@ class basic_json
|
||||
return m_value.object->find(key)->second;
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a string argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3853,7 +3804,7 @@ class basic_json
|
||||
#endif
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a string argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3897,7 +3848,7 @@ class basic_json
|
||||
return m_value.object->find(key)->second;
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(305, diagnostics() + "cannot use operator[] with a string argument with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -3969,7 +3920,7 @@ class basic_json
|
||||
return default_value;
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(306, diagnostics() + "cannot use value() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -4042,7 +3993,7 @@ class basic_json
|
||||
}
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(306, diagnostics() + "cannot use value() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -4196,7 +4147,7 @@ class basic_json
|
||||
// make sure iterator fits the current value
|
||||
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterator does not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
IteratorType result = end();
|
||||
@ -4212,7 +4163,7 @@ class basic_json
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
|
||||
JSON_THROW(invalid_iterator::create(205, "iterator out of range", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
if (is_string())
|
||||
@ -4248,7 +4199,7 @@ class basic_json
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(type_error::create(307, diagnostics() + "cannot use erase() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
return result;
|
||||
@ -4309,7 +4260,7 @@ class basic_json
|
||||
// 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, diagnostics() + "iterators do not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
IteratorType result = end();
|
||||
@ -4326,7 +4277,7 @@ class basic_json
|
||||
if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
|
||||
|| !last.m_it.primitive_iterator.is_end()))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(204, diagnostics() + "iterators out of range"));
|
||||
JSON_THROW(invalid_iterator::create(204, "iterators out of range", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
if (is_string())
|
||||
@ -4364,7 +4315,7 @@ class basic_json
|
||||
}
|
||||
|
||||
default:
|
||||
JSON_THROW(type_error::create(307, diagnostics() + "cannot use erase() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
return result;
|
||||
@ -4407,7 +4358,7 @@ class basic_json
|
||||
return m_value.object->erase(key);
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(307, diagnostics() + "cannot use erase() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -4441,14 +4392,14 @@ class basic_json
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(idx >= size()))
|
||||
{
|
||||
JSON_THROW(out_of_range::create(401, diagnostics() + "array index " + std::to_string(idx) + " is out of range"));
|
||||
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(307, diagnostics() + "cannot use erase() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -5393,7 +5344,7 @@ class basic_json
|
||||
// push_back only works for null objects or arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||||
{
|
||||
JSON_THROW(type_error::create(308, diagnostics() + "cannot use push_back() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// transform null object into an array
|
||||
@ -5431,7 +5382,7 @@ class basic_json
|
||||
// push_back only works for null objects or arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||||
{
|
||||
JSON_THROW(type_error::create(308, diagnostics() + "cannot use push_back() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// transform null object into an array
|
||||
@ -5484,7 +5435,7 @@ class basic_json
|
||||
// push_back only works for null objects or objects
|
||||
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
||||
{
|
||||
JSON_THROW(type_error::create(308, diagnostics() + "cannot use push_back() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// transform null object into an object
|
||||
@ -5592,7 +5543,7 @@ class basic_json
|
||||
// emplace_back only works for null objects or arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
||||
{
|
||||
JSON_THROW(type_error::create(311, diagnostics() + "cannot use emplace_back() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// transform null object into an array
|
||||
@ -5654,7 +5605,7 @@ class basic_json
|
||||
// emplace only works for null objects or arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
||||
{
|
||||
JSON_THROW(type_error::create(311, diagnostics() + "cannot use emplace() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// transform null object into an object
|
||||
@ -5730,7 +5681,7 @@ class basic_json
|
||||
// check if iterator pos fits to this JSON value
|
||||
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterator does not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// insert to array and return iterator
|
||||
@ -5743,7 +5694,7 @@ class basic_json
|
||||
#endif
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(309, diagnostics() + "cannot use insert() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -5787,7 +5738,7 @@ class basic_json
|
||||
// check if iterator pos fits to this JSON value
|
||||
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterator does not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// insert to array and return iterator
|
||||
@ -5803,7 +5754,7 @@ class basic_json
|
||||
#endif
|
||||
}
|
||||
|
||||
JSON_THROW(type_error::create(309, diagnostics() + "cannot use insert() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -5841,24 +5792,24 @@ class basic_json
|
||||
// insert only works for arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(309, diagnostics() + "cannot use insert() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// check if iterator pos fits to this JSON value
|
||||
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterator does not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", diagnostics_t(*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, diagnostics() + "iterators do not fit"));
|
||||
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(211, diagnostics() + "passed iterators may not belong to container"));
|
||||
JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// insert to array and return iterator
|
||||
@ -5903,13 +5854,13 @@ class basic_json
|
||||
// insert only works for arrays
|
||||
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
||||
{
|
||||
JSON_THROW(type_error::create(309, diagnostics() + "cannot use insert() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// check if iterator pos fits to this JSON value
|
||||
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterator does not fit current value"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// insert to array and return iterator
|
||||
@ -5954,19 +5905,19 @@ class basic_json
|
||||
// insert only works for objects
|
||||
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
||||
{
|
||||
JSON_THROW(type_error::create(309, diagnostics() + "cannot use insert() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), diagnostics_t(*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, diagnostics() + "iterators do not fit"));
|
||||
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// passed iterators must belong to objects
|
||||
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterators first and last must point to objects"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
|
||||
@ -6003,11 +5954,11 @@ class basic_json
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
||||
{
|
||||
JSON_THROW(type_error::create(312, diagnostics() + "cannot use update() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
|
||||
{
|
||||
JSON_THROW(type_error::create(312, diagnostics() + "cannot use update() with " + std::string(j.type_name())));
|
||||
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
for (auto it = j.cbegin(); it != j.cend(); ++it)
|
||||
@ -6054,20 +6005,20 @@ class basic_json
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
||||
{
|
||||
JSON_THROW(type_error::create(312, diagnostics() + "cannot use update() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), diagnostics_t(*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, diagnostics() + "iterators do not fit"));
|
||||
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
// passed iterators must belong to objects
|
||||
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
|
||||
|| !last.m_object->is_object()))
|
||||
{
|
||||
JSON_THROW(invalid_iterator::create(202, diagnostics() + "iterators first and last must point to objects"));
|
||||
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", diagnostics_t(*this)));
|
||||
}
|
||||
|
||||
for (auto it = first; it != last; ++it)
|
||||
@ -6162,7 +6113,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(310, diagnostics() + "cannot use swap() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -6195,7 +6146,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(310, diagnostics() + "cannot use swap() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -6228,7 +6179,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(310, diagnostics() + "cannot use swap() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -6261,7 +6212,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(310, diagnostics() + "cannot use swap() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -6275,7 +6226,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(type_error::create(310, diagnostics() + "cannot use swap() with " + std::string(type_name())));
|
||||
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -8484,7 +8435,7 @@ class basic_json
|
||||
if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
|
||||
{
|
||||
// avoid undefined behavior
|
||||
JSON_THROW(out_of_range::create(401, parent.diagnostics() + "array index " + std::to_string(idx) + " is out of range"));
|
||||
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", diagnostics_t(parent)));
|
||||
}
|
||||
|
||||
// default case: insert add offset
|
||||
@ -8518,7 +8469,7 @@ class basic_json
|
||||
}
|
||||
else
|
||||
{
|
||||
JSON_THROW(out_of_range::create(403, diagnostics() + "key '" + last_path + "' not found"));
|
||||
JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", diagnostics_t(*this)));
|
||||
}
|
||||
}
|
||||
else if (parent.is_array())
|
||||
@ -8531,7 +8482,7 @@ class basic_json
|
||||
// type check: top level value must be an array
|
||||
if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
|
||||
{
|
||||
JSON_THROW(parse_error::create(104, 0, diagnostics() + "JSON patch must be an array of objects"));
|
||||
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", diagnostics_t(json_patch)));
|
||||
}
|
||||
|
||||
// iterate and apply the operations
|
||||
@ -8551,13 +8502,13 @@ class basic_json
|
||||
// check if desired value is present
|
||||
if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
|
||||
{
|
||||
JSON_THROW(parse_error::create(105, 0, diagnostics() + error_msg + " must have member '" + member + "'"));
|
||||
JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", diagnostics_t(val)));
|
||||
}
|
||||
|
||||
// check if result is of type string
|
||||
if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
|
||||
{
|
||||
JSON_THROW(parse_error::create(105, 0, diagnostics() + error_msg + " must have string member '" + member + "'"));
|
||||
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", diagnostics_t(val)));
|
||||
}
|
||||
|
||||
// no error: return value
|
||||
@ -8567,7 +8518,7 @@ class basic_json
|
||||
// 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, diagnostics() + "JSON patch must be an array of objects"));
|
||||
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", diagnostics_t(val)));
|
||||
}
|
||||
|
||||
// collect mandatory members
|
||||
@ -8645,7 +8596,7 @@ class basic_json
|
||||
// throw an exception if test fails
|
||||
if (JSON_HEDLEY_UNLIKELY(!success))
|
||||
{
|
||||
JSON_THROW(other_error::create(501, val.diagnostics() + "unsuccessful: " + val.dump()));
|
||||
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), diagnostics_t(val)));
|
||||
}
|
||||
|
||||
break;
|
||||
@ -8655,7 +8606,7 @@ class basic_json
|
||||
{
|
||||
// op must be "add", "remove", "replace", "move", "copy", or
|
||||
// "test"
|
||||
JSON_THROW(parse_error::create(105, 0, diagnostics() + "operation value '" + op + "' is invalid"));
|
||||
JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", diagnostics_t(val)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -692,7 +692,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {"op", "add", "path", "", "value", 1};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.104] parse error: (/0) JSON patch must be an array of objects");
|
||||
#else
|
||||
"[json.exception.parse_error.104] parse error: JSON patch must be an array of objects");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'op'")
|
||||
@ -701,7 +705,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"foo", "bar"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation must have member 'op'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation must have member 'op'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'op'")
|
||||
@ -710,7 +718,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation must have string member 'op'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation must have string member 'op'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("invalid operation")
|
||||
@ -719,7 +731,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "foo"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation value 'foo' is invalid");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation value 'foo' is invalid");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@ -731,7 +747,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "add"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'add' must have member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'add' must have member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -740,7 +760,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "add"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'add' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'add' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'value'")
|
||||
@ -749,7 +773,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "add"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'add' must have member 'value'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'add' must have member 'value'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("invalid array index")
|
||||
@ -770,7 +798,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "remove"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'remove' must have member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'remove' must have member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -779,7 +811,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "remove"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'remove' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'remove' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("nonexisting target location (array)")
|
||||
@ -818,7 +854,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "replace"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'replace' must have member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'replace' must have member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -827,7 +867,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "replace"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'replace' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'replace' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'value'")
|
||||
@ -836,7 +880,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "replace"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'replace' must have member 'value'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'replace' must have member 'value'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("nonexisting target location (array)")
|
||||
@ -866,7 +914,12 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "move"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
"[json.exception.parse_error.105] parse error: operation 'move' must have member 'path'");
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'move' must have member 'path'"
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'move' must have member 'path'"
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -875,7 +928,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "move"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'move' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'move' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'from'")
|
||||
@ -884,7 +941,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "move"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'move' must have member 'from'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'move' must have member 'from'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'from'")
|
||||
@ -893,7 +954,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "move"}, {"path", ""}, {"from", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'move' must have string member 'from'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'move' must have string member 'from'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("nonexisting from location (array)")
|
||||
@ -923,7 +988,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "copy"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'copy' must have member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'copy' must have member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -932,7 +1001,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "copy"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'copy' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'copy' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'from'")
|
||||
@ -941,7 +1014,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "copy"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'copy' must have member 'from'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'copy' must have member 'from'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'from'")
|
||||
@ -950,7 +1027,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "copy"}, {"path", ""}, {"from", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'copy' must have string member 'from'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'copy' must have string member 'from'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("nonexisting from location (array)")
|
||||
@ -980,7 +1061,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "test"}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'test' must have member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'test' must have member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("non-string 'path'")
|
||||
@ -989,7 +1074,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "test"}, {"path", 1}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'test' must have string member 'path'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'test' must have string member 'path'");
|
||||
#endif
|
||||
}
|
||||
|
||||
SECTION("missing 'value'")
|
||||
@ -998,7 +1087,11 @@ TEST_CASE("JSON patch")
|
||||
json patch = {{{"op", "test"}, {"path", ""}}};
|
||||
CHECK_THROWS_AS(j.patch(patch), json::parse_error&);
|
||||
CHECK_THROWS_WITH(j.patch(patch),
|
||||
#if JSON_DIAGNOSTICS
|
||||
"[json.exception.parse_error.105] parse error: (/0) operation 'test' must have member 'value'");
|
||||
#else
|
||||
"[json.exception.parse_error.105] parse error: operation 'test' must have member 'value'");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user