2015-02-12 22:54:42 +01:00
|
|
|
/*!
|
|
|
|
@file
|
|
|
|
@copyright The code is licensed under the MIT License
|
|
|
|
<http://opensource.org/licenses/MIT>,
|
|
|
|
Copyright (c) 2013-2015 Niels Lohmann.
|
|
|
|
@author Niels Lohmann <http://nlohmann.me>
|
|
|
|
@see https://github.com/nlohmann/json
|
|
|
|
*/
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@defgroup container Container
|
|
|
|
@brief C++ Container concept
|
|
|
|
|
|
|
|
A Container is an object used to store other objects and taking care of the
|
|
|
|
management of the memory used by the objects it contains.
|
|
|
|
|
|
|
|
@see http://en.cppreference.com/w/cpp/concept/Container
|
|
|
|
|
|
|
|
@defgroup reversiblecontainer Reversible Container
|
|
|
|
@brief C++ Reversible Container concept
|
|
|
|
@ingroup container
|
|
|
|
|
|
|
|
A ReversibleContainer is a Container that has iterators that meet the
|
|
|
|
requirements of either BidirectionalIterator or RandomAccessIterator. Such
|
|
|
|
iterators allow a ReversibleContainer to be iterated over in reverse.
|
|
|
|
|
|
|
|
@see http://en.cppreference.com/w/cpp/concept/ReversibleContainer
|
|
|
|
*/
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
#ifndef _NLOHMANN_JSON
|
|
|
|
#define _NLOHMANN_JSON
|
|
|
|
|
|
|
|
#include <algorithm>
|
2015-02-15 11:44:49 +01:00
|
|
|
#include <cmath>
|
2015-03-23 20:27:30 +01:00
|
|
|
#include <cstdio>
|
2015-02-05 22:45:33 +01:00
|
|
|
#include <functional>
|
|
|
|
#include <initializer_list>
|
2015-02-16 22:47:30 +01:00
|
|
|
#include <iomanip>
|
2015-02-05 22:45:33 +01:00
|
|
|
#include <iostream>
|
|
|
|
#include <iterator>
|
|
|
|
#include <limits>
|
|
|
|
#include <map>
|
|
|
|
#include <memory>
|
2015-02-16 22:47:30 +01:00
|
|
|
#include <sstream>
|
2015-02-05 22:45:33 +01:00
|
|
|
#include <string>
|
|
|
|
#include <type_traits>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
/*!
|
2015-02-22 17:52:27 +01:00
|
|
|
@brief namespace for Niels Lohmann
|
2015-02-05 22:45:33 +01:00
|
|
|
@see https://github.com/nlohmann
|
|
|
|
*/
|
|
|
|
namespace nlohmann
|
|
|
|
{
|
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief JSON
|
|
|
|
|
|
|
|
@tparam ObjectType type for JSON objects
|
|
|
|
(@c std::map by default)
|
|
|
|
@tparam ArrayType type for JSON arrays
|
|
|
|
(@c std::vector by default)
|
|
|
|
@tparam StringType type for JSON strings and object keys
|
|
|
|
(@c std::string by default)
|
|
|
|
@tparam BooleanType type for JSON booleans
|
|
|
|
(@c bool by default)
|
|
|
|
@tparam NumberIntegerType type for JSON integer numbers
|
|
|
|
(@c int64_t by default)
|
2015-02-08 14:38:52 +01:00
|
|
|
@tparam NumberFloatType type for JSON floating-point numbers
|
2015-02-05 22:45:33 +01:00
|
|
|
(@c double by default)
|
2015-02-15 23:13:46 +01:00
|
|
|
@tparam Allocator type of the allocator to use
|
|
|
|
(@c std::allocator by default)
|
2015-02-15 14:52:00 +01:00
|
|
|
|
2015-02-15 23:27:35 +01:00
|
|
|
@note ObjectType trick from http://stackoverflow.com/a/9860911
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
@see RFC 7159 <http://rfc7159.net/rfc7159>
|
|
|
|
@see ECMA 404 <http://www.ecma-international.org/publications/standards/Ecma-404.htm>
|
2015-02-05 22:45:33 +01:00
|
|
|
*/
|
|
|
|
template <
|
|
|
|
template<typename U, typename V, typename... Args> class ObjectType = std::map,
|
|
|
|
template<typename U, typename... Args> class ArrayType = std::vector,
|
|
|
|
class StringType = std::string,
|
|
|
|
class BooleanType = bool,
|
|
|
|
class NumberIntegerType = int64_t,
|
2015-02-15 22:49:26 +01:00
|
|
|
class NumberFloatType = double,
|
|
|
|
template<typename U> class Allocator = std::allocator
|
2015-02-05 22:45:33 +01:00
|
|
|
>
|
|
|
|
class basic_json
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/////////////////////
|
|
|
|
// container types //
|
|
|
|
/////////////////////
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
// forward declarations
|
2015-02-05 22:45:33 +01:00
|
|
|
class iterator;
|
|
|
|
class const_iterator;
|
2015-03-26 17:06:33 +01:00
|
|
|
class reverse_iterator;
|
|
|
|
class const_reverse_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief the type of elements in a basic_json container
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
using value_type = basic_json;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief the type of an element reference
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
using reference = basic_json&;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief the type of an element const reference
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
using const_reference = const basic_json&;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief a type to represent differences between iterators
|
|
|
|
@ingroup container
|
|
|
|
*/
|
|
|
|
using difference_type = std::ptrdiff_t;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief a type to represent container sizes
|
|
|
|
@ingroup container
|
|
|
|
*/
|
|
|
|
using size_type = std::size_t;
|
|
|
|
|
|
|
|
/// the allocator type
|
|
|
|
using allocator_type = Allocator<basic_json>;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// the type of an element pointer
|
|
|
|
using pointer = basic_json*;
|
|
|
|
/// the type of an element const pointer
|
|
|
|
using const_pointer = const basic_json*;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief an iterator for a basic_json container
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
using iterator = basic_json::iterator;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief a const iterator for a basic_json container
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
using const_iterator = basic_json::const_iterator;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief a reverse iterator for a basic_json container
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-03-26 17:06:33 +01:00
|
|
|
using reverse_iterator = basic_json::reverse_iterator;
|
2015-02-22 17:52:27 +01:00
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief a const reverse iterator for a basic_json container
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-03-26 17:06:33 +01:00
|
|
|
using const_reverse_iterator = basic_json::const_reverse_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/// returns the allocator associated with the container
|
|
|
|
inline allocator_type get_allocator() const
|
|
|
|
{
|
|
|
|
return allocator_type();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
///////////////////////////
|
|
|
|
// JSON value data types //
|
|
|
|
///////////////////////////
|
|
|
|
|
|
|
|
/// a type for an object
|
|
|
|
using object_t = ObjectType<StringType, basic_json>;
|
|
|
|
/// a type for an array
|
|
|
|
using array_t = ArrayType<basic_json>;
|
|
|
|
/// a type for a string
|
|
|
|
using string_t = StringType;
|
|
|
|
/// a type for a boolean
|
|
|
|
using boolean_t = BooleanType;
|
|
|
|
/// a type for a number (integer)
|
|
|
|
using number_integer_t = NumberIntegerType;
|
2015-02-08 14:38:52 +01:00
|
|
|
/// a type for a number (floating-point)
|
2015-02-05 22:45:33 +01:00
|
|
|
using number_float_t = NumberFloatType;
|
|
|
|
/// a type for list initialization
|
|
|
|
using list_init_t = std::initializer_list<basic_json>;
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////
|
|
|
|
// JSON value storage //
|
|
|
|
////////////////////////
|
|
|
|
|
|
|
|
/// a JSON value
|
|
|
|
union json_value
|
|
|
|
{
|
|
|
|
/// object (stored with pointer to save storage)
|
|
|
|
object_t* object;
|
|
|
|
/// array (stored with pointer to save storage)
|
|
|
|
array_t* array;
|
|
|
|
/// string (stored with pointer to save storage)
|
|
|
|
string_t* string;
|
|
|
|
/// bolean
|
|
|
|
boolean_t boolean;
|
|
|
|
/// number (integer)
|
|
|
|
number_integer_t number_integer;
|
2015-02-08 14:38:52 +01:00
|
|
|
/// number (floating-point)
|
2015-02-05 22:45:33 +01:00
|
|
|
number_float_t number_float;
|
|
|
|
|
|
|
|
/// default constructor (for null values)
|
|
|
|
json_value() = default;
|
|
|
|
/// constructor for booleans
|
|
|
|
json_value(boolean_t v) : boolean(v) {}
|
|
|
|
/// constructor for numbers (integer)
|
|
|
|
json_value(number_integer_t v) : number_integer(v) {}
|
2015-02-08 14:38:52 +01:00
|
|
|
/// constructor for numbers (floating-point)
|
2015-02-05 22:45:33 +01:00
|
|
|
json_value(number_float_t v) : number_float(v) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////
|
|
|
|
// JSON value type enumeration //
|
|
|
|
/////////////////////////////////
|
|
|
|
|
|
|
|
/// JSON value type enumeration
|
|
|
|
enum class value_t : uint8_t
|
|
|
|
{
|
2015-02-15 14:52:00 +01:00
|
|
|
null, ///< null value
|
|
|
|
object, ///< object (unordered set of name/value pairs)
|
|
|
|
array, ///< array (ordered collection of values)
|
|
|
|
string, ///< string value
|
|
|
|
boolean, ///< boolean value
|
|
|
|
number_integer, ///< number value (integer)
|
|
|
|
number_float ///< number value (floating-point)
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief comparison operator for JSON value types
|
|
|
|
|
|
|
|
Returns an ordering that is similar to Python:
|
|
|
|
- order: null < boolean < number < object < array < string
|
|
|
|
- furthermore, each type is not smaller than itself
|
|
|
|
*/
|
|
|
|
friend bool operator<(const value_t lhs, const value_t rhs)
|
|
|
|
{
|
|
|
|
// no type is smaller than itself
|
|
|
|
if (lhs == rhs)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (lhs)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
// nulls are smaller than all other types
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
// only nulls are smaller than booleans
|
|
|
|
return (rhs != value_t::null);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::number_float):
|
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
|
|
|
switch (rhs)
|
|
|
|
{
|
|
|
|
// numbers are smaller than objects, arrays, and string
|
|
|
|
case (value_t::object):
|
|
|
|
case (value_t::array):
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
switch (rhs)
|
|
|
|
{
|
|
|
|
// objects are smaller than arrays and string
|
|
|
|
case (value_t::array):
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
// arrays are smaller than strings
|
|
|
|
return (rhs == value_t::string);
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
// a string is not smaller than any other types
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
//////////////////
|
|
|
|
// constructors //
|
|
|
|
//////////////////
|
|
|
|
|
2015-02-24 23:19:19 +01:00
|
|
|
/*!
|
|
|
|
@brief create an empty value with a given type
|
|
|
|
@param value the type to create an value of
|
|
|
|
|
|
|
|
@exception std::bad_alloc if allocation for object, array, or string fails.
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline basic_json(const value_t value)
|
|
|
|
: m_type(value)
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::array):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
2015-02-15 22:49:26 +01:00
|
|
|
Allocator<string_t> alloc;
|
|
|
|
m_value.string = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.string, "");
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.boolean = boolean_t(false);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.number_integer = number_integer_t(0);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.number_float = number_float_t(0.0);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief create a null object (implicitly)
|
|
|
|
@ingroup container
|
|
|
|
*/
|
|
|
|
inline basic_json() noexcept = default;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create a null object (explicitly)
|
|
|
|
inline basic_json(std::nullptr_t) noexcept
|
|
|
|
: m_type(value_t::null)
|
|
|
|
{}
|
|
|
|
|
|
|
|
/// create an object (explicit)
|
|
|
|
inline basic_json(const object_t& value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::object)
|
|
|
|
{
|
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object, value);
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create an object (implicit)
|
|
|
|
template <class V, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<string_t, typename V::key_type>::value and
|
|
|
|
std::is_constructible<basic_json, typename V::mapped_type>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline basic_json(const V& value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::object)
|
|
|
|
{
|
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
2015-03-24 17:39:00 +01:00
|
|
|
using std::begin;
|
|
|
|
using std::end;
|
|
|
|
alloc.construct(m_value.object, begin(value), end(value));
|
2015-02-15 23:13:46 +01:00
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create an array (explicit)
|
|
|
|
inline basic_json(const array_t& value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::array)
|
|
|
|
{
|
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array, value);
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create an array (implicit)
|
|
|
|
template <class V, typename
|
|
|
|
std::enable_if<
|
|
|
|
not std::is_same<V, basic_json::iterator>::value and
|
|
|
|
not std::is_same<V, basic_json::const_iterator>::value and
|
2015-02-14 16:47:14 +01:00
|
|
|
not std::is_same<V, basic_json::reverse_iterator>::value and
|
|
|
|
not std::is_same<V, basic_json::const_reverse_iterator>::value and
|
2015-02-11 14:58:52 +01:00
|
|
|
not std::is_same<V, typename array_t::iterator>::value and
|
|
|
|
not std::is_same<V, typename array_t::const_iterator>::value and
|
2015-02-05 22:45:33 +01:00
|
|
|
std::is_constructible<basic_json, typename V::value_type>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline basic_json(const V& value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::array)
|
|
|
|
{
|
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
2015-03-24 17:39:00 +01:00
|
|
|
using std::begin;
|
|
|
|
using std::end;
|
|
|
|
alloc.construct(m_value.array, begin(value), end(value));
|
2015-02-15 23:13:46 +01:00
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create a string (explicit)
|
|
|
|
inline basic_json(const string_t& value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::string)
|
2015-02-15 22:49:26 +01:00
|
|
|
{
|
|
|
|
Allocator<string_t> alloc;
|
|
|
|
m_value.string = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.string, value);
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create a string (explicit)
|
|
|
|
inline basic_json(const typename string_t::value_type* value)
|
2015-02-15 23:13:46 +01:00
|
|
|
: m_type(value_t::string)
|
2015-02-15 22:49:26 +01:00
|
|
|
{
|
|
|
|
Allocator<string_t> alloc;
|
|
|
|
m_value.string = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.string, value);
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
/// create a string (implicit)
|
|
|
|
template <class V, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<string_t, V>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline basic_json(const V& value)
|
|
|
|
: basic_json(string_t(value))
|
|
|
|
{}
|
|
|
|
|
|
|
|
/// create a boolean (explicit)
|
|
|
|
inline basic_json(boolean_t value)
|
|
|
|
: m_type(value_t::boolean), m_value(value)
|
|
|
|
{}
|
|
|
|
|
|
|
|
/// create an integer number (explicit)
|
|
|
|
inline basic_json(const number_integer_t& value)
|
|
|
|
: m_type(value_t::number_integer), m_value(value)
|
|
|
|
{}
|
|
|
|
|
|
|
|
/// create an integer number (implicit)
|
|
|
|
template<typename T, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<number_integer_t, T>::value and
|
|
|
|
std::numeric_limits<T>::is_integer, T>::type
|
|
|
|
= 0>
|
|
|
|
inline basic_json(const T value) noexcept
|
|
|
|
: m_type(value_t::number_integer), m_value(number_integer_t(value))
|
|
|
|
{}
|
|
|
|
|
2015-02-08 14:38:52 +01:00
|
|
|
/// create a floating-point number (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
inline basic_json(const number_float_t& value)
|
|
|
|
: m_type(value_t::number_float), m_value(value)
|
|
|
|
{}
|
|
|
|
|
2015-02-08 14:38:52 +01:00
|
|
|
/// create a floating-point number (implicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template<typename T, typename = typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<number_float_t, T>::value and
|
|
|
|
std::is_floating_point<T>::value>::type
|
|
|
|
>
|
|
|
|
inline basic_json(const T value) noexcept
|
|
|
|
: m_type(value_t::number_float), m_value(number_float_t(value))
|
|
|
|
{}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// create a container (array or object) from an initializer list
|
2015-02-05 22:45:33 +01:00
|
|
|
inline basic_json(list_init_t l, bool type_deduction = true, value_t manual_type = value_t::array)
|
|
|
|
{
|
|
|
|
// the initializer list could describe an object
|
|
|
|
bool is_object = true;
|
|
|
|
|
|
|
|
// check if each element is an array with two elements whose first element
|
|
|
|
// is a string
|
|
|
|
for (const auto& element : l)
|
|
|
|
{
|
|
|
|
if ((element.m_final and element.m_type == value_t::array)
|
|
|
|
or (element.m_type != value_t::array or element.size() != 2
|
|
|
|
or element[0].m_type != value_t::string))
|
|
|
|
{
|
|
|
|
// we found an element that makes it impossible to use the
|
|
|
|
// initializer list as object
|
|
|
|
is_object = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// adjust type if type deduction is not wanted
|
|
|
|
if (not type_deduction)
|
|
|
|
{
|
|
|
|
// mark this object's type as final
|
|
|
|
m_final = true;
|
|
|
|
|
|
|
|
// if array is wanted, do not create an object though possible
|
|
|
|
if (manual_type == value_t::array)
|
|
|
|
{
|
|
|
|
is_object = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if object is wanted but impossible, throw an exception
|
|
|
|
if (manual_type == value_t::object and not is_object)
|
|
|
|
{
|
|
|
|
throw std::logic_error("cannot create JSON object from initializer list");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_object)
|
|
|
|
{
|
|
|
|
// the initializer list is a list of pairs -> create object
|
|
|
|
m_type = value_t::object;
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object);
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
for (auto& element : l)
|
|
|
|
{
|
|
|
|
m_value.object->emplace(std::move(*(element[0].m_value.string)), std::move(element[1]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// the initializer list describes an array -> create array
|
|
|
|
m_type = value_t::array;
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array, std::move(l));
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// explicitly create an array from an initializer list
|
2015-02-05 22:45:33 +01:00
|
|
|
inline static basic_json array(list_init_t l = list_init_t())
|
|
|
|
{
|
|
|
|
return basic_json(l, false, value_t::array);
|
|
|
|
}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// explicitly create an object from an initializer list
|
2015-02-05 22:45:33 +01:00
|
|
|
inline static basic_json object(list_init_t l = list_init_t())
|
|
|
|
{
|
|
|
|
return basic_json(l, false, value_t::object);
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
///////////////////////////////////////
|
|
|
|
// other constructors and destructor //
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief copy constructor
|
2015-02-24 23:19:19 +01:00
|
|
|
|
|
|
|
@exception std::bad_alloc if allocation for object, array, or string fails.
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline basic_json(const basic_json& other)
|
|
|
|
: m_type(other.m_type)
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object, *other.m_value.object);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array, *other.m_value.array);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::string):
|
|
|
|
{
|
2015-02-15 22:49:26 +01:00
|
|
|
Allocator<string_t> alloc;
|
|
|
|
m_value.string = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.string, *other.m_value.string);
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
m_value.boolean = other.m_value.boolean;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
|
|
|
m_value.number_integer = other.m_value.number_integer;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
|
|
|
m_value.number_float = other.m_value.number_float;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// move constructor
|
|
|
|
inline basic_json(basic_json&& other) noexcept
|
|
|
|
: m_type(std::move(other.m_type)),
|
|
|
|
m_value(std::move(other.m_value))
|
|
|
|
{
|
2015-02-08 12:53:10 +01:00
|
|
|
// invalidate payload
|
2015-02-05 22:45:33 +01:00
|
|
|
other.m_type = value_t::null;
|
|
|
|
other.m_value = {};
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief copy assignment
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-13 21:46:33 +01:00
|
|
|
inline reference& operator=(basic_json other) noexcept (
|
|
|
|
std::is_nothrow_move_constructible<value_t>::value and
|
|
|
|
std::is_nothrow_move_assignable<value_t>::value and
|
|
|
|
std::is_nothrow_move_constructible<json_value>::value and
|
|
|
|
std::is_nothrow_move_assignable<json_value>::value
|
|
|
|
)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
std::swap(m_type, other.m_type);
|
|
|
|
std::swap(m_value, other.m_value);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief destructor
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline ~basic_json() noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<object_t> alloc;
|
|
|
|
alloc.destroy(m_value.object);
|
|
|
|
alloc.deallocate(m_value.object, 1);
|
2015-02-05 22:45:33 +01:00
|
|
|
m_value.object = nullptr;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-08 12:53:10 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
alloc.destroy(m_value.array);
|
|
|
|
alloc.deallocate(m_value.array, 1);
|
2015-02-05 22:45:33 +01:00
|
|
|
m_value.array = nullptr;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-08 12:53:10 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::string):
|
|
|
|
{
|
2015-02-15 22:49:26 +01:00
|
|
|
Allocator<string_t> alloc;
|
2015-02-15 22:58:35 +01:00
|
|
|
alloc.destroy(m_value.string);
|
2015-02-15 22:49:26 +01:00
|
|
|
alloc.deallocate(m_value.string, 1);
|
2015-02-05 22:45:33 +01:00
|
|
|
m_value.string = nullptr;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-08 12:53:10 +01:00
|
|
|
|
|
|
|
default:
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-08 12:53:10 +01:00
|
|
|
// all other types need no specific destructor
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
///////////////////////
|
|
|
|
// object inspection //
|
|
|
|
///////////////////////
|
|
|
|
|
|
|
|
/*!
|
2015-02-08 16:08:48 +01:00
|
|
|
@brief serialization
|
|
|
|
|
2015-02-24 23:19:19 +01:00
|
|
|
Serialization function for JSON objects. The function tries to mimick
|
|
|
|
Python's @p json.dumps() function, and currently supports its @p indent
|
|
|
|
parameter.
|
2015-02-05 22:45:33 +01:00
|
|
|
|
2015-02-16 22:47:30 +01:00
|
|
|
@param indent sif indent is nonnegative, then array elements and object
|
|
|
|
members will be pretty-printed with that indent level. An indent level of 0
|
|
|
|
will only insert newlines. -1 (the default) selects the most compact
|
|
|
|
representation
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
@see https://docs.python.org/2/library/json.html#json.dump
|
|
|
|
*/
|
2015-02-15 14:52:00 +01:00
|
|
|
inline string_t dump(const int indent = -1) const noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
if (indent >= 0)
|
|
|
|
{
|
|
|
|
return dump(true, static_cast<unsigned int>(indent));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return dump(false, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 15:47:40 +01:00
|
|
|
/// return the type of the object (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
inline value_t type() const noexcept
|
|
|
|
{
|
|
|
|
return m_type;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
// return whether value is null
|
|
|
|
inline bool is_null() const noexcept
|
|
|
|
{
|
|
|
|
return m_type == value_t::null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return whether value is boolean
|
|
|
|
inline bool is_boolean() const noexcept
|
|
|
|
{
|
|
|
|
return m_type == value_t::boolean;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return whether value is number
|
|
|
|
inline bool is_number() const noexcept
|
|
|
|
{
|
|
|
|
return (m_type == value_t::number_integer) or (m_type == value_t::number_float);
|
|
|
|
}
|
|
|
|
|
|
|
|
// return whether value is object
|
|
|
|
inline bool is_object() const noexcept
|
|
|
|
{
|
|
|
|
return m_type == value_t::object;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return whether value is array
|
|
|
|
inline bool is_array() const noexcept
|
|
|
|
{
|
|
|
|
return m_type == value_t::array;
|
|
|
|
}
|
|
|
|
|
|
|
|
// return whether value is string
|
|
|
|
inline bool is_string() const noexcept
|
|
|
|
{
|
|
|
|
return m_type == value_t::string;
|
|
|
|
}
|
|
|
|
|
2015-02-08 15:47:40 +01:00
|
|
|
/// return the type of the object (implicit)
|
2015-02-24 23:19:19 +01:00
|
|
|
inline operator value_t() const noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return m_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////
|
|
|
|
// value conversion //
|
|
|
|
//////////////////////
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get an object (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template <class T, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<string_t, typename T::key_type>::value and
|
|
|
|
std::is_constructible<basic_json, typename T::mapped_type>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline T get() const
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::object):
|
|
|
|
return T(m_value.object->begin(), m_value.object->end());
|
|
|
|
default:
|
|
|
|
throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get an array (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template <class T, typename
|
|
|
|
std::enable_if<
|
|
|
|
not std::is_same<T, string_t>::value and
|
|
|
|
std::is_constructible<basic_json, typename T::value_type>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline T get() const
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::array):
|
|
|
|
return T(m_value.array->begin(), m_value.array->end());
|
|
|
|
default:
|
|
|
|
throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get a string (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template <typename T, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_constructible<T, string_t>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline T get() const
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::string):
|
|
|
|
return *m_value.string;
|
|
|
|
default:
|
|
|
|
throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get a boolean (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template <typename T, typename
|
|
|
|
std::enable_if<
|
|
|
|
std::is_same<boolean_t, T>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline T get() const
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::boolean):
|
|
|
|
return m_value.boolean;
|
|
|
|
default:
|
|
|
|
throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get a number (explicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template<typename T, typename
|
|
|
|
std::enable_if<
|
|
|
|
not std::is_same<boolean_t, T>::value and
|
|
|
|
std::is_arithmetic<T>::value, int>::type
|
|
|
|
= 0>
|
|
|
|
inline T get() const
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::number_integer):
|
|
|
|
return static_cast<T>(m_value.number_integer);
|
|
|
|
case (value_t::number_float):
|
|
|
|
return static_cast<T>(m_value.number_float);
|
|
|
|
default:
|
|
|
|
throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 16:08:48 +01:00
|
|
|
/// get a value (implicit)
|
2015-02-05 22:45:33 +01:00
|
|
|
template<typename T>
|
|
|
|
inline operator T() const
|
|
|
|
{
|
|
|
|
return get<T>();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////
|
|
|
|
// element access //
|
|
|
|
////////////////////
|
|
|
|
|
|
|
|
/// access specified element with bounds checking
|
|
|
|
inline reference at(size_type pos)
|
|
|
|
{
|
|
|
|
// at only works for arrays
|
|
|
|
if (m_type != value_t::array)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use at with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.array->at(pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element with bounds checking
|
|
|
|
inline const_reference at(size_type pos) const
|
|
|
|
{
|
|
|
|
// at only works for arrays
|
|
|
|
if (m_type != value_t::array)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use at with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.array->at(pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element
|
|
|
|
inline reference operator[](size_type pos)
|
|
|
|
{
|
2015-02-21 13:24:07 +01:00
|
|
|
// implicitly convert null to object
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::array;
|
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array);
|
|
|
|
}
|
|
|
|
|
|
|
|
// [] only works for arrays
|
2015-02-05 22:45:33 +01:00
|
|
|
if (m_type != value_t::array)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
2015-02-21 13:24:07 +01:00
|
|
|
for (size_t i = m_value.array->size(); i <= pos; ++i)
|
|
|
|
{
|
|
|
|
m_value.array->push_back(basic_json());
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
return m_value.array->operator[](pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element
|
|
|
|
inline const_reference operator[](size_type pos) const
|
|
|
|
{
|
|
|
|
// at only works for arrays
|
|
|
|
if (m_type != value_t::array)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.array->operator[](pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element with bounds checking
|
|
|
|
inline reference at(const typename object_t::key_type& key)
|
|
|
|
{
|
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use at with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->at(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element with bounds checking
|
|
|
|
inline const_reference at(const typename object_t::key_type& key) const
|
|
|
|
{
|
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use at with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->at(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access specified element
|
|
|
|
inline reference operator[](const typename object_t::key_type& key)
|
|
|
|
{
|
2015-02-18 22:28:56 +01:00
|
|
|
// implicitly convert null to object
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::object;
|
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object);
|
|
|
|
}
|
|
|
|
|
2015-02-21 13:24:07 +01:00
|
|
|
// [] only works for objects
|
2015-02-05 22:45:33 +01:00
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->operator[](key);
|
|
|
|
}
|
|
|
|
|
2015-02-15 15:16:11 +01:00
|
|
|
/// access specified element
|
|
|
|
inline const_reference operator[](const typename object_t::key_type& key) const
|
|
|
|
{
|
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->operator[](key);
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// access specified element (needed for clang)
|
|
|
|
template<typename T, size_t n>
|
|
|
|
inline reference operator[](const T (&key)[n])
|
|
|
|
{
|
2015-02-18 22:28:56 +01:00
|
|
|
// implicitly convert null to object
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::object;
|
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object);
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->operator[](key);
|
|
|
|
}
|
|
|
|
|
2015-02-15 15:16:11 +01:00
|
|
|
/// access specified element (needed for clang)
|
|
|
|
template<typename T, size_t n>
|
|
|
|
inline const_reference operator[](const T (&key)[n]) const
|
|
|
|
{
|
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use [] with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->operator[](key);
|
|
|
|
}
|
|
|
|
|
2015-03-24 16:50:55 +01:00
|
|
|
/// remove element from an object given a key
|
|
|
|
inline size_type erase(const typename object_t::key_type& key)
|
|
|
|
{
|
|
|
|
// at only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use at with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_value.object->erase(key);
|
|
|
|
}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// find an element in an object
|
2015-02-07 19:04:08 +01:00
|
|
|
inline iterator find(typename object_t::key_type key)
|
2015-02-07 15:57:47 +01:00
|
|
|
{
|
|
|
|
auto result = end();
|
|
|
|
|
|
|
|
if (m_type == value_t::object)
|
|
|
|
{
|
|
|
|
result.m_it.object_iterator = m_value.object->find(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// find an element in an object
|
2015-02-07 19:04:08 +01:00
|
|
|
inline const_iterator find(typename object_t::key_type key) const
|
2015-02-07 15:57:47 +01:00
|
|
|
{
|
|
|
|
auto result = cend();
|
|
|
|
|
|
|
|
if (m_type == value_t::object)
|
|
|
|
{
|
|
|
|
result.m_it.object_iterator = m_value.object->find(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-03-22 19:07:43 +01:00
|
|
|
/// returns the number of occurrences of a key in an object
|
|
|
|
inline size_type count(typename object_t::key_type key) const
|
|
|
|
{
|
|
|
|
// return 0 for all nonobject types
|
|
|
|
return (m_type == value_t::object) ? m_value.object->count(key) : 0;
|
|
|
|
}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
///////////////
|
|
|
|
// iterators //
|
|
|
|
///////////////
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns an iterator to the first element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline iterator begin() noexcept
|
|
|
|
{
|
|
|
|
iterator result(this);
|
|
|
|
result.set_begin();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const iterator to the first element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline const_iterator begin() const noexcept
|
|
|
|
{
|
|
|
|
const_iterator result(this);
|
|
|
|
result.set_begin();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const iterator to the first element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline const_iterator cbegin() const noexcept
|
|
|
|
{
|
|
|
|
const_iterator result(this);
|
|
|
|
result.set_begin();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns an iterator to one past the last element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline iterator end() noexcept
|
|
|
|
{
|
|
|
|
iterator result(this);
|
|
|
|
result.set_end();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const iterator to one past the last element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline const_iterator end() const noexcept
|
|
|
|
{
|
|
|
|
const_iterator result(this);
|
|
|
|
result.set_end();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const iterator to one past the last element
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline const_iterator cend() const noexcept
|
|
|
|
{
|
|
|
|
const_iterator result(this);
|
|
|
|
result.set_end();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a reverse iterator to the first element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-14 16:47:14 +01:00
|
|
|
inline reverse_iterator rbegin() noexcept
|
|
|
|
{
|
|
|
|
return reverse_iterator(end());
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const reverse iterator to the first element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-15 14:52:00 +01:00
|
|
|
inline const_reverse_iterator rbegin() const noexcept
|
|
|
|
{
|
|
|
|
return const_reverse_iterator(end());
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a reverse iterator to one past the last element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-14 16:47:14 +01:00
|
|
|
inline reverse_iterator rend() noexcept
|
|
|
|
{
|
|
|
|
return reverse_iterator(begin());
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const reverse iterator to one past the last element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-15 14:52:00 +01:00
|
|
|
inline const_reverse_iterator rend() const noexcept
|
|
|
|
{
|
|
|
|
return const_reverse_iterator(begin());
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const reverse iterator to the first element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-14 16:47:14 +01:00
|
|
|
inline const_reverse_iterator crbegin() const noexcept
|
|
|
|
{
|
|
|
|
return const_reverse_iterator(cend());
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns a const reverse iterator to one past the last element
|
|
|
|
@ingroup reversiblecontainer
|
|
|
|
*/
|
2015-02-14 16:47:14 +01:00
|
|
|
inline const_reverse_iterator crend() const noexcept
|
|
|
|
{
|
|
|
|
return const_reverse_iterator(cbegin());
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
//////////////
|
|
|
|
// capacity //
|
|
|
|
//////////////
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief checks whether the container is empty
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline bool empty() const noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
return m_value.array->empty();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
return m_value.object->empty();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-08 12:53:10 +01:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
// all other types are nonempty
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns the number of elements
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline size_type size() const noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
return m_value.array->size();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
return m_value.object->size();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-08 12:53:10 +01:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
// all other types have size 1
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief returns the maximum possible number of elements
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
inline size_type max_size() const noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
return m_value.array->max_size();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
return m_value.object->max_size();
|
|
|
|
}
|
2015-02-07 19:04:08 +01:00
|
|
|
|
2015-02-08 12:53:10 +01:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
// all other types have max_size 1
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////
|
|
|
|
// modifiers //
|
|
|
|
///////////////
|
|
|
|
|
|
|
|
/// clears the contents
|
|
|
|
inline void clear() noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.number_integer = 0;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.number_float = 0.0;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
2015-02-07 19:04:08 +01:00
|
|
|
m_value.boolean = false;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
m_value.string->clear();
|
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
m_value.array->clear();
|
|
|
|
break;
|
|
|
|
}
|
2015-02-07 19:14:23 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
m_value.object->clear();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add an object to an array
|
|
|
|
inline void push_back(basic_json&& value)
|
|
|
|
{
|
|
|
|
// push_back only works for null objects or arrays
|
|
|
|
if (not(m_type == value_t::null or m_type == value_t::array))
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot add element to " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// transform null object into an array
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::array;
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// add element to array (move semantics)
|
|
|
|
m_value.array->push_back(std::move(value));
|
|
|
|
// invalidate object
|
|
|
|
value.m_type = value_t::null;
|
|
|
|
}
|
|
|
|
|
2015-02-09 21:10:19 +01:00
|
|
|
/// add an object to an array
|
|
|
|
inline reference operator+=(basic_json&& value)
|
|
|
|
{
|
|
|
|
push_back(std::move(value));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// add an object to an array
|
|
|
|
inline void push_back(const basic_json& value)
|
|
|
|
{
|
|
|
|
// push_back only works for null objects or arrays
|
|
|
|
if (not(m_type == value_t::null or m_type == value_t::array))
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot add element to " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// transform null object into an array
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::array;
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<array_t> alloc;
|
|
|
|
m_value.array = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.array);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// add element to array
|
|
|
|
m_value.array->push_back(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add an object to an array
|
|
|
|
inline reference operator+=(const basic_json& value)
|
|
|
|
{
|
|
|
|
push_back(value);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add an object to an object
|
|
|
|
inline void push_back(const typename object_t::value_type& value)
|
|
|
|
{
|
|
|
|
// push_back only works for null objects or objects
|
|
|
|
if (not(m_type == value_t::null or m_type == value_t::object))
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot add element to " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// transform null object into an object
|
|
|
|
if (m_type == value_t::null)
|
|
|
|
{
|
|
|
|
m_type = value_t::object;
|
2015-02-15 23:13:46 +01:00
|
|
|
Allocator<object_t> alloc;
|
|
|
|
m_value.object = alloc.allocate(1);
|
|
|
|
alloc.construct(m_value.object);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// add element to array
|
|
|
|
m_value.object->insert(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add an object to an object
|
|
|
|
inline reference operator+=(const typename object_t::value_type& value)
|
|
|
|
{
|
|
|
|
push_back(value);
|
|
|
|
return operator[](value.first);
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief exchanges the values
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-13 21:46:33 +01:00
|
|
|
inline void swap(reference other) noexcept (
|
|
|
|
std::is_nothrow_move_constructible<value_t>::value and
|
|
|
|
std::is_nothrow_move_assignable<value_t>::value and
|
|
|
|
std::is_nothrow_move_constructible<json_value>::value and
|
|
|
|
std::is_nothrow_move_assignable<json_value>::value
|
|
|
|
)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
std::swap(m_type, other.m_type);
|
|
|
|
std::swap(m_value, other.m_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// swaps the contents
|
|
|
|
inline void swap(array_t& other)
|
|
|
|
{
|
|
|
|
// swap only works for arrays
|
|
|
|
if (m_type != value_t::array)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use swap with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// swap arrays
|
|
|
|
std::swap(*(m_value.array), other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// swaps the contents
|
|
|
|
inline void swap(object_t& other)
|
|
|
|
{
|
|
|
|
// swap only works for objects
|
|
|
|
if (m_type != value_t::object)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use swap with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// swap arrays
|
|
|
|
std::swap(*(m_value.object), other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// swaps the contents
|
|
|
|
inline void swap(string_t& other)
|
|
|
|
{
|
|
|
|
// swap only works for strings
|
|
|
|
if (m_type != value_t::string)
|
|
|
|
{
|
|
|
|
throw std::runtime_error("cannot use swap with " + type_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
// swap arrays
|
|
|
|
std::swap(*(m_value.string), other);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////
|
|
|
|
// lexicographical comparison operators //
|
|
|
|
//////////////////////////////////////////
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief comparison: equal
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (lhs.type())
|
|
|
|
{
|
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::array)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.array == *rhs.m_value.array;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::object)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.object == *rhs.m_value.object;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::string)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.string == *rhs.m_value.string;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::boolean)
|
|
|
|
{
|
|
|
|
return lhs.m_value.boolean == rhs.m_value.boolean;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::number_integer)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_integer == rhs.m_value.number_integer;
|
|
|
|
}
|
|
|
|
if (rhs.type() == value_t::number_float)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_float);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::number_integer)
|
|
|
|
{
|
2015-03-23 23:03:48 +01:00
|
|
|
return approx(lhs.m_value.number_float, static_cast<number_float_t>(rhs.m_value.number_integer));
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
if (rhs.type() == value_t::number_float)
|
|
|
|
{
|
2015-03-23 23:03:48 +01:00
|
|
|
return approx(lhs.m_value.number_float, rhs.m_value.number_float);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief comparison: not equal
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return not (lhs == rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: less than
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (lhs.type())
|
|
|
|
{
|
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::array)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.array < *rhs.m_value.array;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::object)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.object < *rhs.m_value.object;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::null)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::string)
|
|
|
|
{
|
|
|
|
return *lhs.m_value.string < *rhs.m_value.string;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::boolean)
|
|
|
|
{
|
|
|
|
return lhs.m_value.boolean < rhs.m_value.boolean;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::number_integer)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_integer < rhs.m_value.number_integer;
|
|
|
|
}
|
|
|
|
if (rhs.type() == value_t::number_float)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_float);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
|
|
|
if (rhs.type() == value_t::number_integer)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
|
|
|
|
}
|
|
|
|
if (rhs.type() == value_t::number_float)
|
|
|
|
{
|
|
|
|
return lhs.m_value.number_float < rhs.m_value.number_float;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
// We only reach this line if we cannot compare values. In that case,
|
|
|
|
// we compare types.
|
|
|
|
return lhs.type() < rhs.type();
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: less than or equal
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return not (rhs < lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return not (lhs <= rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than or equal
|
2015-02-24 23:19:19 +01:00
|
|
|
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return not (lhs < rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////
|
|
|
|
// serialization //
|
|
|
|
///////////////////
|
|
|
|
|
|
|
|
/// serialize to stream
|
|
|
|
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
|
|
|
|
{
|
2015-02-10 19:50:26 +01:00
|
|
|
// read width member and use it as indentation parameter if nonzero
|
|
|
|
const int indentation = (o.width() == 0) ? -1 : o.width();
|
|
|
|
|
|
|
|
o << j.dump(indentation);
|
2015-02-05 22:45:33 +01:00
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// serialize to stream
|
|
|
|
friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
|
|
|
|
{
|
2015-02-10 19:50:26 +01:00
|
|
|
// read width member and use it as indentation parameter if nonzero
|
|
|
|
const int indentation = (o.width() == 0) ? -1 : o.width();
|
|
|
|
|
|
|
|
o << j.dump(indentation);
|
2015-02-05 22:45:33 +01:00
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////
|
|
|
|
// deserialization //
|
|
|
|
/////////////////////
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// deserialize from string
|
2015-02-15 14:52:00 +01:00
|
|
|
static basic_json parse(const string_t& s)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return parser(s).parse();
|
|
|
|
}
|
|
|
|
|
2015-03-24 18:05:58 +01:00
|
|
|
/// deserialize from stream
|
|
|
|
static basic_json parse(std::istream& i)
|
|
|
|
{
|
|
|
|
return parser(i).parse();
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// deserialize from stream
|
|
|
|
friend std::istream& operator>>(std::istream& i, basic_json& j)
|
|
|
|
{
|
|
|
|
j = parser(i).parse();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// deserialize from stream
|
|
|
|
friend std::istream& operator<<(basic_json& j, std::istream& i)
|
|
|
|
{
|
|
|
|
j = parser(i).parse();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
///////////////////////////
|
|
|
|
// convenience functions //
|
|
|
|
///////////////////////////
|
|
|
|
|
|
|
|
/// return the type as string
|
|
|
|
inline string_t type_name() const noexcept
|
|
|
|
{
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::null):
|
|
|
|
{
|
|
|
|
return "null";
|
|
|
|
}
|
2015-02-10 19:50:26 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
return "object";
|
|
|
|
}
|
2015-02-10 19:50:26 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
return "array";
|
|
|
|
}
|
2015-02-10 19:50:26 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
return "string";
|
|
|
|
}
|
2015-02-10 19:50:26 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
return "boolean";
|
|
|
|
}
|
2015-02-10 19:50:26 +01:00
|
|
|
|
|
|
|
default:
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return "number";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief escape a string
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
Escape a string by replacing certain special characters by a sequence of an
|
|
|
|
escape character (backslash) and another character and other control
|
|
|
|
characters by a sequence of "\u" followed by a four-digit hex
|
|
|
|
representation.
|
|
|
|
|
|
|
|
@param s the string to escape
|
|
|
|
@return escaped string
|
|
|
|
*/
|
|
|
|
static string_t escape_string(const string_t& s) noexcept
|
|
|
|
{
|
|
|
|
// create a result string of at least the size than s
|
|
|
|
string_t result;
|
|
|
|
result.reserve(s.size());
|
|
|
|
|
|
|
|
for (const auto c : s)
|
|
|
|
{
|
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
// quotation mark (0x22)
|
|
|
|
case '"':
|
|
|
|
{
|
|
|
|
result += "\\\"";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// reverse solidus (0x5c)
|
|
|
|
case '\\':
|
|
|
|
{
|
|
|
|
result += "\\\\";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// backspace (0x08)
|
|
|
|
case '\b':
|
|
|
|
{
|
|
|
|
result += "\\b";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// formfeed (0x0c)
|
|
|
|
case '\f':
|
|
|
|
{
|
|
|
|
result += "\\f";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// newline (0x0a)
|
|
|
|
case '\n':
|
|
|
|
{
|
|
|
|
result += "\\n";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// carriage return (0x0d)
|
|
|
|
case '\r':
|
|
|
|
{
|
|
|
|
result += "\\r";
|
|
|
|
break;
|
|
|
|
}
|
2015-02-24 23:19:19 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// horizontal tab (0x09)
|
|
|
|
case '\t':
|
|
|
|
{
|
|
|
|
result += "\\t";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-15 18:43:17 +01:00
|
|
|
if (c >= 0 and c <= 0x1f)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
// control characters (everything between 0x00 and 0x1f)
|
|
|
|
// -> create four-digit hex representation
|
|
|
|
std::stringstream ss;
|
|
|
|
ss << "\\u" << std::hex << std::setw(4) << std::setfill('0') << int(c);
|
|
|
|
result += ss.str();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// all other characters are added as-is
|
|
|
|
result.append(1, c);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
@brief internal implementation of the serialization function
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
This function is called by the public member function dump and organizes
|
|
|
|
the serializaion internally. The indentation level is propagated as
|
|
|
|
additional parameter. In case of arrays and objects, the function is called
|
|
|
|
recursively. Note that
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
- strings and object keys are escaped using escape_string()
|
2015-03-23 20:27:30 +01:00
|
|
|
- integer numbers are converted to a string before output using
|
|
|
|
std::to_string()
|
2015-02-28 18:11:46 +01:00
|
|
|
- floating-point numbers are converted to a string using "%g" format
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
@param prettyPrint whether the output shall be pretty-printed
|
|
|
|
@param indentStep the indent level
|
|
|
|
@param currentIndent the current indent level (only used internally)
|
|
|
|
*/
|
|
|
|
inline string_t dump(const bool prettyPrint, const unsigned int indentStep,
|
2015-02-15 14:52:00 +01:00
|
|
|
const unsigned int currentIndent = 0) const noexcept
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
// variable to hold indentation for recursive calls
|
|
|
|
auto new_indent = currentIndent;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
// helper function to return whitespace as indentation
|
2015-02-13 21:46:33 +01:00
|
|
|
const auto indent = [prettyPrint, &new_indent]()
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
return prettyPrint ? string_t(new_indent, ' ') : string_t();
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
switch (m_type)
|
|
|
|
{
|
|
|
|
case (value_t::object):
|
|
|
|
{
|
|
|
|
if (m_value.object->empty())
|
|
|
|
{
|
|
|
|
return "{}";
|
|
|
|
}
|
|
|
|
|
|
|
|
string_t result = "{";
|
|
|
|
|
|
|
|
// increase indentation
|
|
|
|
if (prettyPrint)
|
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
new_indent += indentStep;
|
2015-02-05 22:45:33 +01:00
|
|
|
result += "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
|
|
|
|
{
|
|
|
|
if (i != m_value.object->cbegin())
|
|
|
|
{
|
|
|
|
result += prettyPrint ? ",\n" : ",";
|
|
|
|
}
|
|
|
|
result += indent() + "\"" + escape_string(i->first) + "\":" + (prettyPrint ? " " : "")
|
2015-02-13 21:46:33 +01:00
|
|
|
+ i->second.dump(prettyPrint, indentStep, new_indent);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// decrease indentation
|
|
|
|
if (prettyPrint)
|
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
new_indent -= indentStep;
|
2015-02-05 22:45:33 +01:00
|
|
|
result += "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
return result + indent() + "}";
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::array):
|
|
|
|
{
|
|
|
|
if (m_value.array->empty())
|
|
|
|
{
|
|
|
|
return "[]";
|
|
|
|
}
|
|
|
|
|
|
|
|
string_t result = "[";
|
|
|
|
|
|
|
|
// increase indentation
|
|
|
|
if (prettyPrint)
|
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
new_indent += indentStep;
|
2015-02-05 22:45:33 +01:00
|
|
|
result += "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
|
|
|
|
{
|
|
|
|
if (i != m_value.array->cbegin())
|
|
|
|
{
|
|
|
|
result += prettyPrint ? ",\n" : ",";
|
|
|
|
}
|
2015-02-13 21:46:33 +01:00
|
|
|
result += indent() + i->dump(prettyPrint, indentStep, new_indent);
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// decrease indentation
|
|
|
|
if (prettyPrint)
|
|
|
|
{
|
2015-02-13 21:46:33 +01:00
|
|
|
new_indent -= indentStep;
|
2015-02-05 22:45:33 +01:00
|
|
|
result += "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
return result + indent() + "]";
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::string):
|
|
|
|
{
|
|
|
|
return string_t("\"") + escape_string(*m_value.string) + "\"";
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::boolean):
|
|
|
|
{
|
|
|
|
return m_value.boolean ? "true" : "false";
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::number_integer):
|
|
|
|
{
|
|
|
|
return std::to_string(m_value.number_integer);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (value_t::number_float):
|
|
|
|
{
|
2015-03-23 20:27:30 +01:00
|
|
|
// 15 digits of precision allows round-trip IEEE 754
|
|
|
|
// string->double->string
|
|
|
|
const auto sz = static_cast<unsigned int>(std::snprintf(nullptr, 0, "%.15g", m_value.number_float));
|
2015-02-28 18:11:46 +01:00
|
|
|
std::vector<char> buf(sz + 1);
|
|
|
|
std::snprintf(&buf[0], buf.size(), "%.15g", m_value.number_float);
|
2015-03-23 20:27:30 +01:00
|
|
|
return string_t(buf.data());
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
2015-02-10 20:28:16 +01:00
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return "null";
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-23 23:03:48 +01:00
|
|
|
/// "equality" comparison for floating point numbers
|
|
|
|
template<typename T>
|
|
|
|
inline static bool approx(const T a, const T b)
|
|
|
|
{
|
|
|
|
return not (a > b or a < b);
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
private:
|
|
|
|
//////////////////////
|
|
|
|
// member variables //
|
|
|
|
//////////////////////
|
|
|
|
|
|
|
|
/// the type of the current element
|
|
|
|
value_t m_type = value_t::null;
|
|
|
|
|
|
|
|
/// whether the type of JSON object may change later
|
|
|
|
bool m_final = false;
|
|
|
|
|
|
|
|
/// the value of the current element
|
|
|
|
json_value m_value = {};
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-09 18:02:31 +01:00
|
|
|
private:
|
2015-02-05 22:45:33 +01:00
|
|
|
///////////////
|
|
|
|
// iterators //
|
|
|
|
///////////////
|
|
|
|
|
2015-02-09 18:02:31 +01:00
|
|
|
/// an iterator value
|
2015-02-15 14:52:00 +01:00
|
|
|
template<typename array_iterator_t, typename object_iterator_t>
|
2015-02-09 18:02:31 +01:00
|
|
|
union internal_iterator
|
|
|
|
{
|
|
|
|
/// iterator for JSON objects
|
2015-02-15 14:52:00 +01:00
|
|
|
object_iterator_t object_iterator;
|
2015-02-09 18:02:31 +01:00
|
|
|
/// iterator for JSON arrays
|
2015-02-15 14:52:00 +01:00
|
|
|
array_iterator_t array_iterator;
|
2015-02-09 18:02:31 +01:00
|
|
|
/// generic iteraotr for all other value types
|
2015-02-22 17:52:27 +01:00
|
|
|
difference_type generic_iterator;
|
2015-02-09 18:02:31 +01:00
|
|
|
|
|
|
|
/// default constructor
|
2015-02-22 17:52:27 +01:00
|
|
|
internal_iterator() : generic_iterator(-1) {}
|
2015-02-09 18:02:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
public:
|
2015-02-22 17:52:27 +01:00
|
|
|
/// a random access iterator for the basic_json class
|
|
|
|
class iterator : public std::iterator<std::random_access_iterator_tag, basic_json>
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-03-22 19:18:21 +01:00
|
|
|
// allow basic_json class to access m_it
|
|
|
|
friend class basic_json;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
public:
|
|
|
|
/// the type of the values when the iterator is dereferenced
|
|
|
|
using value_type = basic_json::value_type;
|
|
|
|
/// a type to represent differences between iterators
|
|
|
|
using difference_type = basic_json::difference_type;
|
|
|
|
/// defines a pointer to the type iterated over (value_type)
|
|
|
|
using pointer = basic_json::pointer;
|
|
|
|
/// defines a reference to the type iterated over (value_type)
|
|
|
|
using reference = basic_json::reference;
|
|
|
|
/// the category of the iterator
|
|
|
|
using iterator_category = std::bidirectional_iterator_tag;
|
|
|
|
|
2015-02-15 15:16:11 +01:00
|
|
|
/// default constructor
|
|
|
|
inline iterator() = default;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// constructor for a given JSON instance
|
2015-02-24 23:19:19 +01:00
|
|
|
inline iterator(pointer object) noexcept : m_object(object)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = typename object_t::iterator();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = typename array_t::iterator();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = -1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-22 17:50:43 +01:00
|
|
|
/// copy constructor
|
|
|
|
inline iterator(const iterator& other) noexcept
|
|
|
|
: m_object(other.m_object), m_it(other.m_it)
|
|
|
|
{}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// copy assignment
|
2015-03-22 17:50:43 +01:00
|
|
|
inline iterator& operator=(iterator other) noexcept (
|
|
|
|
std::is_nothrow_move_constructible<pointer>::value and
|
|
|
|
std::is_nothrow_move_assignable<pointer>::value and
|
|
|
|
std::is_nothrow_move_constructible<internal_iterator<typename array_t::iterator, typename object_t::iterator>>::value
|
|
|
|
and
|
|
|
|
std::is_nothrow_move_assignable<internal_iterator<typename array_t::iterator, typename object_t::iterator>>::value
|
|
|
|
)
|
|
|
|
{
|
|
|
|
std::swap(m_object, other.m_object);
|
|
|
|
std::swap(m_it, other.m_it);
|
2015-02-05 22:45:33 +01:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-03-24 19:08:03 +01:00
|
|
|
private:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// set the iterator to the first value
|
|
|
|
inline void set_begin() noexcept
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = m_object->m_value.object->begin();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = m_object->m_value.array->begin();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
2015-02-07 15:57:47 +01:00
|
|
|
// set to end so begin()==end() is true: null is empty
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 0;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// set the iterator past the last value
|
|
|
|
inline void set_end() noexcept
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = m_object->m_value.object->end();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = m_object->m_value.array->end();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-24 19:08:03 +01:00
|
|
|
public:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// return a reference to the value pointed to by the iterator
|
2015-02-22 17:52:27 +01:00
|
|
|
inline reference operator*()
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return m_it.object_iterator->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return *m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
if (m_it.generic_iterator == 0)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return *m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// dereference the iterator
|
2015-02-22 17:52:27 +01:00
|
|
|
inline pointer operator->()
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return &(m_it.object_iterator->second);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return &*m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
if (m_it.generic_iterator == 0)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-increment (it++)
|
|
|
|
inline iterator operator++(int)
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
auto result = *this;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator++;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-increment (++it)
|
|
|
|
inline iterator& operator++()
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
++m_it.object_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
++m_it.array_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
++m_it.generic_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-decrement (it--)
|
|
|
|
inline iterator operator--(int)
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
auto result = *this;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator--;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-decrement (--it)
|
|
|
|
inline iterator& operator--()
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
--m_it.object_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
--m_it.array_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
--m_it.generic_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: equal
|
|
|
|
inline bool operator==(const iterator& other) const
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
// if objects are not the same, the comparison is undefined
|
|
|
|
if (m_object != other.m_object)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
throw std::domain_error("cannot compare iterators of different containers");
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return (m_it.object_iterator == other.m_it.object_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return (m_it.array_iterator == other.m_it.array_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return (m_it.generic_iterator == other.m_it.generic_iterator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: not equal
|
|
|
|
inline bool operator!=(const iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator==(other);
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/// comparison: smaller
|
|
|
|
inline bool operator<(const iterator& other) const
|
|
|
|
{
|
|
|
|
// if objects are not the same, the comparison is undefined
|
|
|
|
if (m_object != other.m_object)
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot compare iterators of different containers");
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator< for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return (m_it.array_iterator < other.m_it.array_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return (m_it.generic_iterator < other.m_it.generic_iterator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: less than or equal
|
|
|
|
inline bool operator<=(const iterator& other) const
|
|
|
|
{
|
|
|
|
return not other.operator < (*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than
|
|
|
|
inline bool operator>(const iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator<=(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than or equal
|
|
|
|
inline bool operator>=(const iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator<(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add to iterator
|
|
|
|
inline iterator& operator+=(difference_type i)
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator+= for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator += i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
m_it.generic_iterator += i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// subtract from iterator
|
|
|
|
inline iterator& operator-=(difference_type i)
|
|
|
|
{
|
|
|
|
return operator+=(-i);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add to iterator
|
|
|
|
inline iterator operator+(difference_type i)
|
|
|
|
{
|
|
|
|
auto result = *this;
|
|
|
|
result += i;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// subtract from iterator
|
|
|
|
inline iterator operator-(difference_type i)
|
|
|
|
{
|
|
|
|
auto result = *this;
|
|
|
|
result -= i;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// return difference
|
|
|
|
inline difference_type operator-(const iterator& other) const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator- for object iterators");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return m_it.array_iterator - other.m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return m_it.generic_iterator - other.m_it.generic_iterator;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access to successor
|
|
|
|
inline reference operator[](difference_type n)
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator[] for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return *(m_it.array_iterator + n);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
if (m_it.generic_iterator == -n)
|
|
|
|
{
|
|
|
|
return *m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-26 17:06:33 +01:00
|
|
|
/// return the key of an object iterator
|
2015-03-24 19:08:03 +01:00
|
|
|
inline typename object_t::key_type key() const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return m_it.object_iterator->first;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use key() for non-object iterators");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-26 17:06:33 +01:00
|
|
|
/// return the key of an iterator
|
2015-03-24 19:08:03 +01:00
|
|
|
inline reference value()
|
|
|
|
{
|
|
|
|
return operator*();
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
private:
|
|
|
|
/// associated JSON instance
|
|
|
|
pointer m_object = nullptr;
|
|
|
|
/// the actual iterator of the associated instance
|
2015-02-15 14:52:00 +01:00
|
|
|
internal_iterator<typename array_t::iterator, typename object_t::iterator> m_it;
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/// a const random access iterator for the basic_json class
|
|
|
|
class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-03-22 19:18:21 +01:00
|
|
|
// allow basic_json class to access m_it
|
|
|
|
friend class basic_json;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
public:
|
|
|
|
/// the type of the values when the iterator is dereferenced
|
|
|
|
using value_type = basic_json::value_type;
|
|
|
|
/// a type to represent differences between iterators
|
|
|
|
using difference_type = basic_json::difference_type;
|
|
|
|
/// defines a pointer to the type iterated over (value_type)
|
|
|
|
using pointer = basic_json::const_pointer;
|
|
|
|
/// defines a reference to the type iterated over (value_type)
|
|
|
|
using reference = basic_json::const_reference;
|
|
|
|
/// the category of the iterator
|
|
|
|
using iterator_category = std::bidirectional_iterator_tag;
|
|
|
|
|
2015-02-15 15:16:11 +01:00
|
|
|
/// default constructor
|
|
|
|
inline const_iterator() = default;
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// constructor for a given JSON instance
|
2015-02-24 23:19:19 +01:00
|
|
|
inline const_iterator(pointer object) noexcept : m_object(object)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = typename object_t::const_iterator();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = typename array_t::const_iterator();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = -1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
/// copy constructor given a nonconst iterator
|
2015-02-24 23:19:19 +01:00
|
|
|
inline const_iterator(const iterator& other) noexcept : m_object(other.m_object)
|
2015-02-09 18:02:31 +01:00
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = other.m_it.object_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = other.m_it.array_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
m_it.generic_iterator = other.m_it.generic_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-05 22:45:33 +01:00
|
|
|
|
2015-03-22 17:50:43 +01:00
|
|
|
/// copy constructor
|
|
|
|
inline const_iterator(const const_iterator& other) noexcept
|
|
|
|
: m_object(other.m_object), m_it(other.m_it)
|
|
|
|
{}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
/// copy assignment
|
2015-03-22 17:50:43 +01:00
|
|
|
inline const_iterator& operator=(const_iterator other) noexcept(
|
|
|
|
std::is_nothrow_move_constructible<pointer>::value and
|
|
|
|
std::is_nothrow_move_assignable<pointer>::value and
|
|
|
|
std::is_nothrow_move_constructible<internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator>>::value
|
|
|
|
and
|
|
|
|
std::is_nothrow_move_assignable<internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator>>::value
|
|
|
|
)
|
|
|
|
{
|
|
|
|
std::swap(m_object, other.m_object);
|
|
|
|
std::swap(m_it, other.m_it);
|
2015-02-05 22:45:33 +01:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-03-24 19:08:03 +01:00
|
|
|
private:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// set the iterator to the first value
|
|
|
|
inline void set_begin() noexcept
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = m_object->m_value.object->cbegin();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = m_object->m_value.array->cbegin();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
2015-02-07 15:57:47 +01:00
|
|
|
// set to end so begin()==end() is true: null is empty
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 0;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// set the iterator past the last value
|
|
|
|
inline void set_end() noexcept
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator = m_object->m_value.object->cend();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator = m_object->m_value.array->cend();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator = 1;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-24 19:08:03 +01:00
|
|
|
public:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// return a reference to the value pointed to by the iterator
|
|
|
|
inline reference operator*() const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return m_it.object_iterator->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return *m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
if (m_it.generic_iterator == 0)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return *m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// dereference the iterator
|
|
|
|
inline pointer operator->() const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return &(m_it.object_iterator->second);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return &*m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
if (m_it.generic_iterator == 0)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
return m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-increment (it++)
|
|
|
|
inline const_iterator operator++(int)
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
auto result = *this;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator++;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-increment (++it)
|
|
|
|
inline const_iterator& operator++()
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
++m_it.object_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
++m_it.array_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
++m_it.generic_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-decrement (it--)
|
|
|
|
inline const_iterator operator--(int)
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
auto result = *this;
|
2015-02-05 22:45:33 +01:00
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
m_it.object_iterator--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
m_it.generic_iterator--;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-decrement (--it)
|
|
|
|
inline const_iterator& operator--()
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
--m_it.object_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
--m_it.array_iterator;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
--m_it.generic_iterator;
|
2015-02-05 22:45:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: equal
|
|
|
|
inline bool operator==(const const_iterator& other) const
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
// if objects are not the same, the comparison is undefined
|
|
|
|
if (m_object != other.m_object)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
throw std::domain_error("cannot compare iterators of different containers");
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return (m_it.object_iterator == other.m_it.object_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return (m_it.array_iterator == other.m_it.array_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return (m_it.generic_iterator == other.m_it.generic_iterator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: not equal
|
|
|
|
inline bool operator!=(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator==(other);
|
|
|
|
}
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/// comparison: smaller
|
|
|
|
inline bool operator<(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
// if objects are not the same, the comparison is undefined
|
|
|
|
if (m_object != other.m_object)
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot compare iterators of different containers");
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator< for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return (m_it.array_iterator < other.m_it.array_iterator);
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return (m_it.generic_iterator < other.m_it.generic_iterator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: less than or equal
|
|
|
|
inline bool operator<=(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
return not other.operator < (*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than
|
|
|
|
inline bool operator>(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator<=(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// comparison: greater than or equal
|
|
|
|
inline bool operator>=(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
return not operator<(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add to iterator
|
|
|
|
inline const_iterator& operator+=(difference_type i)
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator+= for object iterators");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
m_it.array_iterator += i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
m_it.generic_iterator += i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// subtract from iterator
|
|
|
|
inline const_iterator& operator-=(difference_type i)
|
|
|
|
{
|
|
|
|
return operator+=(-i);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// add to iterator
|
|
|
|
inline const_iterator operator+(difference_type i)
|
|
|
|
{
|
|
|
|
auto result = *this;
|
|
|
|
result += i;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// subtract from iterator
|
|
|
|
inline const_iterator operator-(difference_type i)
|
|
|
|
{
|
|
|
|
auto result = *this;
|
|
|
|
result -= i;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// return difference
|
|
|
|
inline difference_type operator-(const const_iterator& other) const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator- for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return m_it.array_iterator - other.m_it.array_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return m_it.generic_iterator - other.m_it.generic_iterator;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// access to successor
|
|
|
|
inline reference operator[](difference_type n) const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use operator[] for object iterators");
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::array):
|
|
|
|
{
|
|
|
|
return *(m_it.array_iterator + n);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (basic_json::value_t::null):
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
if (m_it.generic_iterator == -n)
|
|
|
|
{
|
|
|
|
return *m_object;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::out_of_range("cannot get value");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-26 17:06:33 +01:00
|
|
|
/// return the key of an object iterator
|
2015-03-24 19:08:03 +01:00
|
|
|
inline typename object_t::key_type key() const
|
|
|
|
{
|
|
|
|
switch (m_object->m_type)
|
|
|
|
{
|
|
|
|
case (basic_json::value_t::object):
|
|
|
|
{
|
|
|
|
return m_it.object_iterator->first;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
throw std::domain_error("cannot use key() for non-object iterators");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-26 17:06:33 +01:00
|
|
|
/// return the value of an iterator
|
2015-03-24 19:08:03 +01:00
|
|
|
inline reference value() const
|
|
|
|
{
|
|
|
|
return operator*();
|
|
|
|
}
|
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
private:
|
|
|
|
/// associated JSON instance
|
|
|
|
pointer m_object = nullptr;
|
|
|
|
/// the actual iterator of the associated instance
|
2015-02-15 14:52:00 +01:00
|
|
|
internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator> m_it;
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
|
2015-03-26 17:06:33 +01:00
|
|
|
/// a reverse random access iterator for the basic_json class
|
|
|
|
class reverse_iterator : private std::reverse_iterator<basic_json::iterator>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
inline reverse_iterator(const typename std::reverse_iterator<basic_json::iterator>::iterator_type&
|
|
|
|
it)
|
|
|
|
: std::reverse_iterator<basic_json::iterator>(it) {}
|
|
|
|
|
|
|
|
/// return the key of an object iterator
|
|
|
|
inline typename object_t::key_type key() const
|
|
|
|
{
|
|
|
|
return this->base().key();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// return the value of an iterator
|
|
|
|
inline reference value() const
|
|
|
|
{
|
|
|
|
return this->base().operator * ();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// a const reverse random access iterator for the basic_json class
|
|
|
|
class const_reverse_iterator : private std::reverse_iterator<basic_json::const_iterator>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
inline const_reverse_iterator(const typename
|
|
|
|
std::reverse_iterator<basic_json::const_iterator>::iterator_type& it)
|
|
|
|
: std::reverse_iterator<basic_json::const_iterator>(it) {}
|
|
|
|
|
|
|
|
/// return the key of an object iterator
|
|
|
|
inline typename object_t::key_type key() const
|
|
|
|
{
|
|
|
|
return this->base().key();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// return the value of an iterator
|
|
|
|
inline reference value() const
|
|
|
|
{
|
|
|
|
return this->base().operator * ();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-02-07 15:57:47 +01:00
|
|
|
|
2015-02-05 22:45:33 +01:00
|
|
|
private:
|
2015-02-15 14:52:00 +01:00
|
|
|
//////////////////////
|
|
|
|
// lexer and parser //
|
|
|
|
//////////////////////
|
2015-02-05 22:45:33 +01:00
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/*!
|
|
|
|
@brief lexical analysis
|
|
|
|
|
|
|
|
This class organizes the lexical analysis during JSON deserialization. The
|
|
|
|
core of it is a scanner generated by re2c <http://re2c.org> that processes
|
|
|
|
a buffer and recognizes tokens according to RFC 7159 and ECMA-404.
|
|
|
|
*/
|
2015-02-11 09:10:28 +01:00
|
|
|
class lexer
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-11 09:10:28 +01:00
|
|
|
public:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// token types for the parser
|
|
|
|
enum class token_type
|
|
|
|
{
|
2015-02-15 14:52:00 +01:00
|
|
|
uninitialized, ///< indicating the scanner is uninitialized
|
|
|
|
literal_true, ///< the "true" literal
|
|
|
|
literal_false, ///< the "false" literal
|
|
|
|
literal_null, ///< the "null" literal
|
|
|
|
value_string, ///< a string - use get_string() for actual value
|
|
|
|
value_number, ///< a number - use get_number() for actual value
|
|
|
|
begin_array, ///< the character for array begin "["
|
|
|
|
begin_object, ///< the character for object begin "{"
|
|
|
|
end_array, ///< the character for array end "]"
|
|
|
|
end_object, ///< the character for object end "}"
|
|
|
|
name_separator, ///< the name separator ":"
|
|
|
|
value_separator, ///< the value separator ","
|
|
|
|
parse_error, ///< indicating a parse error
|
|
|
|
end_of_input ///< indicating the end of the input buffer
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
|
2015-02-15 13:35:51 +01:00
|
|
|
/// the char type to use in the lexer
|
2015-02-17 00:22:12 +01:00
|
|
|
using lexer_char_t = unsigned char;
|
2015-02-15 13:35:51 +01:00
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/// constructor with a given buffer
|
|
|
|
inline lexer(const string_t& s) noexcept
|
2015-03-24 18:05:58 +01:00
|
|
|
: m_stream(nullptr), m_buffer(s)
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
2015-03-24 18:05:58 +01:00
|
|
|
m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
|
2015-02-11 09:10:28 +01:00
|
|
|
m_start = m_cursor = m_content;
|
2015-02-15 14:52:00 +01:00
|
|
|
m_limit = m_content + s.size();
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
2015-03-24 18:05:58 +01:00
|
|
|
inline lexer(std::istream* s) noexcept
|
|
|
|
: m_stream(s)
|
|
|
|
{
|
|
|
|
getline(*m_stream, m_buffer);
|
|
|
|
m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
|
|
|
|
m_start = m_cursor = m_content;
|
|
|
|
m_limit = m_content + m_buffer.size();
|
|
|
|
}
|
2015-02-11 09:10:28 +01:00
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/// default constructor
|
2015-02-11 09:10:28 +01:00
|
|
|
inline lexer() = default;
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/*!
|
|
|
|
@brief create a string from a Unicode code point
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
@param codepoint1 the code point (can be high surrogate)
|
|
|
|
@param codepoint2 the code point (can be low surrogate or 0)
|
2015-02-15 14:52:00 +01:00
|
|
|
@return string representation of the code point
|
2015-02-15 16:56:54 +01:00
|
|
|
@exception std::out_of_range if code point is >0x10ffff
|
|
|
|
@exception std::invalid_argument if the low surrogate is invalid
|
2015-02-15 14:52:00 +01:00
|
|
|
|
|
|
|
@see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
|
|
|
|
*/
|
2015-03-22 17:30:48 +01:00
|
|
|
inline static string_t to_unicode(const size_t codepoint1,
|
|
|
|
const size_t codepoint2 = 0)
|
2015-02-15 11:44:49 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
string_t result;
|
2015-02-15 11:44:49 +01:00
|
|
|
|
2015-02-15 16:56:54 +01:00
|
|
|
// calculate the codepoint from the given code points
|
|
|
|
size_t codepoint = codepoint1;
|
|
|
|
if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
|
|
|
|
{
|
|
|
|
if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
|
|
|
|
{
|
|
|
|
codepoint =
|
|
|
|
// high surrogate occupies the most significant 22 bits
|
|
|
|
(codepoint1 << 10)
|
|
|
|
// low surrogate occupies the least significant 15 bits
|
|
|
|
+ codepoint2
|
|
|
|
// there is still the 0xD800, 0xDC00 and 0x10000 noise
|
|
|
|
// in the result so we have to substract with:
|
|
|
|
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
|
|
|
|
- 0x35FDC00;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw std::invalid_argument("missing or wrong low surrogate");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-15 11:44:49 +01:00
|
|
|
if (codepoint <= 0x7f)
|
|
|
|
{
|
2015-03-22 17:30:48 +01:00
|
|
|
// 1-byte characters: 0xxxxxxx (ASCII)
|
2015-02-15 13:35:51 +01:00
|
|
|
result.append(1, static_cast<typename string_t::value_type>(codepoint));
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
else if (codepoint <= 0x7ff)
|
|
|
|
{
|
|
|
|
// 2-byte characters: 110xxxxx 10xxxxxx
|
2015-02-15 13:35:51 +01:00
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
else if (codepoint <= 0xffff)
|
|
|
|
{
|
|
|
|
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
|
2015-02-15 13:35:51 +01:00
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
else if (codepoint <= 0x10ffff)
|
|
|
|
{
|
|
|
|
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
2015-02-15 13:35:51 +01:00
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
|
|
|
|
result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
throw std::out_of_range("code points above 0x10FFFF are invalid");
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/// return name of values of type token_type
|
|
|
|
inline static std::string token_type_name(token_type t) noexcept
|
2015-02-11 10:16:43 +01:00
|
|
|
{
|
|
|
|
switch (t)
|
|
|
|
{
|
|
|
|
case (token_type::uninitialized):
|
|
|
|
return "<uninitialized>";
|
|
|
|
case (token_type::literal_true):
|
|
|
|
return "true literal";
|
|
|
|
case (token_type::literal_false):
|
|
|
|
return "false literal";
|
|
|
|
case (token_type::literal_null):
|
|
|
|
return "null literal";
|
|
|
|
case (token_type::value_string):
|
|
|
|
return "string literal";
|
|
|
|
case (token_type::value_number):
|
|
|
|
return "number literal";
|
|
|
|
case (token_type::begin_array):
|
|
|
|
return "[";
|
|
|
|
case (token_type::begin_object):
|
|
|
|
return "{";
|
|
|
|
case (token_type::end_array):
|
|
|
|
return "]";
|
|
|
|
case (token_type::end_object):
|
|
|
|
return "}";
|
|
|
|
case (token_type::name_separator):
|
|
|
|
return ":";
|
|
|
|
case (token_type::value_separator):
|
|
|
|
return ",";
|
|
|
|
case (token_type::end_of_input):
|
|
|
|
return "<end of input>";
|
2015-02-11 10:57:17 +01:00
|
|
|
default:
|
|
|
|
return "<parse error>";
|
2015-02-11 10:16:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-11 09:41:23 +01:00
|
|
|
/*!
|
|
|
|
This function implements a scanner for JSON. It is specified using
|
|
|
|
regular expressions that try to follow RFC 7159 and ECMA-404 as close
|
|
|
|
as possible. These regular expressions are then translated into a
|
2015-02-15 14:52:00 +01:00
|
|
|
deterministic finite automaton (DFA) by the tool re2c
|
|
|
|
<http://re2c.org>. As a result, the translated code for this function
|
|
|
|
consists of a large block of code with goto jumps.
|
2015-02-11 09:41:23 +01:00
|
|
|
|
|
|
|
@return the class of the next token read from the buffer
|
|
|
|
*/
|
2015-02-15 14:52:00 +01:00
|
|
|
inline token_type scan() noexcept
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
2015-02-11 10:16:43 +01:00
|
|
|
// pointer for backtracking information
|
2015-03-24 18:05:58 +01:00
|
|
|
m_marker = nullptr;
|
2015-02-15 13:35:51 +01:00
|
|
|
|
|
|
|
// remember the begin of the token
|
|
|
|
m_start = m_cursor;
|
|
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
lexer_char_t yych;
|
|
|
|
unsigned int yyaccept = 0;
|
|
|
|
static const unsigned char yybm[] =
|
|
|
|
{
|
|
|
|
0, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 96, 96, 64, 64, 96, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
96, 64, 0, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
192, 192, 192, 192, 192, 192, 192, 192,
|
|
|
|
192, 192, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 0, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64,
|
|
|
|
};
|
|
|
|
|
2015-03-24 18:05:58 +01:00
|
|
|
if ((m_limit - m_cursor) < 5)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '9')
|
|
|
|
{
|
|
|
|
if (yych <= ' ')
|
|
|
|
{
|
|
|
|
if (yych <= '\n')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 0x00)
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_27;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 0x08)
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_29;
|
|
|
|
}
|
|
|
|
if (yych >= '\n')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_4;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == '\r')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_2;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 0x1F)
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_29;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= ',')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == '"')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_26;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '+')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_29;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_14;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '-')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_22;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_29;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '0')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_23;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_25;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'm')
|
|
|
|
{
|
|
|
|
if (yych <= '\\')
|
|
|
|
{
|
|
|
|
if (yych <= ':')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_16;
|
|
|
|
}
|
|
|
|
if (yych == '[')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_6;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_29;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= ']')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_8;
|
|
|
|
}
|
|
|
|
if (yych == 'f')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_21;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_29;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-02-14 17:34:06 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 'z')
|
|
|
|
{
|
|
|
|
if (yych <= 'n')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_18;
|
|
|
|
}
|
|
|
|
if (yych == 't')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_20;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_29;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= '{')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_10;
|
|
|
|
}
|
|
|
|
if (yych == '}')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_12;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_29;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
basic_json_parser_2:
|
|
|
|
++m_cursor;
|
|
|
|
yych = *m_cursor;
|
|
|
|
goto basic_json_parser_5;
|
|
|
|
basic_json_parser_3:
|
|
|
|
{
|
|
|
|
return scan();
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_4:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_5:
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yybm[0 + yych] & 32)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_4;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_3;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_6:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::begin_array;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_8:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::end_array;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_10:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::begin_object;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_12:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::end_object;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_14:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::value_separator;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_16:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::name_separator;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_18:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 0;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych == 'u')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_59;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_19:
|
2015-02-15 13:35:51 +01:00
|
|
|
{
|
|
|
|
return token_type::parse_error;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_20:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 0;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych == 'r')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_55;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_19;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_21:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 0;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych == 'a')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_50;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_19;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_22:
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych <= '/')
|
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_19;
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
if (yych <= '0')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_49;
|
|
|
|
}
|
|
|
|
if (yych <= '9')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_40;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_19;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_23:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 1;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych <= 'D')
|
|
|
|
{
|
|
|
|
if (yych == '.')
|
2015-02-14 17:34:06 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_42;
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'E')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == 'e')
|
2015-02-14 17:34:06 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
basic_json_parser_24:
|
|
|
|
{
|
|
|
|
return token_type::value_number;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_25:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 1;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
goto basic_json_parser_41;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_26:
|
2015-02-15 13:35:51 +01:00
|
|
|
yyaccept = 0;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych <= 0x00)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_19;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_31;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_27:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::end_of_input;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_29:
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *++m_cursor;
|
|
|
|
goto basic_json_parser_19;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_30:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_31:
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yybm[0 + yych] & 64)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_30;
|
|
|
|
}
|
|
|
|
if (yych <= 0x00)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
if (yych <= '"')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_34;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_33;
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_32:
|
2015-02-15 13:35:51 +01:00
|
|
|
m_cursor = m_marker;
|
|
|
|
if (yyaccept == 0)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_19;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
basic_json_parser_33:
|
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= 'e')
|
|
|
|
{
|
|
|
|
if (yych <= '/')
|
2015-02-14 17:34:06 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == '"')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_30;
|
|
|
|
}
|
|
|
|
if (yych <= '.')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_30;
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '\\')
|
2015-02-14 17:34:06 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '[')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == 'b')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'q')
|
|
|
|
{
|
|
|
|
if (yych <= 'f')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_30;
|
|
|
|
}
|
|
|
|
if (yych == 'n')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 's')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 'r')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 't')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 'u')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_36;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_34:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::value_string;
|
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
basic_json_parser_36:
|
2015-02-15 13:35:51 +01:00
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '@')
|
|
|
|
{
|
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= ':')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'F')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_37;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '`')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= 'g')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
basic_json_parser_37:
|
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '@')
|
|
|
|
{
|
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= ':')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'F')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_38;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '`')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= 'g')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
basic_json_parser_38:
|
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '@')
|
|
|
|
{
|
2015-02-14 16:47:14 +01:00
|
|
|
if (yych <= '/')
|
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= ':')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'F')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_39;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '`')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych >= 'g')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
basic_json_parser_39:
|
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '@')
|
|
|
|
{
|
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '9')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'F')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '`')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= 'f')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_30;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
basic_json_parser_40:
|
|
|
|
yyaccept = 1;
|
|
|
|
m_marker = ++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if ((m_limit - m_cursor) < 3)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
basic_json_parser_41:
|
|
|
|
if (yybm[0 + yych] & 128)
|
|
|
|
{
|
|
|
|
goto basic_json_parser_40;
|
|
|
|
}
|
|
|
|
if (yych <= 'D')
|
|
|
|
{
|
|
|
|
if (yych != '.')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_24;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'E')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == 'e')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
basic_json_parser_42:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych <= '/')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
if (yych <= '9')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_47;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
basic_json_parser_43:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych <= ',')
|
|
|
|
{
|
|
|
|
if (yych != '+')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= '-')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_44;
|
|
|
|
}
|
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-14 17:34:06 +01:00
|
|
|
goto basic_json_parser_32;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '9')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_45;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
basic_json_parser_44:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych <= '/')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
if (yych >= ':')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
basic_json_parser_45:
|
|
|
|
++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if (m_limit <= m_cursor)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= '/')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
if (yych <= '9')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_45;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_24;
|
|
|
|
basic_json_parser_47:
|
|
|
|
yyaccept = 1;
|
|
|
|
m_marker = ++m_cursor;
|
2015-03-24 18:05:58 +01:00
|
|
|
if ((m_limit - m_cursor) < 3)
|
|
|
|
{
|
|
|
|
yyfill();
|
|
|
|
};
|
2015-02-15 13:35:51 +01:00
|
|
|
yych = *m_cursor;
|
|
|
|
if (yych <= 'D')
|
|
|
|
{
|
|
|
|
if (yych <= '/')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_24;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych <= '9')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_47;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'E')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == 'e')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
|
|
|
}
|
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
basic_json_parser_49:
|
|
|
|
yyaccept = 1;
|
|
|
|
yych = *(m_marker = ++m_cursor);
|
|
|
|
if (yych <= 'D')
|
|
|
|
{
|
|
|
|
if (yych == '.')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_42;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (yych <= 'E')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
if (yych == 'e')
|
2015-02-14 16:47:14 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_43;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
goto basic_json_parser_24;
|
|
|
|
}
|
|
|
|
basic_json_parser_50:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'l')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 's')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'e')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::literal_false;
|
|
|
|
}
|
|
|
|
basic_json_parser_55:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'u')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'e')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::literal_true;
|
|
|
|
}
|
|
|
|
basic_json_parser_59:
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'l')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
yych = *++m_cursor;
|
|
|
|
if (yych != 'l')
|
|
|
|
{
|
|
|
|
goto basic_json_parser_32;
|
|
|
|
}
|
|
|
|
++m_cursor;
|
|
|
|
{
|
|
|
|
return token_type::literal_null;
|
2015-02-14 16:47:14 +01:00
|
|
|
}
|
2015-02-14 17:34:06 +01:00
|
|
|
}
|
2015-02-15 13:35:51 +01:00
|
|
|
|
2015-03-24 18:05:58 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/// append data from the stream to the internal buffer
|
|
|
|
inline void yyfill() noexcept
|
|
|
|
{
|
|
|
|
if (not m_stream or not * m_stream)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ssize_t offset_start = m_start - m_content;
|
|
|
|
const ssize_t offset_marker = m_marker - m_start;
|
|
|
|
const ssize_t offset_cursor = m_cursor - m_start;
|
|
|
|
|
|
|
|
m_buffer.erase(0, static_cast<size_t>(offset_start));
|
|
|
|
std::string line;
|
|
|
|
std::getline(*m_stream, line);
|
|
|
|
m_buffer += line;
|
|
|
|
|
|
|
|
m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
|
|
|
|
m_start = m_content;
|
|
|
|
m_marker = m_start + offset_marker;
|
|
|
|
m_cursor = m_start + offset_cursor;
|
|
|
|
m_limit = m_start + m_buffer.size() - 1;
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/// return string representation of last read token
|
|
|
|
inline string_t get_token() const noexcept
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
2015-02-17 00:22:12 +01:00
|
|
|
return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
|
|
|
|
static_cast<size_t>(m_cursor - m_start));
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
2015-02-15 14:52:00 +01:00
|
|
|
@brief return string value for string tokens
|
|
|
|
|
|
|
|
The function iterates the characters between the opening and closing
|
|
|
|
quotes of the string value. The complete string is the range
|
|
|
|
[m_start,m_cursor). Consequently, we iterate from m_start+1 to
|
|
|
|
m_cursor-1.
|
|
|
|
|
|
|
|
We differentiate two cases:
|
|
|
|
|
|
|
|
1. Escaped characters. In this case, a new character is constructed
|
|
|
|
according to the nature of the escape. Some escapes create new
|
|
|
|
characters (e.g., @c "\\n" is replaced by @c "\n"), some are copied
|
|
|
|
as is (e.g., @c "\\\\"). Furthermore, Unicode escapes of the shape
|
|
|
|
@c "\\uxxxx" need special care. In this case, to_unicode takes care
|
|
|
|
of the construction of the values.
|
|
|
|
2. Unescaped characters are copied as is.
|
2015-02-11 09:10:28 +01:00
|
|
|
|
|
|
|
@return string value of current token without opening and closing quotes
|
2015-02-15 14:52:00 +01:00
|
|
|
@exception std::out_of_range if to_unicode fails
|
2015-02-11 09:10:28 +01:00
|
|
|
*/
|
2015-02-15 13:35:51 +01:00
|
|
|
inline string_t get_string() const
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
2015-02-15 13:35:51 +01:00
|
|
|
string_t result;
|
2015-02-15 11:44:49 +01:00
|
|
|
result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
|
|
|
|
|
|
|
|
// iterate the result between the quotes
|
2015-02-17 00:22:12 +01:00
|
|
|
for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
|
2015-02-15 11:44:49 +01:00
|
|
|
{
|
|
|
|
// process escaped characters
|
|
|
|
if (*i == '\\')
|
|
|
|
{
|
|
|
|
// read next character
|
|
|
|
++i;
|
|
|
|
|
|
|
|
switch (*i)
|
|
|
|
{
|
|
|
|
// the default escapes
|
|
|
|
case 't':
|
|
|
|
{
|
|
|
|
result += "\t";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'b':
|
|
|
|
{
|
|
|
|
result += "\b";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'f':
|
|
|
|
{
|
|
|
|
result += "\f";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'n':
|
|
|
|
{
|
|
|
|
result += "\n";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'r':
|
|
|
|
{
|
|
|
|
result += "\r";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// characters that are not "un"escsaped
|
|
|
|
case '\\':
|
|
|
|
{
|
|
|
|
result += "\\\\";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case '/':
|
|
|
|
{
|
|
|
|
result += "\\/";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case '"':
|
|
|
|
{
|
|
|
|
result += "\\\"";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// unicode
|
|
|
|
case 'u':
|
|
|
|
{
|
2015-02-15 16:56:54 +01:00
|
|
|
// get code xxxx from uxxxx
|
2015-02-17 00:22:12 +01:00
|
|
|
auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
|
|
|
|
4).c_str(), nullptr, 16);
|
2015-02-15 16:56:54 +01:00
|
|
|
|
|
|
|
if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
|
|
|
|
{
|
2015-02-15 17:07:19 +01:00
|
|
|
// make sure there is a subsequent unicode
|
2015-02-15 17:40:46 +01:00
|
|
|
if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
|
2015-02-15 17:07:19 +01:00
|
|
|
{
|
|
|
|
throw std::invalid_argument("missing low surrogate");
|
|
|
|
}
|
|
|
|
|
2015-02-15 16:56:54 +01:00
|
|
|
// get code yyyy from uxxxx\uyyyy
|
2015-02-17 00:22:12 +01:00
|
|
|
auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
|
|
|
|
(i + 7), 4).c_str(), nullptr, 16);
|
2015-02-15 16:56:54 +01:00
|
|
|
result += to_unicode(codepoint, codepoint2);
|
|
|
|
// skip the next 11 characters (xxxx\uyyyy)
|
|
|
|
i += 11;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// add unicode character(s)
|
|
|
|
result += to_unicode(codepoint);
|
|
|
|
// skip the next four characters (xxxx)
|
|
|
|
i += 4;
|
|
|
|
}
|
2015-02-15 11:44:49 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// all other characters are just copied to the end of the
|
|
|
|
// string
|
2015-02-17 00:22:12 +01:00
|
|
|
result.append(1, static_cast<typename string_t::value_type>(*i));
|
2015-02-15 11:44:49 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
|
|
|
|
2015-02-15 14:52:00 +01:00
|
|
|
/*!
|
|
|
|
@brief return number value for number tokens
|
|
|
|
|
|
|
|
This function translates the last token into a floating point number.
|
|
|
|
The pointer m_begin points to the beginning of the parsed number. We
|
|
|
|
pass this pointer to std::strtod which sets endptr to the first
|
|
|
|
character past the converted number. If this pointer is not the same as
|
|
|
|
m_cursor, then either more or less characters have been used during the
|
|
|
|
comparison. This can happen for inputs like "01" which will be treated
|
|
|
|
like number 0 followed by number 1.
|
|
|
|
|
|
|
|
@return the result of the number conversion or NAN if the conversion
|
|
|
|
read past the current token. The latter case needs to be treated by the
|
|
|
|
caller function.
|
|
|
|
|
|
|
|
@exception std::range_error if passed value is out of range
|
|
|
|
*/
|
2015-02-11 09:10:28 +01:00
|
|
|
inline number_float_t get_number() const
|
|
|
|
{
|
|
|
|
// conversion
|
2015-02-17 00:22:12 +01:00
|
|
|
typename string_t::value_type* endptr;
|
|
|
|
const auto float_val = std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start),
|
2015-02-15 14:52:00 +01:00
|
|
|
&endptr);
|
2015-02-11 09:10:28 +01:00
|
|
|
|
2015-02-14 17:34:06 +01:00
|
|
|
// return float_val if the whole number was translated and NAN
|
|
|
|
// otherwise
|
2015-02-17 00:22:12 +01:00
|
|
|
return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2015-03-24 18:05:58 +01:00
|
|
|
/// optional input stream
|
|
|
|
std::istream* m_stream;
|
2015-02-11 09:41:23 +01:00
|
|
|
/// the buffer
|
2015-03-24 18:05:58 +01:00
|
|
|
string_t m_buffer;
|
|
|
|
/// the buffer pointer
|
2015-02-15 14:52:00 +01:00
|
|
|
const lexer_char_t* m_content = nullptr;
|
2015-03-24 18:05:58 +01:00
|
|
|
/// pointer to the beginning of the current symbol
|
2015-02-15 14:52:00 +01:00
|
|
|
const lexer_char_t* m_start = nullptr;
|
2015-03-24 18:05:58 +01:00
|
|
|
/// pointer for backtracking information
|
|
|
|
const lexer_char_t* m_marker = nullptr;
|
2015-02-11 09:41:23 +01:00
|
|
|
/// pointer to the current symbol
|
2015-02-15 14:52:00 +01:00
|
|
|
const lexer_char_t* m_cursor = nullptr;
|
2015-02-11 09:41:23 +01:00
|
|
|
/// pointer to the end of the buffer
|
2015-02-15 14:52:00 +01:00
|
|
|
const lexer_char_t* m_limit = nullptr;
|
2015-02-11 09:10:28 +01:00
|
|
|
};
|
|
|
|
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief syntax analysis
|
|
|
|
*/
|
2015-02-11 09:10:28 +01:00
|
|
|
class parser
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/// constructor for strings
|
2015-03-24 18:05:58 +01:00
|
|
|
inline parser(const string_t& s) : m_lexer(s)
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
|
|
|
// read first token
|
|
|
|
get_token();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// a parser reading from an input stream
|
2015-03-24 18:05:58 +01:00
|
|
|
inline parser(std::istream& _is) : m_lexer(&_is)
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
|
|
|
// read first token
|
|
|
|
get_token();
|
|
|
|
}
|
|
|
|
|
2015-02-11 17:24:14 +01:00
|
|
|
/// public parser interface
|
2015-02-11 09:10:28 +01:00
|
|
|
inline basic_json parse()
|
2015-02-11 17:24:14 +01:00
|
|
|
{
|
|
|
|
basic_json result = parse_internal();
|
|
|
|
|
|
|
|
expect(lexer::token_type::end_of_input);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
/// the actual parser
|
|
|
|
inline basic_json parse_internal()
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
|
|
|
switch (last_token)
|
|
|
|
{
|
|
|
|
case (lexer::token_type::begin_object):
|
|
|
|
{
|
|
|
|
// explicitly set result to object to cope with {}
|
|
|
|
basic_json result(value_t::object);
|
|
|
|
|
|
|
|
// read next token
|
|
|
|
get_token();
|
|
|
|
|
|
|
|
// closing } -> we are done
|
|
|
|
if (last_token == lexer::token_type::end_object)
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// otherwise: parse key-value pairs
|
|
|
|
do
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
// ugly, but could be fixed with loop reorganization
|
|
|
|
if (last_token == lexer::token_type::value_separator)
|
|
|
|
{
|
|
|
|
get_token();
|
|
|
|
}
|
|
|
|
|
2015-02-11 09:10:28 +01:00
|
|
|
// store key
|
|
|
|
expect(lexer::token_type::value_string);
|
|
|
|
const auto key = m_lexer.get_string();
|
|
|
|
|
|
|
|
// parse separator (:)
|
|
|
|
get_token();
|
|
|
|
expect(lexer::token_type::name_separator);
|
|
|
|
|
|
|
|
// parse value
|
|
|
|
get_token();
|
2015-02-11 17:24:14 +01:00
|
|
|
result[key] = parse_internal();
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
2015-02-11 17:24:14 +01:00
|
|
|
while (last_token == lexer::token_type::value_separator);
|
2015-02-11 09:10:28 +01:00
|
|
|
|
|
|
|
// closing }
|
|
|
|
expect(lexer::token_type::end_object);
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::begin_array):
|
|
|
|
{
|
|
|
|
// explicitly set result to object to cope with []
|
|
|
|
basic_json result(value_t::array);
|
|
|
|
|
|
|
|
// read next token
|
|
|
|
get_token();
|
|
|
|
|
|
|
|
// closing ] -> we are done
|
|
|
|
if (last_token == lexer::token_type::end_array)
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// otherwise: parse values
|
|
|
|
do
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
// ugly, but could be fixed with loop reorganization
|
|
|
|
if (last_token == lexer::token_type::value_separator)
|
|
|
|
{
|
|
|
|
get_token();
|
|
|
|
}
|
2015-02-11 09:10:28 +01:00
|
|
|
|
2015-02-11 17:24:14 +01:00
|
|
|
// parse value
|
|
|
|
result.push_back(parse_internal());
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
2015-02-11 17:24:14 +01:00
|
|
|
while (last_token == lexer::token_type::value_separator);
|
2015-02-11 09:10:28 +01:00
|
|
|
|
|
|
|
// closing ]
|
|
|
|
expect(lexer::token_type::end_array);
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::literal_null):
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
return basic_json(nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::value_string):
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
const auto s = m_lexer.get_string();
|
|
|
|
get_token();
|
|
|
|
return basic_json(s);
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::literal_true):
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
return basic_json(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::literal_false):
|
|
|
|
{
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
return basic_json(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
case (lexer::token_type::value_number):
|
|
|
|
{
|
|
|
|
auto float_val = m_lexer.get_number();
|
|
|
|
|
2015-02-14 17:34:06 +01:00
|
|
|
// NAN is returned if token could not be translated
|
|
|
|
// completely
|
2015-02-11 09:10:28 +01:00
|
|
|
if (std::isnan(float_val))
|
|
|
|
{
|
|
|
|
throw std::invalid_argument(std::string("parse error - ") +
|
2015-02-14 17:34:06 +01:00
|
|
|
m_lexer.get_token() + " is not a number");
|
2015-02-11 09:10:28 +01:00
|
|
|
}
|
|
|
|
|
2015-02-11 17:24:14 +01:00
|
|
|
get_token();
|
|
|
|
|
2015-02-11 09:10:28 +01:00
|
|
|
// check if conversion loses precision
|
|
|
|
const auto int_val = static_cast<number_integer_t>(float_val);
|
2015-03-23 23:03:48 +01:00
|
|
|
if (approx(float_val, static_cast<number_float_t>(int_val)))
|
2015-02-11 09:10:28 +01:00
|
|
|
{
|
|
|
|
// we basic_json not lose precision -> return int
|
|
|
|
return basic_json(int_val);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// we would lose precision -> returnfloat
|
|
|
|
return basic_json(float_val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
std::string error_msg = "parse error - unexpected \'";
|
2015-02-14 17:34:06 +01:00
|
|
|
error_msg += m_lexer.get_token();
|
2015-02-11 09:10:28 +01:00
|
|
|
error_msg += "\' (";
|
2015-02-11 10:16:43 +01:00
|
|
|
error_msg += lexer::token_type_name(last_token) + ")";
|
2015-02-11 09:10:28 +01:00
|
|
|
throw std::invalid_argument(error_msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// get next token from lexer
|
|
|
|
inline typename lexer::token_type get_token()
|
|
|
|
{
|
|
|
|
last_token = m_lexer.scan();
|
|
|
|
return last_token;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void expect(typename lexer::token_type t) const
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
if (t != last_token)
|
|
|
|
{
|
|
|
|
std::string error_msg = "parse error - unexpected \'";
|
2015-02-14 17:34:06 +01:00
|
|
|
error_msg += m_lexer.get_token();
|
2015-02-11 10:16:43 +01:00
|
|
|
error_msg += "\' (" + lexer::token_type_name(last_token);
|
|
|
|
error_msg += "); expected " + lexer::token_type_name(t);
|
2015-02-05 22:45:33 +01:00
|
|
|
throw std::invalid_argument(error_msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 12:53:10 +01:00
|
|
|
private:
|
2015-02-05 22:45:33 +01:00
|
|
|
/// the type of the last read token
|
2015-02-11 09:10:28 +01:00
|
|
|
typename lexer::token_type last_token = lexer::token_type::uninitialized;
|
2015-02-14 17:34:06 +01:00
|
|
|
/// the lexer
|
2015-02-11 09:10:28 +01:00
|
|
|
lexer m_lexer;
|
2015-02-05 22:45:33 +01:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/////////////
|
|
|
|
// presets //
|
|
|
|
/////////////
|
|
|
|
|
|
|
|
/// default JSON class
|
|
|
|
using json = basic_json<>;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
// nonmember functions //
|
|
|
|
/////////////////////////
|
|
|
|
|
|
|
|
// specialization of std::swap, and std::hash
|
|
|
|
namespace std
|
|
|
|
{
|
2015-02-22 17:52:27 +01:00
|
|
|
/*!
|
|
|
|
@brief exchanges the values of two JSON objects
|
|
|
|
@ingroup container
|
|
|
|
*/
|
2015-02-05 22:45:33 +01:00
|
|
|
template <>
|
|
|
|
inline void swap(nlohmann::json& j1,
|
|
|
|
nlohmann::json& j2) noexcept(
|
|
|
|
is_nothrow_move_constructible<nlohmann::json>::value and
|
|
|
|
is_nothrow_move_assignable<nlohmann::json>::value
|
|
|
|
)
|
|
|
|
{
|
|
|
|
j1.swap(j2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// hash value for JSON objects
|
|
|
|
template <>
|
|
|
|
struct hash<nlohmann::json>
|
|
|
|
{
|
2015-02-07 15:57:47 +01:00
|
|
|
/// return a hash value for a JSON object
|
2015-02-07 19:14:23 +01:00
|
|
|
inline size_t operator()(const nlohmann::json& j) const
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
|
|
|
// a naive hashing via the string representation
|
2015-02-16 23:17:28 +01:00
|
|
|
const auto& h = hash<nlohmann::json::string_t>();
|
|
|
|
return h(j.dump());
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
This operator implements a user-defined string literal for JSON objects. It can
|
|
|
|
be used by adding \p "_json" to a string literal and returns a JSON object if
|
|
|
|
no parse error occurred.
|
|
|
|
|
|
|
|
@param s a string representation of a JSON object
|
|
|
|
@return a JSON object
|
|
|
|
*/
|
2015-02-07 19:14:23 +01:00
|
|
|
inline nlohmann::json operator "" _json(const char* s, std::size_t)
|
2015-02-05 22:45:33 +01:00
|
|
|
{
|
2015-02-16 23:17:28 +01:00
|
|
|
return nlohmann::json::parse(reinterpret_cast<nlohmann::json::string_t::value_type*>
|
|
|
|
(const_cast<char*>(s)));
|
2015-02-05 22:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|