diff --git a/Makefile b/Makefile
index 381d3ecb786438a6254b63174849ac08b51fec9f..069562bb783948a35b313161356607d06fe25a5f 100644
--- a/Makefile
+++ b/Makefile
@@ -5,10 +5,10 @@ CFLAGS=-g -O3 -ffast-math -fopenmp -c -Wall -std=c++11 $(INCLUDE)
LDFLAGS=-fopenmp -std=c++11 #-lprofiler -Wl,-no_pie
SOURCES=omp_util.cpp fast_log.cpp display_node.cpp penguin.cpp connect4.cpp morpion.cpp test_two_players_game.cpp test_connect4.cpp monte_carlo.cpp test_monte_carlo.cpp test_fast_log.cpp\
statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp test_mcts_two_players.cpp test_minmax.cpp\
-jsoncpp.cpp bits.cpp test_bits.cpp main.cpp
+bits.cpp test_bits.cpp main.cpp
OBJECTS=$(addprefix $(BIN)/, $(SOURCES:.cpp=.o))
EXECUTABLE=$(BIN)/theturk
-vpath %.cpp src/game:src/main:src/util:src/monte_carlo:src/mcts:src/gdl:src/minmax:src/json
+vpath %.cpp src/game:src/main:src/util:src/monte_carlo:src/mcts:src/gdl:src/minmax
all: $(EXECUTABLE)
diff --git a/src/game/penguin.cpp b/src/game/penguin.cpp
index dde9a8791eee90db08dced98f77572f8cf05ddd4..eacc90ae91cca5d30c8cbbec62e1294da9492926 100644
--- a/src/game/penguin.cpp
+++ b/src/game/penguin.cpp
@@ -381,34 +381,34 @@ namespace game
{
}
- Json::Value penguin::to_JSON() const
+ json penguin::to_JSON() const
{
- Json::Value json;
- json["bitboards"]["onefish"] = state.one_fish;
- json["bitboards"]["twofish"] = state.two_fish;
- json["bitboards"]["threefish"] = state.three_fish;
-
- json["penguins"]["red"][0] = state.p1_red;
- json["penguins"]["red"][1] = state.p2_red;
- json["penguins"]["red"][2] = state.p3_red;
- json["penguins"]["red"][3] = state.p4_red;
- json["penguins"]["blue"][0] = state.p1_blue;
- json["penguins"]["blue"][1] = state.p2_blue;
- json["penguins"]["blue"][2] = state.p3_blue;
- json["penguins"]["blue"][3] = state.p4_blue;
-
- json["score"]["red"] = state.score_red;
- json["score"]["blue"] = state.score_blue;
-
- json["possible_moves"]["red"] = state.nb_moves_red;
- json["possible_moves"]["blue"] = state.nb_moves_blue;
-
- json["current_player"] = state.current_player_red ? "Red" : "Blue";
+ json json_state;
+ json_state["bitboards"]["onefish"] = state.one_fish;
+ json_state["bitboards"]["twofish"] = state.two_fish;
+ json_state["bitboards"]["threefish"] = state.three_fish;
+
+ json_state["penguins"]["red"][0] = state.p1_red;
+ json_state["penguins"]["red"][1] = state.p2_red;
+ json_state["penguins"]["red"][2] = state.p3_red;
+ json_state["penguins"]["red"][3] = state.p4_red;
+ json_state["penguins"]["blue"][0] = state.p1_blue;
+ json_state["penguins"]["blue"][1] = state.p2_blue;
+ json_state["penguins"]["blue"][2] = state.p3_blue;
+ json_state["penguins"]["blue"][3] = state.p4_blue;
+
+ json_state["score"]["red"] = state.score_red;
+ json_state["score"]["blue"] = state.score_blue;
+
+ json_state["possible_moves"]["red"] = state.nb_moves_red;
+ json_state["possible_moves"]["blue"] = state.nb_moves_blue;
+
+ json_state["current_player"] = state.current_player_red ? "Red" : "Blue";
- json["nb_moves"]["red"] = state.nb_moves_red;
- json["nb_moves"]["blue"] = state.nb_moves_blue;
+ json_state["nb_moves"]["red"] = state.nb_moves_red;
+ json_state["nb_moves"]["blue"] = state.nb_moves_blue;
- return json;
+ return json_state;
}
string penguin::to_string() const
diff --git a/src/game/penguin.hpp b/src/game/penguin.hpp
index f3b0fcd76c8d31c03ce67cbd9dc21f2aaa552b64..55cb68bb6df17c80ff1d9428786ff1fd68271cda 100644
--- a/src/game/penguin.hpp
+++ b/src/game/penguin.hpp
@@ -2,8 +2,9 @@
#define __PENGUIN_HPP__
#include "game.hpp"
-#include "json.h"
-#include <random>
+#include "json.hpp"
+using json = nlohmann::json;
+#include <random>
#include <array>
#include <iostream>
#include <memory>
@@ -52,7 +53,7 @@ namespace game
void undo(std::uint16_t m) {}
std::string player_to_string(std::uint8_t player) const; //String representation of a player
std::string move_to_string(std::uint16_t m) const; //String representation of a move (for example, A1)
- Json::Value to_JSON() const;
+ json to_JSON() const;
std::string to_string() const; //String representation of the entire game
std::set<int> to_input_vector() const;
void from_input_vector(const std::set<int>& input);
diff --git a/src/json/json-forwards.h b/src/json/json-forwards.h
deleted file mode 100644
index a48f61f0e51ea21e6552ea8f08fb6b047832f513..0000000000000000000000000000000000000000
--- a/src/json/json-forwards.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/// Json-cpp amalgated forward header (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json-forwards.h"
-/// This header provides forward declaration for all JsonCpp types.
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-The author (Baptiste Lepilleur) explicitly disclaims copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
-released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
- http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED
-# define JSON_FORWARD_AMALGATED_H_INCLUDED
-/// If defined, indicates that the source file is amalgated
-/// to prevent private header inclusion.
-#define JSON_IS_AMALGAMATION
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_CONFIG_H_INCLUDED
-#define JSON_CONFIG_H_INCLUDED
-#include <stddef.h>
-#include <string> //typdef String
-
-/// If defined, indicates that json library is embedded in CppTL library.
-//# define JSON_IN_CPPTL 1
-
-/// If defined, indicates that json may leverage CppTL library
-//# define JSON_USE_CPPTL 1
-/// If defined, indicates that cpptl vector based map should be used instead of
-/// std::map
-/// as Value container.
-//# define JSON_USE_CPPTL_SMALLMAP 1
-
-// If non-zero, the library uses exceptions to report bad input instead of C
-// assertion macros. The default is to use exceptions.
-#ifndef JSON_USE_EXCEPTION
-#define JSON_USE_EXCEPTION 1
-#endif
-
-/// If defined, indicates that the source file is amalgated
-/// to prevent private header inclusion.
-/// Remarks: it is automatically defined in the generated amalgated header.
-// #define JSON_IS_AMALGAMATION
-
-#ifdef JSON_IN_CPPTL
-#include <cpptl/config.h>
-#ifndef JSON_USE_CPPTL
-#define JSON_USE_CPPTL 1
-#endif
-#endif
-
-#ifdef JSON_IN_CPPTL
-#define JSON_API CPPTL_API
-#elif defined(JSON_DLL_BUILD)
-#if defined(_MSC_VER)
-#define JSON_API __declspec(dllexport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#elif defined(JSON_DLL)
-#if defined(_MSC_VER)
-#define JSON_API __declspec(dllimport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#endif // ifdef JSON_IN_CPPTL
-#if !defined(JSON_API)
-#define JSON_API
-#endif
-
-// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
-// integer
-// Storages, and 64 bits integer support is disabled.
-// #define JSON_NO_INT64 1
-
-#if defined(_MSC_VER) // MSVC
-# if _MSC_VER <= 1200 // MSVC 6
- // Microsoft Visual Studio 6 only support conversion from __int64 to double
- // (no conversion from unsigned __int64).
-# define JSON_USE_INT64_DOUBLE_CONVERSION 1
- // Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255'
- // characters in the debug information)
- // All projects I've ever seen with VS6 were using this globally (not bothering
- // with pragma push/pop).
-# pragma warning(disable : 4786)
-# endif // MSVC 6
-
-# if _MSC_VER >= 1500 // MSVC 2008
- /// Indicates that the following function is deprecated.
-# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
-# endif
-
-#endif // defined(_MSC_VER)
-
-
-#ifndef JSON_HAS_RVALUE_REFERENCES
-
-#if defined(_MSC_VER) && _MSC_VER >= 1600 // MSVC >= 2010
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // MSVC >= 2010
-
-#ifdef __clang__
-#if __has_feature(cxx_rvalue_references)
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // has_feature
-
-#elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // GXX_EXPERIMENTAL
-
-#endif // __clang__ || __GNUC__
-
-#endif // not defined JSON_HAS_RVALUE_REFERENCES
-
-#ifndef JSON_HAS_RVALUE_REFERENCES
-#define JSON_HAS_RVALUE_REFERENCES 0
-#endif
-
-#ifdef __clang__
-#elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
-# if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
-# define JSONCPP_DEPRECATED(message) __attribute__ ((deprecated(message)))
-# elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-# define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
-# endif // GNUC version
-#endif // __clang__ || __GNUC__
-
-#if !defined(JSONCPP_DEPRECATED)
-#define JSONCPP_DEPRECATED(message)
-#endif // if !defined(JSONCPP_DEPRECATED)
-
-#if __GNUC__ >= 6
-# define JSON_USE_INT64_DOUBLE_CONVERSION 1
-#endif
-
-namespace Json {
-typedef int Int;
-typedef unsigned int UInt;
-#if defined(JSON_NO_INT64)
-typedef int LargestInt;
-typedef unsigned int LargestUInt;
-#undef JSON_HAS_INT64
-#else // if defined(JSON_NO_INT64)
-// For Microsoft Visual use specific types as long long is not supported
-#if defined(_MSC_VER) // Microsoft Visual Studio
-typedef __int64 Int64;
-typedef unsigned __int64 UInt64;
-#else // if defined(_MSC_VER) // Other platforms, use long long
-typedef long long int Int64;
-typedef unsigned long long int UInt64;
-#endif // if defined(_MSC_VER)
-typedef Int64 LargestInt;
-typedef UInt64 LargestUInt;
-#define JSON_HAS_INT64
-#endif // if defined(JSON_NO_INT64)
-#define JSONCPP_STRING std::string
-#define JSONCPP_OSTRINGSTREAM std::ostringstream
-#define JSONCPP_OSTREAM std::ostream
-#define JSONCPP_ISTRINGSTREAM std::istringstream
-#define JSONCPP_ISTREAM std::istream
-} // end namespace Json
-
-#endif // JSON_CONFIG_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_FORWARDS_H_INCLUDED
-#define JSON_FORWARDS_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-// writer.h
-class FastWriter;
-class StyledWriter;
-
-// reader.h
-class Reader;
-
-// features.h
-class Features;
-
-// value.h
-typedef unsigned int ArrayIndex;
-class StaticString;
-class Path;
-class PathArgument;
-class Value;
-class ValueIteratorBase;
-class ValueIterator;
-class ValueConstIterator;
-
-} // namespace Json
-
-#endif // JSON_FORWARDS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED
diff --git a/src/json/json.h b/src/json/json.h
deleted file mode 100644
index 1bc42e274d8b733a26b86bb788b720d26932937d..0000000000000000000000000000000000000000
--- a/src/json/json.h
+++ /dev/null
@@ -1,2086 +0,0 @@
-/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json.h"
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-The author (Baptiste Lepilleur) explicitly disclaims copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
-released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
- http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#ifndef JSON_AMALGATED_H_INCLUDED
-# define JSON_AMALGATED_H_INCLUDED
-/// If defined, indicates that the source file is amalgated
-/// to prevent private header inclusion.
-#define JSON_IS_AMALGAMATION
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/version.h
-// //////////////////////////////////////////////////////////////////////
-
-// DO NOT EDIT. This file (and "version") is generated by CMake.
-// Run CMake configure step to update it.
-#ifndef JSON_VERSION_H_INCLUDED
-# define JSON_VERSION_H_INCLUDED
-
-# define JSONCPP_VERSION_STRING "1.7.0"
-# define JSONCPP_VERSION_MAJOR 1
-# define JSONCPP_VERSION_MINOR 7
-# define JSONCPP_VERSION_PATCH 0
-# define JSONCPP_VERSION_QUALIFIER
-# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
-
-#endif // JSON_VERSION_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/version.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_CONFIG_H_INCLUDED
-#define JSON_CONFIG_H_INCLUDED
-#include <stddef.h>
-#include <string> //typdef String
-
-/// If defined, indicates that json library is embedded in CppTL library.
-//# define JSON_IN_CPPTL 1
-
-/// If defined, indicates that json may leverage CppTL library
-//# define JSON_USE_CPPTL 1
-/// If defined, indicates that cpptl vector based map should be used instead of
-/// std::map
-/// as Value container.
-//# define JSON_USE_CPPTL_SMALLMAP 1
-
-// If non-zero, the library uses exceptions to report bad input instead of C
-// assertion macros. The default is to use exceptions.
-#ifndef JSON_USE_EXCEPTION
-#define JSON_USE_EXCEPTION 1
-#endif
-
-/// If defined, indicates that the source file is amalgated
-/// to prevent private header inclusion.
-/// Remarks: it is automatically defined in the generated amalgated header.
-// #define JSON_IS_AMALGAMATION
-
-#ifdef JSON_IN_CPPTL
-#include <cpptl/config.h>
-#ifndef JSON_USE_CPPTL
-#define JSON_USE_CPPTL 1
-#endif
-#endif
-
-#ifdef JSON_IN_CPPTL
-#define JSON_API CPPTL_API
-#elif defined(JSON_DLL_BUILD)
-#if defined(_MSC_VER)
-#define JSON_API __declspec(dllexport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#elif defined(JSON_DLL)
-#if defined(_MSC_VER)
-#define JSON_API __declspec(dllimport)
-#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
-#endif // if defined(_MSC_VER)
-#endif // ifdef JSON_IN_CPPTL
-#if !defined(JSON_API)
-#define JSON_API
-#endif
-
-// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
-// integer
-// Storages, and 64 bits integer support is disabled.
-// #define JSON_NO_INT64 1
-
-#if defined(_MSC_VER) // MSVC
-# if _MSC_VER <= 1200 // MSVC 6
- // Microsoft Visual Studio 6 only support conversion from __int64 to double
- // (no conversion from unsigned __int64).
-# define JSON_USE_INT64_DOUBLE_CONVERSION 1
- // Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255'
- // characters in the debug information)
- // All projects I've ever seen with VS6 were using this globally (not bothering
- // with pragma push/pop).
-# pragma warning(disable : 4786)
-# endif // MSVC 6
-
-# if _MSC_VER >= 1500 // MSVC 2008
- /// Indicates that the following function is deprecated.
-# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
-# endif
-
-#endif // defined(_MSC_VER)
-
-
-#ifndef JSON_HAS_RVALUE_REFERENCES
-
-#if defined(_MSC_VER) && _MSC_VER >= 1600 // MSVC >= 2010
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // MSVC >= 2010
-
-#ifdef __clang__
-#if __has_feature(cxx_rvalue_references)
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // has_feature
-
-#elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
-#define JSON_HAS_RVALUE_REFERENCES 1
-#endif // GXX_EXPERIMENTAL
-
-#endif // __clang__ || __GNUC__
-
-#endif // not defined JSON_HAS_RVALUE_REFERENCES
-
-#ifndef JSON_HAS_RVALUE_REFERENCES
-#define JSON_HAS_RVALUE_REFERENCES 0
-#endif
-
-#ifdef __clang__
-#elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
-# if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
-# define JSONCPP_DEPRECATED(message) __attribute__ ((deprecated(message)))
-# elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-# define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
-# endif // GNUC version
-#endif // __clang__ || __GNUC__
-
-#if !defined(JSONCPP_DEPRECATED)
-#define JSONCPP_DEPRECATED(message)
-#endif // if !defined(JSONCPP_DEPRECATED)
-
-#if __GNUC__ >= 6
-# define JSON_USE_INT64_DOUBLE_CONVERSION 1
-#endif
-
-namespace Json {
-typedef int Int;
-typedef unsigned int UInt;
-#if defined(JSON_NO_INT64)
-typedef int LargestInt;
-typedef unsigned int LargestUInt;
-#undef JSON_HAS_INT64
-#else // if defined(JSON_NO_INT64)
-// For Microsoft Visual use specific types as long long is not supported
-#if defined(_MSC_VER) // Microsoft Visual Studio
-typedef __int64 Int64;
-typedef unsigned __int64 UInt64;
-#else // if defined(_MSC_VER) // Other platforms, use long long
-typedef long long int Int64;
-typedef unsigned long long int UInt64;
-#endif // if defined(_MSC_VER)
-typedef Int64 LargestInt;
-typedef UInt64 LargestUInt;
-#define JSON_HAS_INT64
-#endif // if defined(JSON_NO_INT64)
-#define JSONCPP_STRING std::string
-#define JSONCPP_OSTRINGSTREAM std::ostringstream
-#define JSONCPP_OSTREAM std::ostream
-#define JSONCPP_ISTRINGSTREAM std::istringstream
-#define JSONCPP_ISTREAM std::istream
-} // end namespace Json
-
-#endif // JSON_CONFIG_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/config.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_FORWARDS_H_INCLUDED
-#define JSON_FORWARDS_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-// writer.h
-class FastWriter;
-class StyledWriter;
-
-// reader.h
-class Reader;
-
-// features.h
-class Features;
-
-// value.h
-typedef unsigned int ArrayIndex;
-class StaticString;
-class Path;
-class PathArgument;
-class Value;
-class ValueIteratorBase;
-class ValueIterator;
-class ValueConstIterator;
-
-} // namespace Json
-
-#endif // JSON_FORWARDS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/forwards.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/features.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef CPPTL_JSON_FEATURES_H_INCLUDED
-#define CPPTL_JSON_FEATURES_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "forwards.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-/** \brief Configuration passed to reader and writer.
- * This configuration object can be used to force the Reader or Writer
- * to behave in a standard conforming way.
- */
-class JSON_API Features {
-public:
- /** \brief A configuration that allows all features and assumes all strings
- * are UTF-8.
- * - C & C++ comments are allowed
- * - Root object can be any JSON value
- * - Assumes Value strings are encoded in UTF-8
- */
- static Features all();
-
- /** \brief A configuration that is strictly compatible with the JSON
- * specification.
- * - Comments are forbidden.
- * - Root object must be either an array or an object value.
- * - Assumes Value strings are encoded in UTF-8
- */
- static Features strictMode();
-
- /** \brief Initialize the configuration like JsonConfig::allFeatures;
- */
- Features();
-
- /// \c true if comments are allowed. Default: \c true.
- bool allowComments_;
-
- /// \c true if root must be either an array or an object value. Default: \c
- /// false.
- bool strictRoot_;
-
- /// \c true if dropped null placeholders are allowed. Default: \c false.
- bool allowDroppedNullPlaceholders_;
-
- /// \c true if numeric object key are allowed. Default: \c false.
- bool allowNumericKeys_;
-};
-
-} // namespace Json
-
-#endif // CPPTL_JSON_FEATURES_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/features.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/value.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef CPPTL_JSON_H_INCLUDED
-#define CPPTL_JSON_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "forwards.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <string>
-#include <vector>
-#include <exception>
-
-#ifndef JSON_USE_CPPTL_SMALLMAP
-#include <map>
-#else
-#include <cpptl/smallmap.h>
-#endif
-#ifdef JSON_USE_CPPTL
-#include <cpptl/forwards.h>
-#endif
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(push)
-#pragma warning(disable : 4251)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-/** \brief JSON (JavaScript Object Notation).
- */
-namespace Json {
-
-/** Base class for all exceptions we throw.
- *
- * We use nothing but these internally. Of course, STL can throw others.
- */
-class JSON_API Exception : public std::exception {
-public:
- Exception(JSONCPP_STRING const& msg);
- ~Exception() throw() override;
- char const* what() const throw() override;
-protected:
- JSONCPP_STRING msg_;
-};
-
-/** Exceptions which the user cannot easily avoid.
- *
- * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
- *
- * \remark derived from Json::Exception
- */
-class JSON_API RuntimeError : public Exception {
-public:
- RuntimeError(JSONCPP_STRING const& msg);
-};
-
-/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
- *
- * These are precondition-violations (user bugs) and internal errors (our bugs).
- *
- * \remark derived from Json::Exception
- */
-class JSON_API LogicError : public Exception {
-public:
- LogicError(JSONCPP_STRING const& msg);
-};
-
-/// used internally
-void throwRuntimeError(JSONCPP_STRING const& msg);
-/// used internally
-void throwLogicError(JSONCPP_STRING const& msg);
-
-/** \brief Type of the value held by a Value object.
- */
-enum ValueType {
- nullValue = 0, ///< 'null' value
- intValue, ///< signed integer value
- uintValue, ///< unsigned integer value
- realValue, ///< double value
- stringValue, ///< UTF-8 string value
- booleanValue, ///< bool value
- arrayValue, ///< array value (ordered list)
- objectValue ///< object value (collection of name/value pairs).
-};
-
-enum CommentPlacement {
- commentBefore = 0, ///< a comment placed on the line before a value
- commentAfterOnSameLine, ///< a comment just after a value on the same line
- commentAfter, ///< a comment on the line after a value (only make sense for
- /// root value)
- numberOfCommentPlacement
-};
-
-//# ifdef JSON_USE_CPPTL
-// typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
-// typedef CppTL::AnyEnumerator<const Value &> EnumValues;
-//# endif
-
-/** \brief Lightweight wrapper to tag static string.
- *
- * Value constructor and objectValue member assignement takes advantage of the
- * StaticString and avoid the cost of string duplication when storing the
- * string or the member name.
- *
- * Example of usage:
- * \code
- * Json::Value aValue( StaticString("some text") );
- * Json::Value object;
- * static const StaticString code("code");
- * object[code] = 1234;
- * \endcode
- */
-class JSON_API StaticString {
-public:
- explicit StaticString(const char* czstring) : c_str_(czstring) {}
-
- operator const char*() const { return c_str_; }
-
- const char* c_str() const { return c_str_; }
-
-private:
- const char* c_str_;
-};
-
-/** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
- *
- * This class is a discriminated union wrapper that can represents a:
- * - signed integer [range: Value::minInt - Value::maxInt]
- * - unsigned integer (range: 0 - Value::maxUInt)
- * - double
- * - UTF-8 string
- * - boolean
- * - 'null'
- * - an ordered list of Value
- * - collection of name/value pairs (javascript object)
- *
- * The type of the held value is represented by a #ValueType and
- * can be obtained using type().
- *
- * Values of an #objectValue or #arrayValue can be accessed using operator[]()
- * methods.
- * Non-const methods will automatically create the a #nullValue element
- * if it does not exist.
- * The sequence of an #arrayValue will be automatically resized and initialized
- * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
- *
- * The get() methods can be used to obtain default value in the case the
- * required element does not exist.
- *
- * It is possible to iterate over the list of a #objectValue values using
- * the getMemberNames() method.
- *
- * \note #Value string-length fit in size_t, but keys must be < 2^30.
- * (The reason is an implementation detail.) A #CharReader will raise an
- * exception if a bound is exceeded to avoid security holes in your app,
- * but the Value API does *not* check bounds. That is the responsibility
- * of the caller.
- */
-class JSON_API Value {
- friend class ValueIteratorBase;
-public:
- typedef std::vector<JSONCPP_STRING> Members;
- typedef ValueIterator iterator;
- typedef ValueConstIterator const_iterator;
- typedef Json::UInt UInt;
- typedef Json::Int Int;
-#if defined(JSON_HAS_INT64)
- typedef Json::UInt64 UInt64;
- typedef Json::Int64 Int64;
-#endif // defined(JSON_HAS_INT64)
- typedef Json::LargestInt LargestInt;
- typedef Json::LargestUInt LargestUInt;
- typedef Json::ArrayIndex ArrayIndex;
-
- static const Value& null; ///< We regret this reference to a global instance; prefer the simpler Value().
- static const Value& nullRef; ///< just a kludge for binary-compatibility; same as null
- /// Minimum signed integer value that can be stored in a Json::Value.
- static const LargestInt minLargestInt;
- /// Maximum signed integer value that can be stored in a Json::Value.
- static const LargestInt maxLargestInt;
- /// Maximum unsigned integer value that can be stored in a Json::Value.
- static const LargestUInt maxLargestUInt;
-
- /// Minimum signed int value that can be stored in a Json::Value.
- static const Int minInt;
- /// Maximum signed int value that can be stored in a Json::Value.
- static const Int maxInt;
- /// Maximum unsigned int value that can be stored in a Json::Value.
- static const UInt maxUInt;
-
-#if defined(JSON_HAS_INT64)
- /// Minimum signed 64 bits int value that can be stored in a Json::Value.
- static const Int64 minInt64;
- /// Maximum signed 64 bits int value that can be stored in a Json::Value.
- static const Int64 maxInt64;
- /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
- static const UInt64 maxUInt64;
-#endif // defined(JSON_HAS_INT64)
-
-private:
-#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
- class CZString {
- public:
- enum DuplicationPolicy {
- noDuplication = 0,
- duplicate,
- duplicateOnCopy
- };
- CZString(ArrayIndex index);
- CZString(char const* str, unsigned length, DuplicationPolicy allocate);
- CZString(CZString const& other);
-#if JSON_HAS_RVALUE_REFERENCES
- CZString(CZString&& other);
-#endif
- ~CZString();
- CZString& operator=(CZString other);
- bool operator<(CZString const& other) const;
- bool operator==(CZString const& other) const;
- ArrayIndex index() const;
- //const char* c_str() const; ///< \deprecated
- char const* data() const;
- unsigned length() const;
- bool isStaticString() const;
-
- private:
- void swap(CZString& other);
-
- struct StringStorage {
- unsigned policy_: 2;
- unsigned length_: 30; // 1GB max
- };
-
- char const* cstr_; // actually, a prefixed string, unless policy is noDup
- union {
- ArrayIndex index_;
- StringStorage storage_;
- };
- };
-
-public:
-#ifndef JSON_USE_CPPTL_SMALLMAP
- typedef std::map<CZString, Value> ObjectValues;
-#else
- typedef CppTL::SmallMap<CZString, Value> ObjectValues;
-#endif // ifndef JSON_USE_CPPTL_SMALLMAP
-#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-
-public:
- /** \brief Create a default Value of the given type.
-
- This is a very useful constructor.
- To create an empty array, pass arrayValue.
- To create an empty object, pass objectValue.
- Another Value can then be set to this one by assignment.
-This is useful since clear() and resize() will not alter types.
-
- Examples:
-\code
-Json::Value null_value; // null
-Json::Value arr_value(Json::arrayValue); // []
-Json::Value obj_value(Json::objectValue); // {}
-\endcode
- */
- Value(ValueType type = nullValue);
- Value(Int value);
- Value(UInt value);
-#if defined(JSON_HAS_INT64)
- Value(Int64 value);
- Value(UInt64 value);
-#endif // if defined(JSON_HAS_INT64)
- Value(double value);
- Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)
- Value(const char* begin, const char* end); ///< Copy all, incl zeroes.
- /** \brief Constructs a value from a static string.
-
- * Like other value string constructor but do not duplicate the string for
- * internal storage. The given string must remain alive after the call to this
- * constructor.
- * \note This works only for null-terminated strings. (We cannot change the
- * size of this class, so we have nowhere to store the length,
- * which might be computed later for various operations.)
- *
- * Example of usage:
- * \code
- * static StaticString foo("some text");
- * Json::Value aValue(foo);
- * \endcode
- */
- Value(const StaticString& value);
- Value(const JSONCPP_STRING& value); ///< Copy data() til size(). Embedded zeroes too.
-#ifdef JSON_USE_CPPTL
- Value(const CppTL::ConstString& value);
-#endif
- Value(bool value);
- /// Deep copy.
- Value(const Value& other);
-#if JSON_HAS_RVALUE_REFERENCES
- /// Move constructor
- Value(Value&& other);
-#endif
- ~Value();
-
- /// Deep copy, then swap(other).
- /// \note Over-write existing comments. To preserve comments, use #swapPayload().
- Value& operator=(Value other);
- /// Swap everything.
- void swap(Value& other);
- /// Swap values but leave comments and source offsets in place.
- void swapPayload(Value& other);
-
- ValueType type() const;
-
- /// Compare payload only, not comments etc.
- bool operator<(const Value& other) const;
- bool operator<=(const Value& other) const;
- bool operator>=(const Value& other) const;
- bool operator>(const Value& other) const;
- bool operator==(const Value& other) const;
- bool operator!=(const Value& other) const;
- int compare(const Value& other) const;
-
- const char* asCString() const; ///< Embedded zeroes could cause you trouble!
- JSONCPP_STRING asString() const; ///< Embedded zeroes are possible.
- /** Get raw char* of string-value.
- * \return false if !string. (Seg-fault if str or end are NULL.)
- */
- bool getString(
- char const** begin, char const** end) const;
-#ifdef JSON_USE_CPPTL
- CppTL::ConstString asConstString() const;
-#endif
- Int asInt() const;
- UInt asUInt() const;
-#if defined(JSON_HAS_INT64)
- Int64 asInt64() const;
- UInt64 asUInt64() const;
-#endif // if defined(JSON_HAS_INT64)
- LargestInt asLargestInt() const;
- LargestUInt asLargestUInt() const;
- float asFloat() const;
- double asDouble() const;
- bool asBool() const;
-
- bool isNull() const;
- bool isBool() const;
- bool isInt() const;
- bool isInt64() const;
- bool isUInt() const;
- bool isUInt64() const;
- bool isIntegral() const;
- bool isDouble() const;
- bool isNumeric() const;
- bool isString() const;
- bool isArray() const;
- bool isObject() const;
-
- bool isConvertibleTo(ValueType other) const;
-
- /// Number of values in array or object
- ArrayIndex size() const;
-
- /// \brief Return true if empty array, empty object, or null;
- /// otherwise, false.
- bool empty() const;
-
- /// Return isNull()
- bool operator!() const;
-
- /// Remove all object members and array elements.
- /// \pre type() is arrayValue, objectValue, or nullValue
- /// \post type() is unchanged
- void clear();
-
- /// Resize the array to size elements.
- /// New elements are initialized to null.
- /// May only be called on nullValue or arrayValue.
- /// \pre type() is arrayValue or nullValue
- /// \post type() is arrayValue
- void resize(ArrayIndex size);
-
- /// Access an array element (zero based index ).
- /// If the array contains less than index element, then null value are
- /// inserted
- /// in the array so that its size is index+1.
- /// (You may need to say 'value[0u]' to get your compiler to distinguish
- /// this from the operator[] which takes a string.)
- Value& operator[](ArrayIndex index);
-
- /// Access an array element (zero based index ).
- /// If the array contains less than index element, then null value are
- /// inserted
- /// in the array so that its size is index+1.
- /// (You may need to say 'value[0u]' to get your compiler to distinguish
- /// this from the operator[] which takes a string.)
- Value& operator[](int index);
-
- /// Access an array element (zero based index )
- /// (You may need to say 'value[0u]' to get your compiler to distinguish
- /// this from the operator[] which takes a string.)
- const Value& operator[](ArrayIndex index) const;
-
- /// Access an array element (zero based index )
- /// (You may need to say 'value[0u]' to get your compiler to distinguish
- /// this from the operator[] which takes a string.)
- const Value& operator[](int index) const;
-
- /// If the array contains at least index+1 elements, returns the element
- /// value,
- /// otherwise returns defaultValue.
- Value get(ArrayIndex index, const Value& defaultValue) const;
- /// Return true if index < size().
- bool isValidIndex(ArrayIndex index) const;
- /// \brief Append value to array at the end.
- ///
- /// Equivalent to jsonvalue[jsonvalue.size()] = value;
- Value& append(const Value& value);
-
- /// Access an object value by name, create a null member if it does not exist.
- /// \note Because of our implementation, keys are limited to 2^30 -1 chars.
- /// Exceeding that will cause an exception.
- Value& operator[](const char* key);
- /// Access an object value by name, returns null if there is no member with
- /// that name.
- const Value& operator[](const char* key) const;
- /// Access an object value by name, create a null member if it does not exist.
- /// \param key may contain embedded nulls.
- Value& operator[](const JSONCPP_STRING& key);
- /// Access an object value by name, returns null if there is no member with
- /// that name.
- /// \param key may contain embedded nulls.
- const Value& operator[](const JSONCPP_STRING& key) const;
- /** \brief Access an object value by name, create a null member if it does not
- exist.
-
- * If the object has no entry for that name, then the member name used to store
- * the new entry is not duplicated.
- * Example of use:
- * \code
- * Json::Value object;
- * static const StaticString code("code");
- * object[code] = 1234;
- * \endcode
- */
- Value& operator[](const StaticString& key);
-#ifdef JSON_USE_CPPTL
- /// Access an object value by name, create a null member if it does not exist.
- Value& operator[](const CppTL::ConstString& key);
- /// Access an object value by name, returns null if there is no member with
- /// that name.
- const Value& operator[](const CppTL::ConstString& key) const;
-#endif
- /// Return the member named key if it exist, defaultValue otherwise.
- /// \note deep copy
- Value get(const char* key, const Value& defaultValue) const;
- /// Return the member named key if it exist, defaultValue otherwise.
- /// \note deep copy
- /// \note key may contain embedded nulls.
- Value get(const char* begin, const char* end, const Value& defaultValue) const;
- /// Return the member named key if it exist, defaultValue otherwise.
- /// \note deep copy
- /// \param key may contain embedded nulls.
- Value get(const JSONCPP_STRING& key, const Value& defaultValue) const;
-#ifdef JSON_USE_CPPTL
- /// Return the member named key if it exist, defaultValue otherwise.
- /// \note deep copy
- Value get(const CppTL::ConstString& key, const Value& defaultValue) const;
-#endif
- /// Most general and efficient version of isMember()const, get()const,
- /// and operator[]const
- /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
- Value const* find(char const* begin, char const* end) const;
- /// Most general and efficient version of object-mutators.
- /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30
- /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.
- Value const* demand(char const* begin, char const* end);
- /// \brief Remove and return the named member.
- ///
- /// Do nothing if it did not exist.
- /// \return the removed Value, or null.
- /// \pre type() is objectValue or nullValue
- /// \post type() is unchanged
- /// \deprecated
- Value removeMember(const char* key);
- /// Same as removeMember(const char*)
- /// \param key may contain embedded nulls.
- /// \deprecated
- Value removeMember(const JSONCPP_STRING& key);
- /// Same as removeMember(const char* begin, const char* end, Value* removed),
- /// but 'key' is null-terminated.
- bool removeMember(const char* key, Value* removed);
- /** \brief Remove the named map member.
-
- Update 'removed' iff removed.
- \param key may contain embedded nulls.
- \return true iff removed (no exceptions)
- */
- bool removeMember(JSONCPP_STRING const& key, Value* removed);
- /// Same as removeMember(JSONCPP_STRING const& key, Value* removed)
- bool removeMember(const char* begin, const char* end, Value* removed);
- /** \brief Remove the indexed array element.
-
- O(n) expensive operations.
- Update 'removed' iff removed.
- \return true iff removed (no exceptions)
- */
- bool removeIndex(ArrayIndex i, Value* removed);
-
- /// Return true if the object has a member named key.
- /// \note 'key' must be null-terminated.
- bool isMember(const char* key) const;
- /// Return true if the object has a member named key.
- /// \param key may contain embedded nulls.
- bool isMember(const JSONCPP_STRING& key) const;
- /// Same as isMember(JSONCPP_STRING const& key)const
- bool isMember(const char* begin, const char* end) const;
-#ifdef JSON_USE_CPPTL
- /// Return true if the object has a member named key.
- bool isMember(const CppTL::ConstString& key) const;
-#endif
-
- /// \brief Return a list of the member names.
- ///
- /// If null, return an empty list.
- /// \pre type() is objectValue or nullValue
- /// \post if type() was nullValue, it remains nullValue
- Members getMemberNames() const;
-
- //# ifdef JSON_USE_CPPTL
- // EnumMemberNames enumMemberNames() const;
- // EnumValues enumValues() const;
- //# endif
-
- /// \deprecated Always pass len.
- JSONCPP_DEPRECATED("Use setComment(JSONCPP_STRING const&) instead.")
- void setComment(const char* comment, CommentPlacement placement);
- /// Comments must be //... or /* ... */
- void setComment(const char* comment, size_t len, CommentPlacement placement);
- /// Comments must be //... or /* ... */
- void setComment(const JSONCPP_STRING& comment, CommentPlacement placement);
- bool hasComment(CommentPlacement placement) const;
- /// Include delimiters and embedded newlines.
- JSONCPP_STRING getComment(CommentPlacement placement) const;
-
- JSONCPP_STRING toStyledString() const;
-
- const_iterator begin() const;
- const_iterator end() const;
-
- iterator begin();
- iterator end();
-
- // Accessors for the [start, limit) range of bytes within the JSON text from
- // which this value was parsed, if any.
- void setOffsetStart(ptrdiff_t start);
- void setOffsetLimit(ptrdiff_t limit);
- ptrdiff_t getOffsetStart() const;
- ptrdiff_t getOffsetLimit() const;
-
-private:
- void initBasic(ValueType type, bool allocated = false);
-
- Value& resolveReference(const char* key);
- Value& resolveReference(const char* key, const char* end);
-
- struct CommentInfo {
- CommentInfo();
- ~CommentInfo();
-
- void setComment(const char* text, size_t len);
-
- char* comment_;
- };
-
- // struct MemberNamesTransform
- //{
- // typedef const char *result_type;
- // const char *operator()( const CZString &name ) const
- // {
- // return name.c_str();
- // }
- //};
-
- union ValueHolder {
- LargestInt int_;
- LargestUInt uint_;
- double real_;
- bool bool_;
- char* string_; // actually ptr to unsigned, followed by str, unless !allocated_
- ObjectValues* map_;
- } value_;
- ValueType type_ : 8;
- unsigned int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
- // If not allocated_, string_ must be null-terminated.
- CommentInfo* comments_;
-
- // [start, limit) byte offsets in the source JSON text from which this Value
- // was extracted.
- ptrdiff_t start_;
- ptrdiff_t limit_;
-};
-
-/** \brief Experimental and untested: represents an element of the "path" to
- * access a node.
- */
-class JSON_API PathArgument {
-public:
- friend class Path;
-
- PathArgument();
- PathArgument(ArrayIndex index);
- PathArgument(const char* key);
- PathArgument(const JSONCPP_STRING& key);
-
-private:
- enum Kind {
- kindNone = 0,
- kindIndex,
- kindKey
- };
- JSONCPP_STRING key_;
- ArrayIndex index_;
- Kind kind_;
-};
-
-/** \brief Experimental and untested: represents a "path" to access a node.
- *
- * Syntax:
- * - "." => root node
- * - ".[n]" => elements at index 'n' of root node (an array value)
- * - ".name" => member named 'name' of root node (an object value)
- * - ".name1.name2.name3"
- * - ".[0][1][2].name1[3]"
- * - ".%" => member name is provided as parameter
- * - ".[%]" => index is provied as parameter
- */
-class JSON_API Path {
-public:
- Path(const JSONCPP_STRING& path,
- const PathArgument& a1 = PathArgument(),
- const PathArgument& a2 = PathArgument(),
- const PathArgument& a3 = PathArgument(),
- const PathArgument& a4 = PathArgument(),
- const PathArgument& a5 = PathArgument());
-
- const Value& resolve(const Value& root) const;
- Value resolve(const Value& root, const Value& defaultValue) const;
- /// Creates the "path" to access the specified node and returns a reference on
- /// the node.
- Value& make(Value& root) const;
-
-private:
- typedef std::vector<const PathArgument*> InArgs;
- typedef std::vector<PathArgument> Args;
-
- void makePath(const JSONCPP_STRING& path, const InArgs& in);
- void addPathInArg(const JSONCPP_STRING& path,
- const InArgs& in,
- InArgs::const_iterator& itInArg,
- PathArgument::Kind kind);
- void invalidPath(const JSONCPP_STRING& path, int location);
-
- Args args_;
-};
-
-/** \brief base class for Value iterators.
- *
- */
-class JSON_API ValueIteratorBase {
-public:
- typedef std::bidirectional_iterator_tag iterator_category;
- typedef unsigned int size_t;
- typedef int difference_type;
- typedef ValueIteratorBase SelfType;
-
- bool operator==(const SelfType& other) const { return isEqual(other); }
-
- bool operator!=(const SelfType& other) const { return !isEqual(other); }
-
- difference_type operator-(const SelfType& other) const {
- return other.computeDistance(*this);
- }
-
- /// Return either the index or the member name of the referenced value as a
- /// Value.
- Value key() const;
-
- /// Return the index of the referenced Value, or -1 if it is not an arrayValue.
- UInt index() const;
-
- /// Return the member name of the referenced Value, or "" if it is not an
- /// objectValue.
- /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
- JSONCPP_STRING name() const;
-
- /// Return the member name of the referenced Value. "" if it is not an
- /// objectValue.
- /// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls.
- JSONCPP_DEPRECATED("Use `key = name();` instead.")
- char const* memberName() const;
- /// Return the member name of the referenced Value, or NULL if it is not an
- /// objectValue.
- /// \note Better version than memberName(). Allows embedded nulls.
- char const* memberName(char const** end) const;
-
-protected:
- Value& deref() const;
-
- void increment();
-
- void decrement();
-
- difference_type computeDistance(const SelfType& other) const;
-
- bool isEqual(const SelfType& other) const;
-
- void copy(const SelfType& other);
-
-private:
- Value::ObjectValues::iterator current_;
- // Indicates that iterator is for a null value.
- bool isNull_;
-
-public:
- // For some reason, BORLAND needs these at the end, rather
- // than earlier. No idea why.
- ValueIteratorBase();
- explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
-};
-
-/** \brief const iterator for object and array value.
- *
- */
-class JSON_API ValueConstIterator : public ValueIteratorBase {
- friend class Value;
-
-public:
- typedef const Value value_type;
- //typedef unsigned int size_t;
- //typedef int difference_type;
- typedef const Value& reference;
- typedef const Value* pointer;
- typedef ValueConstIterator SelfType;
-
- ValueConstIterator();
- ValueConstIterator(ValueIterator const& other);
-
-private:
-/*! \internal Use by Value to create an iterator.
- */
- explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
-public:
- SelfType& operator=(const ValueIteratorBase& other);
-
- SelfType operator++(int) {
- SelfType temp(*this);
- ++*this;
- return temp;
- }
-
- SelfType operator--(int) {
- SelfType temp(*this);
- --*this;
- return temp;
- }
-
- SelfType& operator--() {
- decrement();
- return *this;
- }
-
- SelfType& operator++() {
- increment();
- return *this;
- }
-
- reference operator*() const { return deref(); }
-
- pointer operator->() const { return &deref(); }
-};
-
-/** \brief Iterator for object and array value.
- */
-class JSON_API ValueIterator : public ValueIteratorBase {
- friend class Value;
-
-public:
- typedef Value value_type;
- typedef unsigned int size_t;
- typedef int difference_type;
- typedef Value& reference;
- typedef Value* pointer;
- typedef ValueIterator SelfType;
-
- ValueIterator();
- explicit ValueIterator(const ValueConstIterator& other);
- ValueIterator(const ValueIterator& other);
-
-private:
-/*! \internal Use by Value to create an iterator.
- */
- explicit ValueIterator(const Value::ObjectValues::iterator& current);
-public:
- SelfType& operator=(const SelfType& other);
-
- SelfType operator++(int) {
- SelfType temp(*this);
- ++*this;
- return temp;
- }
-
- SelfType operator--(int) {
- SelfType temp(*this);
- --*this;
- return temp;
- }
-
- SelfType& operator--() {
- decrement();
- return *this;
- }
-
- SelfType& operator++() {
- increment();
- return *this;
- }
-
- reference operator*() const { return deref(); }
-
- pointer operator->() const { return &deref(); }
-};
-
-} // namespace Json
-
-
-namespace std {
-/// Specialize std::swap() for Json::Value.
-template<>
-inline void swap(Json::Value& a, Json::Value& b) { a.swap(b); }
-}
-
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // CPPTL_JSON_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/value.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/reader.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef CPPTL_JSON_READER_H_INCLUDED
-#define CPPTL_JSON_READER_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "features.h"
-#include "value.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <deque>
-#include <iosfwd>
-#include <stack>
-#include <string>
-#include <istream>
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(push)
-#pragma warning(disable : 4251)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-namespace Json {
-
-/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
- *Value.
- *
- * \deprecated Use CharReader and CharReaderBuilder.
- */
-class JSON_API Reader {
-public:
- typedef char Char;
- typedef const Char* Location;
-
- /** \brief An error tagged with where in the JSON text it was encountered.
- *
- * The offsets give the [start, limit) range of bytes within the text. Note
- * that this is bytes, not codepoints.
- *
- */
- struct StructuredError {
- ptrdiff_t offset_start;
- ptrdiff_t offset_limit;
- std::string message;
- };
-
- /** \brief Constructs a Reader allowing all features
- * for parsing.
- */
- Reader();
-
- /** \brief Constructs a Reader allowing the specified feature set
- * for parsing.
- */
- Reader(const Features& features);
-
- /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
- * document.
- * \param document UTF-8 encoded string containing the document to read.
- * \param root [out] Contains the root value of the document if it was
- * successfully parsed.
- * \param collectComments \c true to collect comment and allow writing them
- * back during
- * serialization, \c false to discard comments.
- * This parameter is ignored if
- * Features::allowComments_
- * is \c false.
- * \return \c true if the document was successfully parsed, \c false if an
- * error occurred.
- */
- bool
- parse(const std::string& document, Value& root, bool collectComments = true);
-
- /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
- document.
- * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
- document to read.
- * \param endDoc Pointer on the end of the UTF-8 encoded string of the
- document to read.
- * Must be >= beginDoc.
- * \param root [out] Contains the root value of the document if it was
- * successfully parsed.
- * \param collectComments \c true to collect comment and allow writing them
- back during
- * serialization, \c false to discard comments.
- * This parameter is ignored if
- Features::allowComments_
- * is \c false.
- * \return \c true if the document was successfully parsed, \c false if an
- error occurred.
- */
- bool parse(const char* beginDoc,
- const char* endDoc,
- Value& root,
- bool collectComments = true);
-
- /// \brief Parse from input stream.
- /// \see Json::operator>>(std::istream&, Json::Value&).
- bool parse(JSONCPP_ISTREAM& is, Value& root, bool collectComments = true);
-
- /** \brief Returns a user friendly string that list errors in the parsed
- * document.
- * \return Formatted error message with the list of errors with their location
- * in
- * the parsed document. An empty string is returned if no error
- * occurred
- * during parsing.
- * \deprecated Use getFormattedErrorMessages() instead (typo fix).
- */
- JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
- std::string getFormatedErrorMessages() const;
-
- /** \brief Returns a user friendly string that list errors in the parsed
- * document.
- * \return Formatted error message with the list of errors with their location
- * in
- * the parsed document. An empty string is returned if no error
- * occurred
- * during parsing.
- */
- std::string getFormattedErrorMessages() const;
-
- /** \brief Returns a vector of structured erros encounted while parsing.
- * \return A (possibly empty) vector of StructuredError objects. Currently
- * only one error can be returned, but the caller should tolerate
- * multiple
- * errors. This can occur if the parser recovers from a non-fatal
- * parse error and then encounters additional errors.
- */
- std::vector<StructuredError> getStructuredErrors() const;
-
- /** \brief Add a semantic error message.
- * \param value JSON Value location associated with the error
- * \param message The error message.
- * \return \c true if the error was successfully added, \c false if the
- * Value offset exceeds the document size.
- */
- bool pushError(const Value& value, const std::string& message);
-
- /** \brief Add a semantic error message with extra context.
- * \param value JSON Value location associated with the error
- * \param message The error message.
- * \param extra Additional JSON Value location to contextualize the error
- * \return \c true if the error was successfully added, \c false if either
- * Value offset exceeds the document size.
- */
- bool pushError(const Value& value, const std::string& message, const Value& extra);
-
- /** \brief Return whether there are any errors.
- * \return \c true if there are no errors to report \c false if
- * errors have occurred.
- */
- bool good() const;
-
-private:
- enum TokenType {
- tokenEndOfStream = 0,
- tokenObjectBegin,
- tokenObjectEnd,
- tokenArrayBegin,
- tokenArrayEnd,
- tokenString,
- tokenNumber,
- tokenTrue,
- tokenFalse,
- tokenNull,
- tokenArraySeparator,
- tokenMemberSeparator,
- tokenComment,
- tokenError
- };
-
- class Token {
- public:
- TokenType type_;
- Location start_;
- Location end_;
- };
-
- class ErrorInfo {
- public:
- Token token_;
- std::string message_;
- Location extra_;
- };
-
- typedef std::deque<ErrorInfo> Errors;
-
- bool readToken(Token& token);
- void skipSpaces();
- bool match(Location pattern, int patternLength);
- bool readComment();
- bool readCStyleComment();
- bool readCppStyleComment();
- bool readString();
- void readNumber();
- bool readValue();
- bool readObject(Token& token);
- bool readArray(Token& token);
- bool decodeNumber(Token& token);
- bool decodeNumber(Token& token, Value& decoded);
- bool decodeString(Token& token);
- bool decodeString(Token& token, std::string& decoded);
- bool decodeDouble(Token& token);
- bool decodeDouble(Token& token, Value& decoded);
- bool decodeUnicodeCodePoint(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode);
- bool decodeUnicodeEscapeSequence(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode);
- bool addError(const std::string& message, Token& token, Location extra = 0);
- bool recoverFromError(TokenType skipUntilToken);
- bool addErrorAndRecover(const std::string& message,
- Token& token,
- TokenType skipUntilToken);
- void skipUntilSpace();
- Value& currentValue();
- Char getNextChar();
- void
- getLocationLineAndColumn(Location location, int& line, int& column) const;
- std::string getLocationLineAndColumn(Location location) const;
- void addComment(Location begin, Location end, CommentPlacement placement);
- void skipCommentTokens(Token& token);
-
- typedef std::stack<Value*> Nodes;
- Nodes nodes_;
- Errors errors_;
- std::string document_;
- Location begin_;
- Location end_;
- Location current_;
- Location lastValueEnd_;
- Value* lastValue_;
- std::string commentsBefore_;
- Features features_;
- bool collectComments_;
-}; // Reader
-
-/** Interface for reading JSON from a char array.
- */
-class JSON_API CharReader {
-public:
- virtual ~CharReader() {}
- /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
- document.
- * The document must be a UTF-8 encoded string containing the document to read.
- *
- * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
- document to read.
- * \param endDoc Pointer on the end of the UTF-8 encoded string of the
- document to read.
- * Must be >= beginDoc.
- * \param root [out] Contains the root value of the document if it was
- * successfully parsed.
- * \param errs [out] Formatted error messages (if not NULL)
- * a user friendly string that lists errors in the parsed
- * document.
- * \return \c true if the document was successfully parsed, \c false if an
- error occurred.
- */
- virtual bool parse(
- char const* beginDoc, char const* endDoc,
- Value* root, std::string* errs) = 0;
-
- class JSON_API Factory {
- public:
- virtual ~Factory() {}
- /** \brief Allocate a CharReader via operator new().
- * \throw std::exception if something goes wrong (e.g. invalid settings)
- */
- virtual CharReader* newCharReader() const = 0;
- }; // Factory
-}; // CharReader
-
-/** \brief Build a CharReader implementation.
-
-Usage:
-\code
- using namespace Json;
- CharReaderBuilder builder;
- builder["collectComments"] = false;
- Value value;
- std::string errs;
- bool ok = parseFromStream(builder, std::cin, &value, &errs);
-\endcode
-*/
-class JSON_API CharReaderBuilder : public CharReader::Factory {
-public:
- // Note: We use a Json::Value so that we can add data-members to this class
- // without a major version bump.
- /** Configuration of this builder.
- These are case-sensitive.
- Available settings (case-sensitive):
- - `"collectComments": false or true`
- - true to collect comment and allow writing them
- back during serialization, false to discard comments.
- This parameter is ignored if allowComments is false.
- - `"allowComments": false or true`
- - true if comments are allowed.
- - `"strictRoot": false or true`
- - true if root must be either an array or an object value
- - `"allowDroppedNullPlaceholders": false or true`
- - true if dropped null placeholders are allowed. (See StreamWriterBuilder.)
- - `"allowNumericKeys": false or true`
- - true if numeric object keys are allowed.
- - `"allowSingleQuotes": false or true`
- - true if '' are allowed for strings (both keys and values)
- - `"stackLimit": integer`
- - Exceeding stackLimit (recursive depth of `readValue()`) will
- cause an exception.
- - This is a security issue (seg-faults caused by deeply nested JSON),
- so the default is low.
- - `"failIfExtra": false or true`
- - If true, `parse()` returns false when extra non-whitespace trails
- the JSON value in the input string.
- - `"rejectDupKeys": false or true`
- - If true, `parse()` returns false when a key is duplicated within an object.
- - `"allowSpecialFloats": false or true`
- - If true, special float values (NaNs and infinities) are allowed
- and their values are lossfree restorable.
-
- You can examine 'settings_` yourself
- to see the defaults. You can also write and read them just like any
- JSON Value.
- \sa setDefaults()
- */
- Json::Value settings_;
-
- CharReaderBuilder();
- ~CharReaderBuilder() override;
-
- CharReader* newCharReader() const override;
-
- /** \return true if 'settings' are legal and consistent;
- * otherwise, indicate bad settings via 'invalid'.
- */
- bool validate(Json::Value* invalid) const;
-
- /** A simple way to update a specific setting.
- */
- Value& operator[](std::string key);
-
- /** Called by ctor, but you can use this to reset settings_.
- * \pre 'settings' != NULL (but Json::null is fine)
- * \remark Defaults:
- * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
- */
- static void setDefaults(Json::Value* settings);
- /** Same as old Features::strictMode().
- * \pre 'settings' != NULL (but Json::null is fine)
- * \remark Defaults:
- * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
- */
- static void strictMode(Json::Value* settings);
-};
-
-/** Consume entire stream and use its begin/end.
- * Someday we might have a real StreamReader, but for now this
- * is convenient.
- */
-bool JSON_API parseFromStream(
- CharReader::Factory const&,
- JSONCPP_ISTREAM&,
- Value* root, std::string* errs);
-
-/** \brief Read from 'sin' into 'root'.
-
- Always keep comments from the input JSON.
-
- This can be used to read a file into a particular sub-object.
- For example:
- \code
- Json::Value root;
- cin >> root["dir"]["file"];
- cout << root;
- \endcode
- Result:
- \verbatim
- {
- "dir": {
- "file": {
- // The input stream JSON would be nested here.
- }
- }
- }
- \endverbatim
- \throw std::exception on parse error.
- \see Json::operator<<()
-*/
-JSON_API JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM&, Value&);
-
-} // namespace Json
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // CPPTL_JSON_READER_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/reader.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/writer.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef JSON_WRITER_H_INCLUDED
-#define JSON_WRITER_H_INCLUDED
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "value.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <vector>
-#include <string>
-#include <ostream>
-
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to
-// be used by...
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(push)
-#pragma warning(disable : 4251)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-namespace Json {
-
-class Value;
-
-/**
-
-Usage:
-\code
- using namespace Json;
- void writeToStdout(StreamWriter::Factory const& factory, Value const& value) {
- std::unique_ptr<StreamWriter> const writer(
- factory.newStreamWriter());
- writer->write(value, &std::cout);
- std::cout << std::endl; // add lf and flush
- }
-\endcode
-*/
-class JSON_API StreamWriter {
-protected:
- JSONCPP_OSTREAM* sout_; // not owned; will not delete
-public:
- StreamWriter();
- virtual ~StreamWriter();
- /** Write Value into document as configured in sub-class.
- Do not take ownership of sout, but maintain a reference during function.
- \pre sout != NULL
- \return zero on success (For now, we always return zero, so check the stream instead.)
- \throw std::exception possibly, depending on configuration
- */
- virtual int write(Value const& root, JSONCPP_OSTREAM* sout) = 0;
-
- /** \brief A simple abstract factory.
- */
- class JSON_API Factory {
- public:
- virtual ~Factory();
- /** \brief Allocate a CharReader via operator new().
- * \throw std::exception if something goes wrong (e.g. invalid settings)
- */
- virtual StreamWriter* newStreamWriter() const = 0;
- }; // Factory
-}; // StreamWriter
-
-/** \brief Write into stringstream, then return string, for convenience.
- * A StreamWriter will be created from the factory, used, and then deleted.
- */
-std::string JSON_API writeString(StreamWriter::Factory const& factory, Value const& root);
-
-
-/** \brief Build a StreamWriter implementation.
-
-Usage:
-\code
- using namespace Json;
- Value value = ...;
- StreamWriterBuilder builder;
- builder["commentStyle"] = "None";
- builder["indentation"] = " "; // or whatever you like
- std::unique_ptr<Json::StreamWriter> writer(
- builder.newStreamWriter());
- writer->write(value, &std::cout);
- std::cout << std::endl; // add lf and flush
-\endcode
-*/
-class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
-public:
- // Note: We use a Json::Value so that we can add data-members to this class
- // without a major version bump.
- /** Configuration of this builder.
- Available settings (case-sensitive):
- - "commentStyle": "None" or "All"
- - "indentation": "<anything>"
- - "enableYAMLCompatibility": false or true
- - slightly change the whitespace around colons
- - "dropNullPlaceholders": false or true
- - Drop the "null" string from the writer's output for nullValues.
- Strictly speaking, this is not valid JSON. But when the output is being
- fed to a browser's Javascript, it makes for smaller output and the
- browser can handle the output just fine.
- - "useSpecialFloats": false or true
- - If true, outputs non-finite floating point values in the following way:
- NaN values as "NaN", positive infinity as "Infinity", and negative infinity
- as "-Infinity".
-
- You can examine 'settings_` yourself
- to see the defaults. You can also write and read them just like any
- JSON Value.
- \sa setDefaults()
- */
- Json::Value settings_;
-
- StreamWriterBuilder();
- ~StreamWriterBuilder() override;
-
- /**
- * \throw std::exception if something goes wrong (e.g. invalid settings)
- */
- StreamWriter* newStreamWriter() const override;
-
- /** \return true if 'settings' are legal and consistent;
- * otherwise, indicate bad settings via 'invalid'.
- */
- bool validate(Json::Value* invalid) const;
- /** A simple way to update a specific setting.
- */
- Value& operator[](std::string key);
-
- /** Called by ctor, but you can use this to reset settings_.
- * \pre 'settings' != NULL (but Json::null is fine)
- * \remark Defaults:
- * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
- */
- static void setDefaults(Json::Value* settings);
-};
-
-/** \brief Abstract class for writers.
- * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
- */
-class JSON_API Writer {
-public:
- virtual ~Writer();
-
- virtual std::string write(const Value& root) = 0;
-};
-
-/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
- *without formatting (not human friendly).
- *
- * The JSON document is written in a single line. It is not intended for 'human'
- *consumption,
- * but may be usefull to support feature such as RPC where bandwith is limited.
- * \sa Reader, Value
- * \deprecated Use StreamWriterBuilder.
- */
-class JSON_API FastWriter : public Writer {
-
-public:
- FastWriter();
- ~FastWriter() override {}
-
- void enableYAMLCompatibility();
-
- /** \brief Drop the "null" string from the writer's output for nullValues.
- * Strictly speaking, this is not valid JSON. But when the output is being
- * fed to a browser's Javascript, it makes for smaller output and the
- * browser can handle the output just fine.
- */
- void dropNullPlaceholders();
-
- void omitEndingLineFeed();
-
-public: // overridden from Writer
- std::string write(const Value& root) override;
-
-private:
- void writeValue(const Value& value);
-
- std::string document_;
- bool yamlCompatiblityEnabled_;
- bool dropNullPlaceholders_;
- bool omitEndingLineFeed_;
-};
-
-/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
- *human friendly way.
- *
- * The rules for line break and indent are as follow:
- * - Object value:
- * - if empty then print {} without indent and line break
- * - if not empty the print '{', line break & indent, print one value per
- *line
- * and then unindent and line break and print '}'.
- * - Array value:
- * - if empty then print [] without indent and line break
- * - if the array contains no object value, empty array or some other value
- *types,
- * and all the values fit on one lines, then print the array on a single
- *line.
- * - otherwise, it the values do not fit on one line, or the array contains
- * object or non empty array, then print one value per line.
- *
- * If the Value have comments then they are outputed according to their
- *#CommentPlacement.
- *
- * \sa Reader, Value, Value::setComment()
- * \deprecated Use StreamWriterBuilder.
- */
-class JSON_API StyledWriter : public Writer {
-public:
- StyledWriter();
- ~StyledWriter() override {}
-
-public: // overridden from Writer
- /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
- * \param root Value to serialize.
- * \return String containing the JSON document that represents the root value.
- */
- std::string write(const Value& root) override;
-
-private:
- void writeValue(const Value& value);
- void writeArrayValue(const Value& value);
- bool isMultineArray(const Value& value);
- void pushValue(const std::string& value);
- void writeIndent();
- void writeWithIndent(const std::string& value);
- void indent();
- void unindent();
- void writeCommentBeforeValue(const Value& root);
- void writeCommentAfterValueOnSameLine(const Value& root);
- bool hasCommentForValue(const Value& value);
- static std::string normalizeEOL(const std::string& text);
-
- typedef std::vector<std::string> ChildValues;
-
- ChildValues childValues_;
- std::string document_;
- std::string indentString_;
- unsigned int rightMargin_;
- unsigned int indentSize_;
- bool addChildValues_;
-};
-
-/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
- human friendly way,
- to a stream rather than to a string.
- *
- * The rules for line break and indent are as follow:
- * - Object value:
- * - if empty then print {} without indent and line break
- * - if not empty the print '{', line break & indent, print one value per
- line
- * and then unindent and line break and print '}'.
- * - Array value:
- * - if empty then print [] without indent and line break
- * - if the array contains no object value, empty array or some other value
- types,
- * and all the values fit on one lines, then print the array on a single
- line.
- * - otherwise, it the values do not fit on one line, or the array contains
- * object or non empty array, then print one value per line.
- *
- * If the Value have comments then they are outputed according to their
- #CommentPlacement.
- *
- * \param indentation Each level will be indented by this amount extra.
- * \sa Reader, Value, Value::setComment()
- * \deprecated Use StreamWriterBuilder.
- */
-class JSON_API StyledStreamWriter {
-public:
- StyledStreamWriter(std::string indentation = "\t");
- ~StyledStreamWriter() {}
-
-public:
- /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
- * \param out Stream to write to. (Can be ostringstream, e.g.)
- * \param root Value to serialize.
- * \note There is no point in deriving from Writer, since write() should not
- * return a value.
- */
- void write(JSONCPP_OSTREAM& out, const Value& root);
-
-private:
- void writeValue(const Value& value);
- void writeArrayValue(const Value& value);
- bool isMultineArray(const Value& value);
- void pushValue(const std::string& value);
- void writeIndent();
- void writeWithIndent(const std::string& value);
- void indent();
- void unindent();
- void writeCommentBeforeValue(const Value& root);
- void writeCommentAfterValueOnSameLine(const Value& root);
- bool hasCommentForValue(const Value& value);
- static std::string normalizeEOL(const std::string& text);
-
- typedef std::vector<std::string> ChildValues;
-
- ChildValues childValues_;
- JSONCPP_OSTREAM* document_;
- std::string indentString_;
- unsigned int rightMargin_;
- std::string indentation_;
- bool addChildValues_ : 1;
- bool indented_ : 1;
-};
-
-#if defined(JSON_HAS_INT64)
-std::string JSON_API valueToString(Int value);
-std::string JSON_API valueToString(UInt value);
-#endif // if defined(JSON_HAS_INT64)
-std::string JSON_API valueToString(LargestInt value);
-std::string JSON_API valueToString(LargestUInt value);
-std::string JSON_API valueToString(double value);
-std::string JSON_API valueToString(bool value);
-std::string JSON_API valueToQuotedString(const char* value);
-
-/// \brief Output using the StyledStreamWriter.
-/// \see Json::operator>>()
-JSON_API JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM&, const Value& root);
-
-} // namespace Json
-
-#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-#pragma warning(pop)
-#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
-#endif // JSON_WRITER_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/writer.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: include/json/assertions.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
-#define CPPTL_JSON_ASSERTIONS_H_INCLUDED
-
-#include <stdlib.h>
-#include <sstream>
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include "config.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-/** It should not be possible for a maliciously designed file to
- * cause an abort() or seg-fault, so these macros are used only
- * for pre-condition violations and internal logic errors.
- */
-#if JSON_USE_EXCEPTION
-
-// @todo <= add detail about condition in exception
-# define JSON_ASSERT(condition) \
- {if (!(condition)) {Json::throwLogicError( "assert json failed" );}}
-
-# define JSON_FAIL_MESSAGE(message) \
- { \
- JSONCPP_OSTRINGSTREAM oss; oss << message; \
- Json::throwLogicError(oss.str()); \
- abort(); \
- }
-
-#else // JSON_USE_EXCEPTION
-
-# define JSON_ASSERT(condition) assert(condition)
-
-// The call to assert() will show the failure message in debug builds. In
-// release builds we abort, for a core-dump or debugger.
-# define JSON_FAIL_MESSAGE(message) \
- { \
- JSONCPP_OSTRINGSTREAM oss; oss << message; \
- assert(false && oss.str().c_str()); \
- abort(); \
- }
-
-
-#endif
-
-#define JSON_ASSERT_MESSAGE(condition, message) \
- if (!(condition)) { \
- JSON_FAIL_MESSAGE(message); \
- }
-
-#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: include/json/assertions.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-#endif //ifndef JSON_AMALGATED_H_INCLUDED
diff --git a/src/json/json.hpp b/src/json/json.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..db73336723ede83decfe13bac70f8165a0f52959
--- /dev/null
+++ b/src/json/json.hpp
@@ -0,0 +1,8236 @@
+/*!
+@mainpage
+
+These pages contain the API documentation of JSON for Modern C++, a C++11
+header-only JSON class.
+
+Class @ref nlohmann::basic_json is a good entry point for the documentation.
+
+@copyright The code is licensed under the [MIT
+ License](http://opensource.org/licenses/MIT):
+ <br>
+ Copyright © 2013-2016 Niels Lohmann.
+ <br>
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ <br>
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ <br>
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+
+@author [Niels Lohmann](http://nlohmann.me)
+@see https://github.com/nlohmann/json to download the source code
+
+@version 1.1.0
+*/
+
+#ifndef NLOHMANN_JSON_HPP
+#define NLOHMANN_JSON_HPP
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ciso646>
+#include <cmath>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <functional>
+#include <initializer_list>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// enable ssize_t on MinGW
+#ifdef __GNUC__
+ #ifdef __MINGW32__
+ #include <sys/types.h>
+ #endif
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// enable ssize_t for MSVC
+#ifdef _MSC_VER
+ #include <basetsd.h>
+ using ssize_t = SSIZE_T;
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+
+/*!
+@brief unnamed namespace with internal helper functions
+@since version 1.0.0
+*/
+namespace
+{
+/*!
+@brief Helper to determine whether there's a key_type for T.
+@sa http://stackoverflow.com/a/7728728/266378
+*/
+template<typename T>
+struct has_mapped_type
+{
+ private:
+ template<typename C> static char test(typename C::mapped_type*);
+ template<typename C> static char (&test(...))[2];
+ public:
+ static constexpr bool value = sizeof(test<T>(0)) == 1;
+};
+
+}
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (@c std::map by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (@c std::vector by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (@c std::string by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (@c `bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (@c `int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberFloatType type for JSON floating-point numbers (@c `double` by
+default; will be used in @ref number_float_t)
+@tparam AllocatorType type of the allocator to use (@c `std::allocator` by
+default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):
+ JSON values can be default constructed. The result will be a JSON null value.
+ - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):
+ A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):
+ A JSON value can be copy-constructed from an lvalue expression.
+ - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):
+ A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):
+ A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):
+ JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):
+ JSON values have
+ [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+ All non-static data members are private and standard layout types, the class
+ has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):
+ JSON values can be compared with `==`, see @ref
+ operator==(const_reference,const_reference).
+ - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):
+ JSON values can be compared with `<`, see @ref
+ operator<(const_reference,const_reference).
+ - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):
+ Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+ other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):
+ JSON values can be compared against `std::nullptr_t` objects which are used
+ to model the `null` value.
+- Container
+ - [Container](http://en.cppreference.com/w/cpp/concept/Container):
+ JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);
+ JSON values can be used like STL containers and provide reverse iterator
+ access.
+
+@internal
+@note ObjectType trick from http://stackoverflow.com/a/9860911
+@endinternal
+
+@see RFC 7159 <http://rfc7159.net/rfc7159>
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+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,
+ class NumberFloatType = double,
+ template<typename U> class AllocatorType = std::allocator
+ >
+class basic_json
+{
+ private:
+ /// workaround type for MSVC
+ using basic_json_t = basic_json<ObjectType,
+ ArrayType,
+ StringType,
+ BooleanType,
+ NumberIntegerType,
+ NumberFloatType,
+ AllocatorType>;
+
+ public:
+
+ /////////////////////
+ // container types //
+ /////////////////////
+
+ /// @name container types
+ /// @{
+
+ /// the type of elements in a basic_json container
+ using value_type = basic_json;
+
+ /// the type of an element reference
+ using reference = value_type&;
+ /// the type of an element const reference
+ using const_reference = const value_type&;
+
+ /// a type to represent differences between iterators
+ using difference_type = std::ptrdiff_t;
+ /// a type to represent container sizes
+ using size_type = std::size_t;
+
+ /// the allocator type
+ using allocator_type = AllocatorType<basic_json>;
+
+ /// the type of an element pointer
+ using pointer = typename std::allocator_traits<allocator_type>::pointer;
+ /// the type of an element const pointer
+ using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+ // forward declaration
+ template<typename Base> class json_reverse_iterator;
+
+ /// an iterator for a basic_json container
+ class iterator;
+ /// a const iterator for a basic_json container
+ class const_iterator;
+ /// a reverse iterator for a basic_json container
+ using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+ /// a const reverse iterator for a basic_json container
+ using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+ /// @}
+
+
+ /*!
+ @brief returns the allocator associated with the container
+ */
+ static allocator_type get_allocator()
+ {
+ return allocator_type();
+ }
+
+
+ ///////////////////////////
+ // JSON value data types //
+ ///////////////////////////
+
+ /// @name JSON value data types
+ /// @{
+
+ /*!
+ @brief a type for an object
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+ > An object is an unordered collection of zero or more name/value pairs,
+ > where a name is a string and a value is a string, number, boolean, null,
+ > object, or array.
+
+ To store objects in C++, a type is defined by the template parameters
+ described below.
+
+ @tparam ObjectType the container to store objects (e.g., `std::map` or
+ `std::unordered_map`)
+ @tparam StringType the type of the keys or names (e.g., `std::string`). The
+ comparison function `std::less<StringType>` is used to order elements
+ inside the container.
+ @tparam AllocatorType the allocator to use for objects (e.g.,
+ `std::allocator`)
+
+ #### Default type
+
+ With the default values for @a ObjectType (`std::map`), @a StringType
+ (`std::string`), and @a AllocatorType (`std::allocator`), the default value
+ for @a object_t is:
+
+ @code {.cpp}
+ std::map<
+ std::string, // key_type
+ basic_json, // value_type
+ std::less<std::string>, // key_compare
+ std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+ >
+ @endcode
+
+ #### Behavior
+
+ The choice of @a object_t influences the behavior of the JSON class. With
+ the default type, objects have the following behavior:
+
+ - When all names are unique, objects will be interoperable in the sense
+ that all software implementations receiving that object will agree on the
+ name-value mappings.
+ - When the names within an object are not unique, later stored name/value
+ pairs overwrite previously stored name/value pairs, leaving the used
+ names unique. For instance, `{"key": 1}` and `{"key": 2, "key": 1}` will
+ be treated as equal and both stored as `{"key": 1}`.
+ - Internally, name/value pairs are stored in lexicographical order of the
+ names. Objects will also be serialized (see @ref dump) in this order. For
+ instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored and
+ serialized as `{"a": 2, "b": 1}`.
+ - When comparing objects, the order of the name/value pairs is irrelevant.
+ This makes objects interoperable in the sense that they will not be
+ affected by these differences. For instance, `{"b": 1, "a": 2}` and
+ `{"a": 2, "b": 1}` will be treated as equal.
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+ > An implementation may set limits on the maximum depth of nesting.
+
+ In this class, the object's limit of nesting is not constraint explicitly.
+ However, a maximum depth of nesting may be introduced by the compiler or
+ runtime environment. A theoretical limit can be queried by calling the @ref
+ max_size function of a JSON object.
+
+ #### Storage
+
+ Objects are stored as pointers in a @ref basic_json type. That is, for any
+ access to object values, a pointer of type `object_t*` must be dereferenced.
+
+ @sa @ref array_t -- type for an array value
+
+ @since version 1.0.0
+
+ @note The order name/value pairs are added to the object is *not* preserved
+ by the library. Therefore, iterating an object may return name/value pairs
+ in a different order than they were originally stored. In fact, keys will
+ be traversed in alphabetical order as `std::map` with `std::less` is used
+ by default. Please note this behavior conforms to [RFC
+ 7159](http://rfc7159.net/rfc7159), because any order implements the
+ specified "unordered" nature of JSON objects.
+ */
+ using object_t = ObjectType<StringType,
+ basic_json,
+ std::less<StringType>,
+ AllocatorType<std::pair<const StringType,
+ basic_json>>>;
+
+ /*!
+ @brief a type for an array
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+ > An array is an ordered sequence of zero or more values.
+
+ To store objects in C++, a type is defined by the template parameters
+ explained below.
+
+ @tparam ArrayType container type to store arrays (e.g., `std::vector` or
+ `std::list`)
+ @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+ #### Default type
+
+ With the default values for @a ArrayType (`std::vector`) and @a
+ AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+ @code {.cpp}
+ std::vector<
+ basic_json, // value_type
+ std::allocator<basic_json> // allocator_type
+ >
+ @endcode
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+ > An implementation may set limits on the maximum depth of nesting.
+
+ In this class, the array's limit of nesting is not constraint explicitly.
+ However, a maximum depth of nesting may be introduced by the compiler or
+ runtime environment. A theoretical limit can be queried by calling the @ref
+ max_size function of a JSON array.
+
+ #### Storage
+
+ Arrays are stored as pointers in a @ref basic_json type. That is, for any
+ access to array values, a pointer of type `array_t*` must be dereferenced.
+
+ @sa @ref object_t -- type for an object value
+
+ @since version 1.0.0
+ */
+ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+ /*!
+ @brief a type for a string
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+ > A string is a sequence of zero or more Unicode characters.
+
+ To store objects in C++, a type is defined by the template parameter
+ described below. Unicode values are split by the JSON class into byte-sized
+ characters during deserialization.
+
+ @tparam StringType the container to store strings (e.g., `std::string`).
+ Note this container is used for keys/names in objects, see @ref object_t.
+
+ #### Default type
+
+ With the default values for @a StringType (`std::string`), the default
+ value for @a string_t is:
+
+ @code {.cpp}
+ std::string
+ @endcode
+
+ #### String comparison
+
+ [RFC 7159](http://rfc7159.net/rfc7159) states:
+ > Software implementations are typically required to test names of object
+ > members for equality. Implementations that transform the textual
+ > representation into sequences of Unicode code units and then perform the
+ > comparison numerically, code unit by code unit, are interoperable in the
+ > sense that implementations will agree in all cases on equality or
+ > inequality of two strings. For example, implementations that compare
+ > strings with escaped characters unconverted may incorrectly find that
+ > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+ This implementation is interoperable as it does compare strings code unit
+ by code unit.
+
+ #### Storage
+
+ String values are stored as pointers in a @ref basic_json type. That is,
+ for any access to string values, a pointer of type `string_t*` must be
+ dereferenced.
+
+ @since version 1.0.0
+ */
+ using string_t = StringType;
+
+ /*!
+ @brief a type for a boolean
+
+ [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+ type which differentiates the two literals `true` and `false`.
+
+ To store objects in C++, a type is defined by the template parameter @a
+ BooleanType which chooses the type to use.
+
+ #### Default type
+
+ With the default values for @a BooleanType (`bool`), the default value for
+ @a boolean_t is:
+
+ @code {.cpp}
+ bool
+ @endcode
+
+ #### Storage
+
+ Boolean values are stored directly inside a @ref basic_json type.
+
+ @since version 1.0.0
+ */
+ using boolean_t = BooleanType;
+
+ /*!
+ @brief a type for a number (integer)
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+ > The representation of numbers is similar to that used in most programming
+ > languages. A number is represented in base 10 using decimal digits. It
+ > contains an integer component that may be prefixed with an optional minus
+ > sign, which may be followed by a fraction part and/or an exponent part.
+ > Leading zeros are not allowed. (...) Numeric values that cannot be
+ > represented in the grammar below (such as Infinity and NaN) are not
+ > permitted.
+
+ This description includes both integer and floating-point numbers. However,
+ C++ allows more precise storage if it is known whether the number is an
+ integer or a floating-point number. Therefore, two different types, @ref
+ number_integer_t and @ref number_float_t are used.
+
+ To store integer numbers in C++, a type is defined by the template
+ parameter @a NumberIntegerType which chooses the type to use.
+
+ #### Default type
+
+ With the default values for @a NumberIntegerType (`int64_t`), the default
+ value for @a number_integer_t is:
+
+ @code {.cpp}
+ int64_t
+ @endcode
+
+ #### Default behavior
+
+ - The restrictions about leading zeros is not enforced in C++. Instead,
+ leading zeros in integer literals lead to an interpretation as octal
+ number. Internally, the value will be stored as decimal number. For
+ instance, the C++ integer literal `010` will be serialized to `8`. During
+ deserialization, leading zeros yield an error.
+ - Not-a-number (NaN) values will be serialized to `null`.
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+ > An implementation may set limits on the range and precision of numbers.
+
+ When the default type is used, the maximal integer number that can be
+ stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+ that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+ that are out of range will yield over/underflow when used in a constructor.
+ During deserialization, too large or small integer numbers will be
+ automatically be stored as @ref number_float_t.
+
+ [RFC 7159](http://rfc7159.net/rfc7159) further states:
+ > Note that when such software is used, numbers that are integers and are
+ > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+ > that implementations will agree exactly on their numeric values.
+
+ As this range is a subrange of the exactly supported range [INT64_MIN,
+ INT64_MAX], this class's integer type is interoperable.
+
+ #### Storage
+
+ Integer number values are stored directly inside a @ref basic_json type.
+
+ @sa @ref number_float_t -- type for number values (floating-point)
+
+ @since version 1.0.0
+ */
+ using number_integer_t = NumberIntegerType;
+
+ /*!
+ @brief a type for a number (floating-point)
+
+ [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+ > The representation of numbers is similar to that used in most programming
+ > languages. A number is represented in base 10 using decimal digits. It
+ > contains an integer component that may be prefixed with an optional minus
+ > sign, which may be followed by a fraction part and/or an exponent part.
+ > Leading zeros are not allowed. (...) Numeric values that cannot be
+ > represented in the grammar below (such as Infinity and NaN) are not
+ > permitted.
+
+ This description includes both integer and floating-point numbers. However,
+ C++ allows more precise storage if it is known whether the number is an
+ integer or a floating-point number. Therefore, two different types, @ref
+ number_integer_t and @ref number_float_t are used.
+
+ To store floating-point numbers in C++, a type is defined by the template
+ parameter @a NumberFloatType which chooses the type to use.
+
+ #### Default type
+
+ With the default values for @a NumberFloatType (`double`), the default
+ value for @a number_float_t is:
+
+ @code {.cpp}
+ double
+ @endcode
+
+ #### Default behavior
+
+ - The restrictions about leading zeros is not enforced in C++. Instead,
+ leading zeros in floating-point literals will be ignored. Internally, the
+ value will be stored as decimal number. For instance, the C++
+ floating-point literal `01.2` will be serialized to `1.2`. During
+ deserialization, leading zeros yield an error.
+ - Not-a-number (NaN) values will be serialized to `null`.
+
+ #### Limits
+
+ [RFC 7159](http://rfc7159.net/rfc7159) states:
+ > This specification allows implementations to set limits on the range and
+ > precision of numbers accepted. Since software that implements IEEE
+ > 754-2008 binary64 (double precision) numbers is generally available and
+ > widely used, good interoperability can be achieved by implementations that
+ > expect no more precision or range than these provide, in the sense that
+ > implementations will approximate JSON numbers within the expected
+ > precision.
+
+ This implementation does exactly follow this approach, as it uses double
+ precision floating-point numbers. Note values smaller than
+ `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
+ will be stored as NaN internally and be serialized to `null`.
+
+ #### Storage
+
+ Floating-point number values are stored directly inside a @ref basic_json
+ type.
+
+ @sa @ref number_integer_t -- type for number values (integer)
+
+ @since version 1.0.0
+ */
+ using number_float_t = NumberFloatType;
+
+ /// @}
+
+
+ ///////////////////////////
+ // JSON type enumeration //
+ ///////////////////////////
+
+ /*!
+ @brief the JSON type enumeration
+
+ This enumeration collects the different JSON types. It is internally used
+ to distinguish the stored values, and the functions @ref is_null(), @ref
+ is_object(), @ref is_array(), @ref is_string(), @ref is_boolean(), @ref
+ is_number(), and @ref is_discarded() rely on it.
+
+ @since version 1.0.0
+ */
+ enum class value_t : uint8_t
+ {
+ 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)
+ discarded ///< discarded by the the parser callback function
+ };
+
+
+ private:
+ /// helper for exception-safe object creation
+ template<typename T, typename... Args>
+ static T* create(Args&& ... args)
+ {
+ AllocatorType<T> alloc;
+ auto deleter = [&](T * object)
+ {
+ alloc.deallocate(object, 1);
+ };
+ std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
+ alloc.construct(object.get(), std::forward<Args>(args)...);
+ return object.release();
+ }
+
+ ////////////////////////
+ // JSON value storage //
+ ////////////////////////
+
+ /*!
+ @brief a JSON value
+
+ The actual storage for a JSON value of the @ref basic_json class.
+
+ @since version 1.0.0
+ */
+ union json_value
+ {
+ /// object (stored with pointer to save storage)
+ object_t* object;
+ /// array (stored with pointer to save storage)
+ array_t* array;
+ /// string (stored with pointer to save storage)
+ string_t* string;
+ /// boolean
+ boolean_t boolean;
+ /// number (integer)
+ number_integer_t number_integer;
+ /// number (floating-point)
+ number_float_t number_float;
+
+ /// default constructor (for null values)
+ json_value() noexcept = default;
+ /// constructor for booleans
+ json_value(boolean_t v) noexcept : boolean(v) {}
+ /// constructor for numbers (integer)
+ json_value(number_integer_t v) noexcept : number_integer(v) {}
+ /// constructor for numbers (floating-point)
+ json_value(number_float_t v) noexcept : number_float(v) {}
+ /// constructor for empty values of a given type
+ json_value(value_t t)
+ {
+ switch (t)
+ {
+ case value_t::object:
+ {
+ object = create<object_t>();
+ break;
+ }
+
+ case value_t::array:
+ {
+ array = create<array_t>();
+ break;
+ }
+
+ case value_t::string:
+ {
+ string = create<string_t>("");
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ boolean = boolean_t(false);
+ break;
+ }
+
+ case value_t::number_integer:
+ {
+ number_integer = number_integer_t(0);
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ number_float = number_float_t(0.0);
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ /// constructor for strings
+ json_value(const string_t& value)
+ {
+ string = create<string_t>(value);
+ }
+
+ /// constructor for objects
+ json_value(const object_t& value)
+ {
+ object = create<object_t>(value);
+ }
+
+ /// constructor for arrays
+ json_value(const array_t& value)
+ {
+ array = create<array_t>(value);
+ }
+ };
+
+
+ public:
+ //////////////////////////
+ // JSON parser callback //
+ //////////////////////////
+
+ /*!
+ @brief JSON callback events
+
+ This enumeration lists the parser events that can trigger calling a
+ callback function of type @ref parser_callback_t during parsing.
+
+ @since version 1.0.0
+ */
+ enum class parse_event_t : uint8_t
+ {
+ /// the parser read `{` and started to process a JSON object
+ object_start,
+ /// the parser read `}` and finished processing a JSON object
+ object_end,
+ /// the parser read `[` and started to process a JSON array
+ array_start,
+ /// the parser read `]` and finished processing a JSON array
+ array_end,
+ /// the parser read a key of a value in an object
+ key,
+ /// the parser finished reading a JSON value
+ value
+ };
+
+ /*!
+ @brief per-element parser callback type
+
+ With a parser callback function, the result of parsing a JSON text can be
+ influenced. When passed to @ref parse(std::istream&, parser_callback_t) or
+ @ref parse(const string_t&, parser_callback_t), it is called on certain
+ events (passed as @ref parse_event_t via parameter @a event) with a set
+ recursion depth @a depth and context JSON value @a parsed. The return value
+ of the callback function is a boolean indicating whether the element that
+ emitted the callback shall be kept or not.
+
+ We distinguish six scenarios (determined by the event type) in which the
+ callback function can be called. The following table describes the values
+ of the parameters @a depth, @a event, and @a parsed.
+
+ parameter @a event | description | parameter @a depth | parameter @a parsed
+ ------------------ | ----------- | ------------------ | -------------------
+ parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+ parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+ parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+ parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+ parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+ parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+ Discarding a value (i.e., returning `false`) has different effects
+ depending on the context in which function was called:
+
+ - Discarded values in structured types are skipped. That is, the parser
+ will behave as if the discarded value was never read.
+ - In case a value outside a structured type is skipped, it is replaced with
+ `null`. This case happens if the top-level element is skipped.
+
+ @param[in] depth the depth of the recursion during parsing
+
+ @param[in] event an event of type parse_event_t indicating the context in
+ the callback function has been called
+
+ @param[in,out] parsed the current intermediate parse result; note that
+ writing to this value has no effect for parse_event_t::key events
+
+ @return Whether the JSON value which called the function during parsing
+ should be kept (`true`) or not (`false`). In the latter case, it is either
+ skipped completely or replaced by an empty discarded object.
+
+ @sa @ref parse(std::istream&, parser_callback_t) or
+ @ref parse(const string_t&, parser_callback_t) for examples
+
+ @since version 1.0.0
+ */
+ using parser_callback_t = std::function<bool(int depth, parse_event_t event, basic_json& parsed)>;
+
+
+ //////////////////
+ // constructors //
+ //////////////////
+
+ /// @name constructors and destructors
+ /// @{
+
+ /*!
+ @brief create an empty value with a given type
+
+ Create an empty JSON value with a given type. The value will be default
+ initialized with an empty value which depends on the type:
+
+ Value type | initial value
+ ----------- | -------------
+ null | `null`
+ boolean | `false`
+ string | `""`
+ number | `0`
+ object | `{}`
+ array | `[]`
+
+ @param[in] value_type the type of the value to create
+
+ @complexity Constant.
+
+ @throw std::bad_alloc if allocation for object, array, or string value
+ fails
+
+ @liveexample{The following code shows the constructor for different @ref
+ value_t values,basic_json__value_t}
+
+ @sa @ref basic_json(std::nullptr_t) -- create a `null` value
+ @sa @ref basic_json(boolean_t value) -- create a boolean value
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const object_t&) -- create a object value
+ @sa @ref basic_json(const array_t&) -- create a array value
+ @sa @ref basic_json(const number_float_t) -- create a number
+ (floating-point) value
+ @sa @ref basic_json(const number_integer_t) -- create a number (integer)
+ value
+
+ @since version 1.0.0
+ */
+ basic_json(const value_t value_type)
+ : m_type(value_type), m_value(value_type)
+ {}
+
+ /*!
+ @brief create a null object (implicitly)
+
+ Create a `null` JSON value. This is the implicit version of the `null`
+ value constructor as it takes no parameters.
+
+ @complexity Constant.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - As postcondition, it holds: `basic_json().empty() == true`.
+
+ @liveexample{The following code shows the constructor for a `null` JSON
+ value.,basic_json}
+
+ @sa @ref basic_json(std::nullptr_t) -- create a `null` value
+
+ @since version 1.0.0
+ */
+ basic_json() noexcept = default;
+
+ /*!
+ @brief create a null object (explicitly)
+
+ Create a `null` JSON value. This is the explicitly version of the `null`
+ value constructor as it takes a null pointer as parameter. It allows to
+ create `null` values by explicitly assigning a @c nullptr to a JSON value.
+ The passed null pointer itself is not read -- it is only used to choose the
+ right constructor.
+
+ @complexity Constant.
+
+ @liveexample{The following code shows the constructor with null pointer
+ parameter.,basic_json__nullptr_t}
+
+ @sa @ref basic_json() -- default constructor (implicitly creating a `null`
+ value)
+
+ @since version 1.0.0
+ */
+ basic_json(std::nullptr_t) noexcept
+ : basic_json(value_t::null)
+ {}
+
+ /*!
+ @brief create an object (explicit)
+
+ Create an object JSON value with a given content.
+
+ @param[in] val a value for the object
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for object value fails
+
+ @liveexample{The following code shows the constructor with an @ref object_t
+ parameter.,basic_json__object_t}
+
+ @sa @ref basic_json(const CompatibleObjectType&) -- create an object value
+ from a compatible STL container
+
+ @since version 1.0.0
+ */
+ basic_json(const object_t& val)
+ : m_type(value_t::object), m_value(val)
+ {}
+
+ /*!
+ @brief create an object (implicit)
+
+ Create an object JSON value with a given content. This constructor allows
+ any type that can be used to construct values of type @ref object_t.
+ Examples include the types `std::map` and `std::unordered_map`.
+
+ @tparam CompatibleObjectType an object type whose `key_type` and
+ `value_type` is compatible to @ref object_t
+
+ @param[in] val a value for the object
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for object value fails
+
+ @liveexample{The following code shows the constructor with several
+ compatible object type parameters.,basic_json__CompatibleObjectType}
+
+ @sa @ref basic_json(const object_t&) -- create an object value
+
+ @since version 1.0.0
+ */
+ template <class CompatibleObjectType, typename
+ std::enable_if<
+ std::is_constructible<typename object_t::key_type, typename CompatibleObjectType::key_type>::value and
+ std::is_constructible<basic_json, typename CompatibleObjectType::mapped_type>::value, int>::type
+ = 0>
+ basic_json(const CompatibleObjectType& val)
+ : m_type(value_t::object)
+ {
+ using std::begin;
+ using std::end;
+ m_value.object = create<object_t>(begin(val), end(val));
+ }
+
+ /*!
+ @brief create an array (explicit)
+
+ Create an array JSON value with a given content.
+
+ @param[in] val a value for the array
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for array value fails
+
+ @liveexample{The following code shows the constructor with an @ref array_t
+ parameter.,basic_json__array_t}
+
+ @sa @ref basic_json(const CompatibleArrayType&) -- create an array value
+ from a compatible STL containers
+
+ @since version 1.0.0
+ */
+ basic_json(const array_t& val)
+ : m_type(value_t::array), m_value(val)
+ {}
+
+ /*!
+ @brief create an array (implicit)
+
+ Create an array JSON value with a given content. This constructor allows
+ any type that can be used to construct values of type @ref array_t.
+ Examples include the types `std::vector`, `std::list`, and `std::set`.
+
+ @tparam CompatibleArrayType an object type whose `value_type` is compatible
+ to @ref array_t
+
+ @param[in] val a value for the array
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for array value fails
+
+ @liveexample{The following code shows the constructor with several
+ compatible array type parameters.,basic_json__CompatibleArrayType}
+
+ @sa @ref basic_json(const array_t&) -- create an array value
+
+ @since version 1.0.0
+ */
+ template <class CompatibleArrayType, typename
+ std::enable_if<
+ not std::is_same<CompatibleArrayType, typename basic_json_t::iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::const_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::reverse_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename basic_json_t::const_reverse_iterator>::value and
+ not std::is_same<CompatibleArrayType, typename array_t::iterator>::value and
+ not std::is_same<CompatibleArrayType, typename array_t::const_iterator>::value and
+ std::is_constructible<basic_json, typename CompatibleArrayType::value_type>::value, int>::type
+ = 0>
+ basic_json(const CompatibleArrayType& val)
+ : m_type(value_t::array)
+ {
+ using std::begin;
+ using std::end;
+ m_value.array = create<array_t>(begin(val), end(val));
+ }
+
+ /*!
+ @brief create a string (explicit)
+
+ Create an string JSON value with a given content.
+
+ @param[in] val a value for the string
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the constructor with an @ref string_t
+ parameter.,basic_json__string_t}
+
+ @sa @ref basic_json(const typename string_t::value_type*) -- create a
+ string value from a character pointer
+ @sa @ref basic_json(const CompatibleStringType&) -- create a string value
+ from a compatible string container
+
+ @since version 1.0.0
+ */
+ basic_json(const string_t& val)
+ : m_type(value_t::string), m_value(val)
+ {}
+
+ /*!
+ @brief create a string (explicit)
+
+ Create a string JSON value with a given content.
+
+ @param[in] val a literal value for the string
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the constructor with string literal
+ parameter.,basic_json__string_t_value_type}
+
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const CompatibleStringType&) -- create a string value
+ from a compatible string container
+
+ @since version 1.0.0
+ */
+ basic_json(const typename string_t::value_type* val)
+ : basic_json(string_t(val))
+ {}
+
+ /*!
+ @brief create a string (implicit)
+
+ Create a string JSON value with a given content.
+
+ @param[in] val a value for the string
+
+ @tparam CompatibleStringType an string type which is compatible to @ref
+ string_t
+
+ @complexity Linear in the size of the passed @a val.
+
+ @throw std::bad_alloc if allocation for string value fails
+
+ @liveexample{The following code shows the construction of a string value
+ from a compatible type.,basic_json__CompatibleStringType}
+
+ @sa @ref basic_json(const string_t&) -- create a string value
+ @sa @ref basic_json(const typename string_t::value_type*) -- create a
+ string value from a character pointer
+
+ @since version 1.0.0
+ */
+ template <class CompatibleStringType, typename
+ std::enable_if<
+ std::is_constructible<string_t, CompatibleStringType>::value, int>::type
+ = 0>
+ basic_json(const CompatibleStringType& val)
+ : basic_json(string_t(val))
+ {}
+
+ /*!
+ @brief create a boolean (explicit)
+
+ Creates a JSON boolean type from a given value.
+
+ @param[in] val a boolean value to store
+
+ @complexity Constant.
+
+ @liveexample{The example below demonstrates boolean
+ values.,basic_json__boolean_t}
+
+ @since version 1.0.0
+ */
+ basic_json(boolean_t val)
+ : m_type(value_t::boolean), m_value(val)
+ {}
+
+ /*!
+ @brief create an integer number (explicit)
+
+ Create an integer number JSON value with a given content.
+
+ @tparam T helper type to compare number_integer_t and int (not visible in)
+ the interface.
+
+ @param[in] val an integer to create a JSON number from
+
+ @note This constructor would have the same signature as @ref
+ basic_json(const int value), so we need to switch this one off in case
+ number_integer_t is the same as int. This is done via the helper type @a T.
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of a JSON integer
+ number value.,basic_json__number_integer_t}
+
+ @sa @ref basic_json(const int) -- create a number value (integer)
+ @sa @ref basic_json(const CompatibleNumberIntegerType) -- create a number
+ value (integer) from a compatible number type
+
+ @since version 1.0.0
+ */
+ template<typename T,
+ typename std::enable_if<
+ not (std::is_same<T, int>::value)
+ and std::is_same<T, number_integer_t>::value
+ , int>::type = 0>
+ basic_json(const number_integer_t val)
+ : m_type(value_t::number_integer), m_value(val)
+ {}
+
+ /*!
+ @brief create an integer number from an enum type (explicit)
+
+ Create an integer number JSON value with a given content.
+
+ @param[in] val an integer to create a JSON number from
+
+ @note This constructor allows to pass enums directly to a constructor. As
+ C++ has no way of specifying the type of an anonymous enum explicitly, we
+ can only rely on the fact that such values implicitly convert to int. As
+ int may already be the same type of number_integer_t, we may need to switch
+ off the constructor @ref basic_json(const number_integer_t).
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of a JSON integer
+ number value from an anonymous enum.,basic_json__const_int}
+
+ @sa @ref basic_json(const number_integer_t) -- create a number value
+ (integer)
+ @sa @ref basic_json(const CompatibleNumberIntegerType) -- create a number
+ value (integer) from a compatible number type
+
+ @since version 1.0.0
+ */
+ basic_json(const int val)
+ : m_type(value_t::number_integer),
+ m_value(static_cast<number_integer_t>(val))
+ {}
+
+ /*!
+ @brief create an integer number (implicit)
+
+ Create an integer number JSON value with a given content. This constructor
+ allows any type that can be used to construct values of type @ref
+ number_integer_t. Examples may include the types `int`, `int32_t`, or
+ `short`.
+
+ @tparam CompatibleNumberIntegerType an integer type which is compatible to
+ @ref number_integer_t.
+
+ @param[in] val an integer to create a JSON number from
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of several JSON
+ integer number values from compatible
+ types.,basic_json__CompatibleIntegerNumberType}
+
+ @sa @ref basic_json(const number_integer_t) -- create a number value
+ (integer)
+ @sa @ref basic_json(const int) -- create a number value (integer)
+
+ @since version 1.0.0
+ */
+ template<typename CompatibleNumberIntegerType, typename
+ std::enable_if<
+ std::is_constructible<number_integer_t, CompatibleNumberIntegerType>::value and
+ std::numeric_limits<CompatibleNumberIntegerType>::is_integer, CompatibleNumberIntegerType>::type
+ = 0>
+ basic_json(const CompatibleNumberIntegerType val) noexcept
+ : m_type(value_t::number_integer),
+ m_value(static_cast<number_integer_t>(val))
+ {}
+
+ /*!
+ @brief create a floating-point number (explicit)
+
+ Create a floating-point number JSON value with a given content.
+
+ @param[in] val a floating-point value to create a JSON number from
+
+ @note RFC 7159 <http://www.rfc-editor.org/rfc/rfc7159.txt>, section 6
+ disallows NaN values:
+ > Numeric values that cannot be represented in the grammar below (such
+ > as Infinity and NaN) are not permitted.
+ In case the parameter @a val is not a number, a JSON null value is
+ created instead.
+
+ @complexity Constant.
+
+ @liveexample{The following example creates several floating-point
+ values.,basic_json__number_float_t}
+
+ @sa @ref basic_json(const CompatibleNumberFloatType) -- create a number
+ value (floating-point) from a compatible number type
+
+ @since version 1.0.0
+ */
+ basic_json(const number_float_t val)
+ : m_type(value_t::number_float), m_value(val)
+ {
+ // replace infinity and NAN by null
+ if (not std::isfinite(val))
+ {
+ m_type = value_t::null;
+ m_value = json_value();
+ }
+ }
+
+ /*!
+ @brief create an floating-point number (implicit)
+
+ Create an floating-point number JSON value with a given content. This
+ constructor allows any type that can be used to construct values of type
+ @ref number_float_t. Examples may include the types `float`.
+
+ @tparam CompatibleNumberFloatType a floating-point type which is compatible
+ to @ref number_float_t.
+
+ @param[in] val a floating-point to create a JSON number from
+
+ @note RFC 7159 <http://www.rfc-editor.org/rfc/rfc7159.txt>, section 6
+ disallows NaN values:
+ > Numeric values that cannot be represented in the grammar below (such
+ > as Infinity and NaN) are not permitted.
+ In case the parameter @a val is not a number, a JSON null value is
+ created instead.
+
+ @complexity Constant.
+
+ @liveexample{The example below shows the construction of several JSON
+ floating-point number values from compatible
+ types.,basic_json__CompatibleNumberFloatType}
+
+ @sa @ref basic_json(const number_float_t) -- create a number value
+ (floating-point)
+
+ @since version 1.0.0
+ */
+ template<typename CompatibleNumberFloatType, typename = typename
+ std::enable_if<
+ std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and
+ std::is_floating_point<CompatibleNumberFloatType>::value>::type
+ >
+ basic_json(const CompatibleNumberFloatType val) noexcept
+ : basic_json(number_float_t(val))
+ {}
+
+ /*!
+ @brief create a container (array or object) from an initializer list
+
+ Creates a JSON value of type array or object from the passed initializer
+ list @a init. In case @a type_deduction is `true` (default), the type of
+ the JSON value to be created is deducted from the initializer list @a init
+ according to the following rules:
+
+ 1. If the list is empty, an empty JSON object value `{}` is created.
+ 2. If the list consists of pairs whose first element is a string, a JSON
+ object value is created where the first elements of the pairs are treated
+ as keys and the second elements are as values.
+ 3. In all other cases, an array is created.
+
+ The rules aim to create the best fit between a C++ initializer list and
+ JSON values. The rationale is as follows:
+
+ 1. The empty initializer list is written as `{}` which is exactly an empty
+ JSON object.
+ 2. C++ has now way of describing mapped types other than to list a list of
+ pairs. As JSON requires that keys must be of type string, rule 2 is the
+ weakest constraint one can pose on initializer lists to interpret them as
+ an object.
+ 3. In all other cases, the initializer list could not be interpreted as
+ JSON object type, so interpreting it as JSON array type is safe.
+
+ With the rules described above, the following JSON values cannot be
+ expressed by an initializer list:
+
+ - the empty array (`[]`): use @ref array(std::initializer_list<basic_json>)
+ with an empty initializer list in this case
+ - arrays whose elements satisfy rule 2: use @ref
+ array(std::initializer_list<basic_json>) with the same initializer list
+ in this case
+
+ @note When used without parentheses around an empty initializer list, @ref
+ basic_json() is called instead of this function, yielding the JSON null
+ value.
+
+ @param[in] init initializer list with JSON values
+
+ @param[in] type_deduction internal parameter; when set to `true`, the type
+ of the JSON value is deducted from the initializer list @a init; when set
+ to `false`, the type provided via @a manual_type is forced. This mode is
+ used by the functions @ref array(std::initializer_list<basic_json>) and
+ @ref object(std::initializer_list<basic_json>).
+
+ @param[in] manual_type internal parameter; when @a type_deduction is set to
+ `false`, the created JSON value will use the provided type (only @ref
+ value_t::array and @ref value_t::object are valid); when @a type_deduction
+ is set to `true`, this parameter has no effect
+
+ @throw std::domain_error if @a type_deduction is `false`, @a manual_type is
+ `value_t::object`, but @a init contains an element which is not a pair
+ whose first element is a string; example: `"cannot create object from
+ initializer list"`
+
+ @complexity Linear in the size of the initializer list @a init.
+
+ @liveexample{The example below shows how JSON values are created from
+ initializer lists,basic_json__list_init_t}
+
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
+ value from an initializer list
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ basic_json(std::initializer_list<basic_json> init,
+ bool type_deduction = true,
+ value_t manual_type = value_t::array)
+ {
+ // the initializer list could describe an object
+ bool is_an_object = true;
+
+ // check if each element is an array with two elements whose first
+ // element is a string
+ for (const auto& element : init)
+ {
+ if (not element.is_array() or element.size() != 2
+ or not element[0].is_string())
+ {
+ // we found an element that makes it impossible to use the
+ // initializer list as object
+ is_an_object = false;
+ break;
+ }
+ }
+
+ // adjust type if type deduction is not wanted
+ if (not type_deduction)
+ {
+ // if array is wanted, do not create an object though possible
+ if (manual_type == value_t::array)
+ {
+ is_an_object = false;
+ }
+
+ // if object is wanted but impossible, throw an exception
+ if (manual_type == value_t::object and not is_an_object)
+ {
+ throw std::domain_error("cannot create object from initializer list");
+ }
+ }
+
+ if (is_an_object)
+ {
+ // the initializer list is a list of pairs -> create object
+ m_type = value_t::object;
+ m_value = value_t::object;
+
+ assert(m_value.object != nullptr);
+
+ for (auto& element : init)
+ {
+ 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;
+ m_value.array = create<array_t>(std::move(init));
+ }
+ }
+
+ /*!
+ @brief explicitly create an array from an initializer list
+
+ Creates a JSON array value from a given initializer list. That is, given a
+ list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+ initializer list is empty, the empty array `[]` is created.
+
+ @note This function is only needed to express two edge cases that cannot be
+ realized with the initializer list constructor (@ref
+ basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases
+ are:
+ 1. creating an array whose elements are all pairs whose first element is a
+ string -- in this case, the initializer list constructor would create an
+ object, taking the first elements as keys
+ 2. creating an empty array -- passing the empty initializer list to the
+ initializer list constructor yields an empty object
+
+ @param[in] init initializer list with JSON values to create an array from
+ (optional)
+
+ @return JSON array value
+
+ @complexity Linear in the size of @a init.
+
+ @liveexample{The following code shows an example for the @ref array
+ function.,array}
+
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
+ create a JSON value from an initializer list
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ static basic_json array(std::initializer_list<basic_json> init =
+ std::initializer_list<basic_json>())
+ {
+ return basic_json(init, false, value_t::array);
+ }
+
+ /*!
+ @brief explicitly create an object from an initializer list
+
+ Creates a JSON object value from a given initializer list. The initializer
+ lists elements must be pairs, and their first elements must be strings. If
+ the initializer list is empty, the empty object `{}` is created.
+
+ @note This function is only added for symmetry reasons. In contrast to the
+ related function @ref array(std::initializer_list<basic_json>), there are
+ no cases which can only be expressed by this function. That is, any
+ initializer list @a init can also be passed to the initializer list
+ constructor
+ @ref basic_json(std::initializer_list<basic_json>, bool, value_t).
+
+ @param[in] init initializer list to create an object from (optional)
+
+ @return JSON object value
+
+ @throw std::domain_error if @a init is not a pair whose first elements are
+ strings; thrown by
+ @ref basic_json(std::initializer_list<basic_json>, bool, value_t)
+
+ @complexity Linear in the size of @a init.
+
+ @liveexample{The following code shows an example for the @ref object
+ function.,object}
+
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --
+ create a JSON value from an initializer list
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array
+ value from an initializer list
+
+ @since version 1.0.0
+ */
+ static basic_json object(std::initializer_list<basic_json> init =
+ std::initializer_list<basic_json>())
+ {
+ return basic_json(init, false, value_t::object);
+ }
+
+ /*!
+ @brief construct an array with count copies of given value
+
+ Constructs a JSON array value by creating @a cnt copies of a passed
+ value. In case @a cnt is `0`, an empty array is created. As postcondition,
+ `std::distance(begin(),end()) == cnt` holds.
+
+ @param[in] cnt the number of JSON copies of @a val to create
+ @param[in] val the JSON value to copy
+
+ @complexity Linear in @a cnt.
+
+ @liveexample{The following code shows examples for the @ref
+ basic_json(size_type\, const basic_json&)
+ constructor.,basic_json__size_type_basic_json}
+
+ @since version 1.0.0
+ */
+ basic_json(size_type cnt, const basic_json& val)
+ : m_type(value_t::array)
+ {
+ m_value.array = create<array_t>(cnt, val);
+ }
+
+ /*!
+ @brief construct a JSON container given an iterator range
+
+ Constructs the JSON value with the contents of the range `[first, last)`.
+ The semantics depends on the different types a JSON value can have:
+ - In case of primitive types (number, boolean, or string), @a first must
+ be `begin()` and @a last must be `end()`. In this case, the value is
+ copied. Otherwise, std::out_of_range is thrown.
+ - In case of structured types (array, object), the constructor behaves
+ as similar versions for `std::vector`.
+ - In case of a null type, std::domain_error is thrown.
+
+ @tparam InputIT an input iterator type (@ref iterator or @ref
+ const_iterator)
+
+ @param[in] first begin of the range to copy from (included)
+ @param[in] last end of the range to copy from (excluded)
+
+ @throw std::domain_error if iterators are not compatible; that is, do not
+ belong to the same JSON value; example: `"iterators are not compatible"`
+ @throw std::out_of_range if iterators are for a primitive type (number,
+ boolean, or string) where an out of range error can be detected easily;
+ example: `"iterators out of range"`
+ @throw std::bad_alloc if allocation for object, array, or string fails
+ @throw std::domain_error if called with a null value; example: `"cannot use
+ construct with iterators from null"`
+
+ @complexity Linear in distance between @a first and @a last.
+
+ @liveexample{The example below shows several ways to create JSON values by
+ specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+ @since version 1.0.0
+ */
+ template <class InputIT, typename
+ std::enable_if<
+ std::is_same<InputIT, typename basic_json_t::iterator>::value or
+ std::is_same<InputIT, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ basic_json(InputIT first, InputIT last) : m_type(first.m_object->m_type)
+ {
+ // make sure iterator fits the current value
+ if (first.m_object != last.m_object)
+ {
+ throw std::domain_error("iterators are not compatible");
+ }
+
+ // check if iterator range is complete for primitive values
+ switch (m_type)
+ {
+ case value_t::boolean:
+ case value_t::number_float:
+ case value_t::number_integer:
+ case value_t::string:
+ {
+ if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+ {
+ throw std::out_of_range("iterators out of range");
+ }
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ switch (m_type)
+ {
+ case value_t::number_integer:
+ {
+ assert(first.m_object != nullptr);
+ m_value.number_integer = first.m_object->m_value.number_integer;
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ assert(first.m_object != nullptr);
+ m_value.number_float = first.m_object->m_value.number_float;
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ assert(first.m_object != nullptr);
+ m_value.boolean = first.m_object->m_value.boolean;
+ break;
+ }
+
+ case value_t::string:
+ {
+ assert(first.m_object != nullptr);
+ m_value = *first.m_object->m_value.string;
+ break;
+ }
+
+ case value_t::object:
+ {
+ m_value.object = create<object_t>(first.m_it.object_iterator, last.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ m_value.array = create<array_t>(first.m_it.array_iterator, last.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ assert(first.m_object != nullptr);
+ throw std::domain_error("cannot use construct with iterators from " + first.m_object->type_name());
+ }
+ }
+ }
+
+ ///////////////////////////////////////
+ // other constructors and destructor //
+ ///////////////////////////////////////
+
+ /*!
+ @brief copy constructor
+
+ Creates a copy of a given JSON value.
+
+ @param[in] other the JSON value to copy
+
+ @complexity Linear in the size of @a other.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is linear.
+ - As postcondition, it holds: `other == basic_json(other)`.
+
+ @throw std::bad_alloc if allocation for object, array, or string fails.
+
+ @liveexample{The following code shows an example for the copy
+ constructor.,basic_json__basic_json}
+
+ @since version 1.0.0
+ */
+ basic_json(const basic_json& other)
+ : m_type(other.m_type)
+ {
+ switch (m_type)
+ {
+ case value_t::object:
+ {
+ assert(other.m_value.object != nullptr);
+ m_value = *other.m_value.object;
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(other.m_value.array != nullptr);
+ m_value = *other.m_value.array;
+ break;
+ }
+
+ case value_t::string:
+ {
+ assert(other.m_value.string != nullptr);
+ m_value = *other.m_value.string;
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ m_value = other.m_value.boolean;
+ break;
+ }
+
+ case value_t::number_integer:
+ {
+ m_value = other.m_value.number_integer;
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ m_value = other.m_value.number_float;
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ /*!
+ @brief move constructor
+
+ Move constructor. Constructs a JSON value with the contents of the given
+ value @a other using move semantics. It "steals" the resources from @a
+ other and leaves it as JSON null value.
+
+ @param[in,out] other value to move to this object
+
+ @post @a other is a JSON null value
+
+ @complexity Constant.
+
+ @liveexample{The code below shows the move constructor explicitly called
+ via std::move.,basic_json__moveconstructor}
+
+ @since version 1.0.0
+ */
+ basic_json(basic_json&& other) noexcept
+ : m_type(std::move(other.m_type)),
+ m_value(std::move(other.m_value))
+ {
+ // invalidate payload
+ other.m_type = value_t::null;
+ other.m_value = {};
+ }
+
+ /*!
+ @brief copy assignment
+
+ Copy assignment operator. Copies a JSON value via the "copy and swap"
+ strategy: It is expressed in terms of the copy constructor, destructor, and
+ the swap() member function.
+
+ @param[in] other value to copy from
+
+ @complexity Linear.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is linear.
+
+ @liveexample{The code below shows and example for the copy assignment. It
+ creates a copy of value `a` which is then swapped with `b`. Finally\, the
+ copy of `a` (which is the null value after the swap) is
+ destroyed.,basic_json__copyassignment}
+
+ @since version 1.0.0
+ */
+ 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
+ )
+ {
+ using std::swap;
+ swap(m_type, other.m_type);
+ swap(m_value, other.m_value);
+ return *this;
+ }
+
+ /*!
+ @brief destructor
+
+ Destroys the JSON value and frees all allocated memory.
+
+ @complexity Linear.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is linear.
+ - All stored elements are destroyed and all memory is freed.
+
+ @since version 1.0.0
+ */
+ ~basic_json()
+ {
+ switch (m_type)
+ {
+ case value_t::object:
+ {
+ AllocatorType<object_t> alloc;
+ alloc.destroy(m_value.object);
+ alloc.deallocate(m_value.object, 1);
+ break;
+ }
+
+ case value_t::array:
+ {
+ AllocatorType<array_t> alloc;
+ alloc.destroy(m_value.array);
+ alloc.deallocate(m_value.array, 1);
+ break;
+ }
+
+ case value_t::string:
+ {
+ AllocatorType<string_t> alloc;
+ alloc.destroy(m_value.string);
+ alloc.deallocate(m_value.string, 1);
+ break;
+ }
+
+ default:
+ {
+ // all other types need no specific destructor
+ break;
+ }
+ }
+ }
+
+ /// @}
+
+ public:
+ ///////////////////////
+ // object inspection //
+ ///////////////////////
+
+ /// @name object inspection
+ /// @{
+
+ /*!
+ @brief serialization
+
+ Serialization function for JSON values. The function tries to mimic
+ Python's @p json.dumps() function, and currently supports its @p indent
+ parameter.
+
+ @param[in] indent if 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
+
+ @return string containing the serialization of the JSON value
+
+ @complexity Linear.
+
+ @liveexample{The following example shows the effect of different @a indent
+ parameters to the result of the serialization.,dump}
+
+ @see https://docs.python.org/2/library/json.html#json.dump
+
+ @since version 1.0.0
+ */
+ string_t dump(const int indent = -1) const
+ {
+ std::stringstream ss;
+
+ if (indent >= 0)
+ {
+ dump(ss, true, static_cast<unsigned int>(indent));
+ }
+ else
+ {
+ dump(ss, false, 0);
+ }
+
+ return ss.str();
+ }
+
+ /*!
+ @brief return the type of the JSON value (explicit)
+
+ Return the type of the JSON value as a value from the @ref value_t
+ enumeration.
+
+ @return the type of the JSON value
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref type() for all JSON
+ types.,type}
+
+ @since version 1.0.0
+ */
+ value_t type() const noexcept
+ {
+ return m_type;
+ }
+
+ /*!
+ @brief return whether type is primitive
+
+ This function returns true iff the JSON type is primitive (string, number,
+ boolean, or null).
+
+ @return `true` if type is primitive (string, number, boolean, or null),
+ `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_primitive for all JSON
+ types.,is_primitive}
+
+ @since version 1.0.0
+ */
+ bool is_primitive() const noexcept
+ {
+ return is_null() or is_string() or is_boolean() or is_number();
+ }
+
+ /*!
+ @brief return whether type is structured
+
+ This function returns true iff the JSON type is structured (array or
+ object).
+
+ @return `true` if type is structured (array or object), `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_structured for all JSON
+ types.,is_structured}
+
+ @since version 1.0.0
+ */
+ bool is_structured() const noexcept
+ {
+ return is_array() or is_object();
+ }
+
+ /*!
+ @brief return whether value is null
+
+ This function returns true iff the JSON value is null.
+
+ @return `true` if type is null, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_null for all JSON
+ types.,is_null}
+
+ @since version 1.0.0
+ */
+ bool is_null() const noexcept
+ {
+ return m_type == value_t::null;
+ }
+
+ /*!
+ @brief return whether value is a boolean
+
+ This function returns true iff the JSON value is a boolean.
+
+ @return `true` if type is boolean, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_boolean for all JSON
+ types.,is_boolean}
+
+ @since version 1.0.0
+ */
+ bool is_boolean() const noexcept
+ {
+ return m_type == value_t::boolean;
+ }
+
+ /*!
+ @brief return whether value is a number
+
+ This function returns true iff the JSON value is a number. This includes
+ both integer and floating-point values.
+
+ @return `true` if type is number (regardless whether integer or
+ floating-type), `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_number for all JSON
+ types.,is_number}
+
+ @sa @ref is_number_integer() -- check if value is an integer number
+ @sa @ref is_number_float() -- check if value is a floating-point number
+
+ @since version 1.0.0
+ */
+ bool is_number() const noexcept
+ {
+ return is_number_integer() or is_number_float();
+ }
+
+ /*!
+ @brief return whether value is an integer number
+
+ This function returns true iff the JSON value is an integer number. This
+ excludes floating-point values.
+
+ @return `true` if type is an integer number, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_number_integer for all
+ JSON types.,is_number_integer}
+
+ @sa @ref is_number() -- check if value is a number
+ @sa @ref is_number_float() -- check if value is a floating-point number
+
+ @since version 1.0.0
+ */
+ bool is_number_integer() const noexcept
+ {
+ return m_type == value_t::number_integer;
+ }
+
+ /*!
+ @brief return whether value is a floating-point number
+
+ This function returns true iff the JSON value is a floating-point number.
+ This excludes integer values.
+
+ @return `true` if type is a floating-point number, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_number_float for all
+ JSON types.,is_number_float}
+
+ @sa @ref is_number() -- check if value is number
+ @sa @ref is_number_integer() -- check if value is an integer number
+
+ @since version 1.0.0
+ */
+ bool is_number_float() const noexcept
+ {
+ return m_type == value_t::number_float;
+ }
+
+ /*!
+ @brief return whether value is an object
+
+ This function returns true iff the JSON value is an object.
+
+ @return `true` if type is object, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_object for all JSON
+ types.,is_object}
+
+ @since version 1.0.0
+ */
+ bool is_object() const noexcept
+ {
+ return m_type == value_t::object;
+ }
+
+ /*!
+ @brief return whether value is an array
+
+ This function returns true iff the JSON value is an array.
+
+ @return `true` if type is array, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_array for all JSON
+ types.,is_array}
+
+ @since version 1.0.0
+ */
+ bool is_array() const noexcept
+ {
+ return m_type == value_t::array;
+ }
+
+ /*!
+ @brief return whether value is a string
+
+ This function returns true iff the JSON value is a string.
+
+ @return `true` if type is string, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_string for all JSON
+ types.,is_string}
+
+ @since version 1.0.0
+ */
+ bool is_string() const noexcept
+ {
+ return m_type == value_t::string;
+ }
+
+ /*!
+ @brief return whether value is discarded
+
+ This function returns true iff the JSON value was discarded during parsing
+ with a callback function (see @ref parser_callback_t).
+
+ @note This function will always be `false` for JSON values after parsing.
+ That is, discarded values can only occur during parsing, but will be
+ removed when inside a structured value or replaced by null in other cases.
+
+ @return `true` if type is discarded, `false` otherwise.
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies @ref is_discarded for all JSON
+ types.,is_discarded}
+
+ @since version 1.0.0
+ */
+ bool is_discarded() const noexcept
+ {
+ return m_type == value_t::discarded;
+ }
+
+ /*!
+ @brief return the type of the JSON value (implicit)
+
+ Implicitly return the type of the JSON value as a value from the @ref
+ value_t enumeration.
+
+ @return the type of the JSON value
+
+ @complexity Constant.
+
+ @liveexample{The following code exemplifies the value_t operator for all
+ JSON types.,operator__value_t}
+
+ @since version 1.0.0
+ */
+ operator value_t() const noexcept
+ {
+ return m_type;
+ }
+
+ /// @}
+
+ private:
+ //////////////////
+ // value access //
+ //////////////////
+
+ /// get an object (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
+ std::is_convertible<basic_json_t, typename T::mapped_type>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return T(m_value.object->begin(), m_value.object->end());
+ }
+ else
+ {
+ throw std::domain_error("type must be object, but is " + type_name());
+ }
+ }
+
+ /// get an object (explicit)
+ object_t get_impl(object_t*) const
+ {
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return *(m_value.object);
+ }
+ else
+ {
+ throw std::domain_error("type must be object, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, typename T::value_type>::value and
+ not std::is_same<basic_json_t, typename T::value_type>::value and
+ not std::is_arithmetic<T>::value and
+ not std::is_convertible<std::string, T>::value and
+ not has_mapped_type<T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_array())
+ {
+ T to_vector;
+ assert(m_value.array != nullptr);
+ std::transform(m_value.array->begin(), m_value.array->end(),
+ std::inserter(to_vector, to_vector.end()), [](basic_json i)
+ {
+ return i.get<typename T::value_type>();
+ });
+ return to_vector;
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, T>::value and
+ not std::is_same<basic_json_t, T>::value
+ , int>::type = 0>
+ std::vector<T> get_impl(std::vector<T>*) const
+ {
+ if (is_array())
+ {
+ std::vector<T> to_vector;
+ assert(m_value.array != nullptr);
+ to_vector.reserve(m_value.array->size());
+ std::transform(m_value.array->begin(), m_value.array->end(),
+ std::inserter(to_vector, to_vector.end()), [](basic_json i)
+ {
+ return i.get<T>();
+ });
+ return to_vector;
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ template <class T, typename
+ std::enable_if<
+ std::is_same<basic_json, typename T::value_type>::value and
+ not has_mapped_type<T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ return T(m_value.array->begin(), m_value.array->end());
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get an array (explicit)
+ array_t get_impl(array_t*) const
+ {
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ return *(m_value.array);
+ }
+ else
+ {
+ throw std::domain_error("type must be array, but is " + type_name());
+ }
+ }
+
+ /// get a string (explicit)
+ template <typename T, typename
+ std::enable_if<
+ std::is_convertible<string_t, T>::value
+ , int>::type = 0>
+ T get_impl(T*) const
+ {
+ if (is_string())
+ {
+ assert(m_value.string != nullptr);
+ return *m_value.string;
+ }
+ else
+ {
+ throw std::domain_error("type must be string, but is " + type_name());
+ }
+ }
+
+ /// get a number (explicit)
+ template<typename T, typename
+ std::enable_if<
+ std::is_arithmetic<T>::value
+ , int>::type = 0>
+ T get_impl(T*) 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::domain_error("type must be number, but is " + type_name());
+ }
+ }
+ }
+
+ /// get a boolean (explicit)
+ boolean_t get_impl(boolean_t*) const
+ {
+ if (is_boolean())
+ {
+ return m_value.boolean;
+ }
+ else
+ {
+ throw std::domain_error("type must be boolean, but is " + type_name());
+ }
+ }
+
+ /// get a pointer to the value (object)
+ object_t* get_impl_ptr(object_t*) noexcept
+ {
+ return is_object() ? m_value.object : nullptr;
+ }
+
+ /// get a pointer to the value (object)
+ const object_t* get_impl_ptr(const object_t*) const noexcept
+ {
+ return is_object() ? m_value.object : nullptr;
+ }
+
+ /// get a pointer to the value (array)
+ array_t* get_impl_ptr(array_t*) noexcept
+ {
+ return is_array() ? m_value.array : nullptr;
+ }
+
+ /// get a pointer to the value (array)
+ const array_t* get_impl_ptr(const array_t*) const noexcept
+ {
+ return is_array() ? m_value.array : nullptr;
+ }
+
+ /// get a pointer to the value (string)
+ string_t* get_impl_ptr(string_t*) noexcept
+ {
+ return is_string() ? m_value.string : nullptr;
+ }
+
+ /// get a pointer to the value (string)
+ const string_t* get_impl_ptr(const string_t*) const noexcept
+ {
+ return is_string() ? m_value.string : nullptr;
+ }
+
+ /// get a pointer to the value (boolean)
+ boolean_t* get_impl_ptr(boolean_t*) noexcept
+ {
+ return is_boolean() ? &m_value.boolean : nullptr;
+ }
+
+ /// get a pointer to the value (boolean)
+ const boolean_t* get_impl_ptr(const boolean_t*) const noexcept
+ {
+ return is_boolean() ? &m_value.boolean : nullptr;
+ }
+
+ /// get a pointer to the value (integer number)
+ number_integer_t* get_impl_ptr(number_integer_t*) noexcept
+ {
+ return is_number_integer() ? &m_value.number_integer : nullptr;
+ }
+
+ /// get a pointer to the value (integer number)
+ const number_integer_t* get_impl_ptr(const number_integer_t*) const noexcept
+ {
+ return is_number_integer() ? &m_value.number_integer : nullptr;
+ }
+
+ /// get a pointer to the value (floating-point number)
+ number_float_t* get_impl_ptr(number_float_t*) noexcept
+ {
+ return is_number_float() ? &m_value.number_float : nullptr;
+ }
+
+ /// get a pointer to the value (floating-point number)
+ const number_float_t* get_impl_ptr(const number_float_t*) const noexcept
+ {
+ return is_number_float() ? &m_value.number_float : nullptr;
+ }
+
+ /*!
+ @brief helper function to implement get_ref()
+
+ This funcion helps to implement get_ref() without code duplication for
+ const and non-const overloads
+
+ @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+ @throw std::domain_error if ReferenceType does not match underlying value
+ type of the current JSON
+ */
+ template<typename ReferenceType, typename ThisType>
+ static ReferenceType get_ref_impl(ThisType& obj)
+ {
+ // delegate the call to get_ptr<>()
+ using PointerType = typename std::add_pointer<ReferenceType>::type;
+ auto ptr = obj.template get_ptr<PointerType>();
+
+ if (ptr != nullptr)
+ {
+ return *ptr;
+ }
+ else
+ {
+ throw std::domain_error("incompatible ReferenceType for get_ref, actual type is " +
+ obj.type_name());
+ }
+ }
+
+ public:
+
+ /// @name value access
+ /// @{
+
+ /*!
+ @brief get a value (explicit)
+
+ Explicit type conversion between the JSON value and a compatible value.
+
+ @tparam ValueType non-pointer type compatible to the JSON value, for
+ instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+ `std::vector` types for JSON arrays
+
+ @return copy of the JSON value, converted to type @a ValueType
+
+ @throw std::domain_error in case passed type @a ValueType is incompatible
+ to JSON; example: `"type must be object, but is null"`
+
+ @complexity Linear in the size of the JSON value.
+
+ @liveexample{The example below shows several conversions from JSON values
+ to other types. There a few things to note: (1) Floating-point numbers can
+ be converted to integers\, (2) A JSON array can be converted to a standard
+ `std::vector<short>`\, (3) A JSON object can be converted to C++
+ associative containers such as `std::unordered_map<std::string\,
+ json>`.,get__ValueType_const}
+
+ @internal
+ The idea of using a casted null pointer to choose the correct
+ implementation is from <http://stackoverflow.com/a/8315197/266378>.
+ @endinternal
+
+ @sa @ref operator ValueType() const for implicit conversion
+ @sa @ref get() for pointer-member access
+
+ @since version 1.0.0
+ */
+ template<typename ValueType, typename
+ std::enable_if<
+ not std::is_pointer<ValueType>::value
+ , int>::type = 0>
+ ValueType get() const
+ {
+ return get_impl(static_cast<ValueType*>(nullptr));
+ }
+
+ /*!
+ @brief get a pointer value (explicit)
+
+ Explicit pointer access to the internally stored JSON value. No copies are
+ made.
+
+ @warning The pointer becomes invalid if the underlying JSON object changes.
+
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or @ref
+ number_float_t.
+
+ @return pointer to the internally stored JSON value if the requested
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how pointers to internal values of a
+ JSON value can be requested. Note that no type conversions are made and a
+ `nullptr` is returned if the value and the requested pointer type does not
+ match.,get__PointerType}
+
+ @sa @ref get_ptr() for explicit pointer-member access
+
+ @since version 1.0.0
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ PointerType get() noexcept
+ {
+ // delegate the call to get_ptr
+ return get_ptr<PointerType>();
+ }
+
+ /*!
+ @brief get a pointer value (explicit)
+ @copydoc get()
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ const PointerType get() const noexcept
+ {
+ // delegate the call to get_ptr
+ return get_ptr<PointerType>();
+ }
+
+ /*!
+ @brief get a pointer value (implicit)
+
+ Implicit pointer access to the internally stored JSON value. No copies are
+ made.
+
+ @warning Writing data to the pointee of the result yields an undefined
+ state.
+
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or @ref
+ number_float_t.
+
+ @return pointer to the internally stored JSON value if the requested
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how pointers to internal values of a
+ JSON value can be requested. Note that no type conversions are made and a
+ `nullptr` is returned if the value and the requested pointer type does not
+ match.,get_ptr}
+
+ @since version 1.0.0
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ , int>::type = 0>
+ PointerType get_ptr() noexcept
+ {
+ // delegate the call to get_impl_ptr<>()
+ return get_impl_ptr(static_cast<PointerType>(nullptr));
+ }
+
+ /*!
+ @brief get a pointer value (implicit)
+ @copydoc get_ptr()
+ */
+ template<typename PointerType, typename
+ std::enable_if<
+ std::is_pointer<PointerType>::value
+ and std::is_const<typename std::remove_pointer<PointerType>::type>::value
+ , int>::type = 0>
+ const PointerType get_ptr() const noexcept
+ {
+ // delegate the call to get_impl_ptr<>() const
+ return get_impl_ptr(static_cast<const PointerType>(nullptr));
+ }
+
+ /*!
+ @brief get a reference value (implicit)
+
+ Implict reference access to the internally stored JSON value. No copies are
+ made.
+
+ @warning Writing data to the referee of the result yields an undefined
+ state.
+
+ @tparam ReferenceType reference type; must be a reference to @ref array_t,
+ @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
+ @ref number_float_t.
+
+ @return reference to the internally stored JSON value if the requested
+ reference type @a ReferenceType fits to the JSON value; throws
+ std::domain_error otherwise
+
+ @throw std::domain_error in case passed type @a ReferenceType is
+ incompatible with the stored JSON value
+
+ @complexity Constant.
+
+ @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+ @since version 1.1.0
+ */
+ template<typename ReferenceType, typename
+ std::enable_if<
+ std::is_reference<ReferenceType>::value
+ , int>::type = 0>
+ ReferenceType get_ref()
+ {
+ // delegate call to get_ref_impl
+ return get_ref_impl<ReferenceType>(*this);
+ }
+
+ /*!
+ @brief get a reference value (implicit)
+ @copydoc get_ref()
+ */
+ template<typename ReferenceType, typename
+ std::enable_if<
+ std::is_reference<ReferenceType>::value
+ and std::is_const<typename std::remove_reference<ReferenceType>::type>::value
+ , int>::type = 0>
+ ReferenceType get_ref() const
+ {
+ // delegate call to get_ref_impl
+ return get_ref_impl<ReferenceType>(*this);
+ }
+
+ /*!
+ @brief get a value (implicit)
+
+ Implicit type conversion between the JSON value and a compatible value. The
+ call is realized by calling @ref get() const.
+
+ @tparam ValueType non-pointer type compatible to the JSON value, for
+ instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+ `std::vector` types for JSON arrays. The character type of @ref string_t
+ as well as an initializer list of this type is excluded to avoid
+ ambiguities as these types implicitly convert to `std::string`.
+
+ @return copy of the JSON value, converted to type @a ValueType
+
+ @throw std::domain_error in case passed type @a ValueType is incompatible
+ to JSON, thrown by @ref get() const
+
+ @complexity Linear in the size of the JSON value.
+
+ @liveexample{The example below shows several conversions from JSON values
+ to other types. There a few things to note: (1) Floating-point numbers can
+ be converted to integers\, (2) A JSON array can be converted to a standard
+ `std::vector<short>`\, (3) A JSON object can be converted to C++
+ associative containers such as `std::unordered_map<std::string\,
+ json>`.,operator__ValueType}
+
+ @since version 1.0.0
+ */
+ template < typename ValueType, typename
+ std::enable_if <
+ not std::is_pointer<ValueType>::value
+ and not std::is_same<ValueType, typename string_t::value_type>::value
+#ifndef _MSC_VER // Fix for issue #167 operator<< abiguity under VS2015
+ and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#endif
+ , int >::type = 0 >
+ operator ValueType() const
+ {
+ // delegate the call to get<>() const
+ return get<ValueType>();
+ }
+
+ /// @}
+
+
+ ////////////////////
+ // element access //
+ ////////////////////
+
+ /// @name element access
+ /// @{
+
+ /*!
+ @brief access specified array element with bounds checking
+
+ Returns a reference to the element at specified location @a idx, with
+ bounds checking.
+
+ @param[in] idx index of the element to access
+
+ @return reference to the element at index @a idx
+
+ @throw std::domain_error if the JSON value is not an array; example:
+ `"cannot use at() with string"`
+ @throw std::out_of_range if the index @a idx is out of range of the array;
+ that is, `idx >= size()`; example: `"array index 7 is out of range"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how array elements can be read and
+ written using at.,at__size_type}
+
+ @since version 1.0.0
+ */
+ reference at(size_type idx)
+ {
+ // at only works for arrays
+ if (is_array())
+ {
+ try
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->at(idx);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use at() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified array element with bounds checking
+
+ Returns a const reference to the element at specified location @a idx, with
+ bounds checking.
+
+ @param[in] idx index of the element to access
+
+ @return const reference to the element at index @a idx
+
+ @throw std::domain_error if the JSON value is not an array; example:
+ `"cannot use at() with string"`
+ @throw std::out_of_range if the index @a idx is out of range of the array;
+ that is, `idx >= size()`; example: `"array index 7 is out of range"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how array elements can be read using
+ at.,at__size_type_const}
+
+ @since version 1.0.0
+ */
+ const_reference at(size_type idx) const
+ {
+ // at only works for arrays
+ if (is_array())
+ {
+ try
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->at(idx);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("array index " + std::to_string(idx) + " is out of range");
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use at() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element with bounds checking
+
+ Returns a reference to the element at with specified key @a key, with
+ bounds checking.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if the JSON value is not an object; example:
+ `"cannot use at() with boolean"`
+ @throw std::out_of_range if the key @a key is is not stored in the object;
+ that is, `find(key) == end()`; example: `"key "the fast" not found"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using at.,at__object_t_key_type}
+
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked
+ access by reference
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ reference at(const typename object_t::key_type& key)
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ try
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->at(key);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("key '" + key + "' not found");
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use at() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element with bounds checking
+
+ Returns a const reference to the element at with specified key @a key, with
+ bounds checking.
+
+ @param[in] key key of the element to access
+
+ @return const reference to the element at key @a key
+
+ @throw std::domain_error if the JSON value is not an object; example:
+ `"cannot use at() with boolean"`
+ @throw std::out_of_range if the key @a key is is not stored in the object;
+ that is, `find(key) == end()`; example: `"key "the fast" not found"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ at.,at__object_t_key_type_const}
+
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked
+ access by reference
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ const_reference at(const typename object_t::key_type& key) const
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ try
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->at(key);
+ }
+ catch (std::out_of_range&)
+ {
+ // create better exception explanation
+ throw std::out_of_range("key '" + key + "' not found");
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use at() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified array element
+
+ Returns a reference to the element at specified location @a idx.
+
+ @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+ then the array is silently filled up with `null` values to make `idx` a
+ valid reference to the last stored element.
+
+ @param[in] idx index of the element to access
+
+ @return reference to the element at index @a idx
+
+ @throw std::domain_error if JSON is not an array or null; example: `"cannot
+ use operator[] with null"`
+
+ @complexity Constant if @a idx is in the range of the array. Otherwise
+ linear in `idx - size()`.
+
+ @liveexample{The example below shows how array elements can be read and
+ written using [] operator. Note the addition of `null`
+ values.,operatorarray__size_type}
+
+ @since version 1.0.0
+ */
+ reference operator[](size_type idx)
+ {
+ // implicitly convert null to object
+ if (is_null())
+ {
+ m_type = value_t::array;
+ m_value.array = create<array_t>();
+ }
+
+ // [] only works for arrays
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ for (size_t i = m_value.array->size(); i <= idx; ++i)
+ {
+ m_value.array->push_back(basic_json());
+ }
+
+ return m_value.array->operator[](idx);
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified array element
+
+ Returns a const reference to the element at specified location @a idx.
+
+ @param[in] idx index of the element to access
+
+ @return const reference to the element at index @a idx
+
+ @throw std::domain_error if JSON is not an array; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how array elements can be read using
+ the [] operator.,operatorarray__size_type_const}
+
+ @since version 1.0.0
+ */
+ const_reference operator[](size_type idx) const
+ {
+ // at only works for arrays
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->operator[](idx);
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the [] operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ reference operator[](const typename object_t::key_type& key)
+ {
+ // implicitly convert null to object
+ if (is_null())
+ {
+ m_type = value_t::object;
+ m_value.object = create<object_t>();
+ }
+
+ // [] only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->operator[](key);
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief read-only access specified object element
+
+ Returns a const reference to the element at with specified key @a key. No
+ bounds checking is performed.
+
+ @warning If the element with key @a key does not exist, the behavior is
+ undefined.
+
+ @param[in] key key of the element to access
+
+ @return const reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ the [] operator.,operatorarray__key_type_const}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ const_reference operator[](const typename object_t::key_type& key) const
+ {
+ // [] only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ assert(m_value.object->find(key) != m_value.object->end());
+ return m_value.object->find(key)->second;
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the [] operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ template<typename T, std::size_t n>
+ reference operator[](T * (&key)[n])
+ {
+ return operator[](static_cast<const T>(key));
+ }
+
+ /*!
+ @brief read-only access specified object element
+
+ Returns a const reference to the element at with specified key @a key. No
+ bounds checking is performed.
+
+ @warning If the element with key @a key does not exist, the behavior is
+ undefined.
+
+ @note This function is required for compatibility reasons with Clang.
+
+ @param[in] key key of the element to access
+
+ @return const reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ the [] operator.,operatorarray__key_type_const}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.0.0
+ */
+ template<typename T, std::size_t n>
+ const_reference operator[](T * (&key)[n]) const
+ {
+ return operator[](static_cast<const T>(key));
+ }
+
+ /*!
+ @brief access specified object element
+
+ Returns a reference to the element at with specified key @a key.
+
+ @note If @a key is not found in the object, then it is silently added to
+ the object and filled with a `null` value to make `key` a valid reference.
+ In case the value was `null` before, it is converted to an object.
+
+ @param[in] key key of the element to access
+
+ @return reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object or null; example:
+ `"cannot use operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read and
+ written using the [] operator.,operatorarray__key_type}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.1.0
+ */
+ template<typename T>
+ reference operator[](T* key)
+ {
+ // implicitly convert null to object
+ if (is_null())
+ {
+ m_type = value_t::object;
+ m_value = value_t::object;
+ }
+
+ // at only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->operator[](key);
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief read-only access specified object element
+
+ Returns a const reference to the element at with specified key @a key. No
+ bounds checking is performed.
+
+ @warning If the element with key @a key does not exist, the behavior is
+ undefined.
+
+ @param[in] key key of the element to access
+
+ @return const reference to the element at key @a key
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ operator[] with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be read using
+ the [] operator.,operatorarray__key_type_const}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref value() for access by value with a default value
+
+ @since version 1.1.0
+ */
+ template<typename T>
+ const_reference operator[](T* key) const
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ assert(m_value.object->find(key) != m_value.object->end());
+ return m_value.object->find(key)->second;
+ }
+ else
+ {
+ throw std::domain_error("cannot use operator[] with " + type_name());
+ }
+ }
+
+ /*!
+ @brief access specified object element with default value
+
+ Returns either a copy of an object's element at the specified key @a key or
+ a given default value if no element with key @a key exists.
+
+ The function is basically equivalent to executing
+ @code {.cpp}
+ try {
+ return at(key);
+ } catch(std::out_of_range) {
+ return default_value;
+ }
+ @endcode
+
+ @note Unlike @ref at(const typename object_t::key_type&), this function
+ does not throw if the given key @a key was not found.
+
+ @note Unlike @ref operator[](const typename object_t::key_type& key), this
+ function does not implicitly add an element to the position defined by @a
+ key. This function is furthermore also applicable to const objects.
+
+ @param[in] key key of the element to access
+ @param[in] default_value the value to return if @a key is not found
+
+ @tparam ValueType type compatible to JSON values, for instance `int` for
+ JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+ JSON arrays. Note the type of the expected value at @a key and the default
+ value @a default_value must be compatible.
+
+ @return copy of the element at key @a key or @a default_value if @a key
+ is not found
+
+ @throw std::domain_error if JSON is not an object; example: `"cannot use
+ value() with null"`
+
+ @complexity Logarithmic in the size of the container.
+
+ @liveexample{The example below shows how object elements can be queried
+ with a default value.,basic_json__value}
+
+ @sa @ref at(const typename object_t::key_type&) for access by reference
+ with range checking
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked
+ access by reference
+
+ @since version 1.0.0
+ */
+ template <class ValueType, typename
+ std::enable_if<
+ std::is_convertible<basic_json_t, ValueType>::value
+ , int>::type = 0>
+ ValueType value(const typename object_t::key_type& key, ValueType default_value) const
+ {
+ // at only works for objects
+ if (is_object())
+ {
+ // if key is found, return value and given default value otherwise
+ const auto it = find(key);
+ if (it != end())
+ {
+ return *it;
+ }
+ else
+ {
+ return default_value;
+ }
+ }
+ else
+ {
+ throw std::domain_error("cannot use value() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief overload for a default value of type const char*
+ @copydoc basic_json::value()
+ */
+ string_t value(const typename object_t::key_type& key, const char* default_value) const
+ {
+ return value(key, string_t(default_value));
+ }
+
+ /*!
+ @brief access the first element
+
+ Returns a reference to the first element in the container. For a JSON
+ container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+ @return In case of a structured type (array or object), a reference to the
+ first element is returned. In cast of number, string, or boolean values, a
+ reference to the value is returned.
+
+ @complexity Constant.
+
+ @note Calling `front` on an empty container is undefined.
+
+ @throw std::out_of_range when called on null value
+
+ @liveexample{The following code shows an example for @ref front.,front}
+
+ @since version 1.0.0
+ */
+ reference front()
+ {
+ return *begin();
+ }
+
+ /*!
+ @copydoc basic_json::front()
+ */
+ const_reference front() const
+ {
+ return *cbegin();
+ }
+
+ /*!
+ @brief access the last element
+
+ Returns a reference to the last element in the container. For a JSON
+ container `c`, the expression `c.back()` is equivalent to `{ auto tmp =
+ c.end(); --tmp; return *tmp; }`.
+
+ @return In case of a structured type (array or object), a reference to the
+ last element is returned. In cast of number, string, or boolean values, a
+ reference to the value is returned.
+
+ @complexity Constant.
+
+ @note Calling `back` on an empty container is undefined.
+
+ @throw std::out_of_range when called on null value.
+
+ @liveexample{The following code shows an example for @ref back.,back}
+
+ @since version 1.0.0
+ */
+ reference back()
+ {
+ auto tmp = end();
+ --tmp;
+ return *tmp;
+ }
+
+ /*!
+ @copydoc basic_json::back()
+ */
+ const_reference back() const
+ {
+ auto tmp = cend();
+ --tmp;
+ return *tmp;
+ }
+
+ /*!
+ @brief remove element given an iterator
+
+ Removes the element specified by iterator @a pos. Invalidates iterators and
+ references at or after the point of the erase, including the end()
+ iterator. The iterator @a pos must be valid and dereferenceable. Thus the
+ end() iterator (which is valid, but is not dereferenceable) cannot be used
+ as a value for @a pos.
+
+ If called on a primitive type other than null, the resulting JSON value
+ will be `null`.
+
+ @param[in] pos iterator to the element to remove
+ @return Iterator following the last removed element. If the iterator @a pos
+ refers to the last element, the end() iterator is returned.
+
+ @tparam InteratorType an @ref iterator or @ref const_iterator
+
+ @throw std::domain_error if called on a `null` value; example: `"cannot use
+ erase() with null"`
+ @throw std::domain_error if called on an iterator which does not belong to
+ the current JSON value; example: `"iterator does not fit current value"`
+ @throw std::out_of_range if called on a primitive type with invalid
+ iterator (i.e., any iterator which is not end()); example: `"iterator out
+ of range"`
+
+ @complexity The complexity depends on the type:
+ - objects: amortized constant
+ - arrays: linear in distance between pos and the end of the container
+ - strings: linear in the length of the string
+ - other types: constant
+
+ @liveexample{The example shows the result of erase for different JSON
+ types.,erase__IteratorType}
+
+ @sa @ref erase(InteratorType, InteratorType) -- removes the elements in the
+ given range
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element
+ from an object at the given key
+ @sa @ref erase(const size_type) -- removes the element from an array at the
+ given index
+
+ @since version 1.0.0
+ */
+ template <class InteratorType, typename
+ std::enable_if<
+ std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+ std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ InteratorType erase(InteratorType pos)
+ {
+ // make sure iterator fits the current value
+ if (this != pos.m_object)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ InteratorType result = end();
+
+ switch (m_type)
+ {
+ case value_t::boolean:
+ case value_t::number_float:
+ case value_t::number_integer:
+ case value_t::string:
+ {
+ if (not pos.m_it.primitive_iterator.is_begin())
+ {
+ throw std::out_of_range("iterator out of range");
+ }
+
+ if (is_string())
+ {
+ delete m_value.string;
+ m_value.string = nullptr;
+ }
+
+ m_type = value_t::null;
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ throw std::domain_error("cannot use erase() with " + type_name());
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief remove elements given an iterator range
+
+ Removes the element specified by the range `[first; last)`. Invalidates
+ iterators and references at or after the point of the erase, including the
+ end() iterator. The iterator @a first does not need to be dereferenceable
+ if `first == last`: erasing an empty range is a no-op.
+
+ If called on a primitive type other than null, the resulting JSON value
+ will be `null`.
+
+ @param[in] first iterator to the beginning of the range to remove
+ @param[in] last iterator past the end of the range to remove
+ @return Iterator following the last removed element. If the iterator @a
+ second refers to the last element, the end() iterator is returned.
+
+ @tparam InteratorType an @ref iterator or @ref const_iterator
+
+ @throw std::domain_error if called on a `null` value; example: `"cannot use
+ erase() with null"`
+ @throw std::domain_error if called on iterators which does not belong to
+ the current JSON value; example: `"iterators do not fit current value"`
+ @throw std::out_of_range if called on a primitive type with invalid
+ iterators (i.e., if `first != begin()` and `last != end()`); example:
+ `"iterators out of range"`
+
+ @complexity The complexity depends on the type:
+ - objects: `log(size()) + std::distance(first, last)`
+ - arrays: linear in the distance between @a first and @a last, plus linear
+ in the distance between @a last and end of the container
+ - strings: linear in the length of the string
+ - other types: constant
+
+ @liveexample{The example shows the result of erase for different JSON
+ types.,erase__IteratorType_IteratorType}
+
+ @sa @ref erase(InteratorType) -- removes the element at a given position
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element
+ from an object at the given key
+ @sa @ref erase(const size_type) -- removes the element from an array at the
+ given index
+
+ @since version 1.0.0
+ */
+ template <class InteratorType, typename
+ std::enable_if<
+ std::is_same<InteratorType, typename basic_json_t::iterator>::value or
+ std::is_same<InteratorType, typename basic_json_t::const_iterator>::value
+ , int>::type
+ = 0>
+ InteratorType erase(InteratorType first, InteratorType last)
+ {
+ // make sure iterator fits the current value
+ if (this != first.m_object or this != last.m_object)
+ {
+ throw std::domain_error("iterators do not fit current value");
+ }
+
+ InteratorType result = end();
+
+ switch (m_type)
+ {
+ case value_t::boolean:
+ case value_t::number_float:
+ case value_t::number_integer:
+ case value_t::string:
+ {
+ if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
+ {
+ throw std::out_of_range("iterators out of range");
+ }
+
+ if (is_string())
+ {
+ delete m_value.string;
+ m_value.string = nullptr;
+ }
+
+ m_type = value_t::null;
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+ last.m_it.object_iterator);
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+ last.m_it.array_iterator);
+ break;
+ }
+
+ default:
+ {
+ throw std::domain_error("cannot use erase() with " + type_name());
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief remove element from a JSON object given a key
+
+ Removes elements from a JSON object with the key value @a key.
+
+ @param[in] key value of the elements to remove
+
+ @return Number of elements removed. If ObjectType is the default `std::map`
+ type, the return value will always be `0` (@a key was not found) or `1` (@a
+ key was found).
+
+ @throw std::domain_error when called on a type other than JSON object;
+ example: `"cannot use erase() with null"`
+
+ @complexity `log(size()) + count(key)`
+
+ @liveexample{The example shows the effect of erase.,erase__key_type}
+
+ @sa @ref erase(InteratorType) -- removes the element at a given position
+ @sa @ref erase(InteratorType, InteratorType) -- removes the elements in the
+ given range
+ @sa @ref erase(const size_type) -- removes the element from an array at the
+ given index
+
+ @since version 1.0.0
+ */
+ size_type erase(const typename object_t::key_type& key)
+ {
+ // this erase only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->erase(key);
+ }
+ else
+ {
+ throw std::domain_error("cannot use erase() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief remove element from a JSON array given an index
+
+ Removes element from a JSON array at the index @a idx.
+
+ @param[in] idx index of the element to remove
+
+ @throw std::domain_error when called on a type other than JSON array;
+ example: `"cannot use erase() with null"`
+ @throw std::out_of_range when `idx >= size()`; example: `"index out of
+ range"`
+
+ @complexity Linear in distance between @a idx and the end of the container.
+
+ @liveexample{The example shows the effect of erase.,erase__size_type}
+
+ @sa @ref erase(InteratorType) -- removes the element at a given position
+ @sa @ref erase(InteratorType, InteratorType) -- removes the elements in the
+ given range
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element
+ from an object at the given key
+
+ @since version 1.0.0
+ */
+ void erase(const size_type idx)
+ {
+ // this erase only works for arrays
+ if (is_array())
+ {
+ if (idx >= size())
+ {
+ throw std::out_of_range("index out of range");
+ }
+
+ assert(m_value.array != nullptr);
+ m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+ }
+ else
+ {
+ throw std::domain_error("cannot use erase() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief find an element in a JSON object
+
+ Finds an element in a JSON object with key equivalent to @a key. If the
+ element is not found or the JSON value is not an object, end() is returned.
+
+ @param[in] key key value of the element to search for
+
+ @return Iterator to an element with key equivalent to @a key. If no such
+ element is found, past-the-end (see end()) iterator is returned.
+
+ @complexity Logarithmic in the size of the JSON object.
+
+ @liveexample{The example shows how find is used.,find__key_type}
+
+ @since version 1.0.0
+ */
+ iterator find(typename object_t::key_type key)
+ {
+ auto result = end();
+
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->find(key);
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief find an element in a JSON object
+ @copydoc find(typename object_t::key_type)
+ */
+ const_iterator find(typename object_t::key_type key) const
+ {
+ auto result = cend();
+
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ result.m_it.object_iterator = m_value.object->find(key);
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief returns the number of occurrences of a key in a JSON object
+
+ Returns the number of elements with key @a key. If ObjectType is the
+ default `std::map` type, the return value will always be `0` (@a key was
+ not found) or `1` (@a key was found).
+
+ @param[in] key key value of the element to count
+
+ @return Number of elements with key @a key. If the JSON value is not an
+ object, the return value will be `0`.
+
+ @complexity Logarithmic in the size of the JSON object.
+
+ @liveexample{The example shows how count is used.,count}
+
+ @since version 1.0.0
+ */
+ size_type count(typename object_t::key_type key) const
+ {
+ // return 0 for all nonobject types
+ assert(not is_object() or m_value.object != nullptr);
+ return is_object() ? m_value.object->count(key) : 0;
+ }
+
+ /// @}
+
+
+ ///////////////
+ // iterators //
+ ///////////////
+
+ /// @name iterators
+ /// @{
+
+ /*!
+ @brief returns an iterator to the first element
+
+ Returns an iterator to the first element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return iterator to the first element
+
+ @complexity Constant.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+
+ @liveexample{The following code shows an example for @ref begin.,begin}
+
+ @since version 1.0.0
+ */
+ iterator begin()
+ {
+ iterator result(this);
+ result.set_begin();
+ return result;
+ }
+
+ /*!
+ @copydoc basic_json::cbegin()
+ */
+ const_iterator begin() const
+ {
+ return cbegin();
+ }
+
+ /*!
+ @brief returns a const iterator to the first element
+
+ Returns a const iterator to the first element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return const iterator to the first element
+
+ @complexity Constant.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+ @liveexample{The following code shows an example for @ref cbegin.,cbegin}
+
+ @since version 1.0.0
+ */
+ const_iterator cbegin() const
+ {
+ const_iterator result(this);
+ result.set_begin();
+ return result;
+ }
+
+ /*!
+ @brief returns an iterator to one past the last element
+
+ Returns an iterator to one past the last element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return iterator one past the last element
+
+ @complexity Constant.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+
+ @liveexample{The following code shows an example for @ref end.,end}
+
+ @since version 1.0.0
+ */
+ iterator end()
+ {
+ iterator result(this);
+ result.set_end();
+ return result;
+ }
+
+ /*!
+ @copydoc basic_json::cend()
+ */
+ const_iterator end() const
+ {
+ return cend();
+ }
+
+ /*!
+ @brief returns a const iterator to one past the last element
+
+ Returns a const iterator to one past the last element.
+
+ @image html range-begin-end.svg "Illustration from cppreference.com"
+
+ @return const iterator one past the last element
+
+ @complexity Constant.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+ @liveexample{The following code shows an example for @ref cend.,cend}
+
+ @since version 1.0.0
+ */
+ const_iterator cend() const
+ {
+ const_iterator result(this);
+ result.set_end();
+ return result;
+ }
+
+ /*!
+ @brief returns an iterator to the reverse-beginning
+
+ Returns an iterator to the reverse-beginning; that is, the last element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function satisfies the ReversibleContainer requirements:
+ - The complexity is constant.
+ - Has the semantics of `reverse_iterator(end())`.
+
+ @liveexample{The following code shows an example for @ref rbegin.,rbegin}
+
+ @since version 1.0.0
+ */
+ reverse_iterator rbegin()
+ {
+ return reverse_iterator(end());
+ }
+
+ /*!
+ @copydoc basic_json::crbegin()
+ */
+ const_reverse_iterator rbegin() const
+ {
+ return crbegin();
+ }
+
+ /*!
+ @brief returns an iterator to the reverse-end
+
+ Returns an iterator to the reverse-end; that is, one before the first
+ element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function satisfies the ReversibleContainer requirements:
+ - The complexity is constant.
+ - Has the semantics of `reverse_iterator(begin())`.
+
+ @liveexample{The following code shows an example for @ref rend.,rend}
+
+ @since version 1.0.0
+ */
+ reverse_iterator rend()
+ {
+ return reverse_iterator(begin());
+ }
+
+ /*!
+ @copydoc basic_json::crend()
+ */
+ const_reverse_iterator rend() const
+ {
+ return crend();
+ }
+
+ /*!
+ @brief returns a const reverse iterator to the last element
+
+ Returns a const iterator to the reverse-beginning; that is, the last
+ element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function satisfies the ReversibleContainer requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+ @liveexample{The following code shows an example for @ref crbegin.,crbegin}
+
+ @since version 1.0.0
+ */
+ const_reverse_iterator crbegin() const
+ {
+ return const_reverse_iterator(cend());
+ }
+
+ /*!
+ @brief returns a const reverse iterator to one before the first
+
+ Returns a const reverse iterator to the reverse-end; that is, one before
+ the first element.
+
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+ @complexity Constant.
+
+ @requirement This function satisfies the ReversibleContainer requirements:
+ - The complexity is constant.
+ - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+ @liveexample{The following code shows an example for @ref crend.,crend}
+
+ @since version 1.0.0
+ */
+ const_reverse_iterator crend() const
+ {
+ return const_reverse_iterator(cbegin());
+ }
+
+ private:
+ // forward declaration
+ template<typename IteratorType> class iteration_proxy;
+
+ public:
+ /*!
+ @brief wrapper to access iterator member functions in range-based for
+
+ This function allows to access @ref iterator::key() and @ref
+ iterator::value() during range-based for loops. In these loops, a reference
+ to the JSON values is returned, so there is no access to the underlying
+ iterator.
+
+ @note The name of this function is not yet final and may change in the
+ future.
+ */
+ static iteration_proxy<iterator> iterator_wrapper(reference cont)
+ {
+ return iteration_proxy<iterator>(cont);
+ }
+
+ /*!
+ @copydoc iterator_wrapper(reference)
+ */
+ static iteration_proxy<const_iterator> iterator_wrapper(const_reference cont)
+ {
+ return iteration_proxy<const_iterator>(cont);
+ }
+
+ /// @}
+
+
+ //////////////
+ // capacity //
+ //////////////
+
+ /// @name capacity
+ /// @{
+
+ /*!
+ @brief checks whether the container is empty
+
+ Checks if a JSON value has no elements.
+
+ @return The return value depends on the different types and is
+ defined as follows:
+ Value type | return value
+ ----------- | -------------
+ null | @c true
+ boolean | @c false
+ string | @c false
+ number | @c false
+ object | result of function object_t::empty()
+ array | result of function array_t::empty()
+
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+ Container concept; that is, their empty() functions have constant
+ complexity.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - Has the semantics of `begin() == end()`.
+
+ @liveexample{The following code uses @ref empty to check if a @ref json
+ object contains any elements.,empty}
+
+ @since version 1.0.0
+ */
+ bool empty() const noexcept
+ {
+ switch (m_type)
+ {
+ case value_t::null:
+ {
+ // null values are empty
+ return true;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->empty();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->empty();
+ }
+
+ default:
+ {
+ // all other types are nonempty
+ return false;
+ }
+ }
+ }
+
+ /*!
+ @brief returns the number of elements
+
+ Returns the number of elements in a JSON value.
+
+ @return The return value depends on the different types and is
+ defined as follows:
+ Value type | return value
+ ----------- | -------------
+ null | @c 0
+ boolean | @c 1
+ string | @c 1
+ number | @c 1
+ object | result of function object_t::size()
+ array | result of function array_t::size()
+
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+ Container concept; that is, their size() functions have constant complexity.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - Has the semantics of `std::distance(begin(), end())`.
+
+ @liveexample{The following code calls @ref size on the different value
+ types.,size}
+
+ @since version 1.0.0
+ */
+ size_type size() const noexcept
+ {
+ switch (m_type)
+ {
+ case value_t::null:
+ {
+ // null values are empty
+ return 0;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->size();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->size();
+ }
+
+ default:
+ {
+ // all other types have size 1
+ return 1;
+ }
+ }
+ }
+
+ /*!
+ @brief returns the maximum possible number of elements
+
+ Returns the maximum number of elements a JSON value is able to hold due to
+ system or library implementation limitations, i.e. `std::distance(begin(),
+ end())` for the JSON value.
+
+ @return The return value depends on the different types and is
+ defined as follows:
+ Value type | return value
+ ----------- | -------------
+ null | @c 0 (same as size())
+ boolean | @c 1 (same as size())
+ string | @c 1 (same as size())
+ number | @c 1 (same as size())
+ object | result of function object_t::max_size()
+ array | result of function array_t::max_size()
+
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy the
+ Container concept; that is, their max_size() functions have constant
+ complexity.
+
+ @requirement This function satisfies the Container requirements:
+ - The complexity is constant.
+ - Has the semantics of returning `b.size()` where `b` is the largest
+ possible JSON value.
+
+ @liveexample{The following code calls @ref max_size on the different value
+ types. Note the output is implementation specific.,max_size}
+
+ @since version 1.0.0
+ */
+ size_type max_size() const noexcept
+ {
+ switch (m_type)
+ {
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ return m_value.array->max_size();
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ return m_value.object->max_size();
+ }
+
+ default:
+ {
+ // all other types have max_size() == size()
+ return size();
+ }
+ }
+ }
+
+ /// @}
+
+
+ ///////////////
+ // modifiers //
+ ///////////////
+
+ /// @name modifiers
+ /// @{
+
+ /*!
+ @brief clears the contents
+
+ Clears the content of a JSON value and resets it to the default value as
+ if @ref basic_json(value_t) would have been called:
+
+ Value type | initial value
+ ----------- | -------------
+ null | `null`
+ boolean | `false`
+ string | `""`
+ number | `0`
+ object | `{}`
+ array | `[]`
+
+ @note Floating-point numbers are set to `0.0` which will be serialized to
+ `0`. The vale type remains @ref number_float_t.
+
+ @complexity Linear in the size of the JSON value.
+
+ @liveexample{The example below shows the effect of @ref clear to different
+ JSON types.,clear}
+
+ @since version 1.0.0
+ */
+ void clear() noexcept
+ {
+ switch (m_type)
+ {
+ case value_t::number_integer:
+ {
+ m_value.number_integer = 0;
+ break;
+ }
+
+ case value_t::number_float:
+ {
+ m_value.number_float = 0.0;
+ break;
+ }
+
+ case value_t::boolean:
+ {
+ m_value.boolean = false;
+ break;
+ }
+
+ case value_t::string:
+ {
+ assert(m_value.string != nullptr);
+ m_value.string->clear();
+ break;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+ m_value.array->clear();
+ break;
+ }
+
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+ m_value.object->clear();
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ /*!
+ @brief add an object to an array
+
+ Appends the given element @a val to the end of the JSON value. If the
+ function is called on a JSON null value, an empty array is created before
+ appending @a val.
+
+ @param val the value to add to the JSON array
+
+ @throw std::domain_error when called on a type other than JSON array or
+ null; example: `"cannot use push_back() with number"`
+
+ @complexity Amortized constant.
+
+ @liveexample{The example shows how `push_back` and `+=` can be used to add
+ elements to a JSON array. Note how the `null` value was silently converted
+ to a JSON array.,push_back}
+
+ @since version 1.0.0
+ */
+ void push_back(basic_json&& val)
+ {
+ // push_back only works for null objects or arrays
+ if (not(is_null() or is_array()))
+ {
+ throw std::domain_error("cannot use push_back() with " + type_name());
+ }
+
+ // transform null object into an array
+ if (is_null())
+ {
+ m_type = value_t::array;
+ m_value = value_t::array;
+ }
+
+ // add element to array (move semantics)
+ assert(m_value.array != nullptr);
+ m_value.array->push_back(std::move(val));
+ // invalidate object
+ val.m_type = value_t::null;
+ }
+
+ /*!
+ @brief add an object to an array
+ @copydoc push_back(basic_json&&)
+ */
+ reference operator+=(basic_json&& val)
+ {
+ push_back(std::move(val));
+ return *this;
+ }
+
+ /*!
+ @brief add an object to an array
+ @copydoc push_back(basic_json&&)
+ */
+ void push_back(const basic_json& val)
+ {
+ // push_back only works for null objects or arrays
+ if (not(is_null() or is_array()))
+ {
+ throw std::domain_error("cannot use push_back() with " + type_name());
+ }
+
+ // transform null object into an array
+ if (is_null())
+ {
+ m_type = value_t::array;
+ m_value = value_t::array;
+ }
+
+ // add element to array
+ assert(m_value.array != nullptr);
+ m_value.array->push_back(val);
+ }
+
+ /*!
+ @brief add an object to an array
+ @copydoc push_back(basic_json&&)
+ */
+ reference operator+=(const basic_json& val)
+ {
+ push_back(val);
+ return *this;
+ }
+
+ /*!
+ @brief add an object to an object
+
+ Inserts the given element @a val to the JSON object. If the function is
+ called on a JSON null value, an empty object is created before inserting @a
+ val.
+
+ @param[in] val the value to add to the JSON object
+
+ @throw std::domain_error when called on a type other than JSON object or
+ null; example: `"cannot use push_back() with number"`
+
+ @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+ @liveexample{The example shows how `push_back` and `+=` can be used to add
+ elements to a JSON object. Note how the `null` value was silently converted
+ to a JSON object.,push_back__object_t__value}
+
+ @since version 1.0.0
+ */
+ void push_back(const typename object_t::value_type& val)
+ {
+ // push_back only works for null objects or objects
+ if (not(is_null() or is_object()))
+ {
+ throw std::domain_error("cannot use push_back() with " + type_name());
+ }
+
+ // transform null object into an object
+ if (is_null())
+ {
+ m_type = value_t::object;
+ m_value = value_t::object;
+ }
+
+ // add element to array
+ assert(m_value.object != nullptr);
+ m_value.object->insert(val);
+ }
+
+ /*!
+ @brief add an object to an object
+ @copydoc push_back(const typename object_t::value_type&)
+ */
+ reference operator+=(const typename object_t::value_type& val)
+ {
+ push_back(val);
+ return operator[](val.first);
+ }
+
+ /*!
+ @brief inserts element
+
+ Inserts element @a val before iterator @a pos.
+
+ @param[in] pos iterator before which the content will be inserted; may be
+ the end() iterator
+ @param[in] val element to insert
+ @return iterator pointing to the inserted @a val.
+
+ @throw std::domain_error if called on JSON values other than arrays;
+ example: `"cannot use insert() with string"`
+ @throw std::domain_error if @a pos is not an iterator of *this; example:
+ `"iterator does not fit current value"`
+
+ @complexity Constant plus linear in the distance between pos and end of the
+ container.
+
+ @liveexample{The example shows how insert is used.,insert}
+
+ @since version 1.0.0
+ */
+ iterator insert(const_iterator pos, const basic_json& val)
+ {
+ // insert only works for arrays
+ if (is_array())
+ {
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
+ return result;
+ }
+ else
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief inserts element
+ @copydoc insert(const_iterator, const basic_json&)
+ */
+ iterator insert(const_iterator pos, basic_json&& val)
+ {
+ return insert(pos, val);
+ }
+
+ /*!
+ @brief inserts elements
+
+ Inserts @a cnt copies of @a val before iterator @a pos.
+
+ @param[in] pos iterator before which the content will be inserted; may be
+ the end() iterator
+ @param[in] cnt number of copies of @a val to insert
+ @param[in] val element to insert
+ @return iterator pointing to the first element inserted, or @a pos if
+ `cnt==0`
+
+ @throw std::domain_error if called on JSON values other than arrays;
+ example: `"cannot use insert() with string"`
+ @throw std::domain_error if @a pos is not an iterator of *this; example:
+ `"iterator does not fit current value"`
+
+ @complexity Linear in @a cnt plus linear in the distance between @a pos
+ and end of the container.
+
+ @liveexample{The example shows how insert is used.,insert__count}
+
+ @since version 1.0.0
+ */
+ iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+ {
+ // insert only works for arrays
+ if (is_array())
+ {
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+ return result;
+ }
+ else
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief inserts elements
+
+ Inserts elements from range `[first, last)` before iterator @a pos.
+
+ @param[in] pos iterator before which the content will be inserted; may be
+ the end() iterator
+ @param[in] first begin of the range of elements to insert
+ @param[in] last end of the range of elements to insert
+
+ @throw std::domain_error if called on JSON values other than arrays;
+ example: `"cannot use insert() with string"`
+ @throw std::domain_error if @a pos is not an iterator of *this; example:
+ `"iterator does not fit current value"`
+ @throw std::domain_error if @a first and @a last do not belong to the same
+ JSON value; example: `"iterators do not fit"`
+ @throw std::domain_error if @a first or @a last are iterators into
+ container for which insert is called; example: `"passed iterators may not
+ belong to container"`
+
+ @return iterator pointing to the first element inserted, or @a pos if
+ `first==last`
+
+ @complexity Linear in `std::distance(first, last)` plus linear in the
+ distance between @a pos and end of the container.
+
+ @liveexample{The example shows how insert is used.,insert__range}
+
+ @since version 1.0.0
+ */
+ iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+ {
+ // insert only works for arrays
+ if (not is_array())
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ if (first.m_object != last.m_object)
+ {
+ throw std::domain_error("iterators do not fit");
+ }
+
+ if (first.m_object == this or last.m_object == this)
+ {
+ throw std::domain_error("passed iterators may not belong to container");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(
+ pos.m_it.array_iterator,
+ first.m_it.array_iterator,
+ last.m_it.array_iterator);
+ return result;
+ }
+
+ /*!
+ @brief inserts elements
+
+ Inserts elements from initializer list @a ilist before iterator @a pos.
+
+ @param[in] pos iterator before which the content will be inserted; may be
+ the end() iterator
+ @param[in] ilist initializer list to insert the values from
+
+ @throw std::domain_error if called on JSON values other than arrays;
+ example: `"cannot use insert() with string"`
+ @throw std::domain_error if @a pos is not an iterator of *this; example:
+ `"iterator does not fit current value"`
+
+ @return iterator pointing to the first element inserted, or @a pos if
+ `ilist` is empty
+
+ @complexity Linear in `ilist.size()` plus linear in the distance between @a
+ pos and end of the container.
+
+ @liveexample{The example shows how insert is used.,insert__ilist}
+
+ @since version 1.0.0
+ */
+ iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)
+ {
+ // insert only works for arrays
+ if (not is_array())
+ {
+ throw std::domain_error("cannot use insert() with " + type_name());
+ }
+
+ // check if iterator pos fits to this JSON value
+ if (pos.m_object != this)
+ {
+ throw std::domain_error("iterator does not fit current value");
+ }
+
+ // insert to array and return iterator
+ iterator result(this);
+ assert(m_value.array != nullptr);
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
+ return result;
+ }
+
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of the JSON value with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other JSON value to exchange the contents with
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON arrays can be
+ swapped.,swap__reference}
+
+ @since version 1.0.0
+ */
+ 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
+ )
+ {
+ std::swap(m_type, other.m_type);
+ std::swap(m_value, other.m_value);
+ }
+
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of a JSON array with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other array to exchange the contents with
+
+ @throw std::domain_error when JSON value is not an array; example: `"cannot
+ use swap() with string"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be
+ swapped.,swap__array_t}
+
+ @since version 1.0.0
+ */
+ void swap(array_t& other)
+ {
+ // swap only works for arrays
+ if (is_array())
+ {
+ assert(m_value.array != nullptr);
+ std::swap(*(m_value.array), other);
+ }
+ else
+ {
+ throw std::domain_error("cannot use swap() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of a JSON object with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other object to exchange the contents with
+
+ @throw std::domain_error when JSON value is not an object; example:
+ `"cannot use swap() with string"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be
+ swapped.,swap__object_t}
+
+ @since version 1.0.0
+ */
+ void swap(object_t& other)
+ {
+ // swap only works for objects
+ if (is_object())
+ {
+ assert(m_value.object != nullptr);
+ std::swap(*(m_value.object), other);
+ }
+ else
+ {
+ throw std::domain_error("cannot use swap() with " + type_name());
+ }
+ }
+
+ /*!
+ @brief exchanges the values
+
+ Exchanges the contents of a JSON string with those of @a other. Does not
+ invoke any move, copy, or swap operations on individual elements. All
+ iterators and references remain valid. The past-the-end iterator is
+ invalidated.
+
+ @param[in,out] other string to exchange the contents with
+
+ @throw std::domain_error when JSON value is not a string; example: `"cannot
+ use swap() with boolean"`
+
+ @complexity Constant.
+
+ @liveexample{The example below shows how JSON values can be
+ swapped.,swap__string_t}
+
+ @since version 1.0.0
+ */
+ void swap(string_t& other)
+ {
+ // swap only works for strings
+ if (is_string())
+ {
+ assert(m_value.string != nullptr);
+ std::swap(*(m_value.string), other);
+ }
+ else
+ {
+ throw std::domain_error("cannot use swap() with " + type_name());
+ }
+ }
+
+ /// @}
+
+
+ //////////////////////////////////////////
+ // lexicographical comparison operators //
+ //////////////////////////////////////////
+
+ /// @name lexicographical comparison operators
+ /// @{
+
+ private:
+ /*!
+ @brief comparison operator for JSON types
+
+ Returns an ordering that is similar to Python:
+ - order: null < boolean < number < object < array < string
+ - furthermore, each type is not smaller than itself
+
+ @since version 1.0.0
+ */
+ friend bool operator<(const value_t lhs, const value_t rhs)
+ {
+ static constexpr std::array<uint8_t, 7> order = {{
+ 0, // null
+ 3, // object
+ 4, // array
+ 5, // string
+ 1, // boolean
+ 2, // integer
+ 2 // float
+ }
+ };
+
+ // discarded values are not comparable
+ if (lhs == value_t::discarded or rhs == value_t::discarded)
+ {
+ return false;
+ }
+
+ return order[static_cast<std::size_t>(lhs)] < order[static_cast<std::size_t>(rhs)];
+ }
+
+ public:
+ /*!
+ @brief comparison: equal
+
+ Compares two JSON values for equality according to the following rules:
+ - Two JSON values are equal if (1) they are from the same type and (2)
+ their stored values are the same.
+ - Integer and floating-point numbers are automatically converted before
+ comparison. Floating-point numbers are compared indirectly: two
+ floating-point numbers `f1` and `f2` are considered equal if neither
+ `f1 > f2` nor `f2 > f1` holds.
+ - Two JSON null values are equal.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether the values @a lhs and @a rhs are equal
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__equal}
+
+ @since version 1.0.0
+ */
+ friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+ {
+ const auto lhs_type = lhs.type();
+ const auto rhs_type = rhs.type();
+
+ if (lhs_type == rhs_type)
+ {
+ switch (lhs_type)
+ {
+ case value_t::array:
+ {
+ assert(lhs.m_value.array != nullptr);
+ assert(rhs.m_value.array != nullptr);
+ return *lhs.m_value.array == *rhs.m_value.array;
+ }
+ case value_t::object:
+ {
+ assert(lhs.m_value.object != nullptr);
+ assert(rhs.m_value.object != nullptr);
+ return *lhs.m_value.object == *rhs.m_value.object;
+ }
+ case value_t::null:
+ {
+ return true;
+ }
+ case value_t::string:
+ {
+ assert(lhs.m_value.string != nullptr);
+ assert(rhs.m_value.string != nullptr);
+ return *lhs.m_value.string == *rhs.m_value.string;
+ }
+ case value_t::boolean:
+ {
+ return lhs.m_value.boolean == rhs.m_value.boolean;
+ }
+ case value_t::number_integer:
+ {
+ return lhs.m_value.number_integer == rhs.m_value.number_integer;
+ }
+ case value_t::number_float:
+ {
+ return lhs.m_value.number_float == rhs.m_value.number_float;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ {
+ return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+ }
+ return false;
+ }
+
+ /*!
+ @brief comparison: equal
+
+ The functions compares the given JSON value against a null pointer. As the
+ null pointer can be used to initialize a JSON value to null, a comparison
+ of JSON value @a v with a null pointer should be equivalent to call
+ `v.is_null()`.
+
+ @param[in] v JSON value to consider
+ @return whether @a v is null
+
+ @complexity Constant.
+
+ @liveexample{The example compares several JSON types to the null pointer.
+ ,operator__equal__nullptr_t}
+
+ @since version 1.0.0
+ */
+ friend bool operator==(const_reference v, std::nullptr_t) noexcept
+ {
+ return v.is_null();
+ }
+
+ /*!
+ @brief comparison: equal
+ @copydoc operator==(const_reference, std::nullptr_t)
+ */
+ friend bool operator==(std::nullptr_t, const_reference v) noexcept
+ {
+ return v.is_null();
+ }
+
+ /*!
+ @brief comparison: not equal
+
+ Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether the values @a lhs and @a rhs are not equal
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__notequal}
+
+ @since version 1.0.0
+ */
+ friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (lhs == rhs);
+ }
+
+ /*!
+ @brief comparison: not equal
+
+ The functions compares the given JSON value against a null pointer. As the
+ null pointer can be used to initialize a JSON value to null, a comparison
+ of JSON value @a v with a null pointer should be equivalent to call
+ `not v.is_null()`.
+
+ @param[in] v JSON value to consider
+ @return whether @a v is not null
+
+ @complexity Constant.
+
+ @liveexample{The example compares several JSON types to the null pointer.
+ ,operator__notequal__nullptr_t}
+
+ @since version 1.0.0
+ */
+ friend bool operator!=(const_reference v, std::nullptr_t) noexcept
+ {
+ return not v.is_null();
+ }
+
+ /*!
+ @brief comparison: not equal
+ @copydoc operator!=(const_reference, std::nullptr_t)
+ */
+ friend bool operator!=(std::nullptr_t, const_reference v) noexcept
+ {
+ return not v.is_null();
+ }
+
+ /*!
+ @brief comparison: less than
+
+ Compares whether one JSON value @a lhs is less than another JSON value @a
+ rhs according to the following rules:
+ - If @a lhs and @a rhs have the same type, the values are compared using
+ the default `<` operator.
+ - Integer and floating-point numbers are automatically converted before
+ comparison
+ - In case @a lhs and @a rhs have different types, the values are ignored
+ and the order of the types is considered, see
+ @ref operator<(const value_t, const value_t).
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is less than @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__less}
+
+ @since version 1.0.0
+ */
+ friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+ {
+ const auto lhs_type = lhs.type();
+ const auto rhs_type = rhs.type();
+
+ if (lhs_type == rhs_type)
+ {
+ switch (lhs_type)
+ {
+ case value_t::array:
+ {
+ assert(lhs.m_value.array != nullptr);
+ assert(rhs.m_value.array != nullptr);
+ return *lhs.m_value.array < *rhs.m_value.array;
+ }
+ case value_t::object:
+ {
+ assert(lhs.m_value.object != nullptr);
+ assert(rhs.m_value.object != nullptr);
+ return *lhs.m_value.object < *rhs.m_value.object;
+ }
+ case value_t::null:
+ {
+ return false;
+ }
+ case value_t::string:
+ {
+ assert(lhs.m_value.string != nullptr);
+ assert(rhs.m_value.string != nullptr);
+ return *lhs.m_value.string < *rhs.m_value.string;
+ }
+ case value_t::boolean:
+ {
+ return lhs.m_value.boolean < rhs.m_value.boolean;
+ }
+ case value_t::number_integer:
+ {
+ return lhs.m_value.number_integer < rhs.m_value.number_integer;
+ }
+ case value_t::number_float:
+ {
+ return lhs.m_value.number_float < rhs.m_value.number_float;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+ }
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+ {
+ return static_cast<number_float_t>(lhs.m_value.number_integer) <
+ rhs.m_value.number_float;
+ }
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+ {
+ return lhs.m_value.number_float <
+ static_cast<number_float_t>(rhs.m_value.number_integer);
+ }
+
+ // We only reach this line if we cannot compare values. In that case,
+ // we compare types. Note we have to call the operator explicitly,
+ // because MSVC has problems otherwise.
+ return operator<(lhs_type, rhs_type);
+ }
+
+ /*!
+ @brief comparison: less than or equal
+
+ Compares whether one JSON value @a lhs is less than or equal to another
+ JSON value by calculating `not (rhs < lhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is less than or equal to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__greater}
+
+ @since version 1.0.0
+ */
+ friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (rhs < lhs);
+ }
+
+ /*!
+ @brief comparison: greater than
+
+ Compares whether one JSON value @a lhs is greater than another
+ JSON value by calculating `not (lhs <= rhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is greater than to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__lessequal}
+
+ @since version 1.0.0
+ */
+ friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (lhs <= rhs);
+ }
+
+ /*!
+ @brief comparison: greater than or equal
+
+ Compares whether one JSON value @a lhs is greater than or equal to another
+ JSON value by calculating `not (lhs < rhs)`.
+
+ @param[in] lhs first JSON value to consider
+ @param[in] rhs second JSON value to consider
+ @return whether @a lhs is greater than or equal to @a rhs
+
+ @complexity Linear.
+
+ @liveexample{The example demonstrates comparing several JSON
+ types.,operator__greaterequal}
+
+ @since version 1.0.0
+ */
+ friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+ {
+ return not (lhs < rhs);
+ }
+
+ /// @}
+
+
+ ///////////////////
+ // serialization //
+ ///////////////////
+
+ /// @name serialization
+ /// @{
+
+ /*!
+ @brief serialize to stream
+
+ Serialize the given JSON value @a j to the output stream @a o. The JSON
+ value will be serialized using the @ref dump member function. The
+ indentation of the output can be controlled with the member variable
+ `width` of the output stream @a o. For instance, using the manipulator
+ `std::setw(4)` on @a o sets the indentation level to `4` and the
+ serialization result is the same as calling `dump(4)`.
+
+ @param[in,out] o stream to serialize to
+ @param[in] j JSON value to serialize
+
+ @return the stream @a o
+
+ @complexity Linear.
+
+ @liveexample{The example below shows the serialization with different
+ parameters to `width` to adjust the indentation level.,operator_serialize}
+
+ @since version 1.0.0
+ */
+ friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+ {
+ // read width member and use it as indentation parameter if nonzero
+ const bool pretty_print = (o.width() > 0);
+ const auto indentation = (pretty_print ? o.width() : 0);
+
+ // reset width to 0 for subsequent calls to this stream
+ o.width(0);
+
+ // do the actual serialization
+ j.dump(o, pretty_print, static_cast<unsigned int>(indentation));
+ return o;
+ }
+
+ /*!
+ @brief serialize to stream
+ @copydoc operator<<(std::ostream&, const basic_json&)
+ */
+ friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+ {
+ return o << j;
+ }
+
+ /// @}
+
+
+ /////////////////////
+ // deserialization //
+ /////////////////////
+
+ /// @name deserialization
+ /// @{
+
+ /*!
+ @brief deserialize from string
+
+ @param[in] s string to read a serialized JSON value from
+ @param[in] cb a parser callback function of type @ref parser_callback_t
+ which is used to control the deserialization by filtering unwanted values
+ (optional)
+
+ @return result of the deserialization
+
+ @complexity Linear in the length of the input. The parser is a predictive
+ LL(1) parser. The complexity can be higher if the parser callback function
+ @a cb has a super-linear complexity.
+
+ @note A UTF-8 byte order mark is silently ignored.
+
+ @liveexample{The example below demonstrates the parse function with and
+ without callback function.,parse__string__parser_callback_t}
+
+ @sa @ref parse(std::istream&, parser_callback_t) for a version that reads
+ from an input stream
+
+ @since version 1.0.0
+ */
+ static basic_json parse(const string_t& s, parser_callback_t cb = nullptr)
+ {
+ return parser(s, cb).parse();
+ }
+
+ /*!
+ @brief deserialize from stream
+
+ @param[in,out] i stream to read a serialized JSON value from
+ @param[in] cb a parser callback function of type @ref parser_callback_t
+ which is used to control the deserialization by filtering unwanted values
+ (optional)
+
+ @return result of the deserialization
+
+ @complexity Linear in the length of the input. The parser is a predictive
+ LL(1) parser. The complexity can be higher if the parser callback function
+ @a cb has a super-linear complexity.
+
+ @note A UTF-8 byte order mark is silently ignored.
+
+ @liveexample{The example below demonstrates the parse function with and
+ without callback function.,parse__istream__parser_callback_t}
+
+ @sa @ref parse(const string_t&, parser_callback_t) for a version that reads
+ from a string
+
+ @since version 1.0.0
+ */
+ static basic_json parse(std::istream& i, parser_callback_t cb = nullptr)
+ {
+ return parser(i, cb).parse();
+ }
+
+ /*!
+ @copydoc parse(std::istream&, parser_callback_t)
+ */
+ static basic_json parse(std::istream&& i, parser_callback_t cb = nullptr)
+ {
+ return parser(i, cb).parse();
+ }
+
+ /*!
+ @brief deserialize from stream
+
+ Deserializes an input stream to a JSON value.
+
+ @param[in,out] i input stream to read a serialized JSON value from
+ @param[in,out] j JSON value to write the deserialized input to
+
+ @throw std::invalid_argument in case of parse errors
+
+ @complexity Linear in the length of the input. The parser is a predictive
+ LL(1) parser.
+
+ @note A UTF-8 byte order mark is silently ignored.
+
+ @liveexample{The example below shows how a JSON value is constructed by
+ reading a serialization from a stream.,operator_deserialize}
+
+ @sa parse(std::istream&, parser_callback_t) for a variant with a parser
+ callback function to filter values while parsing
+
+ @since version 1.0.0
+ */
+ friend std::istream& operator<<(basic_json& j, std::istream& i)
+ {
+ j = parser(i).parse();
+ return i;
+ }
+
+ /*!
+ @brief deserialize from stream
+ @copydoc operator<<(basic_json&, std::istream&)
+ */
+ friend std::istream& operator>>(std::istream& i, basic_json& j)
+ {
+ j = parser(i).parse();
+ return i;
+ }
+
+ /// @}
+
+
+ private:
+ ///////////////////////////
+ // convenience functions //
+ ///////////////////////////
+
+ /// return the type as string
+ string_t type_name() const
+ {
+ switch (m_type)
+ {
+ case value_t::null:
+ return "null";
+ case value_t::object:
+ return "object";
+ case value_t::array:
+ return "array";
+ case value_t::string:
+ return "string";
+ case value_t::boolean:
+ return "boolean";
+ case value_t::discarded:
+ return "discarded";
+ default:
+ return "number";
+ }
+ }
+
+ /*!
+ @brief calculates the extra space to escape a JSON string
+
+ @param[in] s the string to escape
+ @return the number of characters required to escape string @a s
+
+ @complexity Linear in the length of string @a s.
+ */
+ static std::size_t extra_space(const string_t& s) noexcept
+ {
+ std::size_t result = 0;
+
+ for (const auto& c : s)
+ {
+ switch (c)
+ {
+ case '"':
+ case '\\':
+ case '\b':
+ case '\f':
+ case '\n':
+ case '\r':
+ case '\t':
+ {
+ // from c (1 byte) to \x (2 bytes)
+ result += 1;
+ break;
+ }
+
+ default:
+ {
+ if (c >= 0x00 and c <= 0x1f)
+ {
+ // from c (1 byte) to \uxxxx (6 bytes)
+ result += 5;
+ }
+ break;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief escape a string
+
+ 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[in] s the string to escape
+ @return the escaped string
+
+ @complexity Linear in the length of string @a s.
+ */
+ static string_t escape_string(const string_t& s) noexcept
+ {
+ const auto space = extra_space(s);
+ if (space == 0)
+ {
+ return s;
+ }
+
+ // create a result string of necessary size
+ string_t result(s.size() + space, '\\');
+ std::size_t pos = 0;
+
+ for (const auto& c : s)
+ {
+ switch (c)
+ {
+ // quotation mark (0x22)
+ case '"':
+ {
+ result[pos + 1] = '"';
+ pos += 2;
+ break;
+ }
+
+ // reverse solidus (0x5c)
+ case '\\':
+ {
+ // nothing to change
+ pos += 2;
+ break;
+ }
+
+ // backspace (0x08)
+ case '\b':
+ {
+ result[pos + 1] = 'b';
+ pos += 2;
+ break;
+ }
+
+ // formfeed (0x0c)
+ case '\f':
+ {
+ result[pos + 1] = 'f';
+ pos += 2;
+ break;
+ }
+
+ // newline (0x0a)
+ case '\n':
+ {
+ result[pos + 1] = 'n';
+ pos += 2;
+ break;
+ }
+
+ // carriage return (0x0d)
+ case '\r':
+ {
+ result[pos + 1] = 'r';
+ pos += 2;
+ break;
+ }
+
+ // horizontal tab (0x09)
+ case '\t':
+ {
+ result[pos + 1] = 't';
+ pos += 2;
+ break;
+ }
+
+ default:
+ {
+ if (c >= 0x00 and c <= 0x1f)
+ {
+ // convert a number 0..15 to its hex representation (0..f)
+ auto hexify = [](const char v) -> char
+ {
+ return (v < 10) ? ('0' + v) : ('a' + v - 10);
+ };
+
+ // print character c as \uxxxx
+ for (const char m :
+ { 'u', '0', '0', hexify(c >> 4), hexify(c & 0x0f)
+ })
+ {
+ result[++pos] = m;
+ }
+
+ ++pos;
+ }
+ else
+ {
+ // all other characters are added as-is
+ result[pos++] = c;
+ }
+ break;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief internal implementation of the serialization function
+
+ This function is called by the public member function dump and organizes
+ the serialization internally. The indentation level is propagated as
+ additional parameter. In case of arrays and objects, the function is called
+ recursively. Note that
+
+ - strings and object keys are escaped using escape_string()
+ - integer numbers are converted implicitly via operator<<
+ - floating-point numbers are converted to a string using "%g" format
+
+ @param[out] o stream to write to
+ @param[in] pretty_print whether the output shall be pretty-printed
+ @param[in] indent_step the indent level
+ @param[in] current_indent the current indent level (only used internally)
+ */
+ void dump(std::ostream& o,
+ const bool pretty_print,
+ const unsigned int indent_step,
+ const unsigned int current_indent = 0) const
+ {
+ // variable to hold indentation for recursive calls
+ unsigned int new_indent = current_indent;
+
+ switch (m_type)
+ {
+ case value_t::object:
+ {
+ assert(m_value.object != nullptr);
+
+ if (m_value.object->empty())
+ {
+ o << "{}";
+ return;
+ }
+
+ o << "{";
+
+ // increase indentation
+ if (pretty_print)
+ {
+ new_indent += indent_step;
+ o << "\n";
+ }
+
+ for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
+ {
+ if (i != m_value.object->cbegin())
+ {
+ o << (pretty_print ? ",\n" : ",");
+ }
+ o << string_t(new_indent, ' ') << "\""
+ << escape_string(i->first) << "\":"
+ << (pretty_print ? " " : "");
+ i->second.dump(o, pretty_print, indent_step, new_indent);
+ }
+
+ // decrease indentation
+ if (pretty_print)
+ {
+ new_indent -= indent_step;
+ o << "\n";
+ }
+
+ o << string_t(new_indent, ' ') + "}";
+ return;
+ }
+
+ case value_t::array:
+ {
+ assert(m_value.array != nullptr);
+
+ if (m_value.array->empty())
+ {
+ o << "[]";
+ return;
+ }
+
+ o << "[";
+
+ // increase indentation
+ if (pretty_print)
+ {
+ new_indent += indent_step;
+ o << "\n";
+ }
+
+ for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
+ {
+ if (i != m_value.array->cbegin())
+ {
+ o << (pretty_print ? ",\n" : ",");
+ }
+ o << string_t(new_indent, ' ');
+ i->dump(o, pretty_print, indent_step, new_indent);
+ }
+
+ // decrease indentation
+ if (pretty_print)
+ {
+ new_indent -= indent_step;
+ o << "\n";
+ }
+
+ o << string_t(new_indent, ' ') << "]";
+ return;
+ }
+
+ case value_t::string:
+ {
+ assert(m_value.string != nullptr);
+ o << string_t("\"") << escape_string(*m_value.string) << "\"";
+ return;
+ }
+
+ case value_t::boolean:
+ {
+ o << (m_value.boolean ? "true" : "false");
+ return;
+ }
+
+ case value_t::number_integer:
+ {
+ o << m_value.number_integer;
+ return;
+ }
+
+ case value_t::number_float:
+ {
+ // If the number is an integer then output as a fixed with with
+ // precision 1 to output "0.0", "1.0" etc as expected for some
+ // round trip tests otherwise 15 digits of precision allows
+ // round-trip IEEE 754 string->double->string; to be safe, we
+ // read this value from
+ // std::numeric_limits<number_float_t>::digits10
+ if (std::fmod(m_value.number_float, 1) == 0)
+ {
+ o << std::fixed << std::setprecision(1);
+ }
+ else
+ {
+ // std::defaultfloat not supported in gcc version < 5
+ o.unsetf(std::ios_base::floatfield);
+ o << std::setprecision(std::numeric_limits<double>::digits10);
+ }
+ o << m_value.number_float;
+ return;
+ }
+
+ case value_t::discarded:
+ {
+ o << "<discarded>";
+ return;
+ }
+
+ case value_t::null:
+ {
+ o << "null";
+ return;
+ }
+ }
+ }
+
+ private:
+ //////////////////////
+ // member variables //
+ //////////////////////
+
+ /// the type of the current element
+ value_t m_type = value_t::null;
+
+ /// the value of the current element
+ json_value m_value = {};
+
+
+ private:
+ ///////////////
+ // iterators //
+ ///////////////
+
+ /*!
+ @brief an iterator for primitive JSON types
+
+ This class models an iterator for primitive JSON types (boolean, number,
+ string). It's only purpose is to allow the iterator/const_iterator classes
+ to "iterate" over primitive values. Internally, the iterator is modeled by
+ a `difference_type` variable. Value begin_value (`0`) models the begin,
+ end_value (`1`) models past the end.
+ */
+ class primitive_iterator_t
+ {
+ public:
+ /// set iterator to a defined beginning
+ void set_begin()
+ {
+ m_it = begin_value;
+ }
+
+ /// set iterator to a defined past the end
+ void set_end()
+ {
+ m_it = end_value;
+ }
+
+ /// return whether the iterator can be dereferenced
+ bool is_begin() const
+ {
+ return (m_it == begin_value);
+ }
+
+ /// return whether the iterator is at end
+ bool is_end() const
+ {
+ return (m_it == end_value);
+ }
+
+ /// return reference to the value to change and compare
+ operator difference_type& ()
+ {
+ return m_it;
+ }
+
+ /// return value to compare
+ operator difference_type () const
+ {
+ return m_it;
+ }
+
+ private:
+ static constexpr difference_type begin_value = 0;
+ static constexpr difference_type end_value = begin_value + 1;
+
+ /// iterator as signed integer type
+ difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
+ };
+
+ /*!
+ @brief an iterator value
+
+ @note This structure could easily be a union, but MSVC currently does not
+ allow unions members with complex constructors, see
+ https://github.com/nlohmann/json/pull/105.
+ */
+ struct internal_iterator
+ {
+ /// iterator for JSON objects
+ typename object_t::iterator object_iterator;
+ /// iterator for JSON arrays
+ typename array_t::iterator array_iterator;
+ /// generic iterator for all other types
+ primitive_iterator_t primitive_iterator;
+
+ /// create an uninitialized internal_iterator
+ internal_iterator()
+ : object_iterator(), array_iterator(), primitive_iterator()
+ {}
+ };
+
+ /// proxy class for the iterator_wrapper functions
+ template<typename IteratorType>
+ class iteration_proxy
+ {
+ private:
+ /// helper class for iteration
+ class iteration_proxy_internal
+ {
+ private:
+ /// the iterator
+ IteratorType anchor;
+ /// an index for arrays (used to create key names)
+ size_t array_index = 0;
+
+ public:
+ iteration_proxy_internal(IteratorType it)
+ : anchor(it)
+ {}
+
+ /// dereference operator (needed for range-based for)
+ iteration_proxy_internal& operator*()
+ {
+ return *this;
+ }
+
+ /// increment operator (needed for range-based for)
+ iteration_proxy_internal& operator++()
+ {
+ ++anchor;
+ ++array_index;
+
+ return *this;
+ }
+
+ /// inequality operator (needed for range-based for)
+ bool operator!= (const iteration_proxy_internal& o) const
+ {
+ return anchor != o.anchor;
+ }
+
+ /// return key of the iterator
+ typename basic_json::string_t key() const
+ {
+ assert(anchor.m_object != nullptr);
+
+ switch (anchor.m_object->type())
+ {
+ // use integer array index as key
+ case value_t::array:
+ {
+ return std::to_string(array_index);
+ }
+
+ // use key from the object
+ case value_t::object:
+ {
+ return anchor.key();
+ }
+
+ // use an empty key for all primitive types
+ default:
+ {
+ return "";
+ }
+ }
+ }
+
+ /// return value of the iterator
+ typename IteratorType::reference value() const
+ {
+ return anchor.value();
+ }
+ };
+
+ /// the container to iterate
+ typename IteratorType::reference container;
+
+ public:
+ /// construct iteration proxy from a container
+ iteration_proxy(typename IteratorType::reference cont)
+ : container(cont)
+ {}
+
+ /// return iterator begin (needed for range-based for)
+ iteration_proxy_internal begin()
+ {
+ return iteration_proxy_internal(container.begin());
+ }
+
+ /// return iterator end (needed for range-based for)
+ iteration_proxy_internal end()
+ {
+ return iteration_proxy_internal(container.end());
+ }
+ };
+
+ public:
+ /*!
+ @brief a const random access iterator for the @ref basic_json class
+
+ This class implements a const iterator for the @ref basic_json class. From
+ this class, the @ref iterator class is derived.
+
+ @requirement The class satisfies the following concept requirements:
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+ The iterator that can be moved to point (forward and backward) to any
+ element in constant time.
+
+ @since version 1.0.0
+ */
+ class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
+ {
+ /// allow basic_json to access private members
+ friend class basic_json;
+
+ public:
+ /// the type of the values when the iterator is dereferenced
+ using value_type = typename basic_json::value_type;
+ /// a type to represent differences between iterators
+ using difference_type = typename basic_json::difference_type;
+ /// defines a pointer to the type iterated over (value_type)
+ using pointer = typename basic_json::const_pointer;
+ /// defines a reference to the type iterated over (value_type)
+ using reference = typename basic_json::const_reference;
+ /// the category of the iterator
+ using iterator_category = std::bidirectional_iterator_tag;
+
+ /// default constructor
+ const_iterator() = default;
+
+ /// constructor for a given JSON instance
+ const_iterator(pointer object) : m_object(object)
+ {
+ assert(m_object != nullptr);
+
+ 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:
+ {
+ m_it.primitive_iterator = primitive_iterator_t();
+ break;
+ }
+ }
+ }
+
+ /// copy constructor given a nonconst iterator
+ const_iterator(const iterator& other) : m_object(other.m_object)
+ {
+ assert(m_object != nullptr);
+
+ 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.primitive_iterator = other.m_it.primitive_iterator;
+ break;
+ }
+ }
+ }
+
+ /// copy constructor
+ const_iterator(const const_iterator& other) noexcept
+ : m_object(other.m_object), m_it(other.m_it)
+ {}
+
+ /// copy assignment
+ 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>::value and
+ std::is_nothrow_move_assignable<internal_iterator>::value
+ )
+ {
+ std::swap(m_object, other.m_object);
+ std::swap(m_it, other.m_it);
+ return *this;
+ }
+
+ private:
+ /// set the iterator to the first value
+ void set_begin()
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object != nullptr);
+ m_it.object_iterator = m_object->m_value.object->begin();
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array != nullptr);
+ m_it.array_iterator = m_object->m_value.array->begin();
+ break;
+ }
+
+ case basic_json::value_t::null:
+ {
+ // set to end so begin()==end() is true: null is empty
+ m_it.primitive_iterator.set_end();
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator.set_begin();
+ break;
+ }
+ }
+ }
+
+ /// set the iterator past the last value
+ void set_end()
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object != nullptr);
+ m_it.object_iterator = m_object->m_value.object->end();
+ break;
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array != nullptr);
+ m_it.array_iterator = m_object->m_value.array->end();
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator.set_end();
+ break;
+ }
+ }
+ }
+
+ public:
+ /// return a reference to the value pointed to by the iterator
+ reference operator*() const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object);
+ assert(m_it.object_iterator != m_object->m_value.object->end());
+ return m_it.object_iterator->second;
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array);
+ assert(m_it.array_iterator != m_object->m_value.array->end());
+ return *m_it.array_iterator;
+ }
+
+ case basic_json::value_t::null:
+ {
+ throw std::out_of_range("cannot get value");
+ }
+
+ default:
+ {
+ if (m_it.primitive_iterator.is_begin())
+ {
+ return *m_object;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// dereference the iterator
+ pointer operator->() const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ assert(m_object->m_value.object);
+ assert(m_it.object_iterator != m_object->m_value.object->end());
+ return &(m_it.object_iterator->second);
+ }
+
+ case basic_json::value_t::array:
+ {
+ assert(m_object->m_value.array);
+ assert(m_it.array_iterator != m_object->m_value.array->end());
+ return &*m_it.array_iterator;
+ }
+
+ default:
+ {
+ if (m_it.primitive_iterator.is_begin())
+ {
+ return m_object;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// post-increment (it++)
+ const_iterator operator++(int)
+ {
+ auto result = *this;
+ ++(*this);
+ return result;
+ }
+
+ /// pre-increment (++it)
+ const_iterator& operator++()
+ {
+ assert(m_object != nullptr);
+
+ 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:
+ {
+ ++m_it.primitive_iterator;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ const_iterator operator--(int)
+ {
+ auto result = *this;
+ --(*this);
+ return result;
+ }
+
+ /// pre-decrement (--it)
+ const_iterator& operator--()
+ {
+ assert(m_object != nullptr);
+
+ 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:
+ {
+ --m_it.primitive_iterator;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// comparison: equal
+ 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");
+ }
+
+ assert(m_object != nullptr);
+
+ 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.primitive_iterator == other.m_it.primitive_iterator);
+ }
+ }
+ }
+
+ /// comparison: not equal
+ bool operator!=(const const_iterator& other) const
+ {
+ return not operator==(other);
+ }
+
+ /// comparison: smaller
+ 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");
+ }
+
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ throw std::domain_error("cannot compare order of object iterators");
+ }
+
+ case basic_json::value_t::array:
+ {
+ return (m_it.array_iterator < other.m_it.array_iterator);
+ }
+
+ default:
+ {
+ return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+ }
+ }
+ }
+
+ /// comparison: less than or equal
+ bool operator<=(const const_iterator& other) const
+ {
+ return not other.operator < (*this);
+ }
+
+ /// comparison: greater than
+ bool operator>(const const_iterator& other) const
+ {
+ return not operator<=(other);
+ }
+
+ /// comparison: greater than or equal
+ bool operator>=(const const_iterator& other) const
+ {
+ return not operator<(other);
+ }
+
+ /// add to iterator
+ const_iterator& operator+=(difference_type i)
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ throw std::domain_error("cannot use offsets with object iterators");
+ }
+
+ case basic_json::value_t::array:
+ {
+ m_it.array_iterator += i;
+ break;
+ }
+
+ default:
+ {
+ m_it.primitive_iterator += i;
+ break;
+ }
+ }
+
+ return *this;
+ }
+
+ /// subtract from iterator
+ const_iterator& operator-=(difference_type i)
+ {
+ return operator+=(-i);
+ }
+
+ /// add to iterator
+ const_iterator operator+(difference_type i)
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ const_iterator operator-(difference_type i)
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ /// return difference
+ difference_type operator-(const const_iterator& other) const
+ {
+ assert(m_object != nullptr);
+
+ switch (m_object->m_type)
+ {
+ case basic_json::value_t::object:
+ {
+ throw std::domain_error("cannot use offsets with object iterators");
+ }
+
+ case basic_json::value_t::array:
+ {
+ return m_it.array_iterator - other.m_it.array_iterator;
+ }
+
+ default:
+ {
+ return m_it.primitive_iterator - other.m_it.primitive_iterator;
+ }
+ }
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ assert(m_object != nullptr);
+
+ 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.primitive_iterator == -n)
+ {
+ return *m_object;
+ }
+ else
+ {
+ throw std::out_of_range("cannot get value");
+ }
+ }
+ }
+ }
+
+ /// return the key of an object iterator
+ typename object_t::key_type key() const
+ {
+ assert(m_object != nullptr);
+
+ if (m_object->is_object())
+ {
+ return m_it.object_iterator->first;
+ }
+ else
+ {
+ throw std::domain_error("cannot use key() for non-object iterators");
+ }
+ }
+
+ /// return the value of an iterator
+ reference value() const
+ {
+ return operator*();
+ }
+
+ private:
+ /// associated JSON instance
+ pointer m_object = nullptr;
+ /// the actual iterator of the associated instance
+ internal_iterator m_it = internal_iterator();
+ };
+
+ /*!
+ @brief a mutable random access iterator for the @ref basic_json class
+
+ @requirement The class satisfies the following concept requirements:
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+ The iterator that can be moved to point (forward and backward) to any
+ element in constant time.
+ - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
+ It is possible to write to the pointed-to element.
+
+ @since version 1.0.0
+ */
+ class iterator : public const_iterator
+ {
+ public:
+ using base_iterator = const_iterator;
+ using pointer = typename basic_json::pointer;
+ using reference = typename basic_json::reference;
+
+ /// default constructor
+ iterator() = default;
+
+ /// constructor for a given JSON instance
+ iterator(pointer object) noexcept
+ : base_iterator(object)
+ {}
+
+ /// copy constructor
+ iterator(const iterator& other) noexcept
+ : base_iterator(other)
+ {}
+
+ /// copy assignment
+ 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>::value and
+ std::is_nothrow_move_assignable<internal_iterator>::value
+ )
+ {
+ base_iterator::operator=(other);
+ return *this;
+ }
+
+ /// return a reference to the value pointed to by the iterator
+ reference operator*()
+ {
+ return const_cast<reference>(base_iterator::operator*());
+ }
+
+ /// dereference the iterator
+ pointer operator->()
+ {
+ return const_cast<pointer>(base_iterator::operator->());
+ }
+
+ /// post-increment (it++)
+ iterator operator++(int)
+ {
+ iterator result = *this;
+ base_iterator::operator++();
+ return result;
+ }
+
+ /// pre-increment (++it)
+ iterator& operator++()
+ {
+ base_iterator::operator++();
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ iterator operator--(int)
+ {
+ iterator result = *this;
+ base_iterator::operator--();
+ return result;
+ }
+
+ /// pre-decrement (--it)
+ iterator& operator--()
+ {
+ base_iterator::operator--();
+ return *this;
+ }
+
+ /// add to iterator
+ iterator& operator+=(difference_type i)
+ {
+ base_iterator::operator+=(i);
+ return *this;
+ }
+
+ /// subtract from iterator
+ iterator& operator-=(difference_type i)
+ {
+ base_iterator::operator-=(i);
+ return *this;
+ }
+
+ /// add to iterator
+ iterator operator+(difference_type i)
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ iterator operator-(difference_type i)
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ difference_type operator-(const iterator& other) const
+ {
+ return base_iterator::operator-(other);
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ return const_cast<reference>(base_iterator::operator[](n));
+ }
+
+ /// return the value of an iterator
+ reference value() const
+ {
+ return const_cast<reference>(base_iterator::value());
+ }
+ };
+
+ /*!
+ @brief a template for a reverse iterator class
+
+ @tparam Base the base iterator type to reverse. Valid types are @ref
+ iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+ create @ref const_reverse_iterator).
+
+ @requirement The class satisfies the following concept requirements:
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):
+ The iterator that can be moved to point (forward and backward) to any
+ element in constant time.
+ - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
+ It is possible to write to the pointed-to element (only if @a Base is
+ @ref iterator).
+
+ @since version 1.0.0
+ */
+ template<typename Base>
+ class json_reverse_iterator : public std::reverse_iterator<Base>
+ {
+ public:
+ /// shortcut to the reverse iterator adaptor
+ using base_iterator = std::reverse_iterator<Base>;
+ /// the reference type for the pointed-to element
+ using reference = typename Base::reference;
+
+ /// create reverse iterator from iterator
+ json_reverse_iterator(const typename base_iterator::iterator_type& it)
+ : base_iterator(it)
+ {}
+
+ /// create reverse iterator from base class
+ json_reverse_iterator(const base_iterator& it)
+ : base_iterator(it)
+ {}
+
+ /// post-increment (it++)
+ json_reverse_iterator operator++(int)
+ {
+ return base_iterator::operator++(1);
+ }
+
+ /// pre-increment (++it)
+ json_reverse_iterator& operator++()
+ {
+ base_iterator::operator++();
+ return *this;
+ }
+
+ /// post-decrement (it--)
+ json_reverse_iterator operator--(int)
+ {
+ return base_iterator::operator--(1);
+ }
+
+ /// pre-decrement (--it)
+ json_reverse_iterator& operator--()
+ {
+ base_iterator::operator--();
+ return *this;
+ }
+
+ /// add to iterator
+ json_reverse_iterator& operator+=(difference_type i)
+ {
+ base_iterator::operator+=(i);
+ return *this;
+ }
+
+ /// add to iterator
+ json_reverse_iterator operator+(difference_type i) const
+ {
+ auto result = *this;
+ result += i;
+ return result;
+ }
+
+ /// subtract from iterator
+ json_reverse_iterator operator-(difference_type i) const
+ {
+ auto result = *this;
+ result -= i;
+ return result;
+ }
+
+ /// return difference
+ difference_type operator-(const json_reverse_iterator& other) const
+ {
+ return this->base() - other.base();
+ }
+
+ /// access to successor
+ reference operator[](difference_type n) const
+ {
+ return *(this->operator+(n));
+ }
+
+ /// return the key of an object iterator
+ typename object_t::key_type key() const
+ {
+ auto it = --this->base();
+ return it.key();
+ }
+
+ /// return the value of an iterator
+ reference value() const
+ {
+ auto it = --this->base();
+ return it.operator * ();
+ }
+ };
+
+
+ private:
+ //////////////////////
+ // lexer and parser //
+ //////////////////////
+
+ /*!
+ @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.
+ */
+ class lexer
+ {
+ public:
+ /// token types for the parser
+ enum class token_type
+ {
+ 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
+ };
+
+ /// the char type to use in the lexer
+ using lexer_char_t = unsigned char;
+
+ /// constructor with a given buffer
+ explicit lexer(const string_t& s) noexcept
+ : m_stream(nullptr), m_buffer(s)
+ {
+ m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
+ assert(m_content != nullptr);
+ m_start = m_cursor = m_content;
+ m_limit = m_content + s.size();
+ }
+
+ /// constructor with a given stream
+ explicit lexer(std::istream* s) noexcept
+ : m_stream(s), m_buffer()
+ {
+ assert(m_stream != nullptr);
+ getline(*m_stream, m_buffer);
+ m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+ assert(m_content != nullptr);
+ m_start = m_cursor = m_content;
+ m_limit = m_content + m_buffer.size();
+ }
+
+ /// default constructor
+ lexer() = default;
+
+ // switch off unwanted functions
+ lexer(const lexer&) = delete;
+ lexer operator=(const lexer&) = delete;
+
+ /*!
+ @brief create a string from a Unicode code point
+
+ @param[in] codepoint1 the code point (can be high surrogate)
+ @param[in] codepoint2 the code point (can be low surrogate or 0)
+
+ @return string representation of the code point
+
+ @throw std::out_of_range if code point is >0x10ffff; example: `"code
+ points above 0x10FFFF are invalid"`
+ @throw std::invalid_argument if the low surrogate is invalid; example:
+ `""missing or wrong low surrogate""`
+
+ @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
+ */
+ static string_t to_unicode(const std::size_t codepoint1,
+ const std::size_t codepoint2 = 0)
+ {
+ string_t result;
+
+ // calculate the codepoint from the given code points
+ std::size_t codepoint = codepoint1;
+
+ // check if codepoint1 is a high surrogate
+ if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
+ {
+ // check if codepoint2 is a low surrogate
+ 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 subtract with:
+ // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+ - 0x35FDC00;
+ }
+ else
+ {
+ throw std::invalid_argument("missing or wrong low surrogate");
+ }
+ }
+
+ if (codepoint < 0x80)
+ {
+ // 1-byte characters: 0xxxxxxx (ASCII)
+ result.append(1, static_cast<typename string_t::value_type>(codepoint));
+ }
+ else if (codepoint <= 0x7ff)
+ {
+ // 2-byte characters: 110xxxxx 10xxxxxx
+ 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)));
+ }
+ else if (codepoint <= 0xffff)
+ {
+ // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+ 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)));
+ }
+ else if (codepoint <= 0x10ffff)
+ {
+ // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ 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)));
+ }
+ else
+ {
+ throw std::out_of_range("code points above 0x10FFFF are invalid");
+ }
+
+ return result;
+ }
+
+ /// return name of values of type token_type (only used for errors)
+ static std::string token_type_name(token_type t)
+ {
+ 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::parse_error:
+ return "<parse error>";
+ case token_type::end_of_input:
+ return "end of input";
+ default:
+ {
+ // catch non-enum values
+ return "unknown token"; // LCOV_EXCL_LINE
+ }
+ }
+ }
+
+ /*!
+ This function implements a scanner for JSON. It is specified using
+ regular expressions that try to follow RFC 7159 as close as possible.
+ These regular expressions are then translated into a 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.
+
+ @return the class of the next token read from the buffer
+ */
+ token_type scan() noexcept
+ {
+ // pointer for backtracking information
+ m_marker = nullptr;
+
+ // remember the begin of the token
+ m_start = m_cursor;
+ assert(m_start != nullptr);
+
+
+ {
+ lexer_char_t yych;
+ unsigned int yyaccept = 0;
+ static const unsigned char yybm[] =
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 32, 32, 0, 0, 32, 0, 0,
+ 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,
+ };
+ if ((m_limit - m_cursor) < 5)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= ':')
+ {
+ if (yych <= ' ')
+ {
+ if (yych <= '\n')
+ {
+ if (yych <= 0x00)
+ {
+ goto basic_json_parser_28;
+ }
+ if (yych <= 0x08)
+ {
+ goto basic_json_parser_30;
+ }
+ if (yych >= '\n')
+ {
+ goto basic_json_parser_4;
+ }
+ }
+ else
+ {
+ if (yych == '\r')
+ {
+ goto basic_json_parser_2;
+ }
+ if (yych <= 0x1F)
+ {
+ goto basic_json_parser_30;
+ }
+ }
+ }
+ else
+ {
+ if (yych <= ',')
+ {
+ if (yych == '"')
+ {
+ goto basic_json_parser_27;
+ }
+ if (yych <= '+')
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_16;
+ }
+ else
+ {
+ if (yych <= '/')
+ {
+ if (yych <= '-')
+ {
+ goto basic_json_parser_23;
+ }
+ goto basic_json_parser_30;
+ }
+ else
+ {
+ if (yych <= '0')
+ {
+ goto basic_json_parser_24;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_26;
+ }
+ goto basic_json_parser_18;
+ }
+ }
+ }
+ }
+ else
+ {
+ if (yych <= 'n')
+ {
+ if (yych <= ']')
+ {
+ if (yych == '[')
+ {
+ goto basic_json_parser_8;
+ }
+ if (yych <= '\\')
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_10;
+ }
+ else
+ {
+ if (yych == 'f')
+ {
+ goto basic_json_parser_22;
+ }
+ if (yych <= 'm')
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_20;
+ }
+ }
+ else
+ {
+ if (yych <= '{')
+ {
+ if (yych == 't')
+ {
+ goto basic_json_parser_21;
+ }
+ if (yych <= 'z')
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_12;
+ }
+ else
+ {
+ if (yych <= '}')
+ {
+ if (yych <= '|')
+ {
+ goto basic_json_parser_30;
+ }
+ goto basic_json_parser_14;
+ }
+ else
+ {
+ if (yych == 0xEF)
+ {
+ goto basic_json_parser_6;
+ }
+ goto basic_json_parser_30;
+ }
+ }
+ }
+ }
+basic_json_parser_2:
+ ++m_cursor;
+ yych = *m_cursor;
+ goto basic_json_parser_5;
+basic_json_parser_3:
+ {
+ return scan();
+ }
+basic_json_parser_4:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+basic_json_parser_5:
+ if (yybm[0 + yych] & 32)
+ {
+ goto basic_json_parser_4;
+ }
+ goto basic_json_parser_3;
+basic_json_parser_6:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 0xBB)
+ {
+ goto basic_json_parser_64;
+ }
+basic_json_parser_7:
+ {
+ return token_type::parse_error;
+ }
+basic_json_parser_8:
+ ++m_cursor;
+ {
+ return token_type::begin_array;
+ }
+basic_json_parser_10:
+ ++m_cursor;
+ {
+ return token_type::end_array;
+ }
+basic_json_parser_12:
+ ++m_cursor;
+ {
+ return token_type::begin_object;
+ }
+basic_json_parser_14:
+ ++m_cursor;
+ {
+ return token_type::end_object;
+ }
+basic_json_parser_16:
+ ++m_cursor;
+ {
+ return token_type::value_separator;
+ }
+basic_json_parser_18:
+ ++m_cursor;
+ {
+ return token_type::name_separator;
+ }
+basic_json_parser_20:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'u')
+ {
+ goto basic_json_parser_60;
+ }
+ goto basic_json_parser_7;
+basic_json_parser_21:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'r')
+ {
+ goto basic_json_parser_56;
+ }
+ goto basic_json_parser_7;
+basic_json_parser_22:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych == 'a')
+ {
+ goto basic_json_parser_51;
+ }
+ goto basic_json_parser_7;
+basic_json_parser_23:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_7;
+ }
+ if (yych <= '0')
+ {
+ goto basic_json_parser_50;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_41;
+ }
+ goto basic_json_parser_7;
+basic_json_parser_24:
+ yyaccept = 1;
+ yych = *(m_marker = ++m_cursor);
+ if (yych <= 'D')
+ {
+ if (yych == '.')
+ {
+ goto basic_json_parser_43;
+ }
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_44;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_44;
+ }
+ }
+basic_json_parser_25:
+ {
+ return token_type::value_number;
+ }
+basic_json_parser_26:
+ yyaccept = 1;
+ yych = *(m_marker = ++m_cursor);
+ goto basic_json_parser_42;
+basic_json_parser_27:
+ yyaccept = 0;
+ yych = *(m_marker = ++m_cursor);
+ if (yych <= 0x0F)
+ {
+ goto basic_json_parser_7;
+ }
+ goto basic_json_parser_32;
+basic_json_parser_28:
+ ++m_cursor;
+ {
+ return token_type::end_of_input;
+ }
+basic_json_parser_30:
+ yych = *++m_cursor;
+ goto basic_json_parser_7;
+basic_json_parser_31:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+basic_json_parser_32:
+ if (yybm[0 + yych] & 64)
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= 0x0F)
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '"')
+ {
+ goto basic_json_parser_35;
+ }
+ goto basic_json_parser_34;
+basic_json_parser_33:
+ m_cursor = m_marker;
+ if (yyaccept == 0)
+ {
+ goto basic_json_parser_7;
+ }
+ else
+ {
+ goto basic_json_parser_25;
+ }
+basic_json_parser_34:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= 'e')
+ {
+ if (yych <= '/')
+ {
+ if (yych == '"')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= '.')
+ {
+ goto basic_json_parser_33;
+ }
+ goto basic_json_parser_31;
+ }
+ else
+ {
+ if (yych <= '\\')
+ {
+ if (yych <= '[')
+ {
+ goto basic_json_parser_33;
+ }
+ goto basic_json_parser_31;
+ }
+ else
+ {
+ if (yych == 'b')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ }
+ }
+ else
+ {
+ if (yych <= 'q')
+ {
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych == 'n')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 's')
+ {
+ if (yych <= 'r')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 't')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= 'u')
+ {
+ goto basic_json_parser_37;
+ }
+ goto basic_json_parser_33;
+ }
+ }
+ }
+basic_json_parser_35:
+ ++m_cursor;
+ {
+ return token_type::value_string;
+ }
+basic_json_parser_37:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= ':')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_38;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= 'g')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+basic_json_parser_38:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= ':')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_39;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= 'g')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+basic_json_parser_39:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= ':')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_40;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= 'g')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+basic_json_parser_40:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '@')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+ else
+ {
+ if (yych <= 'F')
+ {
+ goto basic_json_parser_31;
+ }
+ if (yych <= '`')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= 'f')
+ {
+ goto basic_json_parser_31;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_41:
+ yyaccept = 1;
+ m_marker = ++m_cursor;
+ if ((m_limit - m_cursor) < 3)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+basic_json_parser_42:
+ if (yybm[0 + yych] & 128)
+ {
+ goto basic_json_parser_41;
+ }
+ if (yych <= 'D')
+ {
+ if (yych != '.')
+ {
+ goto basic_json_parser_25;
+ }
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_44;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_44;
+ }
+ goto basic_json_parser_25;
+ }
+basic_json_parser_43:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_48;
+ }
+ goto basic_json_parser_33;
+basic_json_parser_44:
+ yych = *++m_cursor;
+ if (yych <= ',')
+ {
+ if (yych != '+')
+ {
+ goto basic_json_parser_33;
+ }
+ }
+ else
+ {
+ if (yych <= '-')
+ {
+ goto basic_json_parser_45;
+ }
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_46;
+ }
+ goto basic_json_parser_33;
+ }
+basic_json_parser_45:
+ yych = *++m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_33;
+ }
+ if (yych >= ':')
+ {
+ goto basic_json_parser_33;
+ }
+basic_json_parser_46:
+ ++m_cursor;
+ if (m_limit <= m_cursor)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= '/')
+ {
+ goto basic_json_parser_25;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_46;
+ }
+ goto basic_json_parser_25;
+basic_json_parser_48:
+ yyaccept = 1;
+ m_marker = ++m_cursor;
+ if ((m_limit - m_cursor) < 3)
+ {
+ yyfill(); // LCOV_EXCL_LINE;
+ }
+ yych = *m_cursor;
+ if (yych <= 'D')
+ {
+ if (yych <= '/')
+ {
+ goto basic_json_parser_25;
+ }
+ if (yych <= '9')
+ {
+ goto basic_json_parser_48;
+ }
+ goto basic_json_parser_25;
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_44;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_44;
+ }
+ goto basic_json_parser_25;
+ }
+basic_json_parser_50:
+ yyaccept = 1;
+ yych = *(m_marker = ++m_cursor);
+ if (yych <= 'D')
+ {
+ if (yych == '.')
+ {
+ goto basic_json_parser_43;
+ }
+ goto basic_json_parser_25;
+ }
+ else
+ {
+ if (yych <= 'E')
+ {
+ goto basic_json_parser_44;
+ }
+ if (yych == 'e')
+ {
+ goto basic_json_parser_44;
+ }
+ goto basic_json_parser_25;
+ }
+basic_json_parser_51:
+ yych = *++m_cursor;
+ if (yych != 'l')
+ {
+ goto basic_json_parser_33;
+ }
+ yych = *++m_cursor;
+ if (yych != 's')
+ {
+ goto basic_json_parser_33;
+ }
+ yych = *++m_cursor;
+ if (yych != 'e')
+ {
+ goto basic_json_parser_33;
+ }
+ ++m_cursor;
+ {
+ return token_type::literal_false;
+ }
+basic_json_parser_56:
+ yych = *++m_cursor;
+ if (yych != 'u')
+ {
+ goto basic_json_parser_33;
+ }
+ yych = *++m_cursor;
+ if (yych != 'e')
+ {
+ goto basic_json_parser_33;
+ }
+ ++m_cursor;
+ {
+ return token_type::literal_true;
+ }
+basic_json_parser_60:
+ yych = *++m_cursor;
+ if (yych != 'l')
+ {
+ goto basic_json_parser_33;
+ }
+ yych = *++m_cursor;
+ if (yych != 'l')
+ {
+ goto basic_json_parser_33;
+ }
+ ++m_cursor;
+ {
+ return token_type::literal_null;
+ }
+basic_json_parser_64:
+ yych = *++m_cursor;
+ if (yych != 0xBF)
+ {
+ goto basic_json_parser_33;
+ }
+ ++m_cursor;
+ {
+ return scan();
+ }
+ }
+
+
+ }
+
+ /// append data from the stream to the internal buffer
+ void yyfill() noexcept
+ {
+ if (m_stream == nullptr 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;
+ assert(m_stream != nullptr);
+ std::getline(*m_stream, line);
+ m_buffer += "\n" + line; // add line with newline symbol
+
+ m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
+ assert(m_content != nullptr);
+ m_start = m_content;
+ m_marker = m_start + offset_marker;
+ m_cursor = m_start + offset_cursor;
+ m_limit = m_start + m_buffer.size() - 1;
+ }
+
+ /// return string representation of last read token
+ string_t get_token() const noexcept
+ {
+ assert(m_start != nullptr);
+ return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
+ static_cast<size_t>(m_cursor - m_start));
+ }
+
+ /*!
+ @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.
+
+ @return string value of current token without opening and closing quotes
+ @throw std::out_of_range if to_unicode fails
+ */
+ string_t get_string() const
+ {
+ string_t result;
+ result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
+
+ // iterate the result between the quotes
+ for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
+ {
+ // 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;
+ }
+ case '\\':
+ {
+ result += "\\";
+ break;
+ }
+ case '/':
+ {
+ result += "/";
+ break;
+ }
+ case '"':
+ {
+ result += "\"";
+ break;
+ }
+
+ // unicode
+ case 'u':
+ {
+ // get code xxxx from uxxxx
+ auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
+ 4).c_str(), nullptr, 16);
+
+ // check if codepoint is a high surrogate
+ if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+ {
+ // make sure there is a subsequent unicode
+ if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
+ {
+ throw std::invalid_argument("missing low surrogate");
+ }
+
+ // get code yyyy from uxxxx\uyyyy
+ auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
+ (i + 7), 4).c_str(), nullptr, 16);
+ result += to_unicode(codepoint, codepoint2);
+ // skip the next 10 characters (xxxx\uyyyy)
+ i += 10;
+ }
+ else
+ {
+ // add unicode character(s)
+ result += to_unicode(codepoint);
+ // skip the next four characters (xxxx)
+ i += 4;
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ // all other characters are just copied to the end of the
+ // string
+ result.append(1, static_cast<typename string_t::value_type>(*i));
+ }
+ }
+
+ return result;
+ }
+
+ /*!
+ @brief parse floating point number
+
+ This function (and its overloads) serves to select the most approprate
+ standard floating point number parsing function (i.e., `std::strtof`,
+ `std::strtod`, or `std::strtold`) based on the type supplied via the
+ first parameter. Set this to @a static_cast<number_float_t>(nullptr).
+
+ @param[in] type the @ref number_float_t in use
+
+ @param[in,out] endptr recieves a pointer to the first character after
+ the number
+
+ @return the floating point number
+
+ @bug This function uses `std::strtof`, `std::strtod`, or `std::strtold`
+ which use the current C locale to determine which character is used as
+ decimal point character. This may yield to parse errors if the locale
+ does not used `.`.
+ */
+ long double str_to_float_t(long double* /* type */, char** endptr) const
+ {
+ return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /// @copydoc str_to_float_t
+ double str_to_float_t(double*, char** endptr) const
+ {
+ return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /// @copydoc str_to_float_t
+ float str_to_float_t(float*, char** endptr) const
+ {
+ return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+ }
+
+ /*!
+ @brief return number value for number tokens
+
+ This function translates the last token into a floating point number.
+ The pointer m_start 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.
+
+ @throw std::range_error if passed value is out of range
+ */
+ number_float_t get_number() const
+ {
+ // conversion
+ typename string_t::value_type* endptr;
+ assert(m_start != nullptr);
+ number_float_t float_val = str_to_float_t(static_cast<number_float_t*>(nullptr), &endptr);
+
+ // return float_val if the whole number was translated and NAN
+ // otherwise
+ return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
+ }
+
+ private:
+ /// optional input stream
+ std::istream* m_stream = nullptr;
+ /// the buffer
+ string_t m_buffer;
+ /// the buffer pointer
+ const lexer_char_t* m_content = nullptr;
+ /// pointer to the beginning of the current symbol
+ const lexer_char_t* m_start = nullptr;
+ /// pointer for backtracking information
+ const lexer_char_t* m_marker = nullptr;
+ /// pointer to the current symbol
+ const lexer_char_t* m_cursor = nullptr;
+ /// pointer to the end of the buffer
+ const lexer_char_t* m_limit = nullptr;
+ };
+
+ /*!
+ @brief syntax analysis
+
+ This class implements a recursive decent parser.
+ */
+ class parser
+ {
+ public:
+ /// constructor for strings
+ parser(const string_t& s, parser_callback_t cb = nullptr)
+ : callback(cb), m_lexer(s)
+ {
+ // read first token
+ get_token();
+ }
+
+ /// a parser reading from an input stream
+ parser(std::istream& _is, parser_callback_t cb = nullptr)
+ : callback(cb), m_lexer(&_is)
+ {
+ // read first token
+ get_token();
+ }
+
+ /// public parser interface
+ basic_json parse()
+ {
+ basic_json result = parse_internal(true);
+
+ expect(lexer::token_type::end_of_input);
+
+ // return parser result and replace it with null in case the
+ // top-level value was discarded by the callback function
+ return result.is_discarded() ? basic_json() : result;
+ }
+
+ private:
+ /// the actual parser
+ basic_json parse_internal(bool keep)
+ {
+ auto result = basic_json(value_t::discarded);
+
+ switch (last_token)
+ {
+ case lexer::token_type::begin_object:
+ {
+ if (keep and (not callback or (keep = callback(depth++, parse_event_t::object_start, result))))
+ {
+ // explicitly set result to object to cope with {}
+ result.m_type = value_t::object;
+ result.m_value = json_value(value_t::object);
+ }
+
+ // read next token
+ get_token();
+
+ // closing } -> we are done
+ if (last_token == lexer::token_type::end_object)
+ {
+ get_token();
+ if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+ {
+ result = basic_json(value_t::discarded);
+ }
+ return result;
+ }
+
+ // no comma is expected here
+ unexpect(lexer::token_type::value_separator);
+
+ // otherwise: parse key-value pairs
+ do
+ {
+ // ugly, but could be fixed with loop reorganization
+ if (last_token == lexer::token_type::value_separator)
+ {
+ get_token();
+ }
+
+ // store key
+ expect(lexer::token_type::value_string);
+ const auto key = m_lexer.get_string();
+
+ bool keep_tag = false;
+ if (keep)
+ {
+ if (callback)
+ {
+ basic_json k(key);
+ keep_tag = callback(depth, parse_event_t::key, k);
+ }
+ else
+ {
+ keep_tag = true;
+ }
+ }
+
+ // parse separator (:)
+ get_token();
+ expect(lexer::token_type::name_separator);
+
+ // parse and add value
+ get_token();
+ auto value = parse_internal(keep);
+ if (keep and keep_tag and not value.is_discarded())
+ {
+ result[key] = std::move(value);
+ }
+ }
+ while (last_token == lexer::token_type::value_separator);
+
+ // closing }
+ expect(lexer::token_type::end_object);
+ get_token();
+ if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+ {
+ result = basic_json(value_t::discarded);
+ }
+
+ return result;
+ }
+
+ case lexer::token_type::begin_array:
+ {
+ if (keep and (not callback or (keep = callback(depth++, parse_event_t::array_start, result))))
+ {
+ // explicitly set result to object to cope with []
+ result.m_type = value_t::array;
+ result.m_value = json_value(value_t::array);
+ }
+
+ // read next token
+ get_token();
+
+ // closing ] -> we are done
+ if (last_token == lexer::token_type::end_array)
+ {
+ get_token();
+ if (callback and not callback(--depth, parse_event_t::array_end, result))
+ {
+ result = basic_json(value_t::discarded);
+ }
+ return result;
+ }
+
+ // no comma is expected here
+ unexpect(lexer::token_type::value_separator);
+
+ // otherwise: parse values
+ do
+ {
+ // ugly, but could be fixed with loop reorganization
+ if (last_token == lexer::token_type::value_separator)
+ {
+ get_token();
+ }
+
+ // parse value
+ auto value = parse_internal(keep);
+ if (keep and not value.is_discarded())
+ {
+ result.push_back(std::move(value));
+ }
+ }
+ while (last_token == lexer::token_type::value_separator);
+
+ // closing ]
+ expect(lexer::token_type::end_array);
+ get_token();
+ if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+ {
+ result = basic_json(value_t::discarded);
+ }
+
+ return result;
+ }
+
+ case lexer::token_type::literal_null:
+ {
+ get_token();
+ result.m_type = value_t::null;
+ break;
+ }
+
+ case lexer::token_type::value_string:
+ {
+ const auto s = m_lexer.get_string();
+ get_token();
+ result = basic_json(s);
+ break;
+ }
+
+ case lexer::token_type::literal_true:
+ {
+ get_token();
+ result.m_type = value_t::boolean;
+ result.m_value = true;
+ break;
+ }
+
+ case lexer::token_type::literal_false:
+ {
+ get_token();
+ result.m_type = value_t::boolean;
+ result.m_value = false;
+ break;
+ }
+
+ case lexer::token_type::value_number:
+ {
+ result.m_value = m_lexer.get_number();
+
+ // NAN is returned if token could not be translated
+ // completely
+ if (std::isnan(result.m_value.number_float))
+ {
+ throw std::invalid_argument(std::string("parse error - ") +
+ m_lexer.get_token() + " is not a number");
+ }
+
+ get_token();
+
+ // check if conversion loses precision (special case -0.0 always loses precision)
+ const auto int_val = static_cast<number_integer_t>(result.m_value.number_float);
+ if (result.m_value.number_float == static_cast<number_float_t>(int_val) and
+ result.m_value.number_integer != json_value(-0.0f).number_integer)
+ {
+ // we would not lose precision -> return int
+ result.m_type = value_t::number_integer;
+ result.m_value = int_val;
+ }
+ else
+ {
+ // we would lose precision -> return float
+ result.m_type = value_t::number_float;
+ }
+ break;
+ }
+
+ default:
+ {
+ // the last token was unexpected
+ unexpect(last_token);
+ }
+ }
+
+ if (keep and callback and not callback(depth, parse_event_t::value, result))
+ {
+ result = basic_json(value_t::discarded);
+ }
+ return result;
+ }
+
+ /// get next token from lexer
+ typename lexer::token_type get_token()
+ {
+ last_token = m_lexer.scan();
+ return last_token;
+ }
+
+ void expect(typename lexer::token_type t) const
+ {
+ if (t != last_token)
+ {
+ std::string error_msg = "parse error - unexpected ";
+ error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token() + "'") :
+ lexer::token_type_name(last_token));
+ error_msg += "; expected " + lexer::token_type_name(t);
+ throw std::invalid_argument(error_msg);
+ }
+ }
+
+ void unexpect(typename lexer::token_type t) const
+ {
+ if (t == last_token)
+ {
+ std::string error_msg = "parse error - unexpected ";
+ error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token() + "'") :
+ lexer::token_type_name(last_token));
+ throw std::invalid_argument(error_msg);
+ }
+ }
+
+ private:
+ /// current level of recursion
+ int depth = 0;
+ /// callback function
+ parser_callback_t callback;
+ /// the type of the last read token
+ typename lexer::token_type last_token = lexer::token_type::uninitialized;
+ /// the lexer
+ lexer m_lexer;
+ };
+};
+
+
+/////////////
+// presets //
+/////////////
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which uses
+the standard template types.
+
+@since version 1.0.0
+*/
+using json = basic_json<>;
+}
+
+
+/////////////////////////
+// nonmember functions //
+/////////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+/*!
+@brief exchanges the values of two JSON objects
+
+@since version 1.0.0
+*/
+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>
+{
+ /*!
+ @brief return a hash value for a JSON object
+
+ @since version 1.0.0
+ */
+ std::size_t operator()(const nlohmann::json& j) const
+ {
+ // a naive hashing via the string representation
+ const auto& h = hash<nlohmann::json::string_t>();
+ return h(j.dump());
+ }
+};
+}
+
+/*!
+@brief user-defined string literal for JSON values
+
+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[in] s a string representation of a JSON object
+@return a JSON object
+
+@since version 1.0.0
+*/
+inline nlohmann::json operator "" _json(const char* s, std::size_t)
+{
+ return nlohmann::json::parse(reinterpret_cast<const nlohmann::json::string_t::value_type*>(s));
+}
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #pragma GCC diagnostic pop
+#endif
+
+#endif
diff --git a/src/json/jsoncpp.cpp b/src/json/jsoncpp.cpp
deleted file mode 100644
index 58f535dff68fa033f569e83a56c904e0cc8f6214..0000000000000000000000000000000000000000
--- a/src/json/jsoncpp.cpp
+++ /dev/null
@@ -1,5207 +0,0 @@
-/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/).
-/// It is intended to be used with #include "json/json.h"
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-/*
-The JsonCpp library's source code, including accompanying documentation,
-tests and demonstration applications, are licensed under the following
-conditions...
-
-The author (Baptiste Lepilleur) explicitly disclaims copyright in all
-jurisdictions which recognize such a disclaimer. In such jurisdictions,
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
-released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this
-software may choose to accept it either as 1) Public Domain, 2) under the
-conditions of the MIT License (see below), or 3) under the terms of dual
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
- http://en.wikipedia.org/wiki/MIT_License
-
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.
-
-*/
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: LICENSE
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-#include "json.h"
-
-#ifndef JSON_IS_AMALGAMATION
-#error "Compile with -I PATH_TO_JSON_DIRECTORY"
-#endif
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_tool.h
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-
-/* This header provides common string manipulation support, such as UTF-8,
- * portable conversion from/to string...
- *
- * It is an internal header that must not be exposed.
- */
-
-namespace Json {
-
-/// Converts a unicode code-point to UTF-8.
-static inline std::string codePointToUTF8(unsigned int cp) {
- std::string result;
-
- // based on description from http://en.wikipedia.org/wiki/UTF-8
-
- if (cp <= 0x7f) {
- result.resize(1);
- result[0] = static_cast<char>(cp);
- } else if (cp <= 0x7FF) {
- result.resize(2);
- result[1] = static_cast<char>(0x80 | (0x3f & cp));
- result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
- } else if (cp <= 0xFFFF) {
- result.resize(3);
- result[2] = static_cast<char>(0x80 | (0x3f & cp));
- result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
- result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
- } else if (cp <= 0x10FFFF) {
- result.resize(4);
- result[3] = static_cast<char>(0x80 | (0x3f & cp));
- result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
- result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
- result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
- }
-
- return result;
-}
-
-/// Returns true if ch is a control character (in range [1,31]).
-static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
-
-enum {
- /// Constant that specify the size of the buffer that must be passed to
- /// uintToString.
- uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
-};
-
-// Defines a char buffer for use with uintToString().
-typedef char UIntToStringBuffer[uintToStringBufferSize];
-
-/** Converts an unsigned integer to string.
- * @param value Unsigned interger to convert to string
- * @param current Input/Output string buffer.
- * Must have at least uintToStringBufferSize chars free.
- */
-static inline void uintToString(LargestUInt value, char*& current) {
- *--current = 0;
- do {
- *--current = static_cast<signed char>(value % 10U + static_cast<unsigned>('0'));
- value /= 10;
- } while (value != 0);
-}
-
-/** Change ',' to '.' everywhere in buffer.
- *
- * We had a sophisticated way, but it did not work in WinCE.
- * @see https://github.com/open-source-parsers/jsoncpp/pull/9
- */
-static inline void fixNumericLocale(char* begin, char* end) {
- while (begin < end) {
- if (*begin == ',') {
- *begin = '.';
- }
- ++begin;
- }
-}
-
-} // namespace Json {
-
-#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_tool.h
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_reader.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2011 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include <json/assertions.h>
-#include <json/reader.h>
-#include <json/value.h>
-#include "json_tool.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <utility>
-#include <cstdio>
-#include <cassert>
-#include <cstring>
-#include <istream>
-#include <sstream>
-#include <memory>
-#include <set>
-#include <limits>
-
-#if defined(_MSC_VER)
-#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above
-#define snprintf sprintf_s
-#elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#define snprintf std::snprintf
-#else
-#define snprintf _snprintf
-#endif
-#elif defined(__ANDROID__) || defined(__QNXNTO__)
-#define snprintf snprintf
-#elif __cplusplus >= 201103L
-#if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define snprintf std::snprintf
-#endif
-#endif
-
-#if defined(__QNXNTO__)
-#define sscanf std::sscanf
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
-// Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
-#endif
-
-static int const stackLimit_g = 1000;
-static int stackDepth_g = 0; // see readValue()
-
-namespace Json {
-
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
-typedef std::unique_ptr<CharReader> CharReaderPtr;
-#else
-typedef std::auto_ptr<CharReader> CharReaderPtr;
-#endif
-
-// Implementation of class Features
-// ////////////////////////////////
-
-Features::Features()
- : allowComments_(true), strictRoot_(false),
- allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
-
-Features Features::all() { return Features(); }
-
-Features Features::strictMode() {
- Features features;
- features.allowComments_ = false;
- features.strictRoot_ = true;
- features.allowDroppedNullPlaceholders_ = false;
- features.allowNumericKeys_ = false;
- return features;
-}
-
-// Implementation of class Reader
-// ////////////////////////////////
-
-static bool containsNewLine(Reader::Location begin, Reader::Location end) {
- for (; begin < end; ++begin)
- if (*begin == '\n' || *begin == '\r')
- return true;
- return false;
-}
-
-// Class Reader
-// //////////////////////////////////////////////////////////////////
-
-Reader::Reader()
- : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
- lastValue_(), commentsBefore_(), features_(Features::all()),
- collectComments_() {}
-
-Reader::Reader(const Features& features)
- : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
- lastValue_(), commentsBefore_(), features_(features), collectComments_() {
-}
-
-bool
-Reader::parse(const std::string& document, Value& root, bool collectComments) {
- document_ = document;
- const char* begin = document_.c_str();
- const char* end = begin + document_.length();
- return parse(begin, end, root, collectComments);
-}
-
-bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
- // std::istream_iterator<char> begin(sin);
- // std::istream_iterator<char> end;
- // Those would allow streamed input from a file, if parse() were a
- // template function.
-
- // Since std::string is reference-counted, this at least does not
- // create an extra copy.
- std::string doc;
- std::getline(sin, doc, (char)EOF);
- return parse(doc, root, collectComments);
-}
-
-bool Reader::parse(const char* beginDoc,
- const char* endDoc,
- Value& root,
- bool collectComments) {
- if (!features_.allowComments_) {
- collectComments = false;
- }
-
- begin_ = beginDoc;
- end_ = endDoc;
- collectComments_ = collectComments;
- current_ = begin_;
- lastValueEnd_ = 0;
- lastValue_ = 0;
- commentsBefore_ = "";
- errors_.clear();
- while (!nodes_.empty())
- nodes_.pop();
- nodes_.push(&root);
-
- stackDepth_g = 0; // Yes, this is bad coding, but options are limited.
- bool successful = readValue();
- Token token;
- skipCommentTokens(token);
- if (collectComments_ && !commentsBefore_.empty())
- root.setComment(commentsBefore_, commentAfter);
- if (features_.strictRoot_) {
- if (!root.isArray() && !root.isObject()) {
- // Set error location to start of doc, ideally should be first token found
- // in doc
- token.type_ = tokenError;
- token.start_ = beginDoc;
- token.end_ = endDoc;
- addError(
- "A valid JSON document must be either an array or an object value.",
- token);
- return false;
- }
- }
- return successful;
-}
-
-bool Reader::readValue() {
- // This is a non-reentrant way to support a stackLimit. Terrible!
- // But this deprecated class has a security problem: Bad input can
- // cause a seg-fault. This seems like a fair, binary-compatible way
- // to prevent the problem.
- if (stackDepth_g >= stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue().");
- ++stackDepth_g;
-
- Token token;
- skipCommentTokens(token);
- bool successful = true;
-
- if (collectComments_ && !commentsBefore_.empty()) {
- currentValue().setComment(commentsBefore_, commentBefore);
- commentsBefore_ = "";
- }
-
- switch (token.type_) {
- case tokenObjectBegin:
- successful = readObject(token);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- case tokenArrayBegin:
- successful = readArray(token);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- case tokenNumber:
- successful = decodeNumber(token);
- break;
- case tokenString:
- successful = decodeString(token);
- break;
- case tokenTrue:
- {
- Value v(true);
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenFalse:
- {
- Value v(false);
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenNull:
- {
- Value v;
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenArraySeparator:
- case tokenObjectEnd:
- case tokenArrayEnd:
- if (features_.allowDroppedNullPlaceholders_) {
- // "Un-read" the current token and mark the current value as a null
- // token.
- current_--;
- Value v;
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(current_ - begin_ - 1);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- } // Else, fall through...
- default:
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return addError("Syntax error: value, object or array expected.", token);
- }
-
- if (collectComments_) {
- lastValueEnd_ = current_;
- lastValue_ = ¤tValue();
- }
-
- --stackDepth_g;
- return successful;
-}
-
-void Reader::skipCommentTokens(Token& token) {
- if (features_.allowComments_) {
- do {
- readToken(token);
- } while (token.type_ == tokenComment);
- } else {
- readToken(token);
- }
-}
-
-bool Reader::readToken(Token& token) {
- skipSpaces();
- token.start_ = current_;
- Char c = getNextChar();
- bool ok = true;
- switch (c) {
- case '{':
- token.type_ = tokenObjectBegin;
- break;
- case '}':
- token.type_ = tokenObjectEnd;
- break;
- case '[':
- token.type_ = tokenArrayBegin;
- break;
- case ']':
- token.type_ = tokenArrayEnd;
- break;
- case '"':
- token.type_ = tokenString;
- ok = readString();
- break;
- case '/':
- token.type_ = tokenComment;
- ok = readComment();
- break;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- case '-':
- token.type_ = tokenNumber;
- readNumber();
- break;
- case 't':
- token.type_ = tokenTrue;
- ok = match("rue", 3);
- break;
- case 'f':
- token.type_ = tokenFalse;
- ok = match("alse", 4);
- break;
- case 'n':
- token.type_ = tokenNull;
- ok = match("ull", 3);
- break;
- case ',':
- token.type_ = tokenArraySeparator;
- break;
- case ':':
- token.type_ = tokenMemberSeparator;
- break;
- case 0:
- token.type_ = tokenEndOfStream;
- break;
- default:
- ok = false;
- break;
- }
- if (!ok)
- token.type_ = tokenError;
- token.end_ = current_;
- return true;
-}
-
-void Reader::skipSpaces() {
- while (current_ != end_) {
- Char c = *current_;
- if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
- ++current_;
- else
- break;
- }
-}
-
-bool Reader::match(Location pattern, int patternLength) {
- if (end_ - current_ < patternLength)
- return false;
- int index = patternLength;
- while (index--)
- if (current_[index] != pattern[index])
- return false;
- current_ += patternLength;
- return true;
-}
-
-bool Reader::readComment() {
- Location commentBegin = current_ - 1;
- Char c = getNextChar();
- bool successful = false;
- if (c == '*')
- successful = readCStyleComment();
- else if (c == '/')
- successful = readCppStyleComment();
- if (!successful)
- return false;
-
- if (collectComments_) {
- CommentPlacement placement = commentBefore;
- if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
- if (c != '*' || !containsNewLine(commentBegin, current_))
- placement = commentAfterOnSameLine;
- }
-
- addComment(commentBegin, current_, placement);
- }
- return true;
-}
-
-static std::string normalizeEOL(Reader::Location begin, Reader::Location end) {
- std::string normalized;
- normalized.reserve(static_cast<size_t>(end - begin));
- Reader::Location current = begin;
- while (current != end) {
- char c = *current++;
- if (c == '\r') {
- if (current != end && *current == '\n')
- // convert dos EOL
- ++current;
- // convert Mac EOL
- normalized += '\n';
- } else {
- normalized += c;
- }
- }
- return normalized;
-}
-
-void
-Reader::addComment(Location begin, Location end, CommentPlacement placement) {
- assert(collectComments_);
- const std::string& normalized = normalizeEOL(begin, end);
- if (placement == commentAfterOnSameLine) {
- assert(lastValue_ != 0);
- lastValue_->setComment(normalized, placement);
- } else {
- commentsBefore_ += normalized;
- }
-}
-
-bool Reader::readCStyleComment() {
- while (current_ != end_) {
- Char c = getNextChar();
- if (c == '*' && *current_ == '/')
- break;
- }
- return getNextChar() == '/';
-}
-
-bool Reader::readCppStyleComment() {
- while (current_ != end_) {
- Char c = getNextChar();
- if (c == '\n')
- break;
- if (c == '\r') {
- // Consume DOS EOL. It will be normalized in addComment.
- if (current_ != end_ && *current_ == '\n')
- getNextChar();
- // Break on Moc OS 9 EOL.
- break;
- }
- }
- return true;
-}
-
-void Reader::readNumber() {
- const char *p = current_;
- char c = '0'; // stopgap for already consumed character
- // integral part
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- // fractional part
- if (c == '.') {
- c = (current_ = p) < end_ ? *p++ : 0;
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- }
- // exponential part
- if (c == 'e' || c == 'E') {
- c = (current_ = p) < end_ ? *p++ : 0;
- if (c == '+' || c == '-')
- c = (current_ = p) < end_ ? *p++ : 0;
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- }
-}
-
-bool Reader::readString() {
- Char c = 0;
- while (current_ != end_) {
- c = getNextChar();
- if (c == '\\')
- getNextChar();
- else if (c == '"')
- break;
- }
- return c == '"';
-}
-
-bool Reader::readObject(Token& tokenStart) {
- Token tokenName;
- std::string name;
- Value init(objectValue);
- currentValue().swapPayload(init);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
- while (readToken(tokenName)) {
- bool initialTokenOk = true;
- while (tokenName.type_ == tokenComment && initialTokenOk)
- initialTokenOk = readToken(tokenName);
- if (!initialTokenOk)
- break;
- if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
- return true;
- name = "";
- if (tokenName.type_ == tokenString) {
- if (!decodeString(tokenName, name))
- return recoverFromError(tokenObjectEnd);
- } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
- Value numberName;
- if (!decodeNumber(tokenName, numberName))
- return recoverFromError(tokenObjectEnd);
- name = numberName.asString();
- } else {
- break;
- }
-
- Token colon;
- if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
- return addErrorAndRecover(
- "Missing ':' after object member name", colon, tokenObjectEnd);
- }
- Value& value = currentValue()[name];
- nodes_.push(&value);
- bool ok = readValue();
- nodes_.pop();
- if (!ok) // error already set
- return recoverFromError(tokenObjectEnd);
-
- Token comma;
- if (!readToken(comma) ||
- (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
- comma.type_ != tokenComment)) {
- return addErrorAndRecover(
- "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
- }
- bool finalizeTokenOk = true;
- while (comma.type_ == tokenComment && finalizeTokenOk)
- finalizeTokenOk = readToken(comma);
- if (comma.type_ == tokenObjectEnd)
- return true;
- }
- return addErrorAndRecover(
- "Missing '}' or object member name", tokenName, tokenObjectEnd);
-}
-
-bool Reader::readArray(Token& tokenStart) {
- Value init(arrayValue);
- currentValue().swapPayload(init);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
- skipSpaces();
- if (*current_ == ']') // empty array
- {
- Token endArray;
- readToken(endArray);
- return true;
- }
- int index = 0;
- for (;;) {
- Value& value = currentValue()[index++];
- nodes_.push(&value);
- bool ok = readValue();
- nodes_.pop();
- if (!ok) // error already set
- return recoverFromError(tokenArrayEnd);
-
- Token token;
- // Accept Comment after last item in the array.
- ok = readToken(token);
- while (token.type_ == tokenComment && ok) {
- ok = readToken(token);
- }
- bool badTokenType =
- (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
- if (!ok || badTokenType) {
- return addErrorAndRecover(
- "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
- }
- if (token.type_ == tokenArrayEnd)
- break;
- }
- return true;
-}
-
-bool Reader::decodeNumber(Token& token) {
- Value decoded;
- if (!decodeNumber(token, decoded))
- return false;
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool Reader::decodeNumber(Token& token, Value& decoded) {
- // Attempts to parse the number as an integer. If the number is
- // larger than the maximum supported value of an integer then
- // we decode the number as a double.
- Location current = token.start_;
- bool isNegative = *current == '-';
- if (isNegative)
- ++current;
- // TODO: Help the compiler do the div and mod at compile time or get rid of them.
- Value::LargestUInt maxIntegerValue =
- isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1
- : Value::maxLargestUInt;
- Value::LargestUInt threshold = maxIntegerValue / 10;
- Value::LargestUInt value = 0;
- while (current < token.end_) {
- Char c = *current++;
- if (c < '0' || c > '9')
- return decodeDouble(token, decoded);
- Value::UInt digit(static_cast<Value::UInt>(c - '0'));
- if (value >= threshold) {
- // We've hit or exceeded the max value divided by 10 (rounded down). If
- // a) we've only just touched the limit, b) this is the last digit, and
- // c) it's small enough to fit in that rounding delta, we're okay.
- // Otherwise treat this number as a double to avoid overflow.
- if (value > threshold || current != token.end_ ||
- digit > maxIntegerValue % 10) {
- return decodeDouble(token, decoded);
- }
- }
- value = value * 10 + digit;
- }
- if (isNegative && value == maxIntegerValue)
- decoded = Value::minLargestInt;
- else if (isNegative)
- decoded = -Value::LargestInt(value);
- else if (value <= Value::LargestUInt(Value::maxInt))
- decoded = Value::LargestInt(value);
- else
- decoded = value;
- return true;
-}
-
-bool Reader::decodeDouble(Token& token) {
- Value decoded;
- if (!decodeDouble(token, decoded))
- return false;
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool Reader::decodeDouble(Token& token, Value& decoded) {
- double value = 0;
- std::string buffer(token.start_, token.end_);
- JSONCPP_ISTRINGSTREAM is(buffer);
- if (!(is >> value))
- return addError("'" + std::string(token.start_, token.end_) +
- "' is not a number.",
- token);
- decoded = value;
- return true;
-}
-
-bool Reader::decodeString(Token& token) {
- std::string decoded_string;
- if (!decodeString(token, decoded_string))
- return false;
- Value decoded(decoded_string);
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool Reader::decodeString(Token& token, std::string& decoded) {
- decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
- Location current = token.start_ + 1; // skip '"'
- Location end = token.end_ - 1; // do not include '"'
- while (current != end) {
- Char c = *current++;
- if (c == '"')
- break;
- else if (c == '\\') {
- if (current == end)
- return addError("Empty escape sequence in string", token, current);
- Char escape = *current++;
- switch (escape) {
- case '"':
- decoded += '"';
- break;
- case '/':
- decoded += '/';
- break;
- case '\\':
- decoded += '\\';
- break;
- case 'b':
- decoded += '\b';
- break;
- case 'f':
- decoded += '\f';
- break;
- case 'n':
- decoded += '\n';
- break;
- case 'r':
- decoded += '\r';
- break;
- case 't':
- decoded += '\t';
- break;
- case 'u': {
- unsigned int unicode;
- if (!decodeUnicodeCodePoint(token, current, end, unicode))
- return false;
- decoded += codePointToUTF8(unicode);
- } break;
- default:
- return addError("Bad escape sequence in string", token, current);
- }
- } else {
- decoded += c;
- }
- }
- return true;
-}
-
-bool Reader::decodeUnicodeCodePoint(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode) {
-
- if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
- return false;
- if (unicode >= 0xD800 && unicode <= 0xDBFF) {
- // surrogate pairs
- if (end - current < 6)
- return addError(
- "additional six characters expected to parse unicode surrogate pair.",
- token,
- current);
- unsigned int surrogatePair;
- if (*(current++) == '\\' && *(current++) == 'u') {
- if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
- unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
- } else
- return false;
- } else
- return addError("expecting another \\u token to begin the second half of "
- "a unicode surrogate pair",
- token,
- current);
- }
- return true;
-}
-
-bool Reader::decodeUnicodeEscapeSequence(Token& token,
- Location& current,
- Location end,
- unsigned int& ret_unicode) {
- if (end - current < 4)
- return addError(
- "Bad unicode escape sequence in string: four digits expected.",
- token,
- current);
- int unicode = 0;
- for (int index = 0; index < 4; ++index) {
- Char c = *current++;
- unicode *= 16;
- if (c >= '0' && c <= '9')
- unicode += c - '0';
- else if (c >= 'a' && c <= 'f')
- unicode += c - 'a' + 10;
- else if (c >= 'A' && c <= 'F')
- unicode += c - 'A' + 10;
- else
- return addError(
- "Bad unicode escape sequence in string: hexadecimal digit expected.",
- token,
- current);
- }
- ret_unicode = static_cast<unsigned int>(unicode);
- return true;
-}
-
-bool
-Reader::addError(const std::string& message, Token& token, Location extra) {
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = extra;
- errors_.push_back(info);
- return false;
-}
-
-bool Reader::recoverFromError(TokenType skipUntilToken) {
- size_t const errorCount = errors_.size();
- Token skip;
- for (;;) {
- if (!readToken(skip))
- errors_.resize(errorCount); // discard errors caused by recovery
- if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
- break;
- }
- errors_.resize(errorCount);
- return false;
-}
-
-bool Reader::addErrorAndRecover(const std::string& message,
- Token& token,
- TokenType skipUntilToken) {
- addError(message, token);
- return recoverFromError(skipUntilToken);
-}
-
-Value& Reader::currentValue() { return *(nodes_.top()); }
-
-Reader::Char Reader::getNextChar() {
- if (current_ == end_)
- return 0;
- return *current_++;
-}
-
-void Reader::getLocationLineAndColumn(Location location,
- int& line,
- int& column) const {
- Location current = begin_;
- Location lastLineStart = current;
- line = 0;
- while (current < location && current != end_) {
- Char c = *current++;
- if (c == '\r') {
- if (*current == '\n')
- ++current;
- lastLineStart = current;
- ++line;
- } else if (c == '\n') {
- lastLineStart = current;
- ++line;
- }
- }
- // column & line start at 1
- column = int(location - lastLineStart) + 1;
- ++line;
-}
-
-std::string Reader::getLocationLineAndColumn(Location location) const {
- int line, column;
- getLocationLineAndColumn(location, line, column);
- char buffer[18 + 16 + 16 + 1];
- snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
- return buffer;
-}
-
-// Deprecated. Preserved for backward compatibility
-std::string Reader::getFormatedErrorMessages() const {
- return getFormattedErrorMessages();
-}
-
-std::string Reader::getFormattedErrorMessages() const {
- std::string formattedMessage;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
- formattedMessage +=
- "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
- formattedMessage += " " + error.message_ + "\n";
- if (error.extra_)
- formattedMessage +=
- "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
- }
- return formattedMessage;
-}
-
-std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
- std::vector<Reader::StructuredError> allErrors;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
- Reader::StructuredError structured;
- structured.offset_start = error.token_.start_ - begin_;
- structured.offset_limit = error.token_.end_ - begin_;
- structured.message = error.message_;
- allErrors.push_back(structured);
- }
- return allErrors;
-}
-
-bool Reader::pushError(const Value& value, const std::string& message) {
- ptrdiff_t const length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length)
- return false;
- Token token;
- token.type_ = tokenError;
- token.start_ = begin_ + value.getOffsetStart();
- token.end_ = end_ + value.getOffsetLimit();
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = 0;
- errors_.push_back(info);
- return true;
-}
-
-bool Reader::pushError(const Value& value, const std::string& message, const Value& extra) {
- ptrdiff_t const length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length
- || extra.getOffsetLimit() > length)
- return false;
- Token token;
- token.type_ = tokenError;
- token.start_ = begin_ + value.getOffsetStart();
- token.end_ = begin_ + value.getOffsetLimit();
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = begin_ + extra.getOffsetStart();
- errors_.push_back(info);
- return true;
-}
-
-bool Reader::good() const {
- return !errors_.size();
-}
-
-// exact copy of Features
-class OurFeatures {
-public:
- static OurFeatures all();
- bool allowComments_;
- bool strictRoot_;
- bool allowDroppedNullPlaceholders_;
- bool allowNumericKeys_;
- bool allowSingleQuotes_;
- bool failIfExtra_;
- bool rejectDupKeys_;
- bool allowSpecialFloats_;
- int stackLimit_;
-}; // OurFeatures
-
-// exact copy of Implementation of class Features
-// ////////////////////////////////
-
-OurFeatures OurFeatures::all() { return OurFeatures(); }
-
-// Implementation of class Reader
-// ////////////////////////////////
-
-// exact copy of Reader, renamed to OurReader
-class OurReader {
-public:
- typedef char Char;
- typedef const Char* Location;
- struct StructuredError {
- ptrdiff_t offset_start;
- ptrdiff_t offset_limit;
- std::string message;
- };
-
- OurReader(OurFeatures const& features);
- bool parse(const char* beginDoc,
- const char* endDoc,
- Value& root,
- bool collectComments = true);
- std::string getFormattedErrorMessages() const;
- std::vector<StructuredError> getStructuredErrors() const;
- bool pushError(const Value& value, const std::string& message);
- bool pushError(const Value& value, const std::string& message, const Value& extra);
- bool good() const;
-
-private:
- OurReader(OurReader const&); // no impl
- void operator=(OurReader const&); // no impl
-
- enum TokenType {
- tokenEndOfStream = 0,
- tokenObjectBegin,
- tokenObjectEnd,
- tokenArrayBegin,
- tokenArrayEnd,
- tokenString,
- tokenNumber,
- tokenTrue,
- tokenFalse,
- tokenNull,
- tokenNaN,
- tokenPosInf,
- tokenNegInf,
- tokenArraySeparator,
- tokenMemberSeparator,
- tokenComment,
- tokenError
- };
-
- class Token {
- public:
- TokenType type_;
- Location start_;
- Location end_;
- };
-
- class ErrorInfo {
- public:
- Token token_;
- std::string message_;
- Location extra_;
- };
-
- typedef std::deque<ErrorInfo> Errors;
-
- bool readToken(Token& token);
- void skipSpaces();
- bool match(Location pattern, int patternLength);
- bool readComment();
- bool readCStyleComment();
- bool readCppStyleComment();
- bool readString();
- bool readStringSingleQuote();
- bool readNumber(bool checkInf);
- bool readValue();
- bool readObject(Token& token);
- bool readArray(Token& token);
- bool decodeNumber(Token& token);
- bool decodeNumber(Token& token, Value& decoded);
- bool decodeString(Token& token);
- bool decodeString(Token& token, std::string& decoded);
- bool decodeDouble(Token& token);
- bool decodeDouble(Token& token, Value& decoded);
- bool decodeUnicodeCodePoint(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode);
- bool decodeUnicodeEscapeSequence(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode);
- bool addError(const std::string& message, Token& token, Location extra = 0);
- bool recoverFromError(TokenType skipUntilToken);
- bool addErrorAndRecover(const std::string& message,
- Token& token,
- TokenType skipUntilToken);
- void skipUntilSpace();
- Value& currentValue();
- Char getNextChar();
- void
- getLocationLineAndColumn(Location location, int& line, int& column) const;
- std::string getLocationLineAndColumn(Location location) const;
- void addComment(Location begin, Location end, CommentPlacement placement);
- void skipCommentTokens(Token& token);
-
- typedef std::stack<Value*> Nodes;
- Nodes nodes_;
- Errors errors_;
- std::string document_;
- Location begin_;
- Location end_;
- Location current_;
- Location lastValueEnd_;
- Value* lastValue_;
- std::string commentsBefore_;
- int stackDepth_;
-
- OurFeatures const features_;
- bool collectComments_;
-}; // OurReader
-
-// complete copy of Read impl, for OurReader
-
-OurReader::OurReader(OurFeatures const& features)
- : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(),
- lastValue_(), commentsBefore_(),
- stackDepth_(0),
- features_(features), collectComments_() {
-}
-
-bool OurReader::parse(const char* beginDoc,
- const char* endDoc,
- Value& root,
- bool collectComments) {
- if (!features_.allowComments_) {
- collectComments = false;
- }
-
- begin_ = beginDoc;
- end_ = endDoc;
- collectComments_ = collectComments;
- current_ = begin_;
- lastValueEnd_ = 0;
- lastValue_ = 0;
- commentsBefore_ = "";
- errors_.clear();
- while (!nodes_.empty())
- nodes_.pop();
- nodes_.push(&root);
-
- stackDepth_ = 0;
- bool successful = readValue();
- Token token;
- skipCommentTokens(token);
- if (features_.failIfExtra_) {
- if (token.type_ != tokenError && token.type_ != tokenEndOfStream) {
- addError("Extra non-whitespace after JSON value.", token);
- return false;
- }
- }
- if (collectComments_ && !commentsBefore_.empty())
- root.setComment(commentsBefore_, commentAfter);
- if (features_.strictRoot_) {
- if (!root.isArray() && !root.isObject()) {
- // Set error location to start of doc, ideally should be first token found
- // in doc
- token.type_ = tokenError;
- token.start_ = beginDoc;
- token.end_ = endDoc;
- addError(
- "A valid JSON document must be either an array or an object value.",
- token);
- return false;
- }
- }
- return successful;
-}
-
-bool OurReader::readValue() {
- if (stackDepth_ >= features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue().");
- ++stackDepth_;
- Token token;
- skipCommentTokens(token);
- bool successful = true;
-
- if (collectComments_ && !commentsBefore_.empty()) {
- currentValue().setComment(commentsBefore_, commentBefore);
- commentsBefore_ = "";
- }
-
- switch (token.type_) {
- case tokenObjectBegin:
- successful = readObject(token);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- case tokenArrayBegin:
- successful = readArray(token);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- case tokenNumber:
- successful = decodeNumber(token);
- break;
- case tokenString:
- successful = decodeString(token);
- break;
- case tokenTrue:
- {
- Value v(true);
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenFalse:
- {
- Value v(false);
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenNull:
- {
- Value v;
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenNaN:
- {
- Value v(std::numeric_limits<double>::quiet_NaN());
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenPosInf:
- {
- Value v(std::numeric_limits<double>::infinity());
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenNegInf:
- {
- Value v(-std::numeric_limits<double>::infinity());
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- }
- break;
- case tokenArraySeparator:
- case tokenObjectEnd:
- case tokenArrayEnd:
- if (features_.allowDroppedNullPlaceholders_) {
- // "Un-read" the current token and mark the current value as a null
- // token.
- current_--;
- Value v;
- currentValue().swapPayload(v);
- currentValue().setOffsetStart(current_ - begin_ - 1);
- currentValue().setOffsetLimit(current_ - begin_);
- break;
- } // else, fall through ...
- default:
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return addError("Syntax error: value, object or array expected.", token);
- }
-
- if (collectComments_) {
- lastValueEnd_ = current_;
- lastValue_ = ¤tValue();
- }
-
- --stackDepth_;
- return successful;
-}
-
-void OurReader::skipCommentTokens(Token& token) {
- if (features_.allowComments_) {
- do {
- readToken(token);
- } while (token.type_ == tokenComment);
- } else {
- readToken(token);
- }
-}
-
-bool OurReader::readToken(Token& token) {
- skipSpaces();
- token.start_ = current_;
- Char c = getNextChar();
- bool ok = true;
- switch (c) {
- case '{':
- token.type_ = tokenObjectBegin;
- break;
- case '}':
- token.type_ = tokenObjectEnd;
- break;
- case '[':
- token.type_ = tokenArrayBegin;
- break;
- case ']':
- token.type_ = tokenArrayEnd;
- break;
- case '"':
- token.type_ = tokenString;
- ok = readString();
- break;
- case '\'':
- if (features_.allowSingleQuotes_) {
- token.type_ = tokenString;
- ok = readStringSingleQuote();
- break;
- } // else continue
- case '/':
- token.type_ = tokenComment;
- ok = readComment();
- break;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- token.type_ = tokenNumber;
- readNumber(false);
- break;
- case '-':
- if (readNumber(true)) {
- token.type_ = tokenNumber;
- } else {
- token.type_ = tokenNegInf;
- ok = features_.allowSpecialFloats_ && match("nfinity", 7);
- }
- break;
- case 't':
- token.type_ = tokenTrue;
- ok = match("rue", 3);
- break;
- case 'f':
- token.type_ = tokenFalse;
- ok = match("alse", 4);
- break;
- case 'n':
- token.type_ = tokenNull;
- ok = match("ull", 3);
- break;
- case 'N':
- if (features_.allowSpecialFloats_) {
- token.type_ = tokenNaN;
- ok = match("aN", 2);
- } else {
- ok = false;
- }
- break;
- case 'I':
- if (features_.allowSpecialFloats_) {
- token.type_ = tokenPosInf;
- ok = match("nfinity", 7);
- } else {
- ok = false;
- }
- break;
- case ',':
- token.type_ = tokenArraySeparator;
- break;
- case ':':
- token.type_ = tokenMemberSeparator;
- break;
- case 0:
- token.type_ = tokenEndOfStream;
- break;
- default:
- ok = false;
- break;
- }
- if (!ok)
- token.type_ = tokenError;
- token.end_ = current_;
- return true;
-}
-
-void OurReader::skipSpaces() {
- while (current_ != end_) {
- Char c = *current_;
- if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
- ++current_;
- else
- break;
- }
-}
-
-bool OurReader::match(Location pattern, int patternLength) {
- if (end_ - current_ < patternLength)
- return false;
- int index = patternLength;
- while (index--)
- if (current_[index] != pattern[index])
- return false;
- current_ += patternLength;
- return true;
-}
-
-bool OurReader::readComment() {
- Location commentBegin = current_ - 1;
- Char c = getNextChar();
- bool successful = false;
- if (c == '*')
- successful = readCStyleComment();
- else if (c == '/')
- successful = readCppStyleComment();
- if (!successful)
- return false;
-
- if (collectComments_) {
- CommentPlacement placement = commentBefore;
- if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
- if (c != '*' || !containsNewLine(commentBegin, current_))
- placement = commentAfterOnSameLine;
- }
-
- addComment(commentBegin, current_, placement);
- }
- return true;
-}
-
-void
-OurReader::addComment(Location begin, Location end, CommentPlacement placement) {
- assert(collectComments_);
- const std::string& normalized = normalizeEOL(begin, end);
- if (placement == commentAfterOnSameLine) {
- assert(lastValue_ != 0);
- lastValue_->setComment(normalized, placement);
- } else {
- commentsBefore_ += normalized;
- }
-}
-
-bool OurReader::readCStyleComment() {
- while (current_ != end_) {
- Char c = getNextChar();
- if (c == '*' && *current_ == '/')
- break;
- }
- return getNextChar() == '/';
-}
-
-bool OurReader::readCppStyleComment() {
- while (current_ != end_) {
- Char c = getNextChar();
- if (c == '\n')
- break;
- if (c == '\r') {
- // Consume DOS EOL. It will be normalized in addComment.
- if (current_ != end_ && *current_ == '\n')
- getNextChar();
- // Break on Moc OS 9 EOL.
- break;
- }
- }
- return true;
-}
-
-bool OurReader::readNumber(bool checkInf) {
- const char *p = current_;
- if (checkInf && p != end_ && *p == 'I') {
- current_ = ++p;
- return false;
- }
- char c = '0'; // stopgap for already consumed character
- // integral part
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- // fractional part
- if (c == '.') {
- c = (current_ = p) < end_ ? *p++ : 0;
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- }
- // exponential part
- if (c == 'e' || c == 'E') {
- c = (current_ = p) < end_ ? *p++ : 0;
- if (c == '+' || c == '-')
- c = (current_ = p) < end_ ? *p++ : 0;
- while (c >= '0' && c <= '9')
- c = (current_ = p) < end_ ? *p++ : 0;
- }
- return true;
-}
-bool OurReader::readString() {
- Char c = 0;
- while (current_ != end_) {
- c = getNextChar();
- if (c == '\\')
- getNextChar();
- else if (c == '"')
- break;
- }
- return c == '"';
-}
-
-
-bool OurReader::readStringSingleQuote() {
- Char c = 0;
- while (current_ != end_) {
- c = getNextChar();
- if (c == '\\')
- getNextChar();
- else if (c == '\'')
- break;
- }
- return c == '\'';
-}
-
-bool OurReader::readObject(Token& tokenStart) {
- Token tokenName;
- std::string name;
- Value init(objectValue);
- currentValue().swapPayload(init);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
- while (readToken(tokenName)) {
- bool initialTokenOk = true;
- while (tokenName.type_ == tokenComment && initialTokenOk)
- initialTokenOk = readToken(tokenName);
- if (!initialTokenOk)
- break;
- if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
- return true;
- name = "";
- if (tokenName.type_ == tokenString) {
- if (!decodeString(tokenName, name))
- return recoverFromError(tokenObjectEnd);
- } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
- Value numberName;
- if (!decodeNumber(tokenName, numberName))
- return recoverFromError(tokenObjectEnd);
- name = numberName.asString();
- } else {
- break;
- }
-
- Token colon;
- if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
- return addErrorAndRecover(
- "Missing ':' after object member name", colon, tokenObjectEnd);
- }
- if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30");
- if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
- std::string msg = "Duplicate key: '" + name + "'";
- return addErrorAndRecover(
- msg, tokenName, tokenObjectEnd);
- }
- Value& value = currentValue()[name];
- nodes_.push(&value);
- bool ok = readValue();
- nodes_.pop();
- if (!ok) // error already set
- return recoverFromError(tokenObjectEnd);
-
- Token comma;
- if (!readToken(comma) ||
- (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
- comma.type_ != tokenComment)) {
- return addErrorAndRecover(
- "Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
- }
- bool finalizeTokenOk = true;
- while (comma.type_ == tokenComment && finalizeTokenOk)
- finalizeTokenOk = readToken(comma);
- if (comma.type_ == tokenObjectEnd)
- return true;
- }
- return addErrorAndRecover(
- "Missing '}' or object member name", tokenName, tokenObjectEnd);
-}
-
-bool OurReader::readArray(Token& tokenStart) {
- Value init(arrayValue);
- currentValue().swapPayload(init);
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
- skipSpaces();
- if (*current_ == ']') // empty array
- {
- Token endArray;
- readToken(endArray);
- return true;
- }
- int index = 0;
- for (;;) {
- Value& value = currentValue()[index++];
- nodes_.push(&value);
- bool ok = readValue();
- nodes_.pop();
- if (!ok) // error already set
- return recoverFromError(tokenArrayEnd);
-
- Token token;
- // Accept Comment after last item in the array.
- ok = readToken(token);
- while (token.type_ == tokenComment && ok) {
- ok = readToken(token);
- }
- bool badTokenType =
- (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
- if (!ok || badTokenType) {
- return addErrorAndRecover(
- "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
- }
- if (token.type_ == tokenArrayEnd)
- break;
- }
- return true;
-}
-
-bool OurReader::decodeNumber(Token& token) {
- Value decoded;
- if (!decodeNumber(token, decoded))
- return false;
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool OurReader::decodeNumber(Token& token, Value& decoded) {
- // Attempts to parse the number as an integer. If the number is
- // larger than the maximum supported value of an integer then
- // we decode the number as a double.
- Location current = token.start_;
- bool isNegative = *current == '-';
- if (isNegative)
- ++current;
- // TODO: Help the compiler do the div and mod at compile time or get rid of them.
- Value::LargestUInt maxIntegerValue =
- isNegative ? Value::LargestUInt(-Value::minLargestInt)
- : Value::maxLargestUInt;
- Value::LargestUInt threshold = maxIntegerValue / 10;
- Value::LargestUInt value = 0;
- while (current < token.end_) {
- Char c = *current++;
- if (c < '0' || c > '9')
- return decodeDouble(token, decoded);
- Value::UInt digit(static_cast<Value::UInt>(c - '0'));
- if (value >= threshold) {
- // We've hit or exceeded the max value divided by 10 (rounded down). If
- // a) we've only just touched the limit, b) this is the last digit, and
- // c) it's small enough to fit in that rounding delta, we're okay.
- // Otherwise treat this number as a double to avoid overflow.
- if (value > threshold || current != token.end_ ||
- digit > maxIntegerValue % 10) {
- return decodeDouble(token, decoded);
- }
- }
- value = value * 10 + digit;
- }
- if (isNegative)
- decoded = -Value::LargestInt(value);
- else if (value <= Value::LargestUInt(Value::maxInt))
- decoded = Value::LargestInt(value);
- else
- decoded = value;
- return true;
-}
-
-bool OurReader::decodeDouble(Token& token) {
- Value decoded;
- if (!decodeDouble(token, decoded))
- return false;
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool OurReader::decodeDouble(Token& token, Value& decoded) {
- double value = 0;
- const int bufferSize = 32;
- int count;
- ptrdiff_t const length = token.end_ - token.start_;
-
- // Sanity check to avoid buffer overflow exploits.
- if (length < 0) {
- return addError("Unable to parse token length", token);
- }
- size_t const ulength = static_cast<size_t>(length);
-
- // Avoid using a string constant for the format control string given to
- // sscanf, as this can cause hard to debug crashes on OS X. See here for more
- // info:
- //
- // http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
- char format[] = "%lf";
-
- if (length <= bufferSize) {
- Char buffer[bufferSize + 1];
- memcpy(buffer, token.start_, ulength);
- buffer[length] = 0;
- count = sscanf(buffer, format, &value);
- } else {
- std::string buffer(token.start_, token.end_);
- count = sscanf(buffer.c_str(), format, &value);
- }
-
- if (count != 1)
- return addError("'" + std::string(token.start_, token.end_) +
- "' is not a number.",
- token);
- decoded = value;
- return true;
-}
-
-bool OurReader::decodeString(Token& token) {
- std::string decoded_string;
- if (!decodeString(token, decoded_string))
- return false;
- Value decoded(decoded_string);
- currentValue().swapPayload(decoded);
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
-}
-
-bool OurReader::decodeString(Token& token, std::string& decoded) {
- decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2));
- Location current = token.start_ + 1; // skip '"'
- Location end = token.end_ - 1; // do not include '"'
- while (current != end) {
- Char c = *current++;
- if (c == '"')
- break;
- else if (c == '\\') {
- if (current == end)
- return addError("Empty escape sequence in string", token, current);
- Char escape = *current++;
- switch (escape) {
- case '"':
- decoded += '"';
- break;
- case '/':
- decoded += '/';
- break;
- case '\\':
- decoded += '\\';
- break;
- case 'b':
- decoded += '\b';
- break;
- case 'f':
- decoded += '\f';
- break;
- case 'n':
- decoded += '\n';
- break;
- case 'r':
- decoded += '\r';
- break;
- case 't':
- decoded += '\t';
- break;
- case 'u': {
- unsigned int unicode;
- if (!decodeUnicodeCodePoint(token, current, end, unicode))
- return false;
- decoded += codePointToUTF8(unicode);
- } break;
- default:
- return addError("Bad escape sequence in string", token, current);
- }
- } else {
- decoded += c;
- }
- }
- return true;
-}
-
-bool OurReader::decodeUnicodeCodePoint(Token& token,
- Location& current,
- Location end,
- unsigned int& unicode) {
-
- if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
- return false;
- if (unicode >= 0xD800 && unicode <= 0xDBFF) {
- // surrogate pairs
- if (end - current < 6)
- return addError(
- "additional six characters expected to parse unicode surrogate pair.",
- token,
- current);
- unsigned int surrogatePair;
- if (*(current++) == '\\' && *(current++) == 'u') {
- if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
- unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
- } else
- return false;
- } else
- return addError("expecting another \\u token to begin the second half of "
- "a unicode surrogate pair",
- token,
- current);
- }
- return true;
-}
-
-bool OurReader::decodeUnicodeEscapeSequence(Token& token,
- Location& current,
- Location end,
- unsigned int& ret_unicode) {
- if (end - current < 4)
- return addError(
- "Bad unicode escape sequence in string: four digits expected.",
- token,
- current);
- int unicode = 0;
- for (int index = 0; index < 4; ++index) {
- Char c = *current++;
- unicode *= 16;
- if (c >= '0' && c <= '9')
- unicode += c - '0';
- else if (c >= 'a' && c <= 'f')
- unicode += c - 'a' + 10;
- else if (c >= 'A' && c <= 'F')
- unicode += c - 'A' + 10;
- else
- return addError(
- "Bad unicode escape sequence in string: hexadecimal digit expected.",
- token,
- current);
- }
- ret_unicode = static_cast<unsigned int>(unicode);
- return true;
-}
-
-bool
-OurReader::addError(const std::string& message, Token& token, Location extra) {
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = extra;
- errors_.push_back(info);
- return false;
-}
-
-bool OurReader::recoverFromError(TokenType skipUntilToken) {
- size_t errorCount = errors_.size();
- Token skip;
- for (;;) {
- if (!readToken(skip))
- errors_.resize(errorCount); // discard errors caused by recovery
- if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
- break;
- }
- errors_.resize(errorCount);
- return false;
-}
-
-bool OurReader::addErrorAndRecover(const std::string& message,
- Token& token,
- TokenType skipUntilToken) {
- addError(message, token);
- return recoverFromError(skipUntilToken);
-}
-
-Value& OurReader::currentValue() { return *(nodes_.top()); }
-
-OurReader::Char OurReader::getNextChar() {
- if (current_ == end_)
- return 0;
- return *current_++;
-}
-
-void OurReader::getLocationLineAndColumn(Location location,
- int& line,
- int& column) const {
- Location current = begin_;
- Location lastLineStart = current;
- line = 0;
- while (current < location && current != end_) {
- Char c = *current++;
- if (c == '\r') {
- if (*current == '\n')
- ++current;
- lastLineStart = current;
- ++line;
- } else if (c == '\n') {
- lastLineStart = current;
- ++line;
- }
- }
- // column & line start at 1
- column = int(location - lastLineStart) + 1;
- ++line;
-}
-
-std::string OurReader::getLocationLineAndColumn(Location location) const {
- int line, column;
- getLocationLineAndColumn(location, line, column);
- char buffer[18 + 16 + 16 + 1];
- snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
- return buffer;
-}
-
-std::string OurReader::getFormattedErrorMessages() const {
- std::string formattedMessage;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
- formattedMessage +=
- "* " + getLocationLineAndColumn(error.token_.start_) + "\n";
- formattedMessage += " " + error.message_ + "\n";
- if (error.extra_)
- formattedMessage +=
- "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n";
- }
- return formattedMessage;
-}
-
-std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
- std::vector<OurReader::StructuredError> allErrors;
- for (Errors::const_iterator itError = errors_.begin();
- itError != errors_.end();
- ++itError) {
- const ErrorInfo& error = *itError;
- OurReader::StructuredError structured;
- structured.offset_start = error.token_.start_ - begin_;
- structured.offset_limit = error.token_.end_ - begin_;
- structured.message = error.message_;
- allErrors.push_back(structured);
- }
- return allErrors;
-}
-
-bool OurReader::pushError(const Value& value, const std::string& message) {
- ptrdiff_t length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length)
- return false;
- Token token;
- token.type_ = tokenError;
- token.start_ = begin_ + value.getOffsetStart();
- token.end_ = end_ + value.getOffsetLimit();
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = 0;
- errors_.push_back(info);
- return true;
-}
-
-bool OurReader::pushError(const Value& value, const std::string& message, const Value& extra) {
- ptrdiff_t length = end_ - begin_;
- if(value.getOffsetStart() > length
- || value.getOffsetLimit() > length
- || extra.getOffsetLimit() > length)
- return false;
- Token token;
- token.type_ = tokenError;
- token.start_ = begin_ + value.getOffsetStart();
- token.end_ = begin_ + value.getOffsetLimit();
- ErrorInfo info;
- info.token_ = token;
- info.message_ = message;
- info.extra_ = begin_ + extra.getOffsetStart();
- errors_.push_back(info);
- return true;
-}
-
-bool OurReader::good() const {
- return !errors_.size();
-}
-
-
-class OurCharReader : public CharReader {
- bool const collectComments_;
- OurReader reader_;
-public:
- OurCharReader(
- bool collectComments,
- OurFeatures const& features)
- : collectComments_(collectComments)
- , reader_(features)
- {}
- bool parse(
- char const* beginDoc, char const* endDoc,
- Value* root, std::string* errs) override {
- bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
- if (errs) {
- *errs = reader_.getFormattedErrorMessages();
- }
- return ok;
- }
-};
-
-CharReaderBuilder::CharReaderBuilder()
-{
- setDefaults(&settings_);
-}
-CharReaderBuilder::~CharReaderBuilder()
-{}
-CharReader* CharReaderBuilder::newCharReader() const
-{
- bool collectComments = settings_["collectComments"].asBool();
- OurFeatures features = OurFeatures::all();
- features.allowComments_ = settings_["allowComments"].asBool();
- features.strictRoot_ = settings_["strictRoot"].asBool();
- features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool();
- features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
- features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
- features.stackLimit_ = settings_["stackLimit"].asInt();
- features.failIfExtra_ = settings_["failIfExtra"].asBool();
- features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
- features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
- return new OurCharReader(collectComments, features);
-}
-static void getValidReaderKeys(std::set<std::string>* valid_keys)
-{
- valid_keys->clear();
- valid_keys->insert("collectComments");
- valid_keys->insert("allowComments");
- valid_keys->insert("strictRoot");
- valid_keys->insert("allowDroppedNullPlaceholders");
- valid_keys->insert("allowNumericKeys");
- valid_keys->insert("allowSingleQuotes");
- valid_keys->insert("stackLimit");
- valid_keys->insert("failIfExtra");
- valid_keys->insert("rejectDupKeys");
- valid_keys->insert("allowSpecialFloats");
-}
-bool CharReaderBuilder::validate(Json::Value* invalid) const
-{
- Json::Value my_invalid;
- if (!invalid) invalid = &my_invalid; // so we do not need to test for NULL
- Json::Value& inv = *invalid;
- std::set<std::string> valid_keys;
- getValidReaderKeys(&valid_keys);
- Value::Members keys = settings_.getMemberNames();
- size_t n = keys.size();
- for (size_t i = 0; i < n; ++i) {
- std::string const& key = keys[i];
- if (valid_keys.find(key) == valid_keys.end()) {
- inv[key] = settings_[key];
- }
- }
- return 0u == inv.size();
-}
-Value& CharReaderBuilder::operator[](std::string key)
-{
- return settings_[key];
-}
-// static
-void CharReaderBuilder::strictMode(Json::Value* settings)
-{
-//! [CharReaderBuilderStrictMode]
- (*settings)["allowComments"] = false;
- (*settings)["strictRoot"] = true;
- (*settings)["allowDroppedNullPlaceholders"] = false;
- (*settings)["allowNumericKeys"] = false;
- (*settings)["allowSingleQuotes"] = false;
- (*settings)["stackLimit"] = 1000;
- (*settings)["failIfExtra"] = true;
- (*settings)["rejectDupKeys"] = true;
- (*settings)["allowSpecialFloats"] = false;
-//! [CharReaderBuilderStrictMode]
-}
-// static
-void CharReaderBuilder::setDefaults(Json::Value* settings)
-{
-//! [CharReaderBuilderDefaults]
- (*settings)["collectComments"] = true;
- (*settings)["allowComments"] = true;
- (*settings)["strictRoot"] = false;
- (*settings)["allowDroppedNullPlaceholders"] = false;
- (*settings)["allowNumericKeys"] = false;
- (*settings)["allowSingleQuotes"] = false;
- (*settings)["stackLimit"] = 1000;
- (*settings)["failIfExtra"] = false;
- (*settings)["rejectDupKeys"] = false;
- (*settings)["allowSpecialFloats"] = false;
-//! [CharReaderBuilderDefaults]
-}
-
-//////////////////////////////////
-// global functions
-
-bool parseFromStream(
- CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
- Value* root, std::string* errs)
-{
- JSONCPP_OSTRINGSTREAM ssin;
- ssin << sin.rdbuf();
- std::string doc = ssin.str();
- char const* begin = doc.data();
- char const* end = begin + doc.size();
- // Note that we do not actually need a null-terminator.
- CharReaderPtr const reader(fact.newCharReader());
- return reader->parse(begin, end, root, errs);
-}
-
-JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root) {
- CharReaderBuilder b;
- std::string errs;
- bool ok = parseFromStream(b, sin, &root, &errs);
- if (!ok) {
- fprintf(stderr,
- "Error from reader: %s",
- errs.c_str());
-
- throwRuntimeError(errs);
- }
- return sin;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_reader.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_valueiterator.inl
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2007-2010 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-// included by json_value.cpp
-
-namespace Json {
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueIteratorBase
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueIteratorBase::ValueIteratorBase()
- : current_(), isNull_(true) {
-}
-
-ValueIteratorBase::ValueIteratorBase(
- const Value::ObjectValues::iterator& current)
- : current_(current), isNull_(false) {}
-
-Value& ValueIteratorBase::deref() const {
- return current_->second;
-}
-
-void ValueIteratorBase::increment() {
- ++current_;
-}
-
-void ValueIteratorBase::decrement() {
- --current_;
-}
-
-ValueIteratorBase::difference_type
-ValueIteratorBase::computeDistance(const SelfType& other) const {
-#ifdef JSON_USE_CPPTL_SMALLMAP
- return other.current_ - current_;
-#else
- // Iterator for null value are initialized using the default
- // constructor, which initialize current_ to the default
- // std::map::iterator. As begin() and end() are two instance
- // of the default std::map::iterator, they can not be compared.
- // To allow this, we handle this comparison specifically.
- if (isNull_ && other.isNull_) {
- return 0;
- }
-
- // Usage of std::distance is not portable (does not compile with Sun Studio 12
- // RogueWave STL,
- // which is the one used by default).
- // Using a portable hand-made version for non random iterator instead:
- // return difference_type( std::distance( current_, other.current_ ) );
- difference_type myDistance = 0;
- for (Value::ObjectValues::iterator it = current_; it != other.current_;
- ++it) {
- ++myDistance;
- }
- return myDistance;
-#endif
-}
-
-bool ValueIteratorBase::isEqual(const SelfType& other) const {
- if (isNull_) {
- return other.isNull_;
- }
- return current_ == other.current_;
-}
-
-void ValueIteratorBase::copy(const SelfType& other) {
- current_ = other.current_;
- isNull_ = other.isNull_;
-}
-
-Value ValueIteratorBase::key() const {
- const Value::CZString czstring = (*current_).first;
- if (czstring.data()) {
- if (czstring.isStaticString())
- return Value(StaticString(czstring.data()));
- return Value(czstring.data(), czstring.data() + czstring.length());
- }
- return Value(czstring.index());
-}
-
-UInt ValueIteratorBase::index() const {
- const Value::CZString czstring = (*current_).first;
- if (!czstring.data())
- return czstring.index();
- return Value::UInt(-1);
-}
-
-JSONCPP_STRING ValueIteratorBase::name() const {
- char const* keey;
- char const* end;
- keey = memberName(&end);
- if (!keey) return JSONCPP_STRING();
- return JSONCPP_STRING(keey, end);
-}
-
-char const* ValueIteratorBase::memberName() const {
- const char* cname = (*current_).first.data();
- return cname ? cname : "";
-}
-
-char const* ValueIteratorBase::memberName(char const** end) const {
- const char* cname = (*current_).first.data();
- if (!cname) {
- *end = NULL;
- return NULL;
- }
- *end = cname + (*current_).first.length();
- return cname;
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueConstIterator
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueConstIterator::ValueConstIterator() {}
-
-ValueConstIterator::ValueConstIterator(
- const Value::ObjectValues::iterator& current)
- : ValueIteratorBase(current) {}
-
-ValueConstIterator::ValueConstIterator(ValueIterator const& other)
- : ValueIteratorBase(other) {}
-
-ValueConstIterator& ValueConstIterator::
-operator=(const ValueIteratorBase& other) {
- copy(other);
- return *this;
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class ValueIterator
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-ValueIterator::ValueIterator() {}
-
-ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
- : ValueIteratorBase(current) {}
-
-ValueIterator::ValueIterator(const ValueConstIterator& other)
- : ValueIteratorBase(other) {
- throwRuntimeError("ConstIterator to Iterator should never be allowed.");
-}
-
-ValueIterator::ValueIterator(const ValueIterator& other)
- : ValueIteratorBase(other) {}
-
-ValueIterator& ValueIterator::operator=(const SelfType& other) {
- copy(other);
- return *this;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_valueiterator.inl
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_value.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2011 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include <json/assertions.h>
-#include <json/value.h>
-#include <json/writer.h>
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <math.h>
-#include <sstream>
-#include <utility>
-#include <cstring>
-#include <cassert>
-#ifdef JSON_USE_CPPTL
-#include <cpptl/conststring.h>
-#endif
-#include <cstddef> // size_t
-#include <algorithm> // min()
-
-#define JSON_ASSERT_UNREACHABLE assert(false)
-
-namespace Json {
-
-// This is a walkaround to avoid the static initialization of Value::null.
-// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of
-// 8 (instead of 4) as a bit of future-proofing.
-#if defined(__ARMEL__)
-#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
-#else
-#define ALIGNAS(byte_alignment)
-#endif
-static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 };
-const unsigned char& kNullRef = kNull[0];
-const Value& Value::null = reinterpret_cast<const Value&>(kNullRef);
-const Value& Value::nullRef = null;
-
-const Int Value::minInt = Int(~(UInt(-1) / 2));
-const Int Value::maxInt = Int(UInt(-1) / 2);
-const UInt Value::maxUInt = UInt(-1);
-#if defined(JSON_HAS_INT64)
-const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2));
-const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2);
-const UInt64 Value::maxUInt64 = UInt64(-1);
-// The constant is hard-coded because some compiler have trouble
-// converting Value::maxUInt64 to a double correctly (AIX/xlC).
-// Assumes that UInt64 is a 64 bits integer.
-static const double maxUInt64AsDouble = 18446744073709551615.0;
-#endif // defined(JSON_HAS_INT64)
-const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));
-const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);
-const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
-
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
- // The casts can lose precision, but we are looking only for
- // an approximate range. Might fail on edge cases though. ~cdunn
- //return d >= static_cast<double>(min) && d <= static_cast<double>(max);
- return d >= min && d <= max;
-}
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double integerToDouble(Json::UInt64 value) {
- return static_cast<double>(Int64(value / 2)) * 2.0 + Int64(value & 1);
-}
-
-template <typename T> static inline double integerToDouble(T value) {
- return static_cast<double>(value);
-}
-
-template <typename T, typename U>
-static inline bool InRange(double d, T min, U max) {
- return d >= integerToDouble(min) && d <= integerToDouble(max);
-}
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-
-/** Duplicates the specified string value.
- * @param value Pointer to the string to duplicate. Must be zero-terminated if
- * length is "unknown".
- * @param length Length of the value. if equals to unknown, then it will be
- * computed using strlen(value).
- * @return Pointer on the duplicate instance of string.
- */
-static inline char* duplicateStringValue(const char* value,
- size_t length) {
- // Avoid an integer overflow in the call to malloc below by limiting length
- // to a sane value.
- if (length >= static_cast<size_t>(Value::maxInt))
- length = Value::maxInt - 1;
-
- char* newString = static_cast<char*>(malloc(length + 1));
- if (newString == NULL) {
- throwRuntimeError(
- "in Json::Value::duplicateStringValue(): "
- "Failed to allocate string value buffer");
- }
- memcpy(newString, value, length);
- newString[length] = 0;
- return newString;
-}
-
-/* Record the length as a prefix.
- */
-static inline char* duplicateAndPrefixStringValue(
- const char* value,
- unsigned int length)
-{
- // Avoid an integer overflow in the call to malloc below by limiting length
- // to a sane value.
- JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) - sizeof(unsigned) - 1U,
- "in Json::Value::duplicateAndPrefixStringValue(): "
- "length too big for prefixing");
- unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
- char* newString = static_cast<char*>(malloc(actualLength));
- if (newString == 0) {
- throwRuntimeError(
- "in Json::Value::duplicateAndPrefixStringValue(): "
- "Failed to allocate string value buffer");
- }
- *reinterpret_cast<unsigned*>(newString) = length;
- memcpy(newString + sizeof(unsigned), value, length);
- newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later
- return newString;
-}
-inline static void decodePrefixedString(
- bool isPrefixed, char const* prefixed,
- unsigned* length, char const** value)
-{
- if (!isPrefixed) {
- *length = static_cast<unsigned>(strlen(prefixed));
- *value = prefixed;
- } else {
- *length = *reinterpret_cast<unsigned const*>(prefixed);
- *value = prefixed + sizeof(unsigned);
- }
-}
-/** Free the string duplicated by duplicateStringValue()/duplicateAndPrefixStringValue().
- */
-static inline void releaseStringValue(char* value) { free(value); }
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// ValueInternals...
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-#if !defined(JSON_IS_AMALGAMATION)
-
-#include "json_valueiterator.inl"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-
-namespace Json {
-
-Exception::Exception(JSONCPP_STRING const& msg)
- : msg_(msg)
-{}
-Exception::~Exception() throw()
-{}
-char const* Exception::what() const throw()
-{
- return msg_.c_str();
-}
-RuntimeError::RuntimeError(JSONCPP_STRING const& msg)
- : Exception(msg)
-{}
-LogicError::LogicError(JSONCPP_STRING const& msg)
- : Exception(msg)
-{}
-void throwRuntimeError(JSONCPP_STRING const& msg)
-{
- throw RuntimeError(msg);
-}
-void throwLogicError(JSONCPP_STRING const& msg)
-{
- throw LogicError(msg);
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::CommentInfo
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-Value::CommentInfo::CommentInfo() : comment_(0) {}
-
-Value::CommentInfo::~CommentInfo() {
- if (comment_)
- releaseStringValue(comment_);
-}
-
-void Value::CommentInfo::setComment(const char* text, size_t len) {
- if (comment_) {
- releaseStringValue(comment_);
- comment_ = 0;
- }
- JSON_ASSERT(text != 0);
- JSON_ASSERT_MESSAGE(
- text[0] == '\0' || text[0] == '/',
- "in Json::Value::setComment(): Comments must start with /");
- // It seems that /**/ style comments are acceptable as well.
- comment_ = duplicateStringValue(text, len);
-}
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::CZString
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-// Notes: policy_ indicates if the string was allocated when
-// a string is stored.
-
-Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {}
-
-Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate)
- : cstr_(str) {
- // allocate != duplicate
- storage_.policy_ = allocate & 0x3;
- storage_.length_ = ulength & 0x3FFFFFFF;
-}
-
-Value::CZString::CZString(const CZString& other)
- : cstr_(other.storage_.policy_ != noDuplication && other.cstr_ != 0
- ? duplicateStringValue(other.cstr_, other.storage_.length_)
- : other.cstr_) {
- storage_.policy_ = static_cast<unsigned>(other.cstr_
- ? (static_cast<DuplicationPolicy>(other.storage_.policy_) == noDuplication
- ? noDuplication : duplicate)
- : static_cast<DuplicationPolicy>(other.storage_.policy_));
- storage_.length_ = other.storage_.length_;
-}
-
-#if JSON_HAS_RVALUE_REFERENCES
-Value::CZString::CZString(CZString&& other)
- : cstr_(other.cstr_), index_(other.index_) {
- other.cstr_ = nullptr;
-}
-#endif
-
-Value::CZString::~CZString() {
- if (cstr_ && storage_.policy_ == duplicate)
- releaseStringValue(const_cast<char*>(cstr_));
-}
-
-void Value::CZString::swap(CZString& other) {
- std::swap(cstr_, other.cstr_);
- std::swap(index_, other.index_);
-}
-
-Value::CZString& Value::CZString::operator=(CZString other) {
- swap(other);
- return *this;
-}
-
-bool Value::CZString::operator<(const CZString& other) const {
- if (!cstr_) return index_ < other.index_;
- //return strcmp(cstr_, other.cstr_) < 0;
- // Assume both are strings.
- unsigned this_len = this->storage_.length_;
- unsigned other_len = other.storage_.length_;
- unsigned min_len = std::min(this_len, other_len);
- JSON_ASSERT(this->cstr_ && other.cstr_);
- int comp = memcmp(this->cstr_, other.cstr_, min_len);
- if (comp < 0) return true;
- if (comp > 0) return false;
- return (this_len < other_len);
-}
-
-bool Value::CZString::operator==(const CZString& other) const {
- if (!cstr_) return index_ == other.index_;
- //return strcmp(cstr_, other.cstr_) == 0;
- // Assume both are strings.
- unsigned this_len = this->storage_.length_;
- unsigned other_len = other.storage_.length_;
- if (this_len != other_len) return false;
- JSON_ASSERT(this->cstr_ && other.cstr_);
- int comp = memcmp(this->cstr_, other.cstr_, this_len);
- return comp == 0;
-}
-
-ArrayIndex Value::CZString::index() const { return index_; }
-
-//const char* Value::CZString::c_str() const { return cstr_; }
-const char* Value::CZString::data() const { return cstr_; }
-unsigned Value::CZString::length() const { return storage_.length_; }
-bool Value::CZString::isStaticString() const { return storage_.policy_ == noDuplication; }
-
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// class Value::Value
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-// //////////////////////////////////////////////////////////////////
-
-/*! \internal Default constructor initialization must be equivalent to:
- * memset( this, 0, sizeof(Value) )
- * This optimization is used in ValueInternalMap fast allocator.
- */
-Value::Value(ValueType vtype) {
- initBasic(vtype);
- switch (vtype) {
- case nullValue:
- break;
- case intValue:
- case uintValue:
- value_.int_ = 0;
- break;
- case realValue:
- value_.real_ = 0.0;
- break;
- case stringValue:
- value_.string_ = 0;
- break;
- case arrayValue:
- case objectValue:
- value_.map_ = new ObjectValues();
- break;
- case booleanValue:
- value_.bool_ = false;
- break;
- default:
- JSON_ASSERT_UNREACHABLE;
- }
-}
-
-Value::Value(Int value) {
- initBasic(intValue);
- value_.int_ = value;
-}
-
-Value::Value(UInt value) {
- initBasic(uintValue);
- value_.uint_ = value;
-}
-#if defined(JSON_HAS_INT64)
-Value::Value(Int64 value) {
- initBasic(intValue);
- value_.int_ = value;
-}
-Value::Value(UInt64 value) {
- initBasic(uintValue);
- value_.uint_ = value;
-}
-#endif // defined(JSON_HAS_INT64)
-
-Value::Value(double value) {
- initBasic(realValue);
- value_.real_ = value;
-}
-
-Value::Value(const char* value) {
- initBasic(stringValue, true);
- value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(strlen(value)));
-}
-
-Value::Value(const char* beginValue, const char* endValue) {
- initBasic(stringValue, true);
- value_.string_ =
- duplicateAndPrefixStringValue(beginValue, static_cast<unsigned>(endValue - beginValue));
-}
-
-Value::Value(const JSONCPP_STRING& value) {
- initBasic(stringValue, true);
- value_.string_ =
- duplicateAndPrefixStringValue(value.data(), static_cast<unsigned>(value.length()));
-}
-
-Value::Value(const StaticString& value) {
- initBasic(stringValue);
- value_.string_ = const_cast<char*>(value.c_str());
-}
-
-#ifdef JSON_USE_CPPTL
-Value::Value(const CppTL::ConstString& value) {
- initBasic(stringValue, true);
- value_.string_ = duplicateAndPrefixStringValue(value, static_cast<unsigned>(value.length()));
-}
-#endif
-
-Value::Value(bool value) {
- initBasic(booleanValue);
- value_.bool_ = value;
-}
-
-Value::Value(Value const& other)
- : type_(other.type_), allocated_(false)
- ,
- comments_(0), start_(other.start_), limit_(other.limit_)
-{
- switch (type_) {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- value_ = other.value_;
- break;
- case stringValue:
- if (other.value_.string_ && other.allocated_) {
- unsigned len;
- char const* str;
- decodePrefixedString(other.allocated_, other.value_.string_,
- &len, &str);
- value_.string_ = duplicateAndPrefixStringValue(str, len);
- allocated_ = true;
- } else {
- value_.string_ = other.value_.string_;
- allocated_ = false;
- }
- break;
- case arrayValue:
- case objectValue:
- value_.map_ = new ObjectValues(*other.value_.map_);
- break;
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- if (other.comments_) {
- comments_ = new CommentInfo[numberOfCommentPlacement];
- for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
- const CommentInfo& otherComment = other.comments_[comment];
- if (otherComment.comment_)
- comments_[comment].setComment(
- otherComment.comment_, strlen(otherComment.comment_));
- }
- }
-}
-
-#if JSON_HAS_RVALUE_REFERENCES
-// Move constructor
-Value::Value(Value&& other) {
- initBasic(nullValue);
- swap(other);
-}
-#endif
-
-Value::~Value() {
- switch (type_) {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- break;
- case stringValue:
- if (allocated_)
- releaseStringValue(value_.string_);
- break;
- case arrayValue:
- case objectValue:
- delete value_.map_;
- break;
- default:
- JSON_ASSERT_UNREACHABLE;
- }
-
- if (comments_)
- delete[] comments_;
-}
-
-Value& Value::operator=(Value other) {
- swap(other);
- return *this;
-}
-
-void Value::swapPayload(Value& other) {
- ValueType temp = type_;
- type_ = other.type_;
- other.type_ = temp;
- std::swap(value_, other.value_);
- int temp2 = allocated_;
- allocated_ = other.allocated_;
- other.allocated_ = temp2 & 0x1;
-}
-
-void Value::swap(Value& other) {
- swapPayload(other);
- std::swap(comments_, other.comments_);
- std::swap(start_, other.start_);
- std::swap(limit_, other.limit_);
-}
-
-ValueType Value::type() const { return type_; }
-
-int Value::compare(const Value& other) const {
- if (*this < other)
- return -1;
- if (*this > other)
- return 1;
- return 0;
-}
-
-bool Value::operator<(const Value& other) const {
- int typeDelta = type_ - other.type_;
- if (typeDelta)
- return typeDelta < 0 ? true : false;
- switch (type_) {
- case nullValue:
- return false;
- case intValue:
- return value_.int_ < other.value_.int_;
- case uintValue:
- return value_.uint_ < other.value_.uint_;
- case realValue:
- return value_.real_ < other.value_.real_;
- case booleanValue:
- return value_.bool_ < other.value_.bool_;
- case stringValue:
- {
- if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
- if (other.value_.string_) return true;
- else return false;
- }
- unsigned this_len;
- unsigned other_len;
- char const* this_str;
- char const* other_str;
- decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
- decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
- unsigned min_len = std::min(this_len, other_len);
- JSON_ASSERT(this_str && other_str);
- int comp = memcmp(this_str, other_str, min_len);
- if (comp < 0) return true;
- if (comp > 0) return false;
- return (this_len < other_len);
- }
- case arrayValue:
- case objectValue: {
- int delta = int(value_.map_->size() - other.value_.map_->size());
- if (delta)
- return delta < 0;
- return (*value_.map_) < (*other.value_.map_);
- }
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- return false; // unreachable
-}
-
-bool Value::operator<=(const Value& other) const { return !(other < *this); }
-
-bool Value::operator>=(const Value& other) const { return !(*this < other); }
-
-bool Value::operator>(const Value& other) const { return other < *this; }
-
-bool Value::operator==(const Value& other) const {
- // if ( type_ != other.type_ )
- // GCC 2.95.3 says:
- // attempt to take address of bit-field structure member `Json::Value::type_'
- // Beats me, but a temp solves the problem.
- int temp = other.type_;
- if (type_ != temp)
- return false;
- switch (type_) {
- case nullValue:
- return true;
- case intValue:
- return value_.int_ == other.value_.int_;
- case uintValue:
- return value_.uint_ == other.value_.uint_;
- case realValue:
- return value_.real_ == other.value_.real_;
- case booleanValue:
- return value_.bool_ == other.value_.bool_;
- case stringValue:
- {
- if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
- return (value_.string_ == other.value_.string_);
- }
- unsigned this_len;
- unsigned other_len;
- char const* this_str;
- char const* other_str;
- decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
- decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
- if (this_len != other_len) return false;
- JSON_ASSERT(this_str && other_str);
- int comp = memcmp(this_str, other_str, this_len);
- return comp == 0;
- }
- case arrayValue:
- case objectValue:
- return value_.map_->size() == other.value_.map_->size() &&
- (*value_.map_) == (*other.value_.map_);
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- return false; // unreachable
-}
-
-bool Value::operator!=(const Value& other) const { return !(*this == other); }
-
-const char* Value::asCString() const {
- JSON_ASSERT_MESSAGE(type_ == stringValue,
- "in Json::Value::asCString(): requires stringValue");
- if (value_.string_ == 0) return 0;
- unsigned this_len;
- char const* this_str;
- decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
- return this_str;
-}
-
-bool Value::getString(char const** str, char const** cend) const {
- if (type_ != stringValue) return false;
- if (value_.string_ == 0) return false;
- unsigned length;
- decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
- *cend = *str + length;
- return true;
-}
-
-JSONCPP_STRING Value::asString() const {
- switch (type_) {
- case nullValue:
- return "";
- case stringValue:
- {
- if (value_.string_ == 0) return "";
- unsigned this_len;
- char const* this_str;
- decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
- return JSONCPP_STRING(this_str, this_len);
- }
- case booleanValue:
- return value_.bool_ ? "true" : "false";
- case intValue:
- return valueToString(value_.int_);
- case uintValue:
- return valueToString(value_.uint_);
- case realValue:
- return valueToString(value_.real_);
- default:
- JSON_FAIL_MESSAGE("Type is not convertible to string");
- }
-}
-
-#ifdef JSON_USE_CPPTL
-CppTL::ConstString Value::asConstString() const {
- unsigned len;
- char const* str;
- decodePrefixedString(allocated_, value_.string_,
- &len, &str);
- return CppTL::ConstString(str, len);
-}
-#endif
-
-Value::Int Value::asInt() const {
- switch (type_) {
- case intValue:
- JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
- return Int(value_.int_);
- case uintValue:
- JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
- return Int(value_.uint_);
- case realValue:
- JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
- "double out of Int range");
- return Int(value_.real_);
- case nullValue:
- return 0;
- case booleanValue:
- return value_.bool_ ? 1 : 0;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to Int.");
-}
-
-Value::UInt Value::asUInt() const {
- switch (type_) {
- case intValue:
- JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
- return UInt(value_.int_);
- case uintValue:
- JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
- return UInt(value_.uint_);
- case realValue:
- JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
- "double out of UInt range");
- return UInt(value_.real_);
- case nullValue:
- return 0;
- case booleanValue:
- return value_.bool_ ? 1 : 0;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
-}
-
-#if defined(JSON_HAS_INT64)
-
-Value::Int64 Value::asInt64() const {
- switch (type_) {
- case intValue:
- return Int64(value_.int_);
- case uintValue:
- JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
- return Int64(value_.uint_);
- case realValue:
- JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
- "double out of Int64 range");
- return Int64(value_.real_);
- case nullValue:
- return 0;
- case booleanValue:
- return value_.bool_ ? 1 : 0;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
-}
-
-Value::UInt64 Value::asUInt64() const {
- switch (type_) {
- case intValue:
- JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
- return UInt64(value_.int_);
- case uintValue:
- return UInt64(value_.uint_);
- case realValue:
- JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
- "double out of UInt64 range");
- return UInt64(value_.real_);
- case nullValue:
- return 0;
- case booleanValue:
- return value_.bool_ ? 1 : 0;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
-}
-#endif // if defined(JSON_HAS_INT64)
-
-LargestInt Value::asLargestInt() const {
-#if defined(JSON_NO_INT64)
- return asInt();
-#else
- return asInt64();
-#endif
-}
-
-LargestUInt Value::asLargestUInt() const {
-#if defined(JSON_NO_INT64)
- return asUInt();
-#else
- return asUInt64();
-#endif
-}
-
-double Value::asDouble() const {
- switch (type_) {
- case intValue:
- return static_cast<double>(value_.int_);
- case uintValue:
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- return static_cast<double>(value_.uint_);
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- return integerToDouble(value_.uint_);
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- case realValue:
- return value_.real_;
- case nullValue:
- return 0.0;
- case booleanValue:
- return value_.bool_ ? 1.0 : 0.0;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to double.");
-}
-
-float Value::asFloat() const {
- switch (type_) {
- case intValue:
- return static_cast<float>(value_.int_);
- case uintValue:
-#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- return static_cast<float>(value_.uint_);
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- // This can fail (silently?) if the value is bigger than MAX_FLOAT.
- return static_cast<float>(integerToDouble(value_.uint_));
-#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
- case realValue:
- return static_cast<float>(value_.real_);
- case nullValue:
- return 0.0;
- case booleanValue:
- return value_.bool_ ? 1.0f : 0.0f;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to float.");
-}
-
-bool Value::asBool() const {
- switch (type_) {
- case booleanValue:
- return value_.bool_;
- case nullValue:
- return false;
- case intValue:
- return value_.int_ ? true : false;
- case uintValue:
- return value_.uint_ ? true : false;
- case realValue:
- // This is kind of strange. Not recommended.
- return (value_.real_ != 0.0) ? true : false;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to bool.");
-}
-
-bool Value::isConvertibleTo(ValueType other) const {
- switch (other) {
- case nullValue:
- return (isNumeric() && asDouble() == 0.0) ||
- (type_ == booleanValue && value_.bool_ == false) ||
- (type_ == stringValue && asString() == "") ||
- (type_ == arrayValue && value_.map_->size() == 0) ||
- (type_ == objectValue && value_.map_->size() == 0) ||
- type_ == nullValue;
- case intValue:
- return isInt() ||
- (type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
- type_ == booleanValue || type_ == nullValue;
- case uintValue:
- return isUInt() ||
- (type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
- type_ == booleanValue || type_ == nullValue;
- case realValue:
- return isNumeric() || type_ == booleanValue || type_ == nullValue;
- case booleanValue:
- return isNumeric() || type_ == booleanValue || type_ == nullValue;
- case stringValue:
- return isNumeric() || type_ == booleanValue || type_ == stringValue ||
- type_ == nullValue;
- case arrayValue:
- return type_ == arrayValue || type_ == nullValue;
- case objectValue:
- return type_ == objectValue || type_ == nullValue;
- }
- JSON_ASSERT_UNREACHABLE;
- return false;
-}
-
-/// Number of values in array or object
-ArrayIndex Value::size() const {
- switch (type_) {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- case stringValue:
- return 0;
- case arrayValue: // size of the array is highest index + 1
- if (!value_.map_->empty()) {
- ObjectValues::const_iterator itLast = value_.map_->end();
- --itLast;
- return (*itLast).first.index() + 1;
- }
- return 0;
- case objectValue:
- return ArrayIndex(value_.map_->size());
- }
- JSON_ASSERT_UNREACHABLE;
- return 0; // unreachable;
-}
-
-bool Value::empty() const {
- if (isNull() || isArray() || isObject())
- return size() == 0u;
- else
- return false;
-}
-
-bool Value::operator!() const { return isNull(); }
-
-void Value::clear() {
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
- type_ == objectValue,
- "in Json::Value::clear(): requires complex value");
- start_ = 0;
- limit_ = 0;
- switch (type_) {
- case arrayValue:
- case objectValue:
- value_.map_->clear();
- break;
- default:
- break;
- }
-}
-
-void Value::resize(ArrayIndex newSize) {
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
- "in Json::Value::resize(): requires arrayValue");
- if (type_ == nullValue)
- *this = Value(arrayValue);
- ArrayIndex oldSize = size();
- if (newSize == 0)
- clear();
- else if (newSize > oldSize)
- (*this)[newSize - 1];
- else {
- for (ArrayIndex index = newSize; index < oldSize; ++index) {
- value_.map_->erase(index);
- }
- JSON_ASSERT(size() == newSize);
- }
-}
-
-Value& Value::operator[](ArrayIndex index) {
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == arrayValue,
- "in Json::Value::operator[](ArrayIndex): requires arrayValue");
- if (type_ == nullValue)
- *this = Value(arrayValue);
- CZString key(index);
- ObjectValues::iterator it = value_.map_->lower_bound(key);
- if (it != value_.map_->end() && (*it).first == key)
- return (*it).second;
-
- ObjectValues::value_type defaultValue(key, nullRef);
- it = value_.map_->insert(it, defaultValue);
- return (*it).second;
-}
-
-Value& Value::operator[](int index) {
- JSON_ASSERT_MESSAGE(
- index >= 0,
- "in Json::Value::operator[](int index): index cannot be negative");
- return (*this)[ArrayIndex(index)];
-}
-
-const Value& Value::operator[](ArrayIndex index) const {
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == arrayValue,
- "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
- if (type_ == nullValue)
- return nullRef;
- CZString key(index);
- ObjectValues::const_iterator it = value_.map_->find(key);
- if (it == value_.map_->end())
- return nullRef;
- return (*it).second;
-}
-
-const Value& Value::operator[](int index) const {
- JSON_ASSERT_MESSAGE(
- index >= 0,
- "in Json::Value::operator[](int index) const: index cannot be negative");
- return (*this)[ArrayIndex(index)];
-}
-
-void Value::initBasic(ValueType vtype, bool allocated) {
- type_ = vtype;
- allocated_ = allocated;
- comments_ = 0;
- start_ = 0;
- limit_ = 0;
-}
-
-// Access an object value by name, create a null member if it does not exist.
-// @pre Type of '*this' is object or null.
-// @param key is null-terminated.
-Value& Value::resolveReference(const char* key) {
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
- "in Json::Value::resolveReference(): requires objectValue");
- if (type_ == nullValue)
- *this = Value(objectValue);
- CZString actualKey(
- key, static_cast<unsigned>(strlen(key)), CZString::noDuplication); // NOTE!
- ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
- if (it != value_.map_->end() && (*it).first == actualKey)
- return (*it).second;
-
- ObjectValues::value_type defaultValue(actualKey, nullRef);
- it = value_.map_->insert(it, defaultValue);
- Value& value = (*it).second;
- return value;
-}
-
-// @param key is not null-terminated.
-Value& Value::resolveReference(char const* key, char const* cend)
-{
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
- "in Json::Value::resolveReference(key, end): requires objectValue");
- if (type_ == nullValue)
- *this = Value(objectValue);
- CZString actualKey(
- key, static_cast<unsigned>(cend-key), CZString::duplicateOnCopy);
- ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
- if (it != value_.map_->end() && (*it).first == actualKey)
- return (*it).second;
-
- ObjectValues::value_type defaultValue(actualKey, nullRef);
- it = value_.map_->insert(it, defaultValue);
- Value& value = (*it).second;
- return value;
-}
-
-Value Value::get(ArrayIndex index, const Value& defaultValue) const {
- const Value* value = &((*this)[index]);
- return value == &nullRef ? defaultValue : *value;
-}
-
-bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
-
-Value const* Value::find(char const* key, char const* cend) const
-{
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
- "in Json::Value::find(key, end, found): requires objectValue or nullValue");
- if (type_ == nullValue) return NULL;
- CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
- ObjectValues::const_iterator it = value_.map_->find(actualKey);
- if (it == value_.map_->end()) return NULL;
- return &(*it).second;
-}
-const Value& Value::operator[](const char* key) const
-{
- Value const* found = find(key, key + strlen(key));
- if (!found) return nullRef;
- return *found;
-}
-Value const& Value::operator[](JSONCPP_STRING const& key) const
-{
- Value const* found = find(key.data(), key.data() + key.length());
- if (!found) return nullRef;
- return *found;
-}
-
-Value& Value::operator[](const char* key) {
- return resolveReference(key, key + strlen(key));
-}
-
-Value& Value::operator[](const JSONCPP_STRING& key) {
- return resolveReference(key.data(), key.data() + key.length());
-}
-
-Value& Value::operator[](const StaticString& key) {
- return resolveReference(key.c_str());
-}
-
-#ifdef JSON_USE_CPPTL
-Value& Value::operator[](const CppTL::ConstString& key) {
- return resolveReference(key.c_str(), key.end_c_str());
-}
-Value const& Value::operator[](CppTL::ConstString const& key) const
-{
- Value const* found = find(key.c_str(), key.end_c_str());
- if (!found) return nullRef;
- return *found;
-}
-#endif
-
-Value& Value::append(const Value& value) { return (*this)[size()] = value; }
-
-Value Value::get(char const* key, char const* cend, Value const& defaultValue) const
-{
- Value const* found = find(key, cend);
- return !found ? defaultValue : *found;
-}
-Value Value::get(char const* key, Value const& defaultValue) const
-{
- return get(key, key + strlen(key), defaultValue);
-}
-Value Value::get(JSONCPP_STRING const& key, Value const& defaultValue) const
-{
- return get(key.data(), key.data() + key.length(), defaultValue);
-}
-
-
-bool Value::removeMember(const char* key, const char* cend, Value* removed)
-{
- if (type_ != objectValue) {
- return false;
- }
- CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
- ObjectValues::iterator it = value_.map_->find(actualKey);
- if (it == value_.map_->end())
- return false;
- *removed = it->second;
- value_.map_->erase(it);
- return true;
-}
-bool Value::removeMember(const char* key, Value* removed)
-{
- return removeMember(key, key + strlen(key), removed);
-}
-bool Value::removeMember(JSONCPP_STRING const& key, Value* removed)
-{
- return removeMember(key.data(), key.data() + key.length(), removed);
-}
-Value Value::removeMember(const char* key)
-{
- JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
- "in Json::Value::removeMember(): requires objectValue");
- if (type_ == nullValue)
- return nullRef;
-
- Value removed; // null
- removeMember(key, key + strlen(key), &removed);
- return removed; // still null if removeMember() did nothing
-}
-Value Value::removeMember(const JSONCPP_STRING& key)
-{
- return removeMember(key.c_str());
-}
-
-bool Value::removeIndex(ArrayIndex index, Value* removed) {
- if (type_ != arrayValue) {
- return false;
- }
- CZString key(index);
- ObjectValues::iterator it = value_.map_->find(key);
- if (it == value_.map_->end()) {
- return false;
- }
- *removed = it->second;
- ArrayIndex oldSize = size();
- // shift left all items left, into the place of the "removed"
- for (ArrayIndex i = index; i < (oldSize - 1); ++i){
- CZString keey(i);
- (*value_.map_)[keey] = (*this)[i + 1];
- }
- // erase the last one ("leftover")
- CZString keyLast(oldSize - 1);
- ObjectValues::iterator itLast = value_.map_->find(keyLast);
- value_.map_->erase(itLast);
- return true;
-}
-
-#ifdef JSON_USE_CPPTL
-Value Value::get(const CppTL::ConstString& key,
- const Value& defaultValue) const {
- return get(key.c_str(), key.end_c_str(), defaultValue);
-}
-#endif
-
-bool Value::isMember(char const* key, char const* cend) const
-{
- Value const* value = find(key, cend);
- return NULL != value;
-}
-bool Value::isMember(char const* key) const
-{
- return isMember(key, key + strlen(key));
-}
-bool Value::isMember(JSONCPP_STRING const& key) const
-{
- return isMember(key.data(), key.data() + key.length());
-}
-
-#ifdef JSON_USE_CPPTL
-bool Value::isMember(const CppTL::ConstString& key) const {
- return isMember(key.c_str(), key.end_c_str());
-}
-#endif
-
-Value::Members Value::getMemberNames() const {
- JSON_ASSERT_MESSAGE(
- type_ == nullValue || type_ == objectValue,
- "in Json::Value::getMemberNames(), value must be objectValue");
- if (type_ == nullValue)
- return Value::Members();
- Members members;
- members.reserve(value_.map_->size());
- ObjectValues::const_iterator it = value_.map_->begin();
- ObjectValues::const_iterator itEnd = value_.map_->end();
- for (; it != itEnd; ++it) {
- members.push_back(JSONCPP_STRING((*it).first.data(),
- (*it).first.length()));
- }
- return members;
-}
-//
-//# ifdef JSON_USE_CPPTL
-// EnumMemberNames
-// Value::enumMemberNames() const
-//{
-// if ( type_ == objectValue )
-// {
-// return CppTL::Enum::any( CppTL::Enum::transform(
-// CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
-// MemberNamesTransform() ) );
-// }
-// return EnumMemberNames();
-//}
-//
-//
-// EnumValues
-// Value::enumValues() const
-//{
-// if ( type_ == objectValue || type_ == arrayValue )
-// return CppTL::Enum::anyValues( *(value_.map_),
-// CppTL::Type<const Value &>() );
-// return EnumValues();
-//}
-//
-//# endif
-
-static bool IsIntegral(double d) {
- double integral_part;
- return modf(d, &integral_part) == 0.0;
-}
-
-bool Value::isNull() const { return type_ == nullValue; }
-
-bool Value::isBool() const { return type_ == booleanValue; }
-
-bool Value::isInt() const {
- switch (type_) {
- case intValue:
- return value_.int_ >= minInt && value_.int_ <= maxInt;
- case uintValue:
- return value_.uint_ <= UInt(maxInt);
- case realValue:
- return value_.real_ >= minInt && value_.real_ <= maxInt &&
- IsIntegral(value_.real_);
- default:
- break;
- }
- return false;
-}
-
-bool Value::isUInt() const {
- switch (type_) {
- case intValue:
- return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
- case uintValue:
- return value_.uint_ <= maxUInt;
- case realValue:
- return value_.real_ >= 0 && value_.real_ <= maxUInt &&
- IsIntegral(value_.real_);
- default:
- break;
- }
- return false;
-}
-
-bool Value::isInt64() const {
-#if defined(JSON_HAS_INT64)
- switch (type_) {
- case intValue:
- return true;
- case uintValue:
- return value_.uint_ <= UInt64(maxInt64);
- case realValue:
- // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
- // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
- // require the value to be strictly less than the limit.
- return value_.real_ >= double(minInt64) &&
- value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
- default:
- break;
- }
-#endif // JSON_HAS_INT64
- return false;
-}
-
-bool Value::isUInt64() const {
-#if defined(JSON_HAS_INT64)
- switch (type_) {
- case intValue:
- return value_.int_ >= 0;
- case uintValue:
- return true;
- case realValue:
- // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
- // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
- // require the value to be strictly less than the limit.
- return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
- IsIntegral(value_.real_);
- default:
- break;
- }
-#endif // JSON_HAS_INT64
- return false;
-}
-
-bool Value::isIntegral() const {
-#if defined(JSON_HAS_INT64)
- return isInt64() || isUInt64();
-#else
- return isInt() || isUInt();
-#endif
-}
-
-bool Value::isDouble() const { return type_ == realValue || isIntegral(); }
-
-bool Value::isNumeric() const { return isIntegral() || isDouble(); }
-
-bool Value::isString() const { return type_ == stringValue; }
-
-bool Value::isArray() const { return type_ == arrayValue; }
-
-bool Value::isObject() const { return type_ == objectValue; }
-
-void Value::setComment(const char* comment, size_t len, CommentPlacement placement) {
- if (!comments_)
- comments_ = new CommentInfo[numberOfCommentPlacement];
- if ((len > 0) && (comment[len-1] == '\n')) {
- // Always discard trailing newline, to aid indentation.
- len -= 1;
- }
- comments_[placement].setComment(comment, len);
-}
-
-void Value::setComment(const char* comment, CommentPlacement placement) {
- setComment(comment, strlen(comment), placement);
-}
-
-void Value::setComment(const JSONCPP_STRING& comment, CommentPlacement placement) {
- setComment(comment.c_str(), comment.length(), placement);
-}
-
-bool Value::hasComment(CommentPlacement placement) const {
- return comments_ != 0 && comments_[placement].comment_ != 0;
-}
-
-JSONCPP_STRING Value::getComment(CommentPlacement placement) const {
- if (hasComment(placement))
- return comments_[placement].comment_;
- return "";
-}
-
-void Value::setOffsetStart(ptrdiff_t start) { start_ = start; }
-
-void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; }
-
-ptrdiff_t Value::getOffsetStart() const { return start_; }
-
-ptrdiff_t Value::getOffsetLimit() const { return limit_; }
-
-JSONCPP_STRING Value::toStyledString() const {
- StyledWriter writer;
- return writer.write(*this);
-}
-
-Value::const_iterator Value::begin() const {
- switch (type_) {
- case arrayValue:
- case objectValue:
- if (value_.map_)
- return const_iterator(value_.map_->begin());
- break;
- default:
- break;
- }
- return const_iterator();
-}
-
-Value::const_iterator Value::end() const {
- switch (type_) {
- case arrayValue:
- case objectValue:
- if (value_.map_)
- return const_iterator(value_.map_->end());
- break;
- default:
- break;
- }
- return const_iterator();
-}
-
-Value::iterator Value::begin() {
- switch (type_) {
- case arrayValue:
- case objectValue:
- if (value_.map_)
- return iterator(value_.map_->begin());
- break;
- default:
- break;
- }
- return iterator();
-}
-
-Value::iterator Value::end() {
- switch (type_) {
- case arrayValue:
- case objectValue:
- if (value_.map_)
- return iterator(value_.map_->end());
- break;
- default:
- break;
- }
- return iterator();
-}
-
-// class PathArgument
-// //////////////////////////////////////////////////////////////////
-
-PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
-
-PathArgument::PathArgument(ArrayIndex index)
- : key_(), index_(index), kind_(kindIndex) {}
-
-PathArgument::PathArgument(const char* key)
- : key_(key), index_(), kind_(kindKey) {}
-
-PathArgument::PathArgument(const JSONCPP_STRING& key)
- : key_(key.c_str()), index_(), kind_(kindKey) {}
-
-// class Path
-// //////////////////////////////////////////////////////////////////
-
-Path::Path(const JSONCPP_STRING& path,
- const PathArgument& a1,
- const PathArgument& a2,
- const PathArgument& a3,
- const PathArgument& a4,
- const PathArgument& a5) {
- InArgs in;
- in.push_back(&a1);
- in.push_back(&a2);
- in.push_back(&a3);
- in.push_back(&a4);
- in.push_back(&a5);
- makePath(path, in);
-}
-
-void Path::makePath(const JSONCPP_STRING& path, const InArgs& in) {
- const char* current = path.c_str();
- const char* end = current + path.length();
- InArgs::const_iterator itInArg = in.begin();
- while (current != end) {
- if (*current == '[') {
- ++current;
- if (*current == '%')
- addPathInArg(path, in, itInArg, PathArgument::kindIndex);
- else {
- ArrayIndex index = 0;
- for (; current != end && *current >= '0' && *current <= '9'; ++current)
- index = index * 10 + ArrayIndex(*current - '0');
- args_.push_back(index);
- }
- if (current == end || *current++ != ']')
- invalidPath(path, int(current - path.c_str()));
- } else if (*current == '%') {
- addPathInArg(path, in, itInArg, PathArgument::kindKey);
- ++current;
- } else if (*current == '.') {
- ++current;
- } else {
- const char* beginName = current;
- while (current != end && !strchr("[.", *current))
- ++current;
- args_.push_back(JSONCPP_STRING(beginName, current));
- }
- }
-}
-
-void Path::addPathInArg(const JSONCPP_STRING& /*path*/,
- const InArgs& in,
- InArgs::const_iterator& itInArg,
- PathArgument::Kind kind) {
- if (itInArg == in.end()) {
- // Error: missing argument %d
- } else if ((*itInArg)->kind_ != kind) {
- // Error: bad argument type
- } else {
- args_.push_back(**itInArg);
- }
-}
-
-void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/) {
- // Error: invalid path.
-}
-
-const Value& Path::resolve(const Value& root) const {
- const Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
- if (arg.kind_ == PathArgument::kindIndex) {
- if (!node->isArray() || !node->isValidIndex(arg.index_)) {
- // Error: unable to resolve path (array value expected at position...
- }
- node = &((*node)[arg.index_]);
- } else if (arg.kind_ == PathArgument::kindKey) {
- if (!node->isObject()) {
- // Error: unable to resolve path (object value expected at position...)
- }
- node = &((*node)[arg.key_]);
- if (node == &Value::nullRef) {
- // Error: unable to resolve path (object has no member named '' at
- // position...)
- }
- }
- }
- return *node;
-}
-
-Value Path::resolve(const Value& root, const Value& defaultValue) const {
- const Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
- if (arg.kind_ == PathArgument::kindIndex) {
- if (!node->isArray() || !node->isValidIndex(arg.index_))
- return defaultValue;
- node = &((*node)[arg.index_]);
- } else if (arg.kind_ == PathArgument::kindKey) {
- if (!node->isObject())
- return defaultValue;
- node = &((*node)[arg.key_]);
- if (node == &Value::nullRef)
- return defaultValue;
- }
- }
- return *node;
-}
-
-Value& Path::make(Value& root) const {
- Value* node = &root;
- for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
- const PathArgument& arg = *it;
- if (arg.kind_ == PathArgument::kindIndex) {
- if (!node->isArray()) {
- // Error: node is not an array at position ...
- }
- node = &((*node)[arg.index_]);
- } else if (arg.kind_ == PathArgument::kindKey) {
- if (!node->isObject()) {
- // Error: node is not an object at position...
- }
- node = &((*node)[arg.key_]);
- }
- }
- return *node;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_value.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-// //////////////////////////////////////////////////////////////////////
-// Beginning of content of file: src/lib_json/json_writer.cpp
-// //////////////////////////////////////////////////////////////////////
-
-// Copyright 2011 Baptiste Lepilleur
-// Distributed under MIT license, or public domain if desired and
-// recognized in your jurisdiction.
-// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
-
-#if !defined(JSON_IS_AMALGAMATION)
-#include <json/writer.h>
-#include "json_tool.h"
-#endif // if !defined(JSON_IS_AMALGAMATION)
-#include <iomanip>
-#include <memory>
-#include <sstream>
-#include <utility>
-#include <set>
-#include <cassert>
-#include <cstring>
-#include <cstdio>
-
-#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
-#include <float.h>
-#define isfinite _finite
-#elif defined(__sun) && defined(__SVR4) //Solaris
-#if !defined(isfinite)
-#include <ieeefp.h>
-#define isfinite finite
-#endif
-#elif defined(_AIX)
-#if !defined(isfinite)
-#include <math.h>
-#define isfinite finite
-#endif
-#elif defined(__hpux)
-#if !defined(isfinite)
-#if defined(__ia64) && !defined(finite)
-#define isfinite(x) ((sizeof(x) == sizeof(float) ? \
- _Isfinitef(x) : _IsFinite(x)))
-#else
-#include <math.h>
-#define isfinite finite
-#endif
-#endif
-#else
-#include <cmath>
-#if !(defined(__QNXNTO__)) // QNX already defines isfinite
-#define isfinite std::isfinite
-#endif
-#endif
-
-#if defined(_MSC_VER)
-#if !defined(WINCE) && defined(__STDC_SECURE_LIB__) && _MSC_VER >= 1500 // VC++ 9.0 and above
-#define snprintf sprintf_s
-#elif _MSC_VER >= 1900 // VC++ 14.0 and above
-#define snprintf std::snprintf
-#else
-#define snprintf _snprintf
-#endif
-#elif defined(__ANDROID__) || defined(__QNXNTO__)
-#define snprintf snprintf
-#elif __cplusplus >= 201103L
-#if !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define snprintf std::snprintf
-#endif
-#endif
-
-#if defined(__BORLANDC__)
-#include <float.h>
-#define isfinite _finite
-#define snprintf _snprintf
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
-// Disable warning about strdup being deprecated.
-#pragma warning(disable : 4996)
-#endif
-
-namespace Json {
-
-#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
-typedef std::unique_ptr<StreamWriter> StreamWriterPtr;
-#else
-typedef std::auto_ptr<StreamWriter> StreamWriterPtr;
-#endif
-
-static bool containsControlCharacter(const char* str) {
- while (*str) {
- if (isControlCharacter(*(str++)))
- return true;
- }
- return false;
-}
-
-static bool containsControlCharacter0(const char* str, unsigned len) {
- char const* end = str + len;
- while (end != str) {
- if (isControlCharacter(*str) || 0==*str)
- return true;
- ++str;
- }
- return false;
-}
-
-std::string valueToString(LargestInt value) {
- UIntToStringBuffer buffer;
- char* current = buffer + sizeof(buffer);
- if (value == Value::minLargestInt) {
- uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
- *--current = '-';
- } else if (value < 0) {
- uintToString(LargestUInt(-value), current);
- *--current = '-';
- } else {
- uintToString(LargestUInt(value), current);
- }
- assert(current >= buffer);
- return current;
-}
-
-std::string valueToString(LargestUInt value) {
- UIntToStringBuffer buffer;
- char* current = buffer + sizeof(buffer);
- uintToString(value, current);
- assert(current >= buffer);
- return current;
-}
-
-#if defined(JSON_HAS_INT64)
-
-std::string valueToString(Int value) {
- return valueToString(LargestInt(value));
-}
-
-std::string valueToString(UInt value) {
- return valueToString(LargestUInt(value));
-}
-
-#endif // # if defined(JSON_HAS_INT64)
-
-std::string valueToString(double value, bool useSpecialFloats, unsigned int precision) {
- // Allocate a buffer that is more than large enough to store the 16 digits of
- // precision requested below.
- char buffer[32];
- int len = -1;
-
- char formatString[6];
- sprintf(formatString, "%%.%dg", precision);
-
- // Print into the buffer. We need not request the alternative representation
- // that always has a decimal point because JSON doesn't distingish the
- // concepts of reals and integers.
- if (isfinite(value)) {
- len = snprintf(buffer, sizeof(buffer), formatString, value);
- } else {
- // IEEE standard states that NaN values will not compare to themselves
- if (value != value) {
- len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
- } else if (value < 0) {
- len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "-Infinity" : "-1e+9999");
- } else {
- len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "Infinity" : "1e+9999");
- }
- // For those, we do not need to call fixNumLoc, but it is fast.
- }
- assert(len >= 0);
- fixNumericLocale(buffer, buffer + len);
- return buffer;
-}
-
-std::string valueToString(double value) { return valueToString(value, false, 17); }
-
-std::string valueToString(bool value) { return value ? "true" : "false"; }
-
-std::string valueToQuotedString(const char* value) {
- if (value == NULL)
- return "";
- // Not sure how to handle unicode...
- if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL &&
- !containsControlCharacter(value))
- return std::string("\"") + value + "\"";
- // We have to walk value and escape any special characters.
- // Appending to std::string is not efficient, but this should be rare.
- // (Note: forward slashes are *not* rare, but I am not escaping them.)
- std::string::size_type maxsize =
- strlen(value) * 2 + 3; // allescaped+quotes+NULL
- std::string result;
- result.reserve(maxsize); // to avoid lots of mallocs
- result += "\"";
- for (const char* c = value; *c != 0; ++c) {
- switch (*c) {
- case '\"':
- result += "\\\"";
- break;
- case '\\':
- result += "\\\\";
- break;
- case '\b':
- result += "\\b";
- break;
- case '\f':
- result += "\\f";
- break;
- case '\n':
- result += "\\n";
- break;
- case '\r':
- result += "\\r";
- break;
- case '\t':
- result += "\\t";
- break;
- // case '/':
- // Even though \/ is considered a legal escape in JSON, a bare
- // slash is also legal, so I see no reason to escape it.
- // (I hope I am not misunderstanding something.
- // blep notes: actually escaping \/ may be useful in javascript to avoid </
- // sequence.
- // Should add a flag to allow this compatibility mode and prevent this
- // sequence from occurring.
- default:
- if (isControlCharacter(*c)) {
- JSONCPP_OSTRINGSTREAM oss;
- oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
- << std::setw(4) << static_cast<int>(*c);
- result += oss.str();
- } else {
- result += *c;
- }
- break;
- }
- }
- result += "\"";
- return result;
-}
-
-// https://github.com/upcaste/upcaste/blob/master/src/upcore/src/cstring/strnpbrk.cpp
-static char const* strnpbrk(char const* s, char const* accept, size_t n) {
- assert((s || !n) && accept);
-
- char const* const end = s + n;
- for (char const* cur = s; cur < end; ++cur) {
- int const c = *cur;
- for (char const* a = accept; *a; ++a) {
- if (*a == c) {
- return cur;
- }
- }
- }
- return NULL;
-}
-static std::string valueToQuotedStringN(const char* value, unsigned length) {
- if (value == NULL)
- return "";
- // Not sure how to handle unicode...
- if (strnpbrk(value, "\"\\\b\f\n\r\t", length) == NULL &&
- !containsControlCharacter0(value, length))
- return std::string("\"") + value + "\"";
- // We have to walk value and escape any special characters.
- // Appending to std::string is not efficient, but this should be rare.
- // (Note: forward slashes are *not* rare, but I am not escaping them.)
- std::string::size_type maxsize =
- length * 2 + 3; // allescaped+quotes+NULL
- std::string result;
- result.reserve(maxsize); // to avoid lots of mallocs
- result += "\"";
- char const* end = value + length;
- for (const char* c = value; c != end; ++c) {
- switch (*c) {
- case '\"':
- result += "\\\"";
- break;
- case '\\':
- result += "\\\\";
- break;
- case '\b':
- result += "\\b";
- break;
- case '\f':
- result += "\\f";
- break;
- case '\n':
- result += "\\n";
- break;
- case '\r':
- result += "\\r";
- break;
- case '\t':
- result += "\\t";
- break;
- // case '/':
- // Even though \/ is considered a legal escape in JSON, a bare
- // slash is also legal, so I see no reason to escape it.
- // (I hope I am not misunderstanding something.)
- // blep notes: actually escaping \/ may be useful in javascript to avoid </
- // sequence.
- // Should add a flag to allow this compatibility mode and prevent this
- // sequence from occurring.
- default:
- if ((isControlCharacter(*c)) || (*c == 0)) {
- JSONCPP_OSTRINGSTREAM oss;
- oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
- << std::setw(4) << static_cast<int>(*c);
- result += oss.str();
- } else {
- result += *c;
- }
- break;
- }
- }
- result += "\"";
- return result;
-}
-
-// Class Writer
-// //////////////////////////////////////////////////////////////////
-Writer::~Writer() {}
-
-// Class FastWriter
-// //////////////////////////////////////////////////////////////////
-
-FastWriter::FastWriter()
- : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false),
- omitEndingLineFeed_(false) {}
-
-void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
-
-void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
-
-void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; }
-
-std::string FastWriter::write(const Value& root) {
- document_ = "";
- writeValue(root);
- if (!omitEndingLineFeed_)
- document_ += "\n";
- return document_;
-}
-
-void FastWriter::writeValue(const Value& value) {
- switch (value.type()) {
- case nullValue:
- if (!dropNullPlaceholders_)
- document_ += "null";
- break;
- case intValue:
- document_ += valueToString(value.asLargestInt());
- break;
- case uintValue:
- document_ += valueToString(value.asLargestUInt());
- break;
- case realValue:
- document_ += valueToString(value.asDouble());
- break;
- case stringValue:
- {
- // Is NULL possible for value.string_?
- char const* str;
- char const* end;
- bool ok = value.getString(&str, &end);
- if (ok) document_ += valueToQuotedStringN(str, static_cast<unsigned>(end-str));
- break;
- }
- case booleanValue:
- document_ += valueToString(value.asBool());
- break;
- case arrayValue: {
- document_ += '[';
- ArrayIndex size = value.size();
- for (ArrayIndex index = 0; index < size; ++index) {
- if (index > 0)
- document_ += ',';
- writeValue(value[index]);
- }
- document_ += ']';
- } break;
- case objectValue: {
- Value::Members members(value.getMemberNames());
- document_ += '{';
- for (Value::Members::iterator it = members.begin(); it != members.end();
- ++it) {
- const std::string& name = *it;
- if (it != members.begin())
- document_ += ',';
- document_ += valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length()));
- document_ += yamlCompatiblityEnabled_ ? ": " : ":";
- writeValue(value[name]);
- }
- document_ += '}';
- } break;
- }
-}
-
-// Class StyledWriter
-// //////////////////////////////////////////////////////////////////
-
-StyledWriter::StyledWriter()
- : rightMargin_(74), indentSize_(3), addChildValues_() {}
-
-std::string StyledWriter::write(const Value& root) {
- document_ = "";
- addChildValues_ = false;
- indentString_ = "";
- writeCommentBeforeValue(root);
- writeValue(root);
- writeCommentAfterValueOnSameLine(root);
- document_ += "\n";
- return document_;
-}
-
-void StyledWriter::writeValue(const Value& value) {
- switch (value.type()) {
- case nullValue:
- pushValue("null");
- break;
- case intValue:
- pushValue(valueToString(value.asLargestInt()));
- break;
- case uintValue:
- pushValue(valueToString(value.asLargestUInt()));
- break;
- case realValue:
- pushValue(valueToString(value.asDouble()));
- break;
- case stringValue:
- {
- // Is NULL possible for value.string_?
- char const* str;
- char const* end;
- bool ok = value.getString(&str, &end);
- if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
- else pushValue("");
- break;
- }
- case booleanValue:
- pushValue(valueToString(value.asBool()));
- break;
- case arrayValue:
- writeArrayValue(value);
- break;
- case objectValue: {
- Value::Members members(value.getMemberNames());
- if (members.empty())
- pushValue("{}");
- else {
- writeWithIndent("{");
- indent();
- Value::Members::iterator it = members.begin();
- for (;;) {
- const std::string& name = *it;
- const Value& childValue = value[name];
- writeCommentBeforeValue(childValue);
- writeWithIndent(valueToQuotedString(name.c_str()));
- document_ += " : ";
- writeValue(childValue);
- if (++it == members.end()) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- document_ += ',';
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("}");
- }
- } break;
- }
-}
-
-void StyledWriter::writeArrayValue(const Value& value) {
- unsigned size = value.size();
- if (size == 0)
- pushValue("[]");
- else {
- bool isArrayMultiLine = isMultineArray(value);
- if (isArrayMultiLine) {
- writeWithIndent("[");
- indent();
- bool hasChildValue = !childValues_.empty();
- unsigned index = 0;
- for (;;) {
- const Value& childValue = value[index];
- writeCommentBeforeValue(childValue);
- if (hasChildValue)
- writeWithIndent(childValues_[index]);
- else {
- writeIndent();
- writeValue(childValue);
- }
- if (++index == size) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- document_ += ',';
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("]");
- } else // output on a single line
- {
- assert(childValues_.size() == size);
- document_ += "[ ";
- for (unsigned index = 0; index < size; ++index) {
- if (index > 0)
- document_ += ", ";
- document_ += childValues_[index];
- }
- document_ += " ]";
- }
- }
-}
-
-bool StyledWriter::isMultineArray(const Value& value) {
- ArrayIndex const size = value.size();
- bool isMultiLine = size * 3 >= rightMargin_;
- childValues_.clear();
- for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
- const Value& childValue = value[index];
- isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0);
- }
- if (!isMultiLine) // check if line length > max line length
- {
- childValues_.reserve(size);
- addChildValues_ = true;
- ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
- for (ArrayIndex index = 0; index < size; ++index) {
- if (hasCommentForValue(value[index])) {
- isMultiLine = true;
- }
- writeValue(value[index]);
- lineLength += static_cast<ArrayIndex>(childValues_[index].length());
- }
- addChildValues_ = false;
- isMultiLine = isMultiLine || lineLength >= rightMargin_;
- }
- return isMultiLine;
-}
-
-void StyledWriter::pushValue(const std::string& value) {
- if (addChildValues_)
- childValues_.push_back(value);
- else
- document_ += value;
-}
-
-void StyledWriter::writeIndent() {
- if (!document_.empty()) {
- char last = document_[document_.length() - 1];
- if (last == ' ') // already indented
- return;
- if (last != '\n') // Comments may add new-line
- document_ += '\n';
- }
- document_ += indentString_;
-}
-
-void StyledWriter::writeWithIndent(const std::string& value) {
- writeIndent();
- document_ += value;
-}
-
-void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); }
-
-void StyledWriter::unindent() {
- assert(indentString_.size() >= indentSize_);
- indentString_.resize(indentString_.size() - indentSize_);
-}
-
-void StyledWriter::writeCommentBeforeValue(const Value& root) {
- if (!root.hasComment(commentBefore))
- return;
-
- document_ += "\n";
- writeIndent();
- const std::string& comment = root.getComment(commentBefore);
- std::string::const_iterator iter = comment.begin();
- while (iter != comment.end()) {
- document_ += *iter;
- if (*iter == '\n' &&
- (iter != comment.end() && *(iter + 1) == '/'))
- writeIndent();
- ++iter;
- }
-
- // Comments are stripped of trailing newlines, so add one here
- document_ += "\n";
-}
-
-void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
- if (root.hasComment(commentAfterOnSameLine))
- document_ += " " + root.getComment(commentAfterOnSameLine);
-
- if (root.hasComment(commentAfter)) {
- document_ += "\n";
- document_ += root.getComment(commentAfter);
- document_ += "\n";
- }
-}
-
-bool StyledWriter::hasCommentForValue(const Value& value) {
- return value.hasComment(commentBefore) ||
- value.hasComment(commentAfterOnSameLine) ||
- value.hasComment(commentAfter);
-}
-
-// Class StyledStreamWriter
-// //////////////////////////////////////////////////////////////////
-
-StyledStreamWriter::StyledStreamWriter(std::string indentation)
- : document_(NULL), rightMargin_(74), indentation_(indentation),
- addChildValues_() {}
-
-void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root) {
- document_ = &out;
- addChildValues_ = false;
- indentString_ = "";
- indented_ = true;
- writeCommentBeforeValue(root);
- if (!indented_) writeIndent();
- indented_ = true;
- writeValue(root);
- writeCommentAfterValueOnSameLine(root);
- *document_ << "\n";
- document_ = NULL; // Forget the stream, for safety.
-}
-
-void StyledStreamWriter::writeValue(const Value& value) {
- switch (value.type()) {
- case nullValue:
- pushValue("null");
- break;
- case intValue:
- pushValue(valueToString(value.asLargestInt()));
- break;
- case uintValue:
- pushValue(valueToString(value.asLargestUInt()));
- break;
- case realValue:
- pushValue(valueToString(value.asDouble()));
- break;
- case stringValue:
- {
- // Is NULL possible for value.string_?
- char const* str;
- char const* end;
- bool ok = value.getString(&str, &end);
- if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
- else pushValue("");
- break;
- }
- case booleanValue:
- pushValue(valueToString(value.asBool()));
- break;
- case arrayValue:
- writeArrayValue(value);
- break;
- case objectValue: {
- Value::Members members(value.getMemberNames());
- if (members.empty())
- pushValue("{}");
- else {
- writeWithIndent("{");
- indent();
- Value::Members::iterator it = members.begin();
- for (;;) {
- const std::string& name = *it;
- const Value& childValue = value[name];
- writeCommentBeforeValue(childValue);
- writeWithIndent(valueToQuotedString(name.c_str()));
- *document_ << " : ";
- writeValue(childValue);
- if (++it == members.end()) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- *document_ << ",";
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("}");
- }
- } break;
- }
-}
-
-void StyledStreamWriter::writeArrayValue(const Value& value) {
- unsigned size = value.size();
- if (size == 0)
- pushValue("[]");
- else {
- bool isArrayMultiLine = isMultineArray(value);
- if (isArrayMultiLine) {
- writeWithIndent("[");
- indent();
- bool hasChildValue = !childValues_.empty();
- unsigned index = 0;
- for (;;) {
- const Value& childValue = value[index];
- writeCommentBeforeValue(childValue);
- if (hasChildValue)
- writeWithIndent(childValues_[index]);
- else {
- if (!indented_) writeIndent();
- indented_ = true;
- writeValue(childValue);
- indented_ = false;
- }
- if (++index == size) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- *document_ << ",";
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("]");
- } else // output on a single line
- {
- assert(childValues_.size() == size);
- *document_ << "[ ";
- for (unsigned index = 0; index < size; ++index) {
- if (index > 0)
- *document_ << ", ";
- *document_ << childValues_[index];
- }
- *document_ << " ]";
- }
- }
-}
-
-bool StyledStreamWriter::isMultineArray(const Value& value) {
- ArrayIndex const size = value.size();
- bool isMultiLine = size * 3 >= rightMargin_;
- childValues_.clear();
- for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
- const Value& childValue = value[index];
- isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0);
- }
- if (!isMultiLine) // check if line length > max line length
- {
- childValues_.reserve(size);
- addChildValues_ = true;
- ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
- for (ArrayIndex index = 0; index < size; ++index) {
- if (hasCommentForValue(value[index])) {
- isMultiLine = true;
- }
- writeValue(value[index]);
- lineLength += static_cast<ArrayIndex>(childValues_[index].length());
- }
- addChildValues_ = false;
- isMultiLine = isMultiLine || lineLength >= rightMargin_;
- }
- return isMultiLine;
-}
-
-void StyledStreamWriter::pushValue(const std::string& value) {
- if (addChildValues_)
- childValues_.push_back(value);
- else
- *document_ << value;
-}
-
-void StyledStreamWriter::writeIndent() {
- // blep intended this to look at the so-far-written string
- // to determine whether we are already indented, but
- // with a stream we cannot do that. So we rely on some saved state.
- // The caller checks indented_.
- *document_ << '\n' << indentString_;
-}
-
-void StyledStreamWriter::writeWithIndent(const std::string& value) {
- if (!indented_) writeIndent();
- *document_ << value;
- indented_ = false;
-}
-
-void StyledStreamWriter::indent() { indentString_ += indentation_; }
-
-void StyledStreamWriter::unindent() {
- assert(indentString_.size() >= indentation_.size());
- indentString_.resize(indentString_.size() - indentation_.size());
-}
-
-void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
- if (!root.hasComment(commentBefore))
- return;
-
- if (!indented_) writeIndent();
- const std::string& comment = root.getComment(commentBefore);
- std::string::const_iterator iter = comment.begin();
- while (iter != comment.end()) {
- *document_ << *iter;
- if (*iter == '\n' &&
- (iter != comment.end() && *(iter + 1) == '/'))
- // writeIndent(); // would include newline
- *document_ << indentString_;
- ++iter;
- }
- indented_ = false;
-}
-
-void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
- if (root.hasComment(commentAfterOnSameLine))
- *document_ << ' ' << root.getComment(commentAfterOnSameLine);
-
- if (root.hasComment(commentAfter)) {
- writeIndent();
- *document_ << root.getComment(commentAfter);
- }
- indented_ = false;
-}
-
-bool StyledStreamWriter::hasCommentForValue(const Value& value) {
- return value.hasComment(commentBefore) ||
- value.hasComment(commentAfterOnSameLine) ||
- value.hasComment(commentAfter);
-}
-
-//////////////////////////
-// BuiltStyledStreamWriter
-
-/// Scoped enums are not available until C++11.
-struct CommentStyle {
- /// Decide whether to write comments.
- enum Enum {
- None, ///< Drop all comments.
- Most, ///< Recover odd behavior of previous versions (not implemented yet).
- All ///< Keep all comments.
- };
-};
-
-struct BuiltStyledStreamWriter : public StreamWriter
-{
- BuiltStyledStreamWriter(
- std::string const& indentation,
- CommentStyle::Enum cs,
- std::string const& colonSymbol,
- std::string const& nullSymbol,
- std::string const& endingLineFeedSymbol,
- bool useSpecialFloats,
- unsigned int precision);
- int write(Value const& root, JSONCPP_OSTREAM* sout) override;
-private:
- void writeValue(Value const& value);
- void writeArrayValue(Value const& value);
- bool isMultineArray(Value const& value);
- void pushValue(std::string const& value);
- void writeIndent();
- void writeWithIndent(std::string const& value);
- void indent();
- void unindent();
- void writeCommentBeforeValue(Value const& root);
- void writeCommentAfterValueOnSameLine(Value const& root);
- static bool hasCommentForValue(const Value& value);
-
- typedef std::vector<std::string> ChildValues;
-
- ChildValues childValues_;
- std::string indentString_;
- unsigned int rightMargin_;
- std::string indentation_;
- CommentStyle::Enum cs_;
- std::string colonSymbol_;
- std::string nullSymbol_;
- std::string endingLineFeedSymbol_;
- bool addChildValues_ : 1;
- bool indented_ : 1;
- bool useSpecialFloats_ : 1;
- unsigned int precision_;
-};
-BuiltStyledStreamWriter::BuiltStyledStreamWriter(
- std::string const& indentation,
- CommentStyle::Enum cs,
- std::string const& colonSymbol,
- std::string const& nullSymbol,
- std::string const& endingLineFeedSymbol,
- bool useSpecialFloats,
- unsigned int precision)
- : rightMargin_(74)
- , indentation_(indentation)
- , cs_(cs)
- , colonSymbol_(colonSymbol)
- , nullSymbol_(nullSymbol)
- , endingLineFeedSymbol_(endingLineFeedSymbol)
- , addChildValues_(false)
- , indented_(false)
- , useSpecialFloats_(useSpecialFloats)
- , precision_(precision)
-{
-}
-int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout)
-{
- sout_ = sout;
- addChildValues_ = false;
- indented_ = true;
- indentString_ = "";
- writeCommentBeforeValue(root);
- if (!indented_) writeIndent();
- indented_ = true;
- writeValue(root);
- writeCommentAfterValueOnSameLine(root);
- *sout_ << endingLineFeedSymbol_;
- sout_ = NULL;
- return 0;
-}
-void BuiltStyledStreamWriter::writeValue(Value const& value) {
- switch (value.type()) {
- case nullValue:
- pushValue(nullSymbol_);
- break;
- case intValue:
- pushValue(valueToString(value.asLargestInt()));
- break;
- case uintValue:
- pushValue(valueToString(value.asLargestUInt()));
- break;
- case realValue:
- pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_));
- break;
- case stringValue:
- {
- // Is NULL is possible for value.string_?
- char const* str;
- char const* end;
- bool ok = value.getString(&str, &end);
- if (ok) pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end-str)));
- else pushValue("");
- break;
- }
- case booleanValue:
- pushValue(valueToString(value.asBool()));
- break;
- case arrayValue:
- writeArrayValue(value);
- break;
- case objectValue: {
- Value::Members members(value.getMemberNames());
- if (members.empty())
- pushValue("{}");
- else {
- writeWithIndent("{");
- indent();
- Value::Members::iterator it = members.begin();
- for (;;) {
- std::string const& name = *it;
- Value const& childValue = value[name];
- writeCommentBeforeValue(childValue);
- writeWithIndent(valueToQuotedStringN(name.data(), static_cast<unsigned>(name.length())));
- *sout_ << colonSymbol_;
- writeValue(childValue);
- if (++it == members.end()) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- *sout_ << ",";
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("}");
- }
- } break;
- }
-}
-
-void BuiltStyledStreamWriter::writeArrayValue(Value const& value) {
- unsigned size = value.size();
- if (size == 0)
- pushValue("[]");
- else {
- bool isMultiLine = (cs_ == CommentStyle::All) || isMultineArray(value);
- if (isMultiLine) {
- writeWithIndent("[");
- indent();
- bool hasChildValue = !childValues_.empty();
- unsigned index = 0;
- for (;;) {
- Value const& childValue = value[index];
- writeCommentBeforeValue(childValue);
- if (hasChildValue)
- writeWithIndent(childValues_[index]);
- else {
- if (!indented_) writeIndent();
- indented_ = true;
- writeValue(childValue);
- indented_ = false;
- }
- if (++index == size) {
- writeCommentAfterValueOnSameLine(childValue);
- break;
- }
- *sout_ << ",";
- writeCommentAfterValueOnSameLine(childValue);
- }
- unindent();
- writeWithIndent("]");
- } else // output on a single line
- {
- assert(childValues_.size() == size);
- *sout_ << "[";
- if (!indentation_.empty()) *sout_ << " ";
- for (unsigned index = 0; index < size; ++index) {
- if (index > 0)
- *sout_ << ", ";
- *sout_ << childValues_[index];
- }
- if (!indentation_.empty()) *sout_ << " ";
- *sout_ << "]";
- }
- }
-}
-
-bool BuiltStyledStreamWriter::isMultineArray(Value const& value) {
- ArrayIndex const size = value.size();
- bool isMultiLine = size * 3 >= rightMargin_;
- childValues_.clear();
- for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
- Value const& childValue = value[index];
- isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0);
- }
- if (!isMultiLine) // check if line length > max line length
- {
- childValues_.reserve(size);
- addChildValues_ = true;
- ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
- for (ArrayIndex index = 0; index < size; ++index) {
- if (hasCommentForValue(value[index])) {
- isMultiLine = true;
- }
- writeValue(value[index]);
- lineLength += static_cast<ArrayIndex>(childValues_[index].length());
- }
- addChildValues_ = false;
- isMultiLine = isMultiLine || lineLength >= rightMargin_;
- }
- return isMultiLine;
-}
-
-void BuiltStyledStreamWriter::pushValue(std::string const& value) {
- if (addChildValues_)
- childValues_.push_back(value);
- else
- *sout_ << value;
-}
-
-void BuiltStyledStreamWriter::writeIndent() {
- // blep intended this to look at the so-far-written string
- // to determine whether we are already indented, but
- // with a stream we cannot do that. So we rely on some saved state.
- // The caller checks indented_.
-
- if (!indentation_.empty()) {
- // In this case, drop newlines too.
- *sout_ << '\n' << indentString_;
- }
-}
-
-void BuiltStyledStreamWriter::writeWithIndent(std::string const& value) {
- if (!indented_) writeIndent();
- *sout_ << value;
- indented_ = false;
-}
-
-void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; }
-
-void BuiltStyledStreamWriter::unindent() {
- assert(indentString_.size() >= indentation_.size());
- indentString_.resize(indentString_.size() - indentation_.size());
-}
-
-void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
- if (cs_ == CommentStyle::None) return;
- if (!root.hasComment(commentBefore))
- return;
-
- if (!indented_) writeIndent();
- const std::string& comment = root.getComment(commentBefore);
- std::string::const_iterator iter = comment.begin();
- while (iter != comment.end()) {
- *sout_ << *iter;
- if (*iter == '\n' &&
- (iter != comment.end() && *(iter + 1) == '/'))
- // writeIndent(); // would write extra newline
- *sout_ << indentString_;
- ++iter;
- }
- indented_ = false;
-}
-
-void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) {
- if (cs_ == CommentStyle::None) return;
- if (root.hasComment(commentAfterOnSameLine))
- *sout_ << " " + root.getComment(commentAfterOnSameLine);
-
- if (root.hasComment(commentAfter)) {
- writeIndent();
- *sout_ << root.getComment(commentAfter);
- }
-}
-
-// static
-bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) {
- return value.hasComment(commentBefore) ||
- value.hasComment(commentAfterOnSameLine) ||
- value.hasComment(commentAfter);
-}
-
-///////////////
-// StreamWriter
-
-StreamWriter::StreamWriter()
- : sout_(NULL)
-{
-}
-StreamWriter::~StreamWriter()
-{
-}
-StreamWriter::Factory::~Factory()
-{}
-StreamWriterBuilder::StreamWriterBuilder()
-{
- setDefaults(&settings_);
-}
-StreamWriterBuilder::~StreamWriterBuilder()
-{}
-StreamWriter* StreamWriterBuilder::newStreamWriter() const
-{
- std::string indentation = settings_["indentation"].asString();
- std::string cs_str = settings_["commentStyle"].asString();
- bool eyc = settings_["enableYAMLCompatibility"].asBool();
- bool dnp = settings_["dropNullPlaceholders"].asBool();
- bool usf = settings_["useSpecialFloats"].asBool();
- unsigned int pre = settings_["precision"].asUInt();
- CommentStyle::Enum cs = CommentStyle::All;
- if (cs_str == "All") {
- cs = CommentStyle::All;
- } else if (cs_str == "None") {
- cs = CommentStyle::None;
- } else {
- throwRuntimeError("commentStyle must be 'All' or 'None'");
- }
- std::string colonSymbol = " : ";
- if (eyc) {
- colonSymbol = ": ";
- } else if (indentation.empty()) {
- colonSymbol = ":";
- }
- std::string nullSymbol = "null";
- if (dnp) {
- nullSymbol = "";
- }
- if (pre > 17) pre = 17;
- std::string endingLineFeedSymbol = "";
- return new BuiltStyledStreamWriter(
- indentation, cs,
- colonSymbol, nullSymbol, endingLineFeedSymbol, usf, pre);
-}
-static void getValidWriterKeys(std::set<std::string>* valid_keys)
-{
- valid_keys->clear();
- valid_keys->insert("indentation");
- valid_keys->insert("commentStyle");
- valid_keys->insert("enableYAMLCompatibility");
- valid_keys->insert("dropNullPlaceholders");
- valid_keys->insert("useSpecialFloats");
- valid_keys->insert("precision");
-}
-bool StreamWriterBuilder::validate(Json::Value* invalid) const
-{
- Json::Value my_invalid;
- if (!invalid) invalid = &my_invalid; // so we do not need to test for NULL
- Json::Value& inv = *invalid;
- std::set<std::string> valid_keys;
- getValidWriterKeys(&valid_keys);
- Value::Members keys = settings_.getMemberNames();
- size_t n = keys.size();
- for (size_t i = 0; i < n; ++i) {
- std::string const& key = keys[i];
- if (valid_keys.find(key) == valid_keys.end()) {
- inv[key] = settings_[key];
- }
- }
- return 0u == inv.size();
-}
-Value& StreamWriterBuilder::operator[](std::string key)
-{
- return settings_[key];
-}
-// static
-void StreamWriterBuilder::setDefaults(Json::Value* settings)
-{
- //! [StreamWriterBuilderDefaults]
- (*settings)["commentStyle"] = "All";
- (*settings)["indentation"] = "\t";
- (*settings)["enableYAMLCompatibility"] = false;
- (*settings)["dropNullPlaceholders"] = false;
- (*settings)["useSpecialFloats"] = false;
- (*settings)["precision"] = 17;
- //! [StreamWriterBuilderDefaults]
-}
-
-std::string writeString(StreamWriter::Factory const& builder, Value const& root) {
- JSONCPP_OSTRINGSTREAM sout;
- StreamWriterPtr const writer(builder.newStreamWriter());
- writer->write(root, &sout);
- return sout.str();
-}
-
-JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root) {
- StreamWriterBuilder builder;
- StreamWriterPtr const writer(builder.newStreamWriter());
- writer->write(root, &sout);
- return sout;
-}
-
-} // namespace Json
-
-// //////////////////////////////////////////////////////////////////////
-// End of content of file: src/lib_json/json_writer.cpp
-// //////////////////////////////////////////////////////////////////////
-
-
-
-
-