mirror of
https://github.com/open-source-parsers/jsoncpp.git
synced 2025-08-04 10:36:23 -04:00
Compare commits
No commits in common. "master" and "1.9.6" have entirely different histories.
4
.gitignore
vendored
4
.gitignore
vendored
@ -55,7 +55,3 @@ compile_commands.json
|
||||
|
||||
# temps
|
||||
/version
|
||||
|
||||
# Bazel output paths
|
||||
/bazel-*
|
||||
/MODULE.bazel.lock
|
||||
|
||||
2
AUTHORS
2
AUTHORS
@ -16,7 +16,7 @@ Baruch Siach <baruch@tkos.co.il>
|
||||
Ben Boeckel <mathstuf@gmail.com>
|
||||
Benjamin Knecht <bknecht@logitech.com>
|
||||
Bernd Kuhls <bernd.kuhls@t-online.de>
|
||||
Billy Donahue <billy.donahue@gmail.com>
|
||||
Billy Donahue <billydonahue@google.com>
|
||||
Braden McDorman <bmcdorman@gmail.com>
|
||||
Brandon Myers <bmyers1788@gmail.com>
|
||||
Brendan Drew <brendan.drew@daqri.com>
|
||||
|
||||
@ -55,19 +55,18 @@ endif()
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
||||
|
||||
project(jsoncpp
|
||||
# Note: version must be updated in four places when doing a release. This
|
||||
# Note: version must be updated in three places when doing a release. This
|
||||
# annoying process ensures that amalgamate, CMake, and meson all report the
|
||||
# correct version.
|
||||
# 1. ./meson.build
|
||||
# 2. ./include/json/version.h
|
||||
# 3. ./CMakeLists.txt
|
||||
# 4. ./MODULE.bazel
|
||||
# IMPORTANT: also update the PROJECT_SOVERSION!!
|
||||
VERSION 1.9.7 # <major>[.<minor>[.<patch>[.<tweak>]]]
|
||||
VERSION 1.9.6 # <major>[.<minor>[.<patch>[.<tweak>]]]
|
||||
LANGUAGES CXX)
|
||||
|
||||
message(STATUS "JsonCpp Version: ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
|
||||
set(PROJECT_SOVERSION 27)
|
||||
set(PROJECT_SOVERSION 26)
|
||||
|
||||
include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInSourceBuilds.cmake)
|
||||
include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInBuildInstalls.cmake)
|
||||
@ -94,12 +93,6 @@ if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
|
||||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.")
|
||||
endif()
|
||||
|
||||
include(CheckFunctionExists)
|
||||
check_function_exists(memset_s HAVE_MEMSET_S)
|
||||
if(HAVE_MEMSET_S)
|
||||
add_definitions("-DHAVE_MEMSET_S=1")
|
||||
endif()
|
||||
|
||||
if(JSONCPP_USE_SECURE_MEMORY)
|
||||
add_definitions("-DJSONCPP_USE_SECURE_MEMORY=1")
|
||||
endif()
|
||||
|
||||
14
MODULE.bazel
14
MODULE.bazel
@ -1,14 +0,0 @@
|
||||
module(
|
||||
name = "jsoncpp",
|
||||
|
||||
# Note: version must be updated in four places when doing a release. This
|
||||
# annoying process ensures that amalgamate, CMake, and meson all report the
|
||||
# correct version.
|
||||
# 1. /meson.build
|
||||
# 2. /include/json/version.h
|
||||
# 3. /CMakeLists.txt
|
||||
# 4. /MODULE.bazel
|
||||
# IMPORTANT: also update the SOVERSION!!
|
||||
version = "1.9.7",
|
||||
compatibility_level = 1,
|
||||
)
|
||||
@ -9,7 +9,7 @@ import shutil
|
||||
import string
|
||||
import subprocess
|
||||
import sys
|
||||
import html
|
||||
import cgi
|
||||
|
||||
class BuildDesc:
|
||||
def __init__(self, prepend_envs=None, variables=None, build_type=None, generator=None):
|
||||
@ -195,12 +195,12 @@ def generate_html_report(html_report_path, builds):
|
||||
for variable in variables:
|
||||
build_types = sorted(build_types_by_variable[variable])
|
||||
nb_build_type = len(build_types_by_variable[variable])
|
||||
th_vars.append('<th colspan="%d">%s</th>' % (nb_build_type, html.escape(' '.join(variable))))
|
||||
th_vars.append('<th colspan="%d">%s</th>' % (nb_build_type, cgi.escape(' '.join(variable))))
|
||||
for build_type in build_types:
|
||||
th_build_types.append('<th>%s</th>' % html.escape(build_type))
|
||||
th_build_types.append('<th>%s</th>' % cgi.escape(build_type))
|
||||
tr_builds = []
|
||||
for generator in sorted(builds_by_generator):
|
||||
tds = [ '<td>%s</td>\n' % html.escape(generator) ]
|
||||
tds = [ '<td>%s</td>\n' % cgi.escape(generator) ]
|
||||
for variable in variables:
|
||||
build_types = sorted(build_types_by_variable[variable])
|
||||
for build_type in build_types:
|
||||
|
||||
@ -1,33 +0,0 @@
|
||||
cc_binary(
|
||||
name = "readFromStream_ok",
|
||||
srcs = ["readFromStream/readFromStream.cpp"],
|
||||
deps = ["//:jsoncpp"],
|
||||
args = ["$(location :readFromStream/withComment.json)"],
|
||||
data = ["readFromStream/withComment.json"],
|
||||
)
|
||||
|
||||
cc_binary(
|
||||
name = "readFromStream_err",
|
||||
srcs = ["readFromStream/readFromStream.cpp"],
|
||||
deps = ["//:jsoncpp"],
|
||||
args = ["$(location :readFromStream/errorFormat.json)"],
|
||||
data = ["readFromStream/errorFormat.json"],
|
||||
)
|
||||
|
||||
cc_binary(
|
||||
name = "readFromString",
|
||||
srcs = ["readFromString/readFromString.cpp"],
|
||||
deps = ["//:jsoncpp"],
|
||||
)
|
||||
|
||||
cc_binary(
|
||||
name = "streamWrite",
|
||||
srcs = ["streamWrite/streamWrite.cpp"],
|
||||
deps = ["//:jsoncpp"],
|
||||
)
|
||||
|
||||
cc_binary(
|
||||
name = "stringWrite",
|
||||
srcs = ["stringWrite/stringWrite.cpp"],
|
||||
deps = ["//:jsoncpp"],
|
||||
)
|
||||
@ -6,7 +6,6 @@
|
||||
#ifndef JSON_ALLOCATOR_H_INCLUDED
|
||||
#define JSON_ALLOCATOR_H_INCLUDED
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <memory>
|
||||
|
||||
@ -39,16 +38,8 @@ public:
|
||||
* The memory block is filled with zeroes before being released.
|
||||
*/
|
||||
void deallocate(pointer p, size_type n) {
|
||||
// These constructs will not be removed by the compiler during optimization,
|
||||
// unlike memset.
|
||||
#if defined(HAVE_MEMSET_S)
|
||||
// memset_s is used because memset may be optimized away by the compiler
|
||||
memset_s(p, n * sizeof(T), 0, n * sizeof(T));
|
||||
#elif defined(_WIN32)
|
||||
RtlSecureZeroMemory(p, n * sizeof(T));
|
||||
#else
|
||||
std::fill_n(reinterpret_cast<volatile unsigned char*>(p), n, 0);
|
||||
#endif
|
||||
|
||||
// free using "global operator delete"
|
||||
::operator delete(p);
|
||||
}
|
||||
|
||||
@ -127,7 +127,7 @@ using LargestUInt = UInt64;
|
||||
|
||||
template <typename T>
|
||||
using Allocator =
|
||||
typename std::conditional<JSONCPP_USE_SECURE_MEMORY, SecureAllocator<T>,
|
||||
typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
|
||||
std::allocator<T>>::type;
|
||||
using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
|
||||
using IStringStream =
|
||||
|
||||
@ -39,10 +39,6 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if __cplusplus >= 201703L
|
||||
#define JSONCPP_HAS_STRING_VIEW 1
|
||||
#endif
|
||||
|
||||
#include <array>
|
||||
#include <exception>
|
||||
#include <map>
|
||||
@ -50,10 +46,6 @@
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
#include <string_view>
|
||||
#endif
|
||||
|
||||
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
|
||||
// be used by...
|
||||
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
||||
@ -350,9 +342,6 @@ public:
|
||||
*/
|
||||
Value(const StaticString& value);
|
||||
Value(const String& value);
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
Value(std::string_view value);
|
||||
#endif
|
||||
Value(bool value);
|
||||
Value(std::nullptr_t ptr) = delete;
|
||||
Value(const Value& other);
|
||||
@ -386,7 +375,7 @@ public:
|
||||
int compare(const Value& other) const;
|
||||
|
||||
const char* asCString() const; ///< Embedded zeroes could cause you trouble!
|
||||
#if JSONCPP_USE_SECURE_MEMORY
|
||||
#if JSONCPP_USING_SECURE_MEMORY
|
||||
unsigned getCStringLength() const; // Allows you to understand the length of
|
||||
// the CString
|
||||
#endif
|
||||
@ -395,12 +384,6 @@ public:
|
||||
* \return false if !string. (Seg-fault if str or end are NULL.)
|
||||
*/
|
||||
bool getString(char const** begin, char const** end) const;
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
/** Get string_view of string-value.
|
||||
* \return false if !string. (Seg-fault if str is NULL.)
|
||||
*/
|
||||
bool getString(std::string_view* str) const;
|
||||
#endif
|
||||
Int asInt() const;
|
||||
UInt asUInt() const;
|
||||
#if defined(JSON_HAS_INT64)
|
||||
@ -487,15 +470,6 @@ public:
|
||||
bool insert(ArrayIndex index, const Value& newValue);
|
||||
bool insert(ArrayIndex index, Value&& newValue);
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
/// Access an object value by name, create a null member if it does not exist.
|
||||
/// \param key may contain embedded nulls.
|
||||
Value& operator[](std::string_view 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[](std::string_view key) const;
|
||||
#else
|
||||
/// 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.
|
||||
@ -510,7 +484,6 @@ public:
|
||||
/// that name.
|
||||
/// \param key may contain embedded nulls.
|
||||
const Value& operator[](const String& key) const;
|
||||
#endif
|
||||
/** \brief Access an object value by name, create a null member if it does not
|
||||
* exist.
|
||||
*
|
||||
@ -524,24 +497,18 @@ public:
|
||||
* \endcode
|
||||
*/
|
||||
Value& operator[](const StaticString& key);
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
/// Return the member named key if it exist, defaultValue otherwise.
|
||||
/// \note deep copy
|
||||
Value get(std::string_view key, const Value& defaultValue) const;
|
||||
#else
|
||||
/// 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
|
||||
/// \param key may contain embedded nulls.
|
||||
Value get(const String& key, const Value& defaultValue) const;
|
||||
#endif
|
||||
/// 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 String& key, const Value& defaultValue) const;
|
||||
/// 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
|
||||
@ -549,29 +516,6 @@ public:
|
||||
/// Most general and efficient version of isMember()const, get()const,
|
||||
/// and operator[]const
|
||||
Value const* find(const String& key) const;
|
||||
|
||||
/// Calls find and only returns a valid pointer if the type is found
|
||||
template <typename T, bool (T::*TMemFn)() const>
|
||||
Value const* findValue(const String& key) const {
|
||||
Value const* found = find(key);
|
||||
if (!found || !(found->*TMemFn)())
|
||||
return nullptr;
|
||||
return found;
|
||||
}
|
||||
|
||||
Value const* findNull(const String& key) const;
|
||||
Value const* findBool(const String& key) const;
|
||||
Value const* findInt(const String& key) const;
|
||||
Value const* findInt64(const String& key) const;
|
||||
Value const* findUInt(const String& key) const;
|
||||
Value const* findUInt64(const String& key) const;
|
||||
Value const* findIntegral(const String& key) const;
|
||||
Value const* findDouble(const String& key) const;
|
||||
Value const* findNumeric(const String& key) const;
|
||||
Value const* findString(const String& key) const;
|
||||
Value const* findArray(const String& key) const;
|
||||
Value const* findObject(const String& key) 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.
|
||||
@ -581,28 +525,20 @@ public:
|
||||
/// Do nothing if it did not exist.
|
||||
/// \pre type() is objectValue or nullValue
|
||||
/// \post type() is unchanged
|
||||
#if JSONCPP_HAS_STRING_VIEW
|
||||
void removeMember(std::string_view key);
|
||||
#else
|
||||
void removeMember(const char* key);
|
||||
/// Same as removeMember(const char*)
|
||||
/// \param key may contain embedded nulls.
|
||||
void removeMember(const String& key);
|
||||
#endif
|
||||
/// 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)
|
||||
*/
|
||||
#if JSONCPP_HAS_STRING_VIEW
|
||||
bool removeMember(std::string_view key, Value* removed);
|
||||
#else
|
||||
bool removeMember(String const& key, Value* removed);
|
||||
/// Same as removeMember(const char* begin, const char* end, Value* removed),
|
||||
/// but 'key' is null-terminated.
|
||||
bool removeMember(const char* key, Value* removed);
|
||||
#endif
|
||||
/// Same as removeMember(String const& key, Value* removed)
|
||||
bool removeMember(const char* begin, const char* end, Value* removed);
|
||||
/** \brief Remove the indexed array element.
|
||||
@ -613,18 +549,12 @@ public:
|
||||
*/
|
||||
bool removeIndex(ArrayIndex index, Value* removed);
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
/// Return true if the object has a member named key.
|
||||
/// \param key may contain embedded nulls.
|
||||
bool isMember(std::string_view key) const;
|
||||
#else
|
||||
/// 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 String& key) const;
|
||||
#endif
|
||||
/// Same as isMember(String const& key)const
|
||||
bool isMember(const char* begin, const char* end) const;
|
||||
|
||||
|
||||
@ -1,26 +1,25 @@
|
||||
#ifndef JSON_VERSION_H_INCLUDED
|
||||
#define JSON_VERSION_H_INCLUDED
|
||||
|
||||
// Note: version must be updated in four places when doing a release. This
|
||||
// Note: version must be updated in three places when doing a release. This
|
||||
// annoying process ensures that amalgamate, CMake, and meson all report the
|
||||
// correct version.
|
||||
// 1. /meson.build
|
||||
// 2. /include/json/version.h
|
||||
// 3. /CMakeLists.txt
|
||||
// 4. /MODULE.bazel
|
||||
// IMPORTANT: also update the SOVERSION!!
|
||||
|
||||
#define JSONCPP_VERSION_STRING "1.9.7"
|
||||
#define JSONCPP_VERSION_STRING "1.9.6"
|
||||
#define JSONCPP_VERSION_MAJOR 1
|
||||
#define JSONCPP_VERSION_MINOR 9
|
||||
#define JSONCPP_VERSION_PATCH 7
|
||||
#define JSONCPP_VERSION_PATCH 6
|
||||
#define JSONCPP_VERSION_QUALIFIER
|
||||
#define JSONCPP_VERSION_HEXA \
|
||||
((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | \
|
||||
(JSONCPP_VERSION_PATCH << 8))
|
||||
|
||||
#if !defined(JSONCPP_USE_SECURE_MEMORY)
|
||||
#define JSONCPP_USE_SECURE_MEMORY 0
|
||||
#define JSONCPP_USING_SECURE_MEMORY 0
|
||||
#endif
|
||||
// If non-zero, the library zeroes any memory that it has allocated before
|
||||
// it frees its memory.
|
||||
|
||||
@ -4,3 +4,5 @@
|
||||
@MESON_STATIC_TARGET@
|
||||
|
||||
include ( "${CMAKE_CURRENT_LIST_DIR}/jsoncpp-namespaced-targets.cmake" )
|
||||
|
||||
check_required_components(JsonCpp)
|
||||
|
||||
@ -2,15 +2,14 @@ project(
|
||||
'jsoncpp',
|
||||
'cpp',
|
||||
|
||||
# Note: version must be updated in four places when doing a release. This
|
||||
# Note: version must be updated in three places when doing a release. This
|
||||
# annoying process ensures that amalgamate, CMake, and meson all report the
|
||||
# correct version.
|
||||
# 1. /meson.build
|
||||
# 2. /include/json/version.h
|
||||
# 3. /CMakeLists.txt
|
||||
# 4. /MODULE.bazel
|
||||
# IMPORTANT: also update the SOVERSION!!
|
||||
version : '1.9.7',
|
||||
version : '1.9.6',
|
||||
default_options : [
|
||||
'buildtype=release',
|
||||
'cpp_std=c++11',
|
||||
@ -51,7 +50,7 @@ jsoncpp_lib = library(
|
||||
'src/lib_json/json_value.cpp',
|
||||
'src/lib_json/json_writer.cpp',
|
||||
]),
|
||||
soversion : 27,
|
||||
soversion : 26,
|
||||
install : true,
|
||||
include_directories : jsoncpp_include_directories,
|
||||
cpp_args: dll_export_flag)
|
||||
|
||||
@ -143,7 +143,7 @@ if(BUILD_STATIC_LIBS)
|
||||
|
||||
# avoid name clashes on windows as the shared import lib is also named jsoncpp.lib
|
||||
if(NOT DEFINED STATIC_SUFFIX AND BUILD_SHARED_LIBS)
|
||||
if (MSVC OR ("${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC"))
|
||||
if (WIN32)
|
||||
set(STATIC_SUFFIX "_static")
|
||||
else()
|
||||
set(STATIC_SUFFIX "")
|
||||
|
||||
@ -23,6 +23,13 @@
|
||||
#include <utility>
|
||||
|
||||
#include <cstdio>
|
||||
#if __cplusplus >= 201103L
|
||||
|
||||
#if !defined(sscanf)
|
||||
#define sscanf std::sscanf
|
||||
#endif
|
||||
|
||||
#endif //__cplusplus
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
|
||||
@ -46,7 +53,11 @@ static size_t const stackLimit_g =
|
||||
|
||||
namespace Json {
|
||||
|
||||
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
|
||||
using CharReaderPtr = std::unique_ptr<CharReader>;
|
||||
#else
|
||||
using CharReaderPtr = std::auto_ptr<CharReader>;
|
||||
#endif
|
||||
|
||||
// Implementation of class Features
|
||||
// ////////////////////////////////
|
||||
|
||||
@ -17,10 +17,6 @@
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
#include <string_view>
|
||||
#endif
|
||||
|
||||
// Provide implementation equivalent of std::snprintf for older _MSC compilers
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||
#include <stdarg.h>
|
||||
@ -91,8 +87,7 @@ 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) &&
|
||||
!(static_cast<U>(d) == min && d != static_cast<double>(min));
|
||||
return d >= static_cast<double>(min) && d <= static_cast<double>(max);
|
||||
}
|
||||
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
|
||||
static inline double integerToDouble(Json::UInt64 value) {
|
||||
@ -106,8 +101,7 @@ template <typename T> static inline double integerToDouble(T value) {
|
||||
|
||||
template <typename T, typename U>
|
||||
static inline bool InRange(double d, T min, U max) {
|
||||
return d >= integerToDouble(min) && d <= integerToDouble(max) &&
|
||||
!(static_cast<U>(d) == min && d != integerToDouble(min));
|
||||
return d >= integerToDouble(min) && d <= integerToDouble(max);
|
||||
}
|
||||
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
|
||||
|
||||
@ -169,7 +163,7 @@ inline static void decodePrefixedString(bool isPrefixed, char const* prefixed,
|
||||
/** Free the string duplicated by
|
||||
* duplicateStringValue()/duplicateAndPrefixStringValue().
|
||||
*/
|
||||
#if JSONCPP_USE_SECURE_MEMORY
|
||||
#if JSONCPP_USING_SECURE_MEMORY
|
||||
static inline void releasePrefixedStringValue(char* value) {
|
||||
unsigned length = 0;
|
||||
char const* valueDecoded;
|
||||
@ -184,10 +178,10 @@ static inline void releaseStringValue(char* value, unsigned length) {
|
||||
memset(value, 0, size);
|
||||
free(value);
|
||||
}
|
||||
#else // !JSONCPP_USE_SECURE_MEMORY
|
||||
#else // !JSONCPP_USING_SECURE_MEMORY
|
||||
static inline void releasePrefixedStringValue(char* value) { free(value); }
|
||||
static inline void releaseStringValue(char* value, unsigned) { free(value); }
|
||||
#endif // JSONCPP_USE_SECURE_MEMORY
|
||||
#endif // JSONCPP_USING_SECURE_MEMORY
|
||||
|
||||
} // namespace Json
|
||||
|
||||
@ -424,14 +418,6 @@ Value::Value(const String& value) {
|
||||
value.data(), static_cast<unsigned>(value.length()));
|
||||
}
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
Value::Value(std::string_view value) {
|
||||
initBasic(stringValue, true);
|
||||
value_.string_ = duplicateAndPrefixStringValue(
|
||||
value.data(), static_cast<unsigned>(value.length()));
|
||||
}
|
||||
#endif
|
||||
|
||||
Value::Value(const StaticString& value) {
|
||||
initBasic(stringValue);
|
||||
value_.string_ = const_cast<char*>(value.c_str());
|
||||
@ -613,7 +599,7 @@ const char* Value::asCString() const {
|
||||
return this_str;
|
||||
}
|
||||
|
||||
#if JSONCPP_USE_SECURE_MEMORY
|
||||
#if JSONCPP_USING_SECURE_MEMORY
|
||||
unsigned Value::getCStringLength() const {
|
||||
JSON_ASSERT_MESSAGE(type() == stringValue,
|
||||
"in Json::Value::asCString(): requires stringValue");
|
||||
@ -639,21 +625,6 @@ bool Value::getString(char const** begin, char const** end) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
bool Value::getString(std::string_view* str) const {
|
||||
if (type() != stringValue)
|
||||
return false;
|
||||
if (value_.string_ == nullptr)
|
||||
return false;
|
||||
const char* begin;
|
||||
unsigned length;
|
||||
decodePrefixedString(this->isAllocated(), this->value_.string_, &length,
|
||||
&begin);
|
||||
*str = std::string_view(begin, length);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
String Value::asString() const {
|
||||
switch (type()) {
|
||||
case nullValue:
|
||||
@ -711,7 +682,7 @@ Value::UInt Value::asUInt() const {
|
||||
JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
|
||||
return UInt(value_.uint_);
|
||||
case realValue:
|
||||
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0u, maxUInt),
|
||||
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
|
||||
"double out of UInt range");
|
||||
return UInt(value_.real_);
|
||||
case nullValue:
|
||||
@ -734,11 +705,6 @@ Value::Int64 Value::asInt64() const {
|
||||
JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
|
||||
return Int64(value_.uint_);
|
||||
case realValue:
|
||||
// If the double value is in proximity to minInt64, it will be rounded to
|
||||
// minInt64. The correct value in this scenario is indeterminable
|
||||
JSON_ASSERT_MESSAGE(
|
||||
value_.real_ != minInt64,
|
||||
"Double value is minInt64, precise value cannot be determined");
|
||||
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
|
||||
"double out of Int64 range");
|
||||
return Int64(value_.real_);
|
||||
@ -760,7 +726,7 @@ Value::UInt64 Value::asUInt64() const {
|
||||
case uintValue:
|
||||
return UInt64(value_.uint_);
|
||||
case realValue:
|
||||
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0u, maxUInt64),
|
||||
JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
|
||||
"double out of UInt64 range");
|
||||
return UInt64(value_.real_);
|
||||
case nullValue:
|
||||
@ -871,7 +837,7 @@ bool Value::isConvertibleTo(ValueType other) const {
|
||||
type() == booleanValue || type() == nullValue;
|
||||
case uintValue:
|
||||
return isUInt() ||
|
||||
(type() == realValue && InRange(value_.real_, 0u, maxUInt)) ||
|
||||
(type() == realValue && InRange(value_.real_, 0, maxUInt)) ||
|
||||
type() == booleanValue || type() == nullValue;
|
||||
case realValue:
|
||||
return isNumeric() || type() == booleanValue || type() == nullValue;
|
||||
@ -1129,61 +1095,12 @@ Value const* Value::find(char const* begin, char const* end) const {
|
||||
Value const* Value::find(const String& key) const {
|
||||
return find(key.data(), key.data() + key.length());
|
||||
}
|
||||
|
||||
Value const* Value::findNull(const String& key) const {
|
||||
return findValue<Value, &Value::isNull>(key);
|
||||
}
|
||||
Value const* Value::findBool(const String& key) const {
|
||||
return findValue<Value, &Value::isBool>(key);
|
||||
}
|
||||
Value const* Value::findInt(const String& key) const {
|
||||
return findValue<Value, &Value::isInt>(key);
|
||||
}
|
||||
Value const* Value::findInt64(const String& key) const {
|
||||
return findValue<Value, &Value::isInt64>(key);
|
||||
}
|
||||
Value const* Value::findUInt(const String& key) const {
|
||||
return findValue<Value, &Value::isUInt>(key);
|
||||
}
|
||||
Value const* Value::findUInt64(const String& key) const {
|
||||
return findValue<Value, &Value::isUInt64>(key);
|
||||
}
|
||||
Value const* Value::findIntegral(const String& key) const {
|
||||
return findValue<Value, &Value::isIntegral>(key);
|
||||
}
|
||||
Value const* Value::findDouble(const String& key) const {
|
||||
return findValue<Value, &Value::isDouble>(key);
|
||||
}
|
||||
Value const* Value::findNumeric(const String& key) const {
|
||||
return findValue<Value, &Value::isNumeric>(key);
|
||||
}
|
||||
Value const* Value::findString(const String& key) const {
|
||||
return findValue<Value, &Value::isString>(key);
|
||||
}
|
||||
Value const* Value::findArray(const String& key) const {
|
||||
return findValue<Value, &Value::isArray>(key);
|
||||
}
|
||||
Value const* Value::findObject(const String& key) const {
|
||||
return findValue<Value, &Value::isObject>(key);
|
||||
}
|
||||
|
||||
Value* Value::demand(char const* begin, char const* end) {
|
||||
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
|
||||
"in Json::Value::demand(begin, end): requires "
|
||||
"objectValue or nullValue");
|
||||
return &resolveReference(begin, end);
|
||||
}
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
const Value& Value::operator[](std::string_view key) const {
|
||||
Value const* found = find(key.data(), key.data() + key.length());
|
||||
if (!found)
|
||||
return nullSingleton();
|
||||
return *found;
|
||||
}
|
||||
Value& Value::operator[](std::string_view key) {
|
||||
return resolveReference(key.data(), key.data() + key.length());
|
||||
}
|
||||
#else
|
||||
const Value& Value::operator[](const char* key) const {
|
||||
Value const* found = find(key, key + strlen(key));
|
||||
if (!found)
|
||||
@ -1204,7 +1121,6 @@ Value& Value::operator[](const char* key) {
|
||||
Value& Value::operator[](const String& key) {
|
||||
return resolveReference(key.data(), key.data() + key.length());
|
||||
}
|
||||
#endif
|
||||
|
||||
Value& Value::operator[](const StaticString& key) {
|
||||
return resolveReference(key.c_str());
|
||||
@ -1244,18 +1160,12 @@ Value Value::get(char const* begin, char const* end,
|
||||
Value const* found = find(begin, end);
|
||||
return !found ? defaultValue : *found;
|
||||
}
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
Value Value::get(std::string_view key, const Value& defaultValue) const {
|
||||
return get(key.data(), key.data() + key.length(), defaultValue);
|
||||
}
|
||||
#else
|
||||
Value Value::get(char const* key, Value const& defaultValue) const {
|
||||
return get(key, key + strlen(key), defaultValue);
|
||||
}
|
||||
Value Value::get(String const& key, Value const& defaultValue) const {
|
||||
return get(key.data(), key.data() + key.length(), defaultValue);
|
||||
}
|
||||
#endif
|
||||
|
||||
bool Value::removeMember(const char* begin, const char* end, Value* removed) {
|
||||
if (type() != objectValue) {
|
||||
@ -1271,31 +1181,12 @@ bool Value::removeMember(const char* begin, const char* end, Value* removed) {
|
||||
value_.map_->erase(it);
|
||||
return true;
|
||||
}
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
bool Value::removeMember(std::string_view key, Value* removed) {
|
||||
return removeMember(key.data(), key.data() + key.length(), removed);
|
||||
}
|
||||
#else
|
||||
bool Value::removeMember(const char* key, Value* removed) {
|
||||
return removeMember(key, key + strlen(key), removed);
|
||||
}
|
||||
bool Value::removeMember(String const& key, Value* removed) {
|
||||
return removeMember(key.data(), key.data() + key.length(), removed);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
void Value::removeMember(std::string_view key) {
|
||||
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
|
||||
"in Json::Value::removeMember(): requires objectValue");
|
||||
if (type() == nullValue)
|
||||
return;
|
||||
|
||||
CZString actualKey(key.data(), unsigned(key.length()),
|
||||
CZString::noDuplication);
|
||||
value_.map_->erase(actualKey);
|
||||
}
|
||||
#else
|
||||
void Value::removeMember(const char* key) {
|
||||
JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue,
|
||||
"in Json::Value::removeMember(): requires objectValue");
|
||||
@ -1306,7 +1197,6 @@ void Value::removeMember(const char* key) {
|
||||
value_.map_->erase(actualKey);
|
||||
}
|
||||
void Value::removeMember(const String& key) { removeMember(key.c_str()); }
|
||||
#endif
|
||||
|
||||
bool Value::removeIndex(ArrayIndex index, Value* removed) {
|
||||
if (type() != arrayValue) {
|
||||
@ -1336,18 +1226,12 @@ bool Value::isMember(char const* begin, char const* end) const {
|
||||
Value const* value = find(begin, end);
|
||||
return nullptr != value;
|
||||
}
|
||||
#ifdef JSONCPP_HAS_STRING_VIEW
|
||||
bool Value::isMember(std::string_view key) const {
|
||||
return isMember(key.data(), key.data() + key.length());
|
||||
}
|
||||
#else
|
||||
bool Value::isMember(char const* key) const {
|
||||
return isMember(key, key + strlen(key));
|
||||
}
|
||||
bool Value::isMember(String const& key) const {
|
||||
return isMember(key.data(), key.data() + key.length());
|
||||
}
|
||||
#endif
|
||||
|
||||
Value::Members Value::getMemberNames() const {
|
||||
JSON_ASSERT_MESSAGE(
|
||||
@ -1427,12 +1311,8 @@ bool Value::isInt64() const {
|
||||
// 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.
|
||||
// minInt64 is -2^63 which can be represented as a double, but since double
|
||||
// values in its proximity are also rounded to -2^63, we require the value
|
||||
// to be strictly greater than the limit to avoid returning 'true' for
|
||||
// values that are not in the range
|
||||
return value_.real_ > double(minInt64) && value_.real_ < double(maxInt64) &&
|
||||
IsIntegral(value_.real_);
|
||||
return value_.real_ >= double(minInt64) &&
|
||||
value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -1470,11 +1350,7 @@ bool Value::isIntegral() const {
|
||||
// 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.
|
||||
// minInt64 is -2^63 which can be represented as a double, but since double
|
||||
// values in its proximity are also rounded to -2^63, we require the value
|
||||
// to be strictly greater than the limit to avoid returning 'true' for
|
||||
// values that are not in the range
|
||||
return value_.real_ > double(minInt64) &&
|
||||
return value_.real_ >= double(minInt64) &&
|
||||
value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
|
||||
#else
|
||||
return value_.real_ >= minInt && value_.real_ <= maxUInt &&
|
||||
|
||||
@ -10,8 +10,6 @@
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cctype>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <memory>
|
||||
@ -19,6 +17,67 @@
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
|
||||
#if __cplusplus >= 201103L
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
|
||||
#if !defined(isnan)
|
||||
#define isnan std::isnan
|
||||
#endif
|
||||
|
||||
#if !defined(isfinite)
|
||||
#define isfinite std::isfinite
|
||||
#endif
|
||||
|
||||
#else
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#if !defined(isnan)
|
||||
#include <float.h>
|
||||
#define isnan _isnan
|
||||
#endif
|
||||
|
||||
#if !defined(isfinite)
|
||||
#include <float.h>
|
||||
#define isfinite _finite
|
||||
#endif
|
||||
|
||||
#if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
|
||||
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
|
||||
#endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
|
||||
|
||||
#endif //_MSC_VER
|
||||
|
||||
#if defined(__sun) && defined(__SVR4) // Solaris
|
||||
#if !defined(isfinite)
|
||||
#include <ieeefp.h>
|
||||
#define isfinite finite
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__hpux)
|
||||
#if !defined(isfinite)
|
||||
#if defined(__ia64) && !defined(finite)
|
||||
#define isfinite(x) \
|
||||
((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x)))
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(isnan)
|
||||
// IEEE standard states that NaN values will not compare to themselves
|
||||
#define isnan(x) ((x) != (x))
|
||||
#endif
|
||||
|
||||
#if !defined(__APPLE__)
|
||||
#if !defined(isfinite)
|
||||
#define isfinite finite
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
// Disable warning about strdup being deprecated.
|
||||
#pragma warning(disable : 4996)
|
||||
@ -26,7 +85,11 @@
|
||||
|
||||
namespace Json {
|
||||
|
||||
#if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520)
|
||||
using StreamWriterPtr = std::unique_ptr<StreamWriter>;
|
||||
#else
|
||||
using StreamWriterPtr = std::auto_ptr<StreamWriter>;
|
||||
#endif
|
||||
|
||||
String valueToString(LargestInt value) {
|
||||
UIntToStringBuffer buffer;
|
||||
@ -66,12 +129,12 @@ String valueToString(double value, bool useSpecialFloats,
|
||||
// Print into the buffer. We need not request the alternative representation
|
||||
// that always has a decimal point because JSON doesn't distinguish the
|
||||
// concepts of reals and integers.
|
||||
if (!std::isfinite(value)) {
|
||||
if (std::isnan(value))
|
||||
return useSpecialFloats ? "NaN" : "null";
|
||||
if (value < 0)
|
||||
return useSpecialFloats ? "-Infinity" : "-1e+9999";
|
||||
return useSpecialFloats ? "Infinity" : "1e+9999";
|
||||
if (!isfinite(value)) {
|
||||
static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"},
|
||||
{"null", "-1e+9999", "1e+9999"}};
|
||||
return reps[useSpecialFloats ? 0 : 1][isnan(value) ? 0
|
||||
: (value < 0) ? 1
|
||||
: 2];
|
||||
}
|
||||
|
||||
String buffer(size_t(36), '\0');
|
||||
|
||||
@ -410,7 +410,7 @@ Json::String ToJsonString(const char* toConvert) {
|
||||
|
||||
Json::String ToJsonString(Json::String in) { return in; }
|
||||
|
||||
#if JSONCPP_USE_SECURE_MEMORY
|
||||
#if JSONCPP_USING_SECURE_MEMORY
|
||||
Json::String ToJsonString(std::string in) {
|
||||
return Json::String(in.data(), in.data() + in.length());
|
||||
}
|
||||
|
||||
@ -185,7 +185,7 @@ TestResult& checkEqual(TestResult& result, T expected, U actual,
|
||||
|
||||
Json::String ToJsonString(const char* toConvert);
|
||||
Json::String ToJsonString(Json::String in);
|
||||
#if JSONCPP_USE_SECURE_MEMORY
|
||||
#if JSONCPP_USING_SECURE_MEMORY
|
||||
Json::String ToJsonString(std::string in);
|
||||
#endif
|
||||
|
||||
|
||||
@ -76,8 +76,6 @@ struct ValueTest : JsonTest::TestCase {
|
||||
Json::Value float_{0.00390625f};
|
||||
Json::Value array1_;
|
||||
Json::Value object1_;
|
||||
Json::Value object2_;
|
||||
Json::Value object3_;
|
||||
Json::Value emptyString_{""};
|
||||
Json::Value string1_{"a"};
|
||||
Json::Value string_{"sometext with space"};
|
||||
@ -87,34 +85,6 @@ struct ValueTest : JsonTest::TestCase {
|
||||
ValueTest() {
|
||||
array1_.append(1234);
|
||||
object1_["id"] = 1234;
|
||||
|
||||
// object2 with matching values
|
||||
object2_["null"] = Json::nullValue;
|
||||
object2_["bool"] = true;
|
||||
object2_["int"] = Json::Int{Json::Value::maxInt};
|
||||
object2_["int64"] = Json::Int64{Json::Value::maxInt64};
|
||||
object2_["uint"] = Json::UInt{Json::Value::maxUInt};
|
||||
object2_["uint64"] = Json::UInt64{Json::Value::maxUInt64};
|
||||
object2_["integral"] = 1234;
|
||||
object2_["double"] = 1234.56789;
|
||||
object2_["numeric"] = 0.12345f;
|
||||
object2_["string"] = "string";
|
||||
object2_["array"] = Json::arrayValue;
|
||||
object2_["object"] = Json::objectValue;
|
||||
|
||||
// object3 with not matching values
|
||||
object3_["object"] = Json::nullValue;
|
||||
object3_["null"] = true;
|
||||
object3_["bool"] = Json::Int{Json::Value::maxInt};
|
||||
object3_["int"] = "not_an_int";
|
||||
object3_["int64"] = "not_an_int64";
|
||||
object3_["uint"] = "not_an_uint";
|
||||
object3_["uin64"] = "not_an_uint64";
|
||||
object3_["integral"] = 1234.56789;
|
||||
object3_["double"] = false;
|
||||
object3_["numeric"] = "string";
|
||||
object3_["string"] = Json::arrayValue;
|
||||
object3_["array"] = Json::objectValue;
|
||||
}
|
||||
|
||||
struct IsCheck {
|
||||
@ -264,62 +234,6 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, objects) {
|
||||
const Json::Value* stringFoundUnknownId = object1_.find(stringUnknownIdKey);
|
||||
JSONTEST_ASSERT_EQUAL(nullptr, stringFoundUnknownId);
|
||||
|
||||
// Access through find<Type>()
|
||||
const Json::Value* nullFound = object2_.findNull("null");
|
||||
JSONTEST_ASSERT(nullFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::nullValue, *nullFound);
|
||||
JSONTEST_ASSERT(object3_.findNull("null") == nullptr);
|
||||
|
||||
const Json::Value* boolFound = object2_.findBool("bool");
|
||||
JSONTEST_ASSERT(boolFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(true, *boolFound);
|
||||
JSONTEST_ASSERT(object3_.findBool("bool") == nullptr);
|
||||
|
||||
const Json::Value* intFound = object2_.findInt("int");
|
||||
JSONTEST_ASSERT(intFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::Int{Json::Value::maxInt}, *intFound);
|
||||
JSONTEST_ASSERT(object3_.findInt("int") == nullptr);
|
||||
|
||||
const Json::Value* int64Found = object2_.findInt64("int64");
|
||||
JSONTEST_ASSERT(int64Found != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::Int64{Json::Value::maxInt64}, *int64Found);
|
||||
JSONTEST_ASSERT(object3_.findInt64("int64") == nullptr);
|
||||
|
||||
const Json::Value* uintFound = object2_.findUInt("uint");
|
||||
JSONTEST_ASSERT(uintFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::UInt{Json::Value::maxUInt}, *uintFound);
|
||||
JSONTEST_ASSERT(object3_.findUInt("uint") == nullptr);
|
||||
|
||||
const Json::Value* uint64Found = object2_.findUInt64("uint64");
|
||||
JSONTEST_ASSERT(uint64Found != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::UInt64{Json::Value::maxUInt64}, *uint64Found);
|
||||
JSONTEST_ASSERT(object3_.findUInt64("uint64") == nullptr);
|
||||
|
||||
const Json::Value* integralFound = object2_.findIntegral("integral");
|
||||
JSONTEST_ASSERT(integralFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(1234, *integralFound);
|
||||
JSONTEST_ASSERT(object3_.findIntegral("integral") == nullptr);
|
||||
|
||||
const Json::Value* doubleFound = object2_.findDouble("double");
|
||||
JSONTEST_ASSERT(doubleFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(1234.56789, *doubleFound);
|
||||
JSONTEST_ASSERT(object3_.findDouble("double") == nullptr);
|
||||
|
||||
const Json::Value* numericFound = object2_.findNumeric("numeric");
|
||||
JSONTEST_ASSERT(numericFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(0.12345f, *numericFound);
|
||||
JSONTEST_ASSERT(object3_.findNumeric("numeric") == nullptr);
|
||||
|
||||
const Json::Value* stringFound = object2_.findString("string");
|
||||
JSONTEST_ASSERT(stringFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(std::string{"string"}, *stringFound);
|
||||
JSONTEST_ASSERT(object3_.findString("string") == nullptr);
|
||||
|
||||
const Json::Value* arrayFound = object2_.findArray("array");
|
||||
JSONTEST_ASSERT(arrayFound != nullptr);
|
||||
JSONTEST_ASSERT_EQUAL(Json::arrayValue, *arrayFound);
|
||||
JSONTEST_ASSERT(object3_.findArray("array") == nullptr);
|
||||
|
||||
// Access through demand()
|
||||
const char yetAnotherIdKey[] = "yet another id";
|
||||
const Json::Value* foundYetAnotherId =
|
||||
@ -1277,13 +1191,15 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
|
||||
JSONTEST_ASSERT_EQUAL(true, val.asBool());
|
||||
JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
|
||||
|
||||
// int64 min (floating point constructor). Since double values in proximity of
|
||||
// kint64min are rounded to kint64min, we don't check for conversion to int64.
|
||||
// int64 min (floating point constructor). Note that kint64min *is* exactly
|
||||
// representable as a double.
|
||||
val = Json::Value(double(kint64min));
|
||||
|
||||
JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
|
||||
|
||||
checks = IsCheck();
|
||||
checks.isInt64_ = true;
|
||||
checks.isIntegral_ = true;
|
||||
checks.isDouble_ = true;
|
||||
checks.isNumeric_ = true;
|
||||
JSONTEST_ASSERT_PRED(checkIs(val, checks));
|
||||
@ -1292,6 +1208,8 @@ JSONTEST_FIXTURE_LOCAL(ValueTest, integers) {
|
||||
JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
|
||||
JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
|
||||
|
||||
JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
|
||||
JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
|
||||
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asDouble());
|
||||
JSONTEST_ASSERT_EQUAL(-9223372036854775808.0, val.asFloat());
|
||||
JSONTEST_ASSERT_EQUAL(true, val.asBool());
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user