Skip to content

J
json
Unverified Commit 90798caa authored by Niels Lohmann's avatar Niels Lohmann
Browse files
Options

🚚 rename Hedley macros

parent 025f4cea
Expand all Show whitespace changes
Inline Side-by-side
Showing with 2573 additions and 2569 deletions
Makefile
View file @ 90798caa
......@@ -617,9 +617,13 @@ clean:
$(MAKE) clean -Cdoc
$(MAKE) clean -Ctest
##########################################################################
# Thirdparty code
##########################################################################
update_hedley:
rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
gsed -i 's/HEDLEY_/NLOHMANN_JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
gsed -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | gsed 's/ //g' | gsed 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
$(MAKE) amalgamate
include/nlohmann/detail/conversions/from_json.hpp
View file @ 90798caa
......@@ -26,7 +26,7 @@ namespace detail
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_null()))
if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
{
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
}
......@@ -66,7 +66,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
{
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
}
......@@ -76,7 +76,7 @@ void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_string()))
if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
......@@ -92,7 +92,7 @@ template <
int > = 0 >
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_string()))
if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
......@@ -132,7 +132,7 @@ template<typename BasicJsonType, typename T, typename Allocator,
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_array()))
if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
......@@ -149,7 +149,7 @@ template<typename BasicJsonType, typename T,
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::valarray<T>& l)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_array()))
if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
......@@ -236,7 +236,7 @@ auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_array()))
if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " +
std::string(j.type_name())));
......@@ -249,7 +249,7 @@ template<typename BasicJsonType, typename ConstructibleObjectType,
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_object()))
if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
{
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
}
......@@ -332,14 +332,14 @@ template <typename BasicJsonType, typename Key, typename Value, typename Compare
typename BasicJsonType::string_t, Key>::value>>
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_array()))
if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not p.is_array()))
if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
......@@ -352,14 +352,14 @@ template <typename BasicJsonType, typename Key, typename Value, typename Hash, t
typename BasicJsonType::string_t, Key>::value>>
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not j.is_array()))
if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
m.clear();
for (const auto& p : j)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not p.is_array()))
if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
......
include/nlohmann/detail/conversions/to_chars.hpp
View file @ 90798caa
......@@ -819,7 +819,7 @@ v = buf * 10^decimal_exponent
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
NLOHMANN_JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_NON_NULL(1)
inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
......@@ -879,7 +879,7 @@ len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
template <typename FloatType>
NLOHMANN_JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
......@@ -918,8 +918,8 @@ void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
@return a pointer to the element following the exponent.
@pre -1000 < e < 1000
*/
NLOHMANN_JSON_HEDLEY_NON_NULL(1)
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* append_exponent(char* buf, int e)
{
assert(e > -1000);
......@@ -970,8 +970,8 @@ notation. Otherwise it will be printed in exponential notation.
@pre min_exp < 0
@pre max_exp > 0
*/
NLOHMANN_JSON_HEDLEY_NON_NULL(1)
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_NON_NULL(1)
JSON_HEDLEY_RETURNS_NON_NULL
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
......@@ -1055,8 +1055,8 @@ format. Returns an iterator pointing past-the-end of the decimal representation.
@note The result is NOT null-terminated.
*/
template <typename FloatType>
NLOHMANN_JSON_HEDLEY_NON_NULL(1, 2)
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_NON_NULL(1, 2)
JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value)
{
static_cast<void>(last); // maybe unused - fix warning
......
include/nlohmann/detail/exceptions.hpp
View file @ 90798caa
......@@ -47,7 +47,7 @@ class exception : public std::exception
{
public:
/// returns the explanatory string
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_RETURNS_NON_NULL
const char* what() const noexcept override
{
return m.what();
......@@ -57,7 +57,7 @@ class exception : public std::exception
const int id;
protected:
NLOHMANN_JSON_HEDLEY_NON_NULL(3)
JSON_HEDLEY_NON_NULL(3)
exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
static std::string name(const std::string& ename, int id_)
......@@ -210,7 +210,7 @@ class invalid_iterator : public exception
}
private:
NLOHMANN_JSON_HEDLEY_NON_NULL(3)
JSON_HEDLEY_NON_NULL(3)
invalid_iterator(int id_, const char* what_arg)
: exception(id_, what_arg) {}
};
......@@ -264,7 +264,7 @@ class type_error : public exception
}
private:
NLOHMANN_JSON_HEDLEY_NON_NULL(3)
JSON_HEDLEY_NON_NULL(3)
type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
......@@ -311,7 +311,7 @@ class out_of_range : public exception
}
private:
NLOHMANN_JSON_HEDLEY_NON_NULL(3)
JSON_HEDLEY_NON_NULL(3)
out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
......@@ -349,7 +349,7 @@ class other_error : public exception
}
private:
NLOHMANN_JSON_HEDLEY_NON_NULL(3)
JSON_HEDLEY_NON_NULL(3)
other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
} // namespace detail
......
include/nlohmann/detail/input/input_adapters.hpp
View file @ 90798caa
......@@ -55,7 +55,7 @@ Input adapter for stdio file access. This adapter read only 1 byte and do not us
class file_input_adapter : public input_adapter_protocol
{
public:
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
explicit file_input_adapter(std::FILE* f) noexcept
: m_file(f)
{}
......@@ -131,7 +131,7 @@ class input_stream_adapter : public input_adapter_protocol
class input_buffer_adapter : public input_adapter_protocol
{
public:
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
input_buffer_adapter(const char* b, const std::size_t l) noexcept
: cursor(b), limit(b + l)
{}
......@@ -145,7 +145,7 @@ class input_buffer_adapter : public input_adapter_protocol
std::char_traits<char>::int_type get_character() noexcept override
{
if (NLOHMANN_JSON_HEDLEY_LIKELY(cursor < limit))
if (JSON_HEDLEY_LIKELY(cursor < limit))
{
return std::char_traits<char>::to_int_type(*(cursor++));
}
......@@ -335,7 +335,7 @@ class input_adapter
{
public:
// native support
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
input_adapter(std::FILE* file)
: ia(std::make_shared<file_input_adapter>(file)) {}
/// input adapter for input stream
......@@ -404,7 +404,7 @@ class input_adapter
"each element in the iterator range must have the size of 1 byte");
const auto len = static_cast<size_t>(std::distance(first, last));
if (NLOHMANN_JSON_HEDLEY_LIKELY(len > 0))
if (JSON_HEDLEY_LIKELY(len > 0))
{
// there is at least one element: use the address of first
ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
......
include/nlohmann/detail/input/json_sax.hpp
View file @ 90798caa
......@@ -206,7 +206,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
......@@ -232,7 +232,7 @@ class json_sax_dom_parser
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
......@@ -288,7 +288,7 @@ class json_sax_dom_parser
object to which we can add elements
*/
template<typename Value>
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_RETURNS_NON_NULL
BasicJsonType* handle_value(Value&& v)
{
if (ref_stack.empty())
......@@ -395,7 +395,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check object limit
if (ref_stack.back() and NLOHMANN_JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
}
......@@ -458,7 +458,7 @@ class json_sax_dom_callback_parser
ref_stack.push_back(val.second);
// check array limit
if (ref_stack.back() and NLOHMANN_JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
}
......
include/nlohmann/detail/input/lexer.hpp
View file @ 90798caa
......@@ -59,7 +59,7 @@ class lexer
};
/// return name of values of type token_type (only used for errors)
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_RETURNS_NON_NULL
static const char* token_type_name(const token_type t) noexcept
{
switch (t)
......@@ -201,7 +201,7 @@ class lexer
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (NLOHMANN_JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
{
add(current);
}
......@@ -300,7 +300,7 @@ class lexer
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
......@@ -310,18 +310,18 @@ class lexer
if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (NLOHMANN_JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (NLOHMANN_JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
......@@ -348,7 +348,7 @@ class lexer
}
else
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
......@@ -723,7 +723,7 @@ class lexer
case 0xDE:
case 0xDF:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
......@@ -733,7 +733,7 @@ class lexer
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -757,7 +757,7 @@ class lexer
case 0xEE:
case 0xEF:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -767,7 +767,7 @@ class lexer
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -777,7 +777,7 @@ class lexer
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -789,7 +789,7 @@ class lexer
case 0xF2:
case 0xF3:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -799,7 +799,7 @@ class lexer
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
......@@ -816,19 +816,19 @@ class lexer
}
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
static void strtof(float& f, const char* str, char** endptr) noexcept
{
f = std::strtof(str, endptr);
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
static void strtof(double& f, const char* str, char** endptr) noexcept
{
f = std::strtod(str, endptr);
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
static void strtof(long double& f, const char* str, char** endptr) noexcept
{
f = std::strtold(str, endptr);
......@@ -1204,14 +1204,14 @@ scan_number_done:
@param[in] length the length of the passed literal text
@param[in] return_type the token type to return on success
*/
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
token_type scan_literal(const char* literal_text, const std::size_t length,
token_type return_type)
{
assert(current == literal_text[0]);
for (std::size_t i = 1; i < length; ++i)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(get() != literal_text[i]))
if (JSON_HEDLEY_UNLIKELY(get() != literal_text[i]))
{
error_message = "invalid literal";
return token_type::parse_error;
......@@ -1257,7 +1257,7 @@ scan_number_done:
current = ia->get_character();
}
if (NLOHMANN_JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
{
token_string.push_back(std::char_traits<char>::to_char_type(current));
}
......@@ -1298,7 +1298,7 @@ scan_number_done:
--position.chars_read_current_line;
}
if (NLOHMANN_JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
{
assert(not token_string.empty());
token_string.pop_back();
......@@ -1377,7 +1377,7 @@ scan_number_done:
}
/// return syntax error message
NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
JSON_HEDLEY_RETURNS_NON_NULL
constexpr const char* get_error_message() const noexcept
{
return error_message;
......
include/nlohmann/detail/input/parser.hpp
View file @ 90798caa
......@@ -147,7 +147,7 @@ class parser
}
template <typename SAX>
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
bool sax_parse(SAX* sax, const bool strict = true)
{
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
......@@ -167,7 +167,7 @@ class parser
private:
template <typename SAX>
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax)
{
// stack to remember the hierarchy of structured values we are parsing
......@@ -185,7 +185,7 @@ class parser
{
case token_type::begin_object:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
{
return false;
}
......@@ -193,7 +193,7 @@ class parser
// closing } -> we are done
if (get_token() == token_type::end_object)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->end_object()))
if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
{
return false;
}
......@@ -201,20 +201,20 @@ class parser
}
// parse key
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
{
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")));
}
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
{
return false;
}
// parse separator (:)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
......@@ -232,7 +232,7 @@ class parser
case token_type::begin_array:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
{
return false;
}
......@@ -240,7 +240,7 @@ class parser
// closing ] -> we are done
if (get_token() == token_type::end_array)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->end_array()))
if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
{
return false;
}
......@@ -258,14 +258,14 @@ class parser
{
const auto res = m_lexer.get_number_float();
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
{
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() + "'"));
}
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
{
return false;
}
......@@ -275,7 +275,7 @@ class parser
case token_type::literal_false:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
{
return false;
}
......@@ -284,7 +284,7 @@ class parser
case token_type::literal_null:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->null()))
if (JSON_HEDLEY_UNLIKELY(not sax->null()))
{
return false;
}
......@@ -293,7 +293,7 @@ class parser
case token_type::literal_true:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
{
return false;
}
......@@ -302,7 +302,7 @@ class parser
case token_type::value_integer:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
{
return false;
}
......@@ -311,7 +311,7 @@ class parser
case token_type::value_string:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
{
return false;
}
......@@ -320,7 +320,7 @@ class parser
case token_type::value_unsigned:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
{
return false;
}
......@@ -368,9 +368,9 @@ class parser
}
// closing ]
if (NLOHMANN_JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->end_array()))
if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
{
return false;
}
......@@ -396,7 +396,7 @@ class parser
if (get_token() == token_type::value_separator)
{
// parse key
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
......@@ -404,13 +404,13 @@ class parser
exception_message(token_type::value_string, "object key")));
}
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
{
return false;
}
// parse separator (:)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
......@@ -424,9 +424,9 @@ class parser
}
// closing }
if (NLOHMANN_JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not sax->end_object()))
if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
{
return false;
}
......
include/nlohmann/detail/iterators/iter_impl.hpp
View file @ 90798caa
......@@ -255,7 +255,7 @@ class iter_impl
default:
{
if (NLOHMANN_JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return *m_object;
}
......@@ -289,7 +289,7 @@ class iter_impl
default:
{
if (NLOHMANN_JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
......@@ -392,7 +392,7 @@ class iter_impl
bool operator==(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
......@@ -428,7 +428,7 @@ class iter_impl
bool operator<(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
......@@ -588,7 +588,7 @@ class iter_impl
default:
{
if (NLOHMANN_JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
{
return *m_object;
}
......@@ -606,7 +606,7 @@ class iter_impl
{
assert(m_object != nullptr);
if (NLOHMANN_JSON_HEDLEY_LIKELY(m_object->is_object()))
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
......
include/nlohmann/detail/json_pointer.hpp
View file @ 90798caa
......@@ -244,7 +244,7 @@ class json_pointer
*/
void pop_back()
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(empty()))
if (JSON_HEDLEY_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
......@@ -268,7 +268,7 @@ class json_pointer
*/
const std::string& back()
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(empty()))
if (JSON_HEDLEY_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
......@@ -332,7 +332,7 @@ class json_pointer
const int res = std::stoi(s, &processed_chars);
// check if the string was completely read
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
{
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
}
......@@ -342,7 +342,7 @@ class json_pointer
json_pointer top() const
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(empty()))
if (JSON_HEDLEY_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
......@@ -474,7 +474,7 @@ class json_pointer
case detail::value_t::array:
{
// error condition (cf. RFC 6901, Sect. 4)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
......@@ -532,7 +532,7 @@ class json_pointer
case detail::value_t::array:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token == "-"))
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(detail::out_of_range::create(402,
......@@ -541,7 +541,7 @@ class json_pointer
}
// error condition (cf. RFC 6901, Sect. 4)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
......@@ -597,7 +597,7 @@ class json_pointer
case detail::value_t::array:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token == "-"))
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
{
// "-" cannot be used for const access
JSON_THROW(detail::out_of_range::create(402,
......@@ -606,7 +606,7 @@ class json_pointer
}
// error condition (cf. RFC 6901, Sect. 4)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
......@@ -656,7 +656,7 @@ class json_pointer
case detail::value_t::array:
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token == "-"))
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(detail::out_of_range::create(402,
......@@ -665,7 +665,7 @@ class json_pointer
}
// error condition (cf. RFC 6901, Sect. 4)
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
......@@ -712,7 +712,7 @@ class json_pointer
}
// check if nonempty reference string begins with slash
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
{
JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" +
......@@ -747,7 +747,7 @@ class json_pointer
assert(reference_token[pos] == '~');
// ~ must be followed by 0 or 1
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
(reference_token[pos + 1] != '0' and
reference_token[pos + 1] != '1')))
{
......@@ -874,7 +874,7 @@ class json_pointer
static BasicJsonType
unflatten(const BasicJsonType& value)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not value.is_object()))
if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
{
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
}
......@@ -884,7 +884,7 @@ class json_pointer
// iterate the JSON object values
for (const auto& element : *value.m_value.object)
{
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
{
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
}
......
include/nlohmann/detail/output/binary_writer.hpp
View file @ 90798caa
......@@ -715,7 +715,7 @@ class binary_writer
static std::size_t calc_bson_entry_header_size(const string_t& name)
{
const auto it = name.find(static_cast<typename string_t::value_type>(0));
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
{
JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
......
include/nlohmann/detail/output/output_adapters.hpp
View file @ 90798caa
......@@ -40,7 +40,7 @@ class output_vector_adapter : public output_adapter_protocol<CharType>
v.push_back(c);
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
std::copy(s, s + length, std::back_inserter(v));
......@@ -64,7 +64,7 @@ class output_stream_adapter : public output_adapter_protocol<CharType>
stream.put(c);
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
stream.write(s, static_cast<std::streamsize>(length));
......@@ -88,7 +88,7 @@ class output_string_adapter : public output_adapter_protocol<CharType>
str.push_back(c);
}
NLOHMANN_JSON_HEDLEY_NON_NULL(2)
JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
str.append(s, length);
......
include/nlohmann/detail/output/serializer.hpp
View file @ 90798caa
......@@ -110,7 +110,7 @@ class serializer
// variable to hold indentation for recursive calls
const auto new_indent = current_indent + indent_step;
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
{
indent_string.resize(indent_string.size() * 2, ' ');
}
......@@ -183,7 +183,7 @@ class serializer
// variable to hold indentation for recursive calls
const auto new_indent = current_indent + indent_step;
if (NLOHMANN_JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
{
indent_string.resize(indent_string.size() * 2, ' ');
}
......@@ -498,7 +498,7 @@ class serializer
}
// we finished processing the string
if (NLOHMANN_JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
{
// write buffer
if (bytes > 0)
......
include/nlohmann/json.hpp
View file @ 90798caa
This diff is collapsed.
include/nlohmann/thirdparty/hedley/hedley.hpp
View file @ 90798caa
This source diff could not be displayed because it is too large. You can view the blob instead.
include/nlohmann/thirdparty/hedley/hedley_undef.hpp
View file @ 90798caa
#undef NLOHMANN_JSON_HEDLEY_ALWAYS_INLINE
#undef NLOHMANN_JSON_HEDLEY_ARM_VERSION
#undef NLOHMANN_JSON_HEDLEY_ARM_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_ARRAY_PARAM
#undef NLOHMANN_JSON_HEDLEY_ASSUME
#undef NLOHMANN_JSON_HEDLEY_BEGIN_C_DECLS
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_BUILTIN
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_EXTENSION
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_FEATURE
#undef NLOHMANN_JSON_HEDLEY_CLANG_HAS_WARNING
#undef NLOHMANN_JSON_HEDLEY_COMPCERT_VERSION
#undef NLOHMANN_JSON_HEDLEY_COMPCERT_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_CONCAT
#undef NLOHMANN_JSON_HEDLEY_CONCAT_EX
#undef NLOHMANN_JSON_HEDLEY_CONST
#undef NLOHMANN_JSON_HEDLEY_CONSTEXPR
#undef NLOHMANN_JSON_HEDLEY_CONST_CAST
#undef NLOHMANN_JSON_HEDLEY_CPP_CAST
#undef NLOHMANN_JSON_HEDLEY_CRAY_VERSION
#undef NLOHMANN_JSON_HEDLEY_CRAY_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_C_DECL
#undef NLOHMANN_JSON_HEDLEY_DEPRECATED
#undef NLOHMANN_JSON_HEDLEY_DEPRECATED_FOR
#undef NLOHMANN_JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#undef NLOHMANN_JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#undef NLOHMANN_JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#undef NLOHMANN_JSON_HEDLEY_DIAGNOSTIC_POP
#undef NLOHMANN_JSON_HEDLEY_DIAGNOSTIC_PUSH
#undef NLOHMANN_JSON_HEDLEY_DMC_VERSION
#undef NLOHMANN_JSON_HEDLEY_DMC_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef NLOHMANN_JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_END_C_DECLS
#undef NLOHMANN_JSON_HEDLEY_FALL_THROUGH
#undef NLOHMANN_JSON_HEDLEY_FLAGS
#undef NLOHMANN_JSON_HEDLEY_FLAGS_CAST
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_BUILTIN
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_EXTENSION
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_FEATURE
#undef NLOHMANN_JSON_HEDLEY_GCC_HAS_WARNING
#undef NLOHMANN_JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_GCC_VERSION
#undef NLOHMANN_JSON_HEDLEY_GCC_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_BUILTIN
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_EXTENSION
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_FEATURE
#undef NLOHMANN_JSON_HEDLEY_GNUC_HAS_WARNING
#undef NLOHMANN_JSON_HEDLEY_GNUC_VERSION
#undef NLOHMANN_JSON_HEDLEY_GNUC_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_HAS_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_HAS_BUILTIN
#undef NLOHMANN_JSON_HEDLEY_HAS_CPP_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
#undef NLOHMANN_JSON_HEDLEY_HAS_EXTENSION
#undef NLOHMANN_JSON_HEDLEY_HAS_FEATURE
#undef NLOHMANN_JSON_HEDLEY_HAS_WARNING
#undef NLOHMANN_JSON_HEDLEY_IAR_VERSION
#undef NLOHMANN_JSON_HEDLEY_IAR_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_IBM_VERSION
#undef NLOHMANN_JSON_HEDLEY_IBM_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_IMPORT
#undef NLOHMANN_JSON_HEDLEY_INLINE
#undef NLOHMANN_JSON_HEDLEY_INTEL_VERSION
#undef NLOHMANN_JSON_HEDLEY_INTEL_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_IS_CONSTANT
#undef NLOHMANN_JSON_HEDLEY_LIKELY
#undef NLOHMANN_JSON_HEDLEY_MALLOC
#undef NLOHMANN_JSON_HEDLEY_MESSAGE
#undef NLOHMANN_JSON_HEDLEY_MSVC_VERSION
#undef NLOHMANN_JSON_HEDLEY_MSVC_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_NEVER_INLINE
#undef NLOHMANN_JSON_HEDLEY_NON_NULL
#undef NLOHMANN_JSON_HEDLEY_NO_RETURN
#undef NLOHMANN_JSON_HEDLEY_NO_THROW
#undef NLOHMANN_JSON_HEDLEY_PELLES_VERSION
#undef NLOHMANN_JSON_HEDLEY_PELLES_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_PGI_VERSION
#undef NLOHMANN_JSON_HEDLEY_PGI_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_PREDICT
#undef NLOHMANN_JSON_HEDLEY_PRINTF_FORMAT
#undef NLOHMANN_JSON_HEDLEY_PRIVATE
#undef NLOHMANN_JSON_HEDLEY_PUBLIC
#undef NLOHMANN_JSON_HEDLEY_PURE
#undef NLOHMANN_JSON_HEDLEY_REINTERPRET_CAST
#undef NLOHMANN_JSON_HEDLEY_REQUIRE
#undef NLOHMANN_JSON_HEDLEY_REQUIRE_CONSTEXPR
#undef NLOHMANN_JSON_HEDLEY_REQUIRE_MSG
#undef NLOHMANN_JSON_HEDLEY_RESTRICT
#undef NLOHMANN_JSON_HEDLEY_RETURNS_NON_NULL
#undef NLOHMANN_JSON_HEDLEY_SENTINEL
#undef NLOHMANN_JSON_HEDLEY_STATIC_ASSERT
#undef NLOHMANN_JSON_HEDLEY_STATIC_CAST
#undef NLOHMANN_JSON_HEDLEY_STRINGIFY
#undef NLOHMANN_JSON_HEDLEY_STRINGIFY_EX
#undef NLOHMANN_JSON_HEDLEY_SUNPRO_VERSION
#undef NLOHMANN_JSON_HEDLEY_SUNPRO_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_TINYC_VERSION
#undef NLOHMANN_JSON_HEDLEY_TINYC_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_TI_VERSION
#undef NLOHMANN_JSON_HEDLEY_TI_VERSION_CHECK
#undef NLOHMANN_JSON_HEDLEY_UNAVAILABLE
#undef NLOHMANN_JSON_HEDLEY_UNLIKELY
#undef NLOHMANN_JSON_HEDLEY_UNPREDICTABLE
#undef NLOHMANN_JSON_HEDLEY_UNREACHABLE
#undef NLOHMANN_JSON_HEDLEY_UNREACHABLE_RETURN
#undef NLOHMANN_JSON_HEDLEY_VERSION
#undef NLOHMANN_JSON_HEDLEY_VERSION_DECODE_MAJOR
#undef NLOHMANN_JSON_HEDLEY_VERSION_DECODE_MINOR
#undef NLOHMANN_JSON_HEDLEY_VERSION_DECODE_REVISION
#undef NLOHMANN_JSON_HEDLEY_VERSION_ENCODE
#undef NLOHMANN_JSON_HEDLEY_WARNING
#undef NLOHMANN_JSON_HEDLEY_WARN_UNUSED_RESULT
#undef JSON_HEDLEY_ALWAYS_INLINE
#undef JSON_HEDLEY_ARM_VERSION
#undef JSON_HEDLEY_ARM_VERSION_CHECK
#undef JSON_HEDLEY_ARRAY_PARAM
#undef JSON_HEDLEY_ASSUME
#undef JSON_HEDLEY_BEGIN_C_DECLS
#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
#undef JSON_HEDLEY_CLANG_HAS_FEATURE
#undef JSON_HEDLEY_CLANG_HAS_WARNING
#undef JSON_HEDLEY_COMPCERT_VERSION
#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
#undef JSON_HEDLEY_CONCAT
#undef JSON_HEDLEY_CONCAT_EX
#undef JSON_HEDLEY_CONST
#undef JSON_HEDLEY_CONSTEXPR
#undef JSON_HEDLEY_CONST_CAST
#undef JSON_HEDLEY_CPP_CAST
#undef JSON_HEDLEY_CRAY_VERSION
#undef JSON_HEDLEY_CRAY_VERSION_CHECK
#undef JSON_HEDLEY_C_DECL
#undef JSON_HEDLEY_DEPRECATED
#undef JSON_HEDLEY_DEPRECATED_FOR
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#undef JSON_HEDLEY_DIAGNOSTIC_POP
#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
#undef JSON_HEDLEY_DMC_VERSION
#undef JSON_HEDLEY_DMC_VERSION_CHECK
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
#undef JSON_HEDLEY_END_C_DECLS
#undef JSON_HEDLEY_FALL_THROUGH
#undef JSON_HEDLEY_FLAGS
#undef JSON_HEDLEY_FLAGS_CAST
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_BUILTIN
#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_GCC_HAS_EXTENSION
#undef JSON_HEDLEY_GCC_HAS_FEATURE
#undef JSON_HEDLEY_GCC_HAS_WARNING
#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
#undef JSON_HEDLEY_GCC_VERSION
#undef JSON_HEDLEY_GCC_VERSION_CHECK
#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
#undef JSON_HEDLEY_GNUC_HAS_FEATURE
#undef JSON_HEDLEY_GNUC_HAS_WARNING
#undef JSON_HEDLEY_GNUC_VERSION
#undef JSON_HEDLEY_GNUC_VERSION_CHECK
#undef JSON_HEDLEY_HAS_ATTRIBUTE
#undef JSON_HEDLEY_HAS_BUILTIN
#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
#undef JSON_HEDLEY_HAS_EXTENSION
#undef JSON_HEDLEY_HAS_FEATURE
#undef JSON_HEDLEY_HAS_WARNING
#undef JSON_HEDLEY_IAR_VERSION
#undef JSON_HEDLEY_IAR_VERSION_CHECK
#undef JSON_HEDLEY_IBM_VERSION
#undef JSON_HEDLEY_IBM_VERSION_CHECK
#undef JSON_HEDLEY_IMPORT
#undef JSON_HEDLEY_INLINE
#undef JSON_HEDLEY_INTEL_VERSION
#undef JSON_HEDLEY_INTEL_VERSION_CHECK
#undef JSON_HEDLEY_IS_CONSTANT
#undef JSON_HEDLEY_LIKELY
#undef JSON_HEDLEY_MALLOC
#undef JSON_HEDLEY_MESSAGE
#undef JSON_HEDLEY_MSVC_VERSION
#undef JSON_HEDLEY_MSVC_VERSION_CHECK
#undef JSON_HEDLEY_NEVER_INLINE
#undef JSON_HEDLEY_NON_NULL
#undef JSON_HEDLEY_NO_RETURN
#undef JSON_HEDLEY_NO_THROW
#undef JSON_HEDLEY_PELLES_VERSION
#undef JSON_HEDLEY_PELLES_VERSION_CHECK
#undef JSON_HEDLEY_PGI_VERSION
#undef JSON_HEDLEY_PGI_VERSION_CHECK
#undef JSON_HEDLEY_PREDICT
#undef JSON_HEDLEY_PRINTF_FORMAT
#undef JSON_HEDLEY_PRIVATE
#undef JSON_HEDLEY_PUBLIC
#undef JSON_HEDLEY_PURE
#undef JSON_HEDLEY_REINTERPRET_CAST
#undef JSON_HEDLEY_REQUIRE
#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
#undef JSON_HEDLEY_REQUIRE_MSG
#undef JSON_HEDLEY_RESTRICT
#undef JSON_HEDLEY_RETURNS_NON_NULL
#undef JSON_HEDLEY_SENTINEL
#undef JSON_HEDLEY_STATIC_ASSERT
#undef JSON_HEDLEY_STATIC_CAST
#undef JSON_HEDLEY_STRINGIFY
#undef JSON_HEDLEY_STRINGIFY_EX
#undef JSON_HEDLEY_SUNPRO_VERSION
#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
#undef JSON_HEDLEY_TINYC_VERSION
#undef JSON_HEDLEY_TINYC_VERSION_CHECK
#undef JSON_HEDLEY_TI_VERSION
#undef JSON_HEDLEY_TI_VERSION_CHECK
#undef JSON_HEDLEY_UNAVAILABLE
#undef JSON_HEDLEY_UNLIKELY
#undef JSON_HEDLEY_UNPREDICTABLE
#undef JSON_HEDLEY_UNREACHABLE
#undef JSON_HEDLEY_UNREACHABLE_RETURN
#undef JSON_HEDLEY_VERSION
#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
#undef JSON_HEDLEY_VERSION_DECODE_MINOR
#undef JSON_HEDLEY_VERSION_DECODE_REVISION
#undef JSON_HEDLEY_VERSION_ENCODE
#undef JSON_HEDLEY_WARNING
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
single_include/nlohmann/json.hpp
View file @ 90798caa
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment