Ran clang-format over all .h and .cpp files.
clang-format -i $(find . -name '*.h' -or -name '*.cpp')
diff --git a/include/json/assertions.h b/include/json/assertions.h
index 9c17461..425253a 100644
--- a/include/json/assertions.h
+++ b/include/json/assertions.h
@@ -4,29 +4,38 @@
// 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
+#define CPPTL_JSON_ASSERTIONS_H_INCLUDED
#include <stdlib.h>
#if !defined(JSON_IS_AMALGAMATION)
-# include <json/config.h>
+#include <json/config.h>
#endif // if !defined(JSON_IS_AMALGAMATION)
#if JSON_USE_EXCEPTION
-# include <stdexcept>
-#define JSON_ASSERT( condition ) assert( condition ); // @todo <= change this into an exception throw
-#define JSON_FAIL_MESSAGE( message ) throw std::runtime_error( message );
-#else // JSON_USE_EXCEPTION
-#define JSON_ASSERT( condition ) assert( condition );
+#include <stdexcept>
+#define JSON_ASSERT(condition) \
+ assert(condition); // @todo <= change this into an exception throw
+#define JSON_FAIL_MESSAGE(message) throw std::runtime_error(message);
+#else // JSON_USE_EXCEPTION
+#define JSON_ASSERT(condition) assert(condition);
// The call to assert() will show the failure message in debug builds. In
// release bugs we write to invalid memory in order to crash hard, so that a
// debugger or crash reporter gets the chance to take over. We still call exit()
// afterward in order to tell the compiler that this macro doesn't return.
-#define JSON_FAIL_MESSAGE( message ) { assert(false && message); strcpy(reinterpret_cast<char*>(666), message); exit(123); }
+#define JSON_FAIL_MESSAGE(message) \
+ { \
+ assert(false &&message); \
+ strcpy(reinterpret_cast<char *>(666), message); \
+ exit(123); \
+ }
#endif
-#define JSON_ASSERT_MESSAGE( condition, message ) if (!( condition )) { JSON_FAIL_MESSAGE( message ) }
+#define JSON_ASSERT_MESSAGE(condition, message) \
+ if (!(condition)) { \
+ JSON_FAIL_MESSAGE(message) \
+ }
#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
diff --git a/include/json/autolink.h b/include/json/autolink.h
index 02328d1..6fcc8af 100644
--- a/include/json/autolink.h
+++ b/include/json/autolink.h
@@ -4,21 +4,22 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_AUTOLINK_H_INCLUDED
-# define JSON_AUTOLINK_H_INCLUDED
+#define JSON_AUTOLINK_H_INCLUDED
-# include "config.h"
+#include "config.h"
-# ifdef JSON_IN_CPPTL
-# include <cpptl/cpptl_autolink.h>
-# endif
+#ifdef JSON_IN_CPPTL
+#include <cpptl/cpptl_autolink.h>
+#endif
-# if !defined(JSON_NO_AUTOLINK) && !defined(JSON_DLL_BUILD) && !defined(JSON_IN_CPPTL)
-# define CPPTL_AUTOLINK_NAME "json"
-# undef CPPTL_AUTOLINK_DLL
-# ifdef JSON_DLL
-# define CPPTL_AUTOLINK_DLL
-# endif
-# include "autolink.h"
-# endif
+#if !defined(JSON_NO_AUTOLINK) && !defined(JSON_DLL_BUILD) && \
+ !defined(JSON_IN_CPPTL)
+#define CPPTL_AUTOLINK_NAME "json"
+#undef CPPTL_AUTOLINK_DLL
+#ifdef JSON_DLL
+#define CPPTL_AUTOLINK_DLL
+#endif
+#include "autolink.h"
+#endif
#endif // JSON_AUTOLINK_H_INCLUDED
diff --git a/include/json/config.h b/include/json/config.h
index 810a56b..f0cea44 100644
--- a/include/json/config.h
+++ b/include/json/config.h
@@ -4,105 +4,109 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_CONFIG_H_INCLUDED
-# define JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
/// 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
+/// 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 defined, indicates that Json specific container should be used
/// (hash table & simple deque container with customizable allocator).
/// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
//# define JSON_VALUE_USE_INTERNAL_MAP 1
-/// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
-/// The memory pools allocator used optimization (initializing Value and ValueInternalLink
+/// Force usage of standard new/malloc based allocator instead of memory pool
+/// based allocator.
+/// The memory pools allocator used optimization (initializing Value and
+/// ValueInternalLink
/// as if it was a POD) that may cause some validation tool to report errors.
/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
//# define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 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
+#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
-# 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
-# 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
+// 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) && _MSC_VER <= 1200 // MSVC 6
+#if defined(_MSC_VER) && _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).
+// 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 // if defined(_MSC_VER) && _MSC_VER < 1200 // MSVC 6
-#if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
+#if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
/// Indicates that the following function is deprecated.
-# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
#endif
#if !defined(JSONCPP_DEPRECATED)
-# define JSONCPP_DEPRECATED(message)
+#define JSONCPP_DEPRECATED(message)
#endif // if !defined(JSONCPP_DEPRECATED)
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)
+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)
} // end namespace Json
-
#endif // JSON_CONFIG_H_INCLUDED
diff --git a/include/json/features.h b/include/json/features.h
index 221d8ff..1bb7bb6 100644
--- a/include/json/features.h
+++ b/include/json/features.h
@@ -4,51 +4,53 @@
// 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
+#define CPPTL_JSON_FEATURES_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
-# include "forwards.h"
+#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 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 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();
+ /** \brief Initialize the configuration like JsonConfig::allFeatures;
+ */
+ Features();
- /// \c true if comments are allowed. Default: \c true.
- bool allowComments_;
+ /// \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 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 dropped null placeholders are allowed. Default: \c false.
+ bool allowDroppedNullPlaceholders_;
- /// \c true if numeric object key are allowed. Default: \c false.
- bool allowNumericKeys_;
- };
+ /// \c true if numeric object key are allowed. Default: \c false.
+ bool allowNumericKeys_;
+};
} // namespace Json
diff --git a/include/json/forwards.h b/include/json/forwards.h
index ab863da..84a26cd 100644
--- a/include/json/forwards.h
+++ b/include/json/forwards.h
@@ -4,41 +4,40 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_FORWARDS_H_INCLUDED
-# define JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
-# include "config.h"
+#include "config.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
- // writer.h
- class FastWriter;
- class StyledWriter;
+// writer.h
+class FastWriter;
+class StyledWriter;
- // reader.h
- class Reader;
+// reader.h
+class Reader;
- // features.h
- class Features;
+// features.h
+class Features;
- // value.h
- typedef unsigned int ArrayIndex;
- class StaticString;
- class Path;
- class PathArgument;
- class Value;
- class ValueIteratorBase;
- class ValueIterator;
- class ValueConstIterator;
+// value.h
+typedef unsigned int ArrayIndex;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- class ValueMapAllocator;
- class ValueInternalLink;
- class ValueInternalArray;
- class ValueInternalMap;
+class ValueMapAllocator;
+class ValueInternalLink;
+class ValueInternalArray;
+class ValueInternalMap;
#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
} // namespace Json
-
#endif // JSON_FORWARDS_H_INCLUDED
diff --git a/include/json/json.h b/include/json/json.h
index da5fc96..8f10ac2 100644
--- a/include/json/json.h
+++ b/include/json/json.h
@@ -4,12 +4,12 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_JSON_H_INCLUDED
-# define JSON_JSON_H_INCLUDED
+#define JSON_JSON_H_INCLUDED
-# include "autolink.h"
-# include "value.h"
-# include "reader.h"
-# include "writer.h"
-# include "features.h"
+#include "autolink.h"
+#include "value.h"
+#include "reader.h"
+#include "writer.h"
+#include "features.h"
#endif // JSON_JSON_H_INCLUDED
diff --git a/include/json/reader.h b/include/json/reader.h
index 6271f71..af8e13c 100644
--- a/include/json/reader.h
+++ b/include/json/reader.h
@@ -4,246 +4,250 @@
// 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
+#define CPPTL_JSON_READER_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
-# include "features.h"
-# include "value.h"
+#include "features.h"
+#include "value.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
-# include <deque>
-# include <iosfwd>
-# include <stack>
-# include <string>
+#include <deque>
+#include <iosfwd>
+#include <stack>
+#include <string>
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to be used by...
+// 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)
+#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.
- *
- */
- class JSON_API Reader
- {
- public:
- typedef char Char;
- typedef const Char *Location;
+/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
+ *Value.
+ *
+ */
+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
- {
- size_t offset_start;
- size_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( std::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;
-
- 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 expectToken( TokenType type, Token &token, const char *message );
- 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 ¤t,
- Location end,
- unsigned int &unicode );
- bool decodeUnicodeEscapeSequence( Token &token,
- Location ¤t,
- 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 ¤tValue();
- 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_;
- };
-
- /** \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<<()
+ /** \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.
+ *
*/
- JSON_API std::istream& operator>>( std::istream&, Value& );
+ struct StructuredError {
+ size_t offset_start;
+ size_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(std::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;
+
+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 expectToken(TokenType type, Token &token, const char *message);
+ 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 ¤t,
+ Location end,
+ unsigned int &unicode);
+ bool decodeUnicodeEscapeSequence(Token &token,
+ Location ¤t,
+ 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 ¤tValue();
+ 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_;
+};
+
+/** \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 std::istream &operator>>(std::istream &, Value &);
} // namespace Json
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-# pragma warning(pop)
+#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
#endif // CPPTL_JSON_READER_H_INCLUDED
diff --git a/include/json/value.h b/include/json/value.h
index f18457a..09db289 100644
--- a/include/json/value.h
+++ b/include/json/value.h
@@ -4,1133 +4,1079 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef CPPTL_JSON_H_INCLUDED
-# define CPPTL_JSON_H_INCLUDED
+#define CPPTL_JSON_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
-# include "forwards.h"
+#include "forwards.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
-# include <string>
-# include <vector>
+#include <string>
+#include <vector>
-# ifndef JSON_USE_CPPTL_SMALLMAP
-# include <map>
-# else
-# include <cpptl/smallmap.h>
-# endif
-# ifdef JSON_USE_CPPTL
-# include <cpptl/forwards.h>
-# endif
+#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...
+// 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)
+#pragma warning(push)
+#pragma warning(disable : 4251)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
/** \brief JSON (JavaScript Object Notation).
*/
namespace Json {
- /** \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).
- };
+/** \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
- };
+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 )
- : str_( czstring )
- {
- }
+/** \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) : str_(czstring) {}
- operator const char *() const
- {
- return str_;
- }
+ operator const char *() const { return str_; }
- const char *c_str() const
- {
- return str_;
- }
+ const char *c_str() const { return str_; }
- private:
- const char *str_;
- };
+private:
+ const char *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 resize and initialized
- * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
- *
- * The get() methods can be used to obtanis 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.
- */
- class JSON_API Value
- {
- friend class ValueIteratorBase;
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- friend class ValueInternalLink;
- friend class ValueInternalMap;
-# endif
- public:
- typedef std::vector<std::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;
+/** \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 resize and initialized
+ * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+ *
+ * The get() methods can be used to obtanis 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.
+ */
+class JSON_API Value {
+ friend class ValueIteratorBase;
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ friend class ValueInternalLink;
+ friend class ValueInternalMap;
+#endif
+public:
+ typedef std::vector<std::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;
+ typedef Json::LargestInt LargestInt;
+ typedef Json::LargestUInt LargestUInt;
+ typedef Json::ArrayIndex ArrayIndex;
- static const Value 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;
+ static const Value 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;
+ /// 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;
+#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:
+private:
#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
-# ifndef JSON_VALUE_USE_INTERNAL_MAP
- class CZString
- {
- public:
- enum DuplicationPolicy
- {
- noDuplication = 0,
- duplicate,
- duplicateOnCopy
- };
- CZString( ArrayIndex index );
- CZString( const char *cstr, DuplicationPolicy allocate );
- CZString( const CZString &other );
- ~CZString();
- CZString &operator =( const CZString &other );
- bool operator<( const CZString &other ) const;
- bool operator==( const CZString &other ) const;
- ArrayIndex index() const;
- const char *c_str() const;
- bool isStaticString() const;
- private:
- void swap( CZString &other );
- const char *cstr_;
- ArrayIndex index_;
- };
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ class CZString {
+ public:
+ enum DuplicationPolicy {
+ noDuplication = 0,
+ duplicate,
+ duplicateOnCopy
+ };
+ CZString(ArrayIndex index);
+ CZString(const char *cstr, DuplicationPolicy allocate);
+ CZString(const CZString &other);
+ ~CZString();
+ CZString &operator=(const CZString &other);
+ bool operator<(const CZString &other) const;
+ bool operator==(const CZString &other) const;
+ ArrayIndex index() const;
+ const char *c_str() const;
+ bool isStaticString() const;
- 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 JSON_VALUE_USE_INTERNAL_MAP
+ private:
+ void swap(CZString &other);
+ const char *cstr_;
+ ArrayIndex index_;
+ };
+
+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 JSON_VALUE_USE_INTERNAL_MAP
#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
- public:
- /** \brief Create a default Value of the given type.
+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.
+ 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 );
+ 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 );
+ Value(Int64 value);
+ Value(UInt64 value);
#endif // if defined(JSON_HAS_INT64)
- Value( double value );
- Value( const char *value );
- Value( const char *beginValue, const char *endValue );
- /** \brief Constructs a value from a static string.
+ Value(double value);
+ Value(const char *value);
+ Value(const char *beginValue, const char *endValue);
+ /** \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.
- * Example of usage:
- * \code
- * Json::Value aValue( StaticString("some text") );
- * \endcode
- */
- Value( const StaticString &value );
- Value( const std::string &value );
-# ifdef JSON_USE_CPPTL
- Value( const CppTL::ConstString &value );
-# endif
- Value( bool value );
- Value( const Value &other );
- ~Value();
+ * 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.
+ * Example of usage:
+ * \code
+ * Json::Value aValue( StaticString("some text") );
+ * \endcode
+ */
+ Value(const StaticString &value);
+ Value(const std::string &value);
+#ifdef JSON_USE_CPPTL
+ Value(const CppTL::ConstString &value);
+#endif
+ Value(bool value);
+ Value(const Value &other);
+ ~Value();
- Value &operator=( const Value &other );
- /// Swap values.
- /// \note Currently, comments are intentionally not swapped, for
- /// both logic and efficiency.
- void swap( Value &other );
+ Value &operator=(const Value &other);
+ /// Swap values.
+ /// \note Currently, comments are intentionally not swapped, for
+ /// both logic and efficiency.
+ void swap(Value &other);
- ValueType type() const;
+ ValueType type() 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;
+ 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;
+ bool operator!=(const Value &other) const;
- int compare( const Value &other ) const;
+ int compare(const Value &other) const;
- const char *asCString() const;
- std::string asString() const;
-# ifdef JSON_USE_CPPTL
- CppTL::ConstString asConstString() const;
-# endif
- Int asInt() const;
- UInt asUInt() const;
+ const char *asCString() const;
+ std::string asString() 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;
+ 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;
+ 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 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;
+ bool isConvertibleTo(ValueType other) const;
- /// Number of values in array or object
- ArrayIndex size() 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;
+ /// \brief Return true if empty array, empty object, or null;
+ /// otherwise, false.
+ bool empty() const;
- /// Return isNull()
- bool operator!() 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();
+ /// 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 );
+ /// 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[](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 ).
+ /// 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[](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;
+ /// 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 );
+ /// 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.
- 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.
- Value &operator[]( const std::string &key );
- /// Access an object value by name, returns null if there is no member with that name.
- const Value &operator[]( const std::string &key ) const;
- /** \brief Access an object value by name, create a null member if it does not exist.
+ /// Access an object value by name, create a null member if it does not exist.
+ 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.
+ Value &operator[](const std::string &key);
+ /// Access an object value by name, returns null if there is no member with
+ /// that name.
+ const Value &operator[](const std::string &key) const;
+ /** \brief Access an object value by name, create a null member if it does not
+ exist.
- * If the object as 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.
- Value get( const char *key,
- const Value &defaultValue ) const;
- /// Return the member named key if it exist, defaultValue otherwise.
- Value get( const std::string &key,
- const Value &defaultValue ) const;
-# ifdef JSON_USE_CPPTL
- /// Return the member named key if it exist, defaultValue otherwise.
- Value get( const CppTL::ConstString &key,
- const Value &defaultValue ) const;
-# endif
- /// \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
- Value removeMember( const char* key );
- /// Same as removeMember(const char*)
- Value removeMember( const std::string &key );
+ * If the object as 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.
+ Value get(const char *key, const Value &defaultValue) const;
+ /// Return the member named key if it exist, defaultValue otherwise.
+ Value get(const std::string &key, const Value &defaultValue) const;
+#ifdef JSON_USE_CPPTL
+ /// Return the member named key if it exist, defaultValue otherwise.
+ Value get(const CppTL::ConstString &key, const Value &defaultValue) const;
+#endif
+ /// \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
+ Value removeMember(const char *key);
+ /// Same as removeMember(const char*)
+ Value removeMember(const std::string &key);
- /// Return true if the object has a member named key.
- bool isMember( const char *key ) const;
- /// Return true if the object has a member named key.
- bool isMember( const std::string &key ) const;
-# ifdef JSON_USE_CPPTL
- /// Return true if the object has a member named key.
- bool isMember( const CppTL::ConstString &key ) const;
-# endif
+ /// Return true if the object has a member named key.
+ bool isMember(const char *key) const;
+ /// Return true if the object has a member named key.
+ bool isMember(const std::string &key) 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;
+ /// \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
+ //# ifdef JSON_USE_CPPTL
+ // EnumMemberNames enumMemberNames() const;
+ // EnumValues enumValues() const;
+ //# endif
- /// Comments must be //... or /* ... */
- void setComment( const char *comment,
- CommentPlacement placement );
- /// Comments must be //... or /* ... */
- void setComment( const std::string &comment,
- CommentPlacement placement );
- bool hasComment( CommentPlacement placement ) const;
- /// Include delimiters and embedded newlines.
- std::string getComment( CommentPlacement placement ) const;
+ /// Comments must be //... or /* ... */
+ void setComment(const char *comment, CommentPlacement placement);
+ /// Comments must be //... or /* ... */
+ void setComment(const std::string &comment, CommentPlacement placement);
+ bool hasComment(CommentPlacement placement) const;
+ /// Include delimiters and embedded newlines.
+ std::string getComment(CommentPlacement placement) const;
- std::string toStyledString() const;
+ std::string toStyledString() const;
- const_iterator begin() const;
- const_iterator end() const;
+ const_iterator begin() const;
+ const_iterator end() const;
- iterator begin();
- iterator end();
+ 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( size_t start );
- void setOffsetLimit( size_t limit );
- size_t getOffsetStart() const;
- size_t getOffsetLimit() const;
+ // Accessors for the [start, limit) range of bytes within the JSON text from
+ // which this value was parsed, if any.
+ void setOffsetStart(size_t start);
+ void setOffsetLimit(size_t limit);
+ size_t getOffsetStart() const;
+ size_t getOffsetLimit() const;
- private:
- Value &resolveReference( const char *key,
- bool isStatic );
-
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- inline bool isItemAvailable() const
- {
- return itemIsUsed_ == 0;
- }
-
- inline void setItemUsed( bool isUsed = true )
- {
- itemIsUsed_ = isUsed ? 1 : 0;
- }
-
- inline bool isMemberNameStatic() const
- {
- return memberNameIsStatic_ == 0;
- }
-
- inline void setMemberNameIsStatic( bool isStatic )
- {
- memberNameIsStatic_ = isStatic ? 1 : 0;
- }
-# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
-
- private:
- struct CommentInfo
- {
- CommentInfo();
- ~CommentInfo();
-
- void setComment( const char *text );
-
- 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_;
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- ValueInternalArray *array_;
- ValueInternalMap *map_;
-#else
- ObjectValues *map_;
-# endif
- } value_;
- ValueType type_ : 8;
- int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container.
- int memberNameIsStatic_ : 1; // used by the ValueInternalMap container.
-# endif
- CommentInfo *comments_;
-
- // [start, limit) byte offsets in the source JSON text from which this Value
- // was extracted.
- size_t start_;
- size_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 std::string &key );
-
- private:
- enum Kind
- {
- kindNone = 0,
- kindIndex,
- kindKey
- };
- std::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 std::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 std::string &path,
- const InArgs &in );
- void addPathInArg( const std::string &path,
- const InArgs &in,
- InArgs::const_iterator &itInArg,
- PathArgument::Kind kind );
- void invalidPath( const std::string &path,
- int location );
-
- Args args_;
- };
-
-
+private:
+ Value &resolveReference(const char *key, bool isStatic);
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- /** \brief Allocator to customize Value internal map.
- * Below is an example of a simple implementation (default implementation actually
- * use memory pool for speed).
- * \code
- class DefaultValueMapAllocator : public ValueMapAllocator
+ inline bool isItemAvailable() const { return itemIsUsed_ == 0; }
+
+ inline void setItemUsed(bool isUsed = true) { itemIsUsed_ = isUsed ? 1 : 0; }
+
+ inline bool isMemberNameStatic() const { return memberNameIsStatic_ == 0; }
+
+ inline void setMemberNameIsStatic(bool isStatic) {
+ memberNameIsStatic_ = isStatic ? 1 : 0;
+ }
+#endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+private:
+ struct CommentInfo {
+ CommentInfo();
+ ~CommentInfo();
+
+ void setComment(const char *text);
+
+ 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_;
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ValueInternalArray *array_;
+ ValueInternalMap *map_;
+#else
+ ObjectValues *map_;
+#endif
+ } value_;
+ ValueType type_ : 8;
+ int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container.
+ int memberNameIsStatic_ : 1; // used by the ValueInternalMap container.
+#endif
+ CommentInfo *comments_;
+
+ // [start, limit) byte offsets in the source JSON text from which this Value
+ // was extracted.
+ size_t start_;
+ size_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 std::string &key);
+
+private:
+ enum Kind {
+ kindNone = 0,
+ kindIndex,
+ kindKey
+ };
+ std::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 std::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 std::string &path, const InArgs &in);
+ void addPathInArg(const std::string &path,
+ const InArgs &in,
+ InArgs::const_iterator &itInArg,
+ PathArgument::Kind kind);
+ void invalidPath(const std::string &path, int location);
+
+ Args args_;
+};
+
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+/** \brief Allocator to customize Value internal map.
+ * Below is an example of a simple implementation (default implementation
+ actually
+ * use memory pool for speed).
+ * \code
+ class DefaultValueMapAllocator : public ValueMapAllocator
+ {
+ public: // overridden from ValueMapAllocator
+ virtual ValueInternalMap *newMap()
{
- public: // overridden from ValueMapAllocator
- virtual ValueInternalMap *newMap()
- {
- return new ValueInternalMap();
- }
+ return new ValueInternalMap();
+ }
- virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
- {
- return new ValueInternalMap( other );
- }
-
- virtual void destructMap( ValueInternalMap *map )
- {
- delete map;
- }
-
- virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
- {
- return new ValueInternalLink[size];
- }
-
- virtual void releaseMapBuckets( ValueInternalLink *links )
- {
- delete [] links;
- }
-
- virtual ValueInternalLink *allocateMapLink()
- {
- return new ValueInternalLink();
- }
-
- virtual void releaseMapLink( ValueInternalLink *link )
- {
- delete link;
- }
- };
- * \endcode
- */
- class JSON_API ValueMapAllocator
- {
- public:
- virtual ~ValueMapAllocator();
- virtual ValueInternalMap *newMap() = 0;
- virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
- virtual void destructMap( ValueInternalMap *map ) = 0;
- virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
- virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
- virtual ValueInternalLink *allocateMapLink() = 0;
- virtual void releaseMapLink( ValueInternalLink *link ) = 0;
- };
-
- /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
- * \internal previous_ & next_ allows for bidirectional traversal.
- */
- class JSON_API ValueInternalLink
- {
- public:
- enum { itemPerLink = 6 }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
- enum InternalFlags {
- flagAvailable = 0,
- flagUsed = 1
- };
-
- ValueInternalLink();
-
- ~ValueInternalLink();
-
- Value items_[itemPerLink];
- char *keys_[itemPerLink];
- ValueInternalLink *previous_;
- ValueInternalLink *next_;
- };
-
-
- /** \brief A linked page based hash-table implementation used internally by Value.
- * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
- * list in each bucket to handle collision. There is an addional twist in that
- * each node of the collision linked list is a page containing a fixed amount of
- * value. This provides a better compromise between memory usage and speed.
- *
- * Each bucket is made up of a chained list of ValueInternalLink. The last
- * link of a given bucket can be found in the 'previous_' field of the following bucket.
- * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
- * Only the last link of a bucket may contains 'available' item. The last link always
- * contains at least one element unless is it the bucket one very first link.
- */
- class JSON_API ValueInternalMap
- {
- friend class ValueIteratorBase;
- friend class Value;
- public:
- typedef unsigned int HashKey;
- typedef unsigned int BucketIndex;
-
-# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
- struct IteratorState
+ virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
{
- IteratorState()
- : map_(0)
- , link_(0)
- , itemIndex_(0)
- , bucketIndex_(0)
- {
- }
- ValueInternalMap *map_;
- ValueInternalLink *link_;
- BucketIndex itemIndex_;
- BucketIndex bucketIndex_;
- };
-# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+ return new ValueInternalMap( other );
+ }
- ValueInternalMap();
- ValueInternalMap( const ValueInternalMap &other );
- ValueInternalMap &operator =( const ValueInternalMap &other );
- ~ValueInternalMap();
-
- void swap( ValueInternalMap &other );
-
- BucketIndex size() const;
-
- void clear();
-
- bool reserveDelta( BucketIndex growth );
-
- bool reserve( BucketIndex newItemCount );
-
- const Value *find( const char *key ) const;
-
- Value *find( const char *key );
-
- Value &resolveReference( const char *key,
- bool isStatic );
-
- void remove( const char *key );
-
- void doActualRemove( ValueInternalLink *link,
- BucketIndex index,
- BucketIndex bucketIndex );
-
- ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
-
- Value &setNewItem( const char *key,
- bool isStatic,
- ValueInternalLink *link,
- BucketIndex index );
-
- Value &unsafeAdd( const char *key,
- bool isStatic,
- HashKey hashedKey );
-
- HashKey hash( const char *key ) const;
-
- int compare( const ValueInternalMap &other ) const;
-
- private:
- void makeBeginIterator( IteratorState &it ) const;
- void makeEndIterator( IteratorState &it ) const;
- static bool equals( const IteratorState &x, const IteratorState &other );
- static void increment( IteratorState &iterator );
- static void incrementBucket( IteratorState &iterator );
- static void decrement( IteratorState &iterator );
- static const char *key( const IteratorState &iterator );
- static const char *key( const IteratorState &iterator, bool &isStatic );
- static Value &value( const IteratorState &iterator );
- static int distance( const IteratorState &x, const IteratorState &y );
-
- private:
- ValueInternalLink *buckets_;
- ValueInternalLink *tailLink_;
- BucketIndex bucketsSize_;
- BucketIndex itemCount_;
- };
-
- /** \brief A simplified deque implementation used internally by Value.
- * \internal
- * It is based on a list of fixed "page", each page contains a fixed number of items.
- * Instead of using a linked-list, a array of pointer is used for fast item look-up.
- * Look-up for an element is as follow:
- * - compute page index: pageIndex = itemIndex / itemsPerPage
- * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
- *
- * Insertion is amortized constant time (only the array containing the index of pointers
- * need to be reallocated when items are appended).
- */
- class JSON_API ValueInternalArray
- {
- friend class Value;
- friend class ValueIteratorBase;
- public:
- enum { itemsPerPage = 8 }; // should be a power of 2 for fast divide and modulo.
- typedef Value::ArrayIndex ArrayIndex;
- typedef unsigned int PageIndex;
-
-# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
- struct IteratorState // Must be a POD
+ virtual void destructMap( ValueInternalMap *map )
{
- IteratorState()
- : array_(0)
- , currentPageIndex_(0)
- , currentItemIndex_(0)
- {
- }
- ValueInternalArray *array_;
- Value **currentPageIndex_;
- unsigned int currentItemIndex_;
- };
-# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+ delete map;
+ }
- ValueInternalArray();
- ValueInternalArray( const ValueInternalArray &other );
- ValueInternalArray &operator =( const ValueInternalArray &other );
- ~ValueInternalArray();
- void swap( ValueInternalArray &other );
+ virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+ {
+ return new ValueInternalLink[size];
+ }
- void clear();
- void resize( ArrayIndex newSize );
+ virtual void releaseMapBuckets( ValueInternalLink *links )
+ {
+ delete [] links;
+ }
- Value &resolveReference( ArrayIndex index );
+ virtual ValueInternalLink *allocateMapLink()
+ {
+ return new ValueInternalLink();
+ }
- Value *find( ArrayIndex index ) const;
-
- ArrayIndex size() const;
-
- int compare( const ValueInternalArray &other ) const;
-
- private:
- static bool equals( const IteratorState &x, const IteratorState &other );
- static void increment( IteratorState &iterator );
- static void decrement( IteratorState &iterator );
- static Value &dereference( const IteratorState &iterator );
- static Value &unsafeDereference( const IteratorState &iterator );
- static int distance( const IteratorState &x, const IteratorState &y );
- static ArrayIndex indexOf( const IteratorState &iterator );
- void makeBeginIterator( IteratorState &it ) const;
- void makeEndIterator( IteratorState &it ) const;
- void makeIterator( IteratorState &it, ArrayIndex index ) const;
-
- void makeIndexValid( ArrayIndex index );
-
- Value **pages_;
- ArrayIndex size_;
- PageIndex pageCount_;
+ virtual void releaseMapLink( ValueInternalLink *link )
+ {
+ delete link;
+ }
};
+ * \endcode
+ */
+class JSON_API ValueMapAllocator {
+public:
+ virtual ~ValueMapAllocator();
+ virtual ValueInternalMap *newMap() = 0;
+ virtual ValueInternalMap *newMapCopy(const ValueInternalMap &other) = 0;
+ virtual void destructMap(ValueInternalMap *map) = 0;
+ virtual ValueInternalLink *allocateMapBuckets(unsigned int size) = 0;
+ virtual void releaseMapBuckets(ValueInternalLink *links) = 0;
+ virtual ValueInternalLink *allocateMapLink() = 0;
+ virtual void releaseMapLink(ValueInternalLink *link) = 0;
+};
- /** \brief Experimental: do not use. Allocator to customize Value internal array.
- * Below is an example of a simple implementation (actual implementation use
- * memory pool).
- \code
+/** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
+ * \internal previous_ & next_ allows for bidirectional traversal.
+ */
+class JSON_API ValueInternalLink {
+public:
+ enum {
+ itemPerLink = 6
+ }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
+ enum InternalFlags {
+ flagAvailable = 0,
+ flagUsed = 1
+ };
+
+ ValueInternalLink();
+
+ ~ValueInternalLink();
+
+ Value items_[itemPerLink];
+ char *keys_[itemPerLink];
+ ValueInternalLink *previous_;
+ ValueInternalLink *next_;
+};
+
+/** \brief A linked page based hash-table implementation used internally by
+ *Value.
+ * \internal ValueInternalMap is a tradional bucket based hash-table, with a
+ *linked
+ * list in each bucket to handle collision. There is an addional twist in that
+ * each node of the collision linked list is a page containing a fixed amount of
+ * value. This provides a better compromise between memory usage and speed.
+ *
+ * Each bucket is made up of a chained list of ValueInternalLink. The last
+ * link of a given bucket can be found in the 'previous_' field of the following
+ *bucket.
+ * The last link of the last bucket is stored in tailLink_ as it has no
+ *following bucket.
+ * Only the last link of a bucket may contains 'available' item. The last link
+ *always
+ * contains at least one element unless is it the bucket one very first link.
+ */
+class JSON_API ValueInternalMap {
+ friend class ValueIteratorBase;
+ friend class Value;
+
+public:
+ typedef unsigned int HashKey;
+ typedef unsigned int BucketIndex;
+
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+ struct IteratorState {
+ IteratorState() : map_(0), link_(0), itemIndex_(0), bucketIndex_(0) {}
+ ValueInternalMap *map_;
+ ValueInternalLink *link_;
+ BucketIndex itemIndex_;
+ BucketIndex bucketIndex_;
+ };
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+ ValueInternalMap();
+ ValueInternalMap(const ValueInternalMap &other);
+ ValueInternalMap &operator=(const ValueInternalMap &other);
+ ~ValueInternalMap();
+
+ void swap(ValueInternalMap &other);
+
+ BucketIndex size() const;
+
+ void clear();
+
+ bool reserveDelta(BucketIndex growth);
+
+ bool reserve(BucketIndex newItemCount);
+
+ const Value *find(const char *key) const;
+
+ Value *find(const char *key);
+
+ Value &resolveReference(const char *key, bool isStatic);
+
+ void remove(const char *key);
+
+ void doActualRemove(ValueInternalLink *link,
+ BucketIndex index,
+ BucketIndex bucketIndex);
+
+ ValueInternalLink *&getLastLinkInBucket(BucketIndex bucketIndex);
+
+ Value &setNewItem(const char *key,
+ bool isStatic,
+ ValueInternalLink *link,
+ BucketIndex index);
+
+ Value &unsafeAdd(const char *key, bool isStatic, HashKey hashedKey);
+
+ HashKey hash(const char *key) const;
+
+ int compare(const ValueInternalMap &other) const;
+
+private:
+ void makeBeginIterator(IteratorState &it) const;
+ void makeEndIterator(IteratorState &it) const;
+ static bool equals(const IteratorState &x, const IteratorState &other);
+ static void increment(IteratorState &iterator);
+ static void incrementBucket(IteratorState &iterator);
+ static void decrement(IteratorState &iterator);
+ static const char *key(const IteratorState &iterator);
+ static const char *key(const IteratorState &iterator, bool &isStatic);
+ static Value &value(const IteratorState &iterator);
+ static int distance(const IteratorState &x, const IteratorState &y);
+
+private:
+ ValueInternalLink *buckets_;
+ ValueInternalLink *tailLink_;
+ BucketIndex bucketsSize_;
+ BucketIndex itemCount_;
+};
+
+/** \brief A simplified deque implementation used internally by Value.
+* \internal
+* It is based on a list of fixed "page", each page contains a fixed number of
+*items.
+* Instead of using a linked-list, a array of pointer is used for fast item
+*look-up.
+* Look-up for an element is as follow:
+* - compute page index: pageIndex = itemIndex / itemsPerPage
+* - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
+*
+* Insertion is amortized constant time (only the array containing the index of
+*pointers
+* need to be reallocated when items are appended).
+*/
+class JSON_API ValueInternalArray {
+ friend class Value;
+ friend class ValueIteratorBase;
+
+public:
+ enum {
+ itemsPerPage = 8
+ }; // should be a power of 2 for fast divide and modulo.
+ typedef Value::ArrayIndex ArrayIndex;
+ typedef unsigned int PageIndex;
+
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+ struct IteratorState // Must be a POD
+ {
+ IteratorState() : array_(0), currentPageIndex_(0), currentItemIndex_(0) {}
+ ValueInternalArray *array_;
+ Value **currentPageIndex_;
+ unsigned int currentItemIndex_;
+ };
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+ ValueInternalArray();
+ ValueInternalArray(const ValueInternalArray &other);
+ ValueInternalArray &operator=(const ValueInternalArray &other);
+ ~ValueInternalArray();
+ void swap(ValueInternalArray &other);
+
+ void clear();
+ void resize(ArrayIndex newSize);
+
+ Value &resolveReference(ArrayIndex index);
+
+ Value *find(ArrayIndex index) const;
+
+ ArrayIndex size() const;
+
+ int compare(const ValueInternalArray &other) const;
+
+private:
+ static bool equals(const IteratorState &x, const IteratorState &other);
+ static void increment(IteratorState &iterator);
+ static void decrement(IteratorState &iterator);
+ static Value &dereference(const IteratorState &iterator);
+ static Value &unsafeDereference(const IteratorState &iterator);
+ static int distance(const IteratorState &x, const IteratorState &y);
+ static ArrayIndex indexOf(const IteratorState &iterator);
+ void makeBeginIterator(IteratorState &it) const;
+ void makeEndIterator(IteratorState &it) const;
+ void makeIterator(IteratorState &it, ArrayIndex index) const;
+
+ void makeIndexValid(ArrayIndex index);
+
+ Value **pages_;
+ ArrayIndex size_;
+ PageIndex pageCount_;
+};
+
+/** \brief Experimental: do not use. Allocator to customize Value internal
+array.
+ * Below is an example of a simple implementation (actual implementation use
+ * memory pool).
+ \code
class DefaultValueArrayAllocator : public ValueArrayAllocator
{
public: // overridden from ValueArrayAllocator
- virtual ~DefaultValueArrayAllocator()
- {
- }
+virtual ~DefaultValueArrayAllocator()
+{
+}
- virtual ValueInternalArray *newArray()
- {
- return new ValueInternalArray();
- }
+virtual ValueInternalArray *newArray()
+{
+ return new ValueInternalArray();
+}
- virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
- {
- return new ValueInternalArray( other );
- }
+virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+{
+ return new ValueInternalArray( other );
+}
- virtual void destruct( ValueInternalArray *array )
- {
- delete array;
- }
+virtual void destruct( ValueInternalArray *array )
+{
+ delete array;
+}
- virtual void reallocateArrayPageIndex( Value **&indexes,
- ValueInternalArray::PageIndex &indexCount,
- ValueInternalArray::PageIndex minNewIndexCount )
- {
- ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
- if ( minNewIndexCount > newIndexCount )
- newIndexCount = minNewIndexCount;
- void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
- if ( !newIndexes )
- throw std::bad_alloc();
- indexCount = newIndexCount;
- indexes = static_cast<Value **>( newIndexes );
- }
- virtual void releaseArrayPageIndex( Value **indexes,
- ValueInternalArray::PageIndex indexCount )
- {
- if ( indexes )
- free( indexes );
- }
+virtual void reallocateArrayPageIndex( Value **&indexes,
+ ValueInternalArray::PageIndex
+&indexCount,
+ ValueInternalArray::PageIndex
+minNewIndexCount )
+{
+ ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+ if ( minNewIndexCount > newIndexCount )
+ newIndexCount = minNewIndexCount;
+ void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+ if ( !newIndexes )
+ throw std::bad_alloc();
+ indexCount = newIndexCount;
+ indexes = static_cast<Value **>( newIndexes );
+}
+virtual void releaseArrayPageIndex( Value **indexes,
+ ValueInternalArray::PageIndex indexCount )
+{
+ if ( indexes )
+ free( indexes );
+}
- virtual Value *allocateArrayPage()
- {
- return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
- }
+virtual Value *allocateArrayPage()
+{
+ return static_cast<Value *>( malloc( sizeof(Value) *
+ValueInternalArray::itemsPerPage ) );
+}
- virtual void releaseArrayPage( Value *value )
- {
- if ( value )
- free( value );
- }
+virtual void releaseArrayPage( Value *value )
+{
+ if ( value )
+ free( value );
+}
};
- \endcode
- */
- class JSON_API ValueArrayAllocator
- {
- public:
- virtual ~ValueArrayAllocator();
- virtual ValueInternalArray *newArray() = 0;
- virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
- virtual void destructArray( ValueInternalArray *array ) = 0;
- /** \brief Reallocate array page index.
- * Reallocates an array of pointer on each page.
- * \param indexes [input] pointer on the current index. May be \c NULL.
- * [output] pointer on the new index of at least
- * \a minNewIndexCount pages.
- * \param indexCount [input] current number of pages in the index.
- * [output] number of page the reallocated index can handle.
- * \b MUST be >= \a minNewIndexCount.
- * \param minNewIndexCount Minimum number of page the new index must be able to
- * handle.
- */
- virtual void reallocateArrayPageIndex( Value **&indexes,
- ValueInternalArray::PageIndex &indexCount,
- ValueInternalArray::PageIndex minNewIndexCount ) = 0;
- virtual void releaseArrayPageIndex( Value **indexes,
- ValueInternalArray::PageIndex indexCount ) = 0;
- virtual Value *allocateArrayPage() = 0;
- virtual void releaseArrayPage( Value *value ) = 0;
- };
+ \endcode
+ */
+class JSON_API ValueArrayAllocator {
+public:
+ virtual ~ValueArrayAllocator();
+ virtual ValueInternalArray *newArray() = 0;
+ virtual ValueInternalArray *newArrayCopy(const ValueInternalArray &other) = 0;
+ virtual void destructArray(ValueInternalArray *array) = 0;
+ /** \brief Reallocate array page index.
+ * Reallocates an array of pointer on each page.
+ * \param indexes [input] pointer on the current index. May be \c NULL.
+ * [output] pointer on the new index of at least
+ * \a minNewIndexCount pages.
+ * \param indexCount [input] current number of pages in the index.
+ * [output] number of page the reallocated index can handle.
+ * \b MUST be >= \a minNewIndexCount.
+ * \param minNewIndexCount Minimum number of page the new index must be able
+ * to
+ * handle.
+ */
+ virtual void
+ reallocateArrayPageIndex(Value **&indexes,
+ ValueInternalArray::PageIndex &indexCount,
+ ValueInternalArray::PageIndex minNewIndexCount) = 0;
+ virtual void
+ releaseArrayPageIndex(Value **indexes,
+ ValueInternalArray::PageIndex indexCount) = 0;
+ virtual Value *allocateArrayPage() = 0;
+ virtual void releaseArrayPage(Value *value) = 0;
+};
#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+/** \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;
- /** \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;
-
- ValueIteratorBase();
+ ValueIteratorBase();
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- explicit ValueIteratorBase( const Value::ObjectValues::iterator ¤t );
+ explicit ValueIteratorBase(const Value::ObjectValues::iterator ¤t);
#else
- ValueIteratorBase( const ValueInternalArray::IteratorState &state );
- ValueIteratorBase( const ValueInternalMap::IteratorState &state );
+ ValueIteratorBase(const ValueInternalArray::IteratorState &state);
+ ValueIteratorBase(const ValueInternalMap::IteratorState &state);
#endif
- bool operator ==( const SelfType &other ) const
- {
- return isEqual( other );
- }
+ bool operator==(const SelfType &other) const { return isEqual(other); }
- 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 computeDistance( other );
- }
+ difference_type operator-(const SelfType &other) const {
+ return computeDistance(other);
+ }
- /// Return either the index or the member name of the referenced value as a Value.
- Value key() const;
+ /// 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. -1 if it is not an arrayValue.
- UInt index() const;
+ /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+ UInt index() const;
- /// Return the member name of the referenced Value. "" if it is not an objectValue.
- const char *memberName() const;
+ /// Return the member name of the referenced Value. "" if it is not an
+ /// objectValue.
+ const char *memberName() const;
- protected:
- Value &deref() const;
+protected:
+ Value &deref() const;
- void increment();
+ void increment();
- void decrement();
+ void decrement();
- difference_type computeDistance( const SelfType &other ) const;
+ difference_type computeDistance(const SelfType &other) const;
- bool isEqual( const SelfType &other ) const;
+ bool isEqual(const SelfType &other) const;
- void copy( const SelfType &other );
+ void copy(const SelfType &other);
- private:
+private:
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- Value::ObjectValues::iterator current_;
- // Indicates that iterator is for a null value.
- bool isNull_;
+ Value::ObjectValues::iterator current_;
+ // Indicates that iterator is for a null value.
+ bool isNull_;
#else
- union
- {
- ValueInternalArray::IteratorState array_;
- ValueInternalMap::IteratorState map_;
- } iterator_;
- bool isArray_;
+ union {
+ ValueInternalArray::IteratorState array_;
+ ValueInternalMap::IteratorState map_;
+ } iterator_;
+ bool isArray_;
#endif
- };
+};
- /** \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;
+/** \brief const iterator for object and array value.
+ *
+ */
+class JSON_API ValueConstIterator : public ValueIteratorBase {
+ friend class Value;
- ValueConstIterator();
- private:
- /*! \internal Use by Value to create an iterator.
- */
+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();
+
+private:
+/*! \internal Use by Value to create an iterator.
+ */
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- explicit ValueConstIterator( const Value::ObjectValues::iterator ¤t );
+ explicit ValueConstIterator(const Value::ObjectValues::iterator ¤t);
#else
- ValueConstIterator( const ValueInternalArray::IteratorState &state );
- ValueConstIterator( const ValueInternalMap::IteratorState &state );
+ ValueConstIterator(const ValueInternalArray::IteratorState &state);
+ ValueConstIterator(const ValueInternalMap::IteratorState &state);
#endif
- public:
- SelfType &operator =( const ValueIteratorBase &other );
+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--( int )
- {
- SelfType temp( *this );
- --*this;
- return temp;
- }
+ SelfType operator--(int) {
+ SelfType temp(*this);
+ --*this;
+ return temp;
+ }
- SelfType &operator--()
- {
- decrement();
- return *this;
- }
+ SelfType &operator--() {
+ decrement();
+ return *this;
+ }
- SelfType &operator++()
- {
- increment();
- return *this;
- }
+ SelfType &operator++() {
+ increment();
+ return *this;
+ }
- reference operator *() const
- {
- return deref();
- }
- };
+ reference operator*() const { return deref(); }
+};
+/** \brief Iterator for object and array value.
+ */
+class JSON_API ValueIterator : public ValueIteratorBase {
+ friend class Value;
- /** \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;
+public:
+ typedef Value value_type;
+ typedef unsigned int size_t;
+ typedef int difference_type;
+ typedef Value &reference;
+ typedef Value *pointer;
+ typedef ValueIterator SelfType;
- ValueIterator();
- ValueIterator( const ValueConstIterator &other );
- ValueIterator( const ValueIterator &other );
- private:
- /*! \internal Use by Value to create an iterator.
- */
+ ValueIterator();
+ ValueIterator(const ValueConstIterator &other);
+ ValueIterator(const ValueIterator &other);
+
+private:
+/*! \internal Use by Value to create an iterator.
+ */
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- explicit ValueIterator( const Value::ObjectValues::iterator ¤t );
+ explicit ValueIterator(const Value::ObjectValues::iterator ¤t);
#else
- ValueIterator( const ValueInternalArray::IteratorState &state );
- ValueIterator( const ValueInternalMap::IteratorState &state );
+ ValueIterator(const ValueInternalArray::IteratorState &state);
+ ValueIterator(const ValueInternalMap::IteratorState &state);
#endif
- public:
+public:
+ SelfType &operator=(const SelfType &other);
- 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--(int) {
+ SelfType temp(*this);
+ --*this;
+ return temp;
+ }
- SelfType operator--( int )
- {
- SelfType temp( *this );
- --*this;
- return temp;
- }
+ SelfType &operator--() {
+ decrement();
+ return *this;
+ }
- SelfType &operator--()
- {
- decrement();
- return *this;
- }
+ SelfType &operator++() {
+ increment();
+ return *this;
+ }
- SelfType &operator++()
- {
- increment();
- return *this;
- }
-
- reference operator *() const
- {
- return deref();
- }
- };
-
+ reference operator*() const { return deref(); }
+};
} // namespace Json
-
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-# pragma warning(pop)
+#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
#endif // CPPTL_JSON_H_INCLUDED
diff --git a/include/json/version.h b/include/json/version.h
index d3466c0..91c4a93 100644
--- a/include/json/version.h
+++ b/include/json/version.h
@@ -1,14 +1,16 @@
-// DO NOT EDIT. This file is generated by CMake from "version"
+// DO NOT EDIT. This file is generated by CMake from "version"
// and "version.h.in" files.
// Run CMake configure step to update it.
#ifndef JSON_VERSION_H_INCLUDED
-# define JSON_VERSION_H_INCLUDED
+#define JSON_VERSION_H_INCLUDED
-# define JSONCPP_VERSION_STRING "0.6.0-dev"
-# define JSONCPP_VERSION_MAJOR 0
-# define JSONCPP_VERSION_MINOR 6
-# define JSONCPP_VERSION_PATCH 0
-# define JSONCPP_VERSION_QUALIFIER -dev
-# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
+#define JSONCPP_VERSION_STRING "0.6.0-dev"
+#define JSONCPP_VERSION_MAJOR 0
+#define JSONCPP_VERSION_MINOR 6
+#define JSONCPP_VERSION_PATCH 0
+#define JSONCPP_VERSION_QUALIFIER -dev
+#define JSONCPP_VERSION_HEXA \
+ ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | \
+ (JSONCPP_VERSION_PATCH << 8))
#endif // JSON_VERSION_H_INCLUDED
diff --git a/include/json/writer.h b/include/json/writer.h
index 23ebd50..2865af8 100644
--- a/include/json/writer.h
+++ b/include/json/writer.h
@@ -4,200 +4,207 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSON_WRITER_H_INCLUDED
-# define JSON_WRITER_H_INCLUDED
+#define JSON_WRITER_H_INCLUDED
#if !defined(JSON_IS_AMALGAMATION)
-# include "value.h"
+#include "value.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
-# include <vector>
-# include <string>
+#include <vector>
+#include <string>
-// Disable warning C4251: <data member>: <type> needs to have dll-interface to be used by...
+// 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)
+#pragma warning(push)
+#pragma warning(disable : 4251)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
namespace Json {
- class Value;
+class Value;
- /** \brief Abstract class for writers.
- */
- class JSON_API Writer
- {
- public:
- virtual ~Writer();
+/** \brief Abstract class for writers.
+ */
+class JSON_API Writer {
+public:
+ virtual ~Writer();
- virtual std::string write( const Value &root ) = 0;
- };
+ 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
- */
- class JSON_API FastWriter : public Writer
- {
- public:
- FastWriter();
- virtual ~FastWriter(){}
+/** \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
+ */
+class JSON_API FastWriter : public Writer {
+public:
+ FastWriter();
+ virtual ~FastWriter() {}
- void enableYAMLCompatibility();
+ 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();
+ /** \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();
- public: // overridden from Writer
- virtual std::string write( const Value &root );
+public: // overridden from Writer
+ virtual std::string write(const Value &root);
- private:
- void writeValue( const Value &value );
+private:
+ void writeValue(const Value &value);
- std::string document_;
- bool yamlCompatiblityEnabled_;
- bool dropNullPlaceholders_;
- };
+ std::string document_;
+ bool yamlCompatiblityEnabled_;
+ bool dropNullPlaceholders_;
+};
- /** \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()
- */
- class JSON_API StyledWriter: public Writer
- {
- public:
- StyledWriter();
- virtual ~StyledWriter(){}
+/** \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()
+ */
+class JSON_API StyledWriter : public Writer {
+public:
+ StyledWriter();
+ virtual ~StyledWriter() {}
- 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.
- */
- virtual std::string write( const Value &root );
+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.
+ */
+ virtual std::string write(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 );
+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;
+ typedef std::vector<std::string> ChildValues;
- ChildValues childValues_;
- std::string document_;
- std::string indentString_;
- int rightMargin_;
- int indentSize_;
- bool addChildValues_;
- };
+ ChildValues childValues_;
+ std::string document_;
+ std::string indentString_;
+ int rightMargin_;
+ 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()
- */
- class JSON_API StyledStreamWriter
- {
- public:
- StyledStreamWriter( std::string indentation="\t" );
- ~StyledStreamWriter(){}
+/** \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()
+ */
+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( std::ostream &out, const Value &root );
+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(std::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 );
+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;
+ typedef std::vector<std::string> ChildValues;
- ChildValues childValues_;
- std::ostream* document_;
- std::string indentString_;
- int rightMargin_;
- std::string indentation_;
- bool addChildValues_;
- };
+ ChildValues childValues_;
+ std::ostream *document_;
+ std::string indentString_;
+ int rightMargin_;
+ std::string indentation_;
+ bool addChildValues_;
+};
-# 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 );
+#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 std::ostream& operator<<( std::ostream&, const Value &root );
+/// \brief Output using the StyledStreamWriter.
+/// \see Json::operator>>()
+JSON_API std::ostream &operator<<(std::ostream &, const Value &root);
} // namespace Json
-
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-# pragma warning(pop)
+#pragma warning(pop)
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
-
#endif // JSON_WRITER_H_INCLUDED
diff --git a/src/jsontestrunner/main.cpp b/src/jsontestrunner/main.cpp
index 81805c2..18e6ef1 100644
--- a/src/jsontestrunner/main.cpp
+++ b/src/jsontestrunner/main.cpp
@@ -6,296 +6,266 @@
/* This executable is used for testing parser/writer using real JSON files.
*/
-
#include <json/json.h>
#include <algorithm> // sort
#include <stdio.h>
-#if defined(_MSC_VER) && _MSC_VER >= 1310
-# pragma warning( disable: 4996 ) // disable fopen deprecation warning
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+#pragma warning(disable : 4996) // disable fopen deprecation warning
#endif
-static std::string
-normalizeFloatingPointStr( double value )
-{
- char buffer[32];
+static std::string normalizeFloatingPointStr(double value) {
+ char buffer[32];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
- sprintf_s( buffer, sizeof(buffer), "%.16g", value );
+ sprintf_s(buffer, sizeof(buffer), "%.16g", value);
#else
- snprintf( buffer, sizeof(buffer), "%.16g", value );
+ snprintf(buffer, sizeof(buffer), "%.16g", value);
#endif
- buffer[sizeof(buffer)-1] = 0;
- std::string s( buffer );
- std::string::size_type index = s.find_last_of( "eE" );
- if ( index != std::string::npos )
+ buffer[sizeof(buffer) - 1] = 0;
+ std::string s(buffer);
+ std::string::size_type index = s.find_last_of("eE");
+ if (index != std::string::npos) {
+ std::string::size_type hasSign =
+ (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+ std::string::size_type exponentStartIndex = index + 1 + hasSign;
+ std::string normalized = s.substr(0, exponentStartIndex);
+ std::string::size_type indexDigit =
+ s.find_first_not_of('0', exponentStartIndex);
+ std::string exponent = "0";
+ if (indexDigit !=
+ std::string::npos) // There is an exponent different from 0
{
- std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
- std::string::size_type exponentStartIndex = index + 1 + hasSign;
- std::string normalized = s.substr( 0, exponentStartIndex );
- std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
- std::string exponent = "0";
- if ( indexDigit != std::string::npos ) // There is an exponent different from 0
- {
- exponent = s.substr( indexDigit );
- }
- return normalized + exponent;
+ exponent = s.substr(indexDigit);
}
- return s;
+ return normalized + exponent;
+ }
+ return s;
}
-
-static std::string
-readInputTestFile( const char *path )
-{
- FILE *file = fopen( path, "rb" );
- if ( !file )
- return std::string("");
- fseek( file, 0, SEEK_END );
- long size = ftell( file );
- fseek( file, 0, SEEK_SET );
- std::string text;
- char *buffer = new char[size+1];
- buffer[size] = 0;
- if ( fread( buffer, 1, size, file ) == (unsigned long)size )
- text = buffer;
- fclose( file );
- delete[] buffer;
- return text;
+static std::string readInputTestFile(const char *path) {
+ FILE *file = fopen(path, "rb");
+ if (!file)
+ return std::string("");
+ fseek(file, 0, SEEK_END);
+ long size = ftell(file);
+ fseek(file, 0, SEEK_SET);
+ std::string text;
+ char *buffer = new char[size + 1];
+ buffer[size] = 0;
+ if (fread(buffer, 1, size, file) == (unsigned long)size)
+ text = buffer;
+ fclose(file);
+ delete[] buffer;
+ return text;
}
static void
-printValueTree( FILE *fout, Json::Value &value, const std::string &path = "." )
-{
- switch ( value.type() )
- {
- case Json::nullValue:
- fprintf( fout, "%s=null\n", path.c_str() );
- break;
- case Json::intValue:
- fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestInt() ).c_str() );
- break;
- case Json::uintValue:
- fprintf( fout, "%s=%s\n", path.c_str(), Json::valueToString( value.asLargestUInt() ).c_str() );
- break;
- case Json::realValue:
- fprintf( fout, "%s=%s\n", path.c_str(), normalizeFloatingPointStr(value.asDouble()).c_str() );
- break;
- case Json::stringValue:
- fprintf( fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str() );
- break;
- case Json::booleanValue:
- fprintf( fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false" );
- break;
- case Json::arrayValue:
- {
- fprintf( fout, "%s=[]\n", path.c_str() );
- int size = value.size();
- for ( int index =0; index < size; ++index )
- {
- static char buffer[16];
+printValueTree(FILE *fout, Json::Value &value, const std::string &path = ".") {
+ switch (value.type()) {
+ case Json::nullValue:
+ fprintf(fout, "%s=null\n", path.c_str());
+ break;
+ case Json::intValue:
+ fprintf(fout,
+ "%s=%s\n",
+ path.c_str(),
+ Json::valueToString(value.asLargestInt()).c_str());
+ break;
+ case Json::uintValue:
+ fprintf(fout,
+ "%s=%s\n",
+ path.c_str(),
+ Json::valueToString(value.asLargestUInt()).c_str());
+ break;
+ case Json::realValue:
+ fprintf(fout,
+ "%s=%s\n",
+ path.c_str(),
+ normalizeFloatingPointStr(value.asDouble()).c_str());
+ break;
+ case Json::stringValue:
+ fprintf(fout, "%s=\"%s\"\n", path.c_str(), value.asString().c_str());
+ break;
+ case Json::booleanValue:
+ fprintf(fout, "%s=%s\n", path.c_str(), value.asBool() ? "true" : "false");
+ break;
+ case Json::arrayValue: {
+ fprintf(fout, "%s=[]\n", path.c_str());
+ int size = value.size();
+ for (int index = 0; index < size; ++index) {
+ static char buffer[16];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
- sprintf_s( buffer, sizeof(buffer), "[%d]", index );
+ sprintf_s(buffer, sizeof(buffer), "[%d]", index);
#else
- snprintf( buffer, sizeof(buffer), "[%d]", index );
+ snprintf(buffer, sizeof(buffer), "[%d]", index);
#endif
- printValueTree( fout, value[index], path + buffer );
- }
- }
- break;
- case Json::objectValue:
- {
- fprintf( fout, "%s={}\n", path.c_str() );
- Json::Value::Members members( value.getMemberNames() );
- std::sort( members.begin(), members.end() );
- std::string suffix = *(path.end()-1) == '.' ? "" : ".";
- for ( Json::Value::Members::iterator it = members.begin();
- it != members.end();
- ++it )
- {
- const std::string &name = *it;
- printValueTree( fout, value[name], path + suffix + name );
- }
- }
- break;
- default:
- break;
- }
+ printValueTree(fout, value[index], path + buffer);
+ }
+ } break;
+ case Json::objectValue: {
+ fprintf(fout, "%s={}\n", path.c_str());
+ Json::Value::Members members(value.getMemberNames());
+ std::sort(members.begin(), members.end());
+ std::string suffix = *(path.end() - 1) == '.' ? "" : ".";
+ for (Json::Value::Members::iterator it = members.begin();
+ it != members.end();
+ ++it) {
+ const std::string &name = *it;
+ printValueTree(fout, value[name], path + suffix + name);
+ }
+ } break;
+ default:
+ break;
+ }
}
+static int parseAndSaveValueTree(const std::string &input,
+ const std::string &actual,
+ const std::string &kind,
+ Json::Value &root,
+ const Json::Features &features,
+ bool parseOnly) {
+ Json::Reader reader(features);
+ bool parsingSuccessful = reader.parse(input, root);
+ if (!parsingSuccessful) {
+ printf("Failed to parse %s file: \n%s\n",
+ kind.c_str(),
+ reader.getFormattedErrorMessages().c_str());
+ return 1;
+ }
-static int
-parseAndSaveValueTree( const std::string &input,
- const std::string &actual,
- const std::string &kind,
- Json::Value &root,
- const Json::Features &features,
- bool parseOnly )
-{
- Json::Reader reader( features );
- bool parsingSuccessful = reader.parse( input, root );
- if ( !parsingSuccessful )
- {
- printf( "Failed to parse %s file: \n%s\n",
- kind.c_str(),
- reader.getFormattedErrorMessages().c_str() );
- return 1;
- }
-
- if ( !parseOnly )
- {
- FILE *factual = fopen( actual.c_str(), "wt" );
- if ( !factual )
- {
- printf( "Failed to create %s actual file.\n", kind.c_str() );
- return 2;
- }
- printValueTree( factual, root );
- fclose( factual );
- }
- return 0;
-}
-
-
-static int
-rewriteValueTree( const std::string &rewritePath,
- const Json::Value &root,
- std::string &rewrite )
-{
- //Json::FastWriter writer;
- //writer.enableYAMLCompatibility();
- Json::StyledWriter writer;
- rewrite = writer.write( root );
- FILE *fout = fopen( rewritePath.c_str(), "wt" );
- if ( !fout )
- {
- printf( "Failed to create rewrite file: %s\n", rewritePath.c_str() );
+ if (!parseOnly) {
+ FILE *factual = fopen(actual.c_str(), "wt");
+ if (!factual) {
+ printf("Failed to create %s actual file.\n", kind.c_str());
return 2;
- }
- fprintf( fout, "%s\n", rewrite.c_str() );
- fclose( fout );
- return 0;
+ }
+ printValueTree(factual, root);
+ fclose(factual);
+ }
+ return 0;
}
-
-static std::string
-removeSuffix( const std::string &path,
- const std::string &extension )
-{
- if ( extension.length() >= path.length() )
- return std::string("");
- std::string suffix = path.substr( path.length() - extension.length() );
- if ( suffix != extension )
- return std::string("");
- return path.substr( 0, path.length() - extension.length() );
+static int rewriteValueTree(const std::string &rewritePath,
+ const Json::Value &root,
+ std::string &rewrite) {
+ // Json::FastWriter writer;
+ // writer.enableYAMLCompatibility();
+ Json::StyledWriter writer;
+ rewrite = writer.write(root);
+ FILE *fout = fopen(rewritePath.c_str(), "wt");
+ if (!fout) {
+ printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
+ return 2;
+ }
+ fprintf(fout, "%s\n", rewrite.c_str());
+ fclose(fout);
+ return 0;
}
+static std::string removeSuffix(const std::string &path,
+ const std::string &extension) {
+ if (extension.length() >= path.length())
+ return std::string("");
+ std::string suffix = path.substr(path.length() - extension.length());
+ if (suffix != extension)
+ return std::string("");
+ return path.substr(0, path.length() - extension.length());
+}
-static void
-printConfig()
-{
- // Print the configuration used to compile JsonCpp
+static void printConfig() {
+// Print the configuration used to compile JsonCpp
#if defined(JSON_NO_INT64)
- printf( "JSON_NO_INT64=1\n" );
+ printf("JSON_NO_INT64=1\n");
#else
- printf( "JSON_NO_INT64=0\n" );
+ printf("JSON_NO_INT64=0\n");
#endif
}
-
-static int
-printUsage( const char *argv[] )
-{
- printf( "Usage: %s [--strict] input-json-file", argv[0] );
- return 3;
+static int printUsage(const char *argv[]) {
+ printf("Usage: %s [--strict] input-json-file", argv[0]);
+ return 3;
}
+int parseCommandLine(int argc,
+ const char *argv[],
+ Json::Features &features,
+ std::string &path,
+ bool &parseOnly) {
+ parseOnly = false;
+ if (argc < 2) {
+ return printUsage(argv);
+ }
-int
-parseCommandLine( int argc, const char *argv[],
- Json::Features &features, std::string &path,
- bool &parseOnly )
-{
- parseOnly = false;
- if ( argc < 2 )
- {
- return printUsage( argv );
- }
+ int index = 1;
+ if (std::string(argv[1]) == "--json-checker") {
+ features = Json::Features::strictMode();
+ parseOnly = true;
+ ++index;
+ }
- int index = 1;
- if ( std::string(argv[1]) == "--json-checker" )
- {
- features = Json::Features::strictMode();
- parseOnly = true;
- ++index;
- }
+ if (std::string(argv[1]) == "--json-config") {
+ printConfig();
+ return 3;
+ }
- if ( std::string(argv[1]) == "--json-config" )
- {
- printConfig();
+ if (index == argc || index + 1 < argc) {
+ return printUsage(argv);
+ }
+
+ path = argv[index];
+ return 0;
+}
+
+int main(int argc, const char *argv[]) {
+ std::string path;
+ Json::Features features;
+ bool parseOnly;
+ int exitCode = parseCommandLine(argc, argv, features, path, parseOnly);
+ if (exitCode != 0) {
+ return exitCode;
+ }
+
+ try {
+ std::string input = readInputTestFile(path.c_str());
+ if (input.empty()) {
+ printf("Failed to read input or empty input: %s\n", path.c_str());
return 3;
- }
+ }
- if ( index == argc || index + 1 < argc )
- {
- return printUsage( argv );
- }
+ std::string basePath = removeSuffix(argv[1], ".json");
+ if (!parseOnly && basePath.empty()) {
+ printf("Bad input path. Path does not end with '.expected':\n%s\n",
+ path.c_str());
+ return 3;
+ }
- path = argv[index];
- return 0;
-}
+ std::string actualPath = basePath + ".actual";
+ std::string rewritePath = basePath + ".rewrite";
+ std::string rewriteActualPath = basePath + ".actual-rewrite";
-
-int main( int argc, const char *argv[] )
-{
- std::string path;
- Json::Features features;
- bool parseOnly;
- int exitCode = parseCommandLine( argc, argv, features, path, parseOnly );
- if ( exitCode != 0 )
- {
- return exitCode;
- }
-
- try
- {
- std::string input = readInputTestFile( path.c_str() );
- if ( input.empty() )
- {
- printf( "Failed to read input or empty input: %s\n", path.c_str() );
- return 3;
+ Json::Value root;
+ exitCode = parseAndSaveValueTree(
+ input, actualPath, "input", root, features, parseOnly);
+ if (exitCode == 0 && !parseOnly) {
+ std::string rewrite;
+ exitCode = rewriteValueTree(rewritePath, root, rewrite);
+ if (exitCode == 0) {
+ Json::Value rewriteRoot;
+ exitCode = parseAndSaveValueTree(rewrite,
+ rewriteActualPath,
+ "rewrite",
+ rewriteRoot,
+ features,
+ parseOnly);
}
+ }
+ }
+ catch (const std::exception &e) {
+ printf("Unhandled exception:\n%s\n", e.what());
+ exitCode = 1;
+ }
- std::string basePath = removeSuffix( argv[1], ".json" );
- if ( !parseOnly && basePath.empty() )
- {
- printf( "Bad input path. Path does not end with '.expected':\n%s\n", path.c_str() );
- return 3;
- }
-
- std::string actualPath = basePath + ".actual";
- std::string rewritePath = basePath + ".rewrite";
- std::string rewriteActualPath = basePath + ".actual-rewrite";
-
- Json::Value root;
- exitCode = parseAndSaveValueTree( input, actualPath, "input", root, features, parseOnly );
- if ( exitCode == 0 && !parseOnly )
- {
- std::string rewrite;
- exitCode = rewriteValueTree( rewritePath, root, rewrite );
- if ( exitCode == 0 )
- {
- Json::Value rewriteRoot;
- exitCode = parseAndSaveValueTree( rewrite, rewriteActualPath,
- "rewrite", rewriteRoot, features, parseOnly );
- }
- }
- }
- catch ( const std::exception &e )
- {
- printf( "Unhandled exception:\n%s\n", e.what() );
- exitCode = 1;
- }
-
- return exitCode;
+ return exitCode;
}
// vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/lib_json/json_batchallocator.h b/src/lib_json/json_batchallocator.h
index 92f1843..7e7ad82 100644
--- a/src/lib_json/json_batchallocator.h
+++ b/src/lib_json/json_batchallocator.h
@@ -4,12 +4,12 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
-# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
+#define JSONCPP_BATCHALLOCATOR_H_INCLUDED
-# include <stdlib.h>
-# include <assert.h>
+#include <stdlib.h>
+#include <assert.h>
-# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
namespace Json {
@@ -18,111 +18,108 @@
* This memory allocator allocates memory for a batch of object (specified by
* the page size, the number of object in each page).
*
- * It does not allow the destruction of a single object. All the allocated objects
- * can be destroyed at once. The memory can be either released or reused for future
+ * It does not allow the destruction of a single object. All the allocated
+ *objects
+ * can be destroyed at once. The memory can be either released or reused for
+ *future
* allocation.
- *
- * The in-place new operator must be used to construct the object using the pointer
+ *
+ * The in-place new operator must be used to construct the object using the
+ *pointer
* returned by allocate.
*/
-template<typename AllocatedType
- ,const unsigned int objectPerAllocation>
-class BatchAllocator
-{
+template <typename AllocatedType, const unsigned int objectPerAllocation>
+class BatchAllocator {
public:
- BatchAllocator( unsigned int objectsPerPage = 255 )
- : freeHead_( 0 )
- , objectsPerPage_( objectsPerPage )
- {
-// printf( "Size: %d => %s\n", sizeof(AllocatedType), typeid(AllocatedType).name() );
- assert( sizeof(AllocatedType) * objectPerAllocation >= sizeof(AllocatedType *) ); // We must be able to store a slist in the object free space.
- assert( objectsPerPage >= 16 );
- batches_ = allocateBatch( 0 ); // allocated a dummy page
- currentBatch_ = batches_;
- }
+ BatchAllocator(unsigned int objectsPerPage = 255)
+ : freeHead_(0), objectsPerPage_(objectsPerPage) {
+ // printf( "Size: %d => %s\n", sizeof(AllocatedType),
+ // typeid(AllocatedType).name() );
+ assert(sizeof(AllocatedType) * objectPerAllocation >=
+ sizeof(AllocatedType *)); // We must be able to store a slist in the
+ // object free space.
+ assert(objectsPerPage >= 16);
+ batches_ = allocateBatch(0); // allocated a dummy page
+ currentBatch_ = batches_;
+ }
- ~BatchAllocator()
- {
- for ( BatchInfo *batch = batches_; batch; )
+ ~BatchAllocator() {
+ for (BatchInfo *batch = batches_; batch;) {
+ BatchInfo *nextBatch = batch->next_;
+ free(batch);
+ batch = nextBatch;
+ }
+ }
+
+ /// allocate space for an array of objectPerAllocation object.
+ /// @warning it is the responsability of the caller to call objects
+ /// constructors.
+ AllocatedType *allocate() {
+ if (freeHead_) // returns node from free list.
+ {
+ AllocatedType *object = freeHead_;
+ freeHead_ = *(AllocatedType **)object;
+ return object;
+ }
+ if (currentBatch_->used_ == currentBatch_->end_) {
+ currentBatch_ = currentBatch_->next_;
+ while (currentBatch_ && currentBatch_->used_ == currentBatch_->end_)
+ currentBatch_ = currentBatch_->next_;
+
+ if (!currentBatch_) // no free batch found, allocate a new one
{
- BatchInfo *nextBatch = batch->next_;
- free( batch );
- batch = nextBatch;
+ currentBatch_ = allocateBatch(objectsPerPage_);
+ currentBatch_->next_ = batches_; // insert at the head of the list
+ batches_ = currentBatch_;
}
- }
+ }
+ AllocatedType *allocated = currentBatch_->used_;
+ currentBatch_->used_ += objectPerAllocation;
+ return allocated;
+ }
- /// allocate space for an array of objectPerAllocation object.
- /// @warning it is the responsability of the caller to call objects constructors.
- AllocatedType *allocate()
- {
- if ( freeHead_ ) // returns node from free list.
- {
- AllocatedType *object = freeHead_;
- freeHead_ = *(AllocatedType **)object;
- return object;
- }
- if ( currentBatch_->used_ == currentBatch_->end_ )
- {
- currentBatch_ = currentBatch_->next_;
- while ( currentBatch_ && currentBatch_->used_ == currentBatch_->end_ )
- currentBatch_ = currentBatch_->next_;
-
- if ( !currentBatch_ ) // no free batch found, allocate a new one
- {
- currentBatch_ = allocateBatch( objectsPerPage_ );
- currentBatch_->next_ = batches_; // insert at the head of the list
- batches_ = currentBatch_;
- }
- }
- AllocatedType *allocated = currentBatch_->used_;
- currentBatch_->used_ += objectPerAllocation;
- return allocated;
- }
-
- /// Release the object.
- /// @warning it is the responsability of the caller to actually destruct the object.
- void release( AllocatedType *object )
- {
- assert( object != 0 );
- *(AllocatedType **)object = freeHead_;
- freeHead_ = object;
- }
+ /// Release the object.
+ /// @warning it is the responsability of the caller to actually destruct the
+ /// object.
+ void release(AllocatedType *object) {
+ assert(object != 0);
+ *(AllocatedType **)object = freeHead_;
+ freeHead_ = object;
+ }
private:
- struct BatchInfo
- {
- BatchInfo *next_;
- AllocatedType *used_;
- AllocatedType *end_;
- AllocatedType buffer_[objectPerAllocation];
- };
+ struct BatchInfo {
+ BatchInfo *next_;
+ AllocatedType *used_;
+ AllocatedType *end_;
+ AllocatedType buffer_[objectPerAllocation];
+ };
- // disabled copy constructor and assignement operator.
- BatchAllocator( const BatchAllocator & );
- void operator =( const BatchAllocator &);
+ // disabled copy constructor and assignement operator.
+ BatchAllocator(const BatchAllocator &);
+ void operator=(const BatchAllocator &);
- static BatchInfo *allocateBatch( unsigned int objectsPerPage )
- {
- const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
- + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
- BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
- batch->next_ = 0;
- batch->used_ = batch->buffer_;
- batch->end_ = batch->buffer_ + objectsPerPage;
- return batch;
- }
+ static BatchInfo *allocateBatch(unsigned int objectsPerPage) {
+ const unsigned int mallocSize =
+ sizeof(BatchInfo) - sizeof(AllocatedType) * objectPerAllocation +
+ sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
+ BatchInfo *batch = static_cast<BatchInfo *>(malloc(mallocSize));
+ batch->next_ = 0;
+ batch->used_ = batch->buffer_;
+ batch->end_ = batch->buffer_ + objectsPerPage;
+ return batch;
+ }
- BatchInfo *batches_;
- BatchInfo *currentBatch_;
- /// Head of a single linked list within the allocated space of freeed object
- AllocatedType *freeHead_;
- unsigned int objectsPerPage_;
+ BatchInfo *batches_;
+ BatchInfo *currentBatch_;
+ /// Head of a single linked list within the allocated space of freeed object
+ AllocatedType *freeHead_;
+ unsigned int objectsPerPage_;
};
-
} // namespace Json
-# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
+#endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
#endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
// vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_reader.cpp b/src/lib_json/json_reader.cpp
index 8fd2f4c..3d0d328 100644
--- a/src/lib_json/json_reader.cpp
+++ b/src/lib_json/json_reader.cpp
@@ -4,10 +4,10 @@
// 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"
+#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>
@@ -15,8 +15,9 @@
#include <cstring>
#include <istream>
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
-#pragma warning( disable : 4996 ) // disable warning about strdup being deprecated.
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning(disable \
+ : 4996) // disable warning about strdup being deprecated.
#endif
namespace Json {
@@ -25,997 +26,816 @@
// ////////////////////////////////
Features::Features()
- : allowComments_( true )
- , strictRoot_( false )
- , allowDroppedNullPlaceholders_ ( false )
- , allowNumericKeys_ ( false )
-{
-}
+ : allowComments_(true), strictRoot_(false),
+ allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {}
+Features Features::all() { return Features(); }
-Features
-Features::all()
-{
- return Features();
-}
-
-
-Features
-Features::strictMode()
-{
- Features features;
- features.allowComments_ = false;
- features.strictRoot_ = true;
- features.allowDroppedNullPlaceholders_ = false;
- features.allowNumericKeys_ = false;
- 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 inline bool
-in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 )
-{
- return c == c1 || c == c2 || c == c3 || c == c4;
+static inline bool in(Reader::Char c,
+ Reader::Char c1,
+ Reader::Char c2,
+ Reader::Char c3,
+ Reader::Char c4) {
+ return c == c1 || c == c2 || c == c3 || c == c4;
}
-static inline bool
-in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4, Reader::Char c5 )
-{
- return c == c1 || c == c2 || c == c3 || c == c4 || c == c5;
+static inline bool in(Reader::Char c,
+ Reader::Char c1,
+ Reader::Char c2,
+ Reader::Char c3,
+ Reader::Char c4,
+ Reader::Char c5) {
+ return c == c1 || c == c2 || c == c3 || c == c4 || c == c5;
}
-
-static bool
-containsNewLine( Reader::Location begin,
- Reader::Location end )
-{
- for ( ;begin < end; ++begin )
- if ( *begin == '\n' || *begin == '\r' )
- return true;
- return false;
+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_()
-{
+ : 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_() {
}
-
-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 );
+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.
-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 );
+ // 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;
- }
+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 );
-
- 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;
-}
+ begin_ = beginDoc;
+ end_ = endDoc;
+ collectComments_ = collectComments;
+ current_ = begin_;
+ lastValueEnd_ = 0;
+ lastValue_ = 0;
+ commentsBefore_ = "";
+ errors_.clear();
+ while (!nodes_.empty())
+ nodes_.pop();
+ nodes_.push(&root);
-
-bool
-Reader::readValue()
-{
- Token token;
- skipCommentTokens( token );
- bool successful = true;
-
- if ( collectComments_ && !commentsBefore_.empty() )
- {
- // Remove newline characters at the end of the comments
- size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
- if (lastNonNewline != std::string::npos)
- {
- commentsBefore_.erase(lastNonNewline+1);
- }
- else
- {
- commentsBefore_.clear();
- }
-
- 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:
- currentValue() = true;
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- break;
- case tokenFalse:
- currentValue() = false;
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- break;
- case tokenNull:
- currentValue() = Value();
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- break;
- case tokenArraySeparator:
- if ( features_.allowDroppedNullPlaceholders_ )
- {
- // "Un-read" the current token and mark the current value as a null
- // token.
- current_--;
- currentValue() = Value();
- 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();
- }
-
- return successful;
-}
-
-
-void
-Reader::skipCommentTokens( Token &token )
-{
- if ( features_.allowComments_ )
- {
- do
- {
- readToken( token );
- }
- while ( token.type_ == tokenComment );
- }
- else
- {
- readToken( token );
- }
-}
-
-
-bool
-Reader::expectToken( TokenType type, Token &token, const char *message )
-{
- readToken( token );
- if ( token.type_ != type )
- return addError( message, token );
- return true;
-}
-
-
-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 )
+ 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.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 )
+ token.start_ = beginDoc;
+ token.end_ = endDoc;
+ addError(
+ "A valid JSON document must be either an array or an object value.",
+ token);
return false;
- int index = patternLength;
- while ( index-- )
- if ( current_[index] != pattern[index] )
- return false;
- current_ += patternLength;
- return true;
+ }
+ }
+ return successful;
}
+bool Reader::readValue() {
+ Token token;
+ skipCommentTokens(token);
+ bool successful = 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_ && !commentsBefore_.empty()) {
+ // Remove newline characters at the end of the comments
+ size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
+ if (lastNonNewline != std::string::npos) {
+ commentsBefore_.erase(lastNonNewline + 1);
+ } else {
+ commentsBefore_.clear();
+ }
- if ( collectComments_ )
- {
- CommentPlacement placement = commentBefore;
- if ( lastValueEnd_ && !containsNewLine( lastValueEnd_, commentBegin ) )
- {
- if ( c != '*' || !containsNewLine( commentBegin, current_ ) )
- placement = commentAfterOnSameLine;
- }
+ currentValue().setComment(commentsBefore_, commentBefore);
+ commentsBefore_ = "";
+ }
- addComment( commentBegin, current_, placement );
- }
- return true;
+ 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:
+ currentValue() = true;
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ break;
+ case tokenFalse:
+ currentValue() = false;
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ break;
+ case tokenNull:
+ currentValue() = Value();
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ break;
+ case tokenArraySeparator:
+ if (features_.allowDroppedNullPlaceholders_) {
+ // "Un-read" the current token and mark the current value as a null
+ // token.
+ current_--;
+ currentValue() = Value();
+ 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();
+ }
+
+ return successful;
}
-
-void
-Reader::addComment( Location begin,
- Location end,
- CommentPlacement placement )
-{
- assert( collectComments_ );
- if ( placement == commentAfterOnSameLine )
- {
- assert( lastValue_ != 0 );
- lastValue_->setComment( std::string( begin, end ), placement );
- }
- else
- {
- if ( !commentsBefore_.empty() )
- commentsBefore_ += "\n";
- commentsBefore_ += std::string( begin, end );
- }
+void Reader::skipCommentTokens(Token &token) {
+ if (features_.allowComments_) {
+ do {
+ readToken(token);
+ } while (token.type_ == tokenComment);
+ } else {
+ readToken(token);
+ }
}
-
-bool
-Reader::readCStyleComment()
-{
- while ( current_ != end_ )
- {
- Char c = getNextChar();
- if ( c == '*' && *current_ == '/' )
- break;
- }
- return getNextChar() == '/';
+bool Reader::expectToken(TokenType type, Token &token, const char *message) {
+ readToken(token);
+ if (token.type_ != type)
+ return addError(message, token);
+ return true;
}
-
-bool
-Reader::readCppStyleComment()
-{
- while ( current_ != end_ )
- {
- Char c = getNextChar();
- if ( c == '\r' || c == '\n' )
- break;
- }
- return true;
+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::readNumber()
-{
- while ( current_ != end_ )
- {
- if ( !(*current_ >= '0' && *current_ <= '9') &&
- !in( *current_, '.', 'e', 'E', '+', '-' ) )
- break;
+void Reader::skipSpaces() {
+ while (current_ != end_) {
+ Char c = *current_;
+ if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++current_;
- }
+ else
+ break;
+ }
}
-bool
-Reader::readString()
-{
- Char c = 0;
- while ( current_ != end_ )
- {
- c = getNextChar();
- if ( c == '\\' )
- getNextChar();
- else if ( c == '"' )
- break;
- }
- return c == '"';
+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;
-bool
-Reader::readObject( Token &tokenStart )
-{
- Token tokenName;
- std::string name;
- currentValue() = Value( objectValue );
- 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;
- }
+ if (collectComments_) {
+ CommentPlacement placement = commentBefore;
+ if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
+ if (c != '*' || !containsNewLine(commentBegin, current_))
+ placement = commentAfterOnSameLine;
+ }
- 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 );
+ addComment(commentBegin, current_, placement);
+ }
+ return true;
}
+void
+Reader::addComment(Location begin, Location end, CommentPlacement placement) {
+ assert(collectComments_);
+ if (placement == commentAfterOnSameLine) {
+ assert(lastValue_ != 0);
+ lastValue_->setComment(std::string(begin, end), placement);
+ } else {
+ if (!commentsBefore_.empty())
+ commentsBefore_ += "\n";
+ commentsBefore_ += std::string(begin, end);
+ }
+}
-bool
-Reader::readArray( Token &tokenStart )
-{
- currentValue() = Value( arrayValue );
- currentValue().setOffsetStart(tokenStart.start_ - begin_);
- skipSpaces();
- if ( *current_ == ']' ) // empty array
- {
- Token endArray;
- readToken( endArray );
+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 == '\r' || c == '\n')
+ break;
+ }
+ return true;
+}
+
+void Reader::readNumber() {
+ while (current_ != end_) {
+ if (!(*current_ >= '0' && *current_ <= '9') &&
+ !in(*current_, '.', 'e', 'E', '+', '-'))
+ break;
+ ++current_;
+ }
+}
+
+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;
+ currentValue() = Value(objectValue);
+ 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;
- }
- int index = 0;
- for (;;)
- {
- Value &value = currentValue()[ index++ ];
- nodes_.push( &value );
- bool ok = readValue();
- nodes_.pop();
- if ( !ok ) // error already set
- return recoverFromError( tokenArrayEnd );
+ 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 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;
+ 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) {
+ currentValue() = Value(arrayValue);
+ 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);
-bool
-Reader::decodeNumber( Token &token )
-{
+ 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;
+ if (!decodeNumber(token, decoded))
+ return false;
currentValue() = decoded;
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
-
-bool
-Reader::decodeNumber( Token &token, Value &decoded )
-{
- bool isDouble = false;
- for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
- {
- isDouble = isDouble
- || in( *inspect, '.', 'e', 'E', '+' )
- || ( *inspect == '-' && inspect != token.start_ );
- }
- if ( isDouble )
- return decodeDouble( token, 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;
- 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 addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
- Value::UInt digit(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 );
- }
+bool Reader::decodeNumber(Token &token, Value &decoded) {
+ bool isDouble = false;
+ for (Location inspect = token.start_; inspect != token.end_; ++inspect) {
+ isDouble = isDouble || in(*inspect, '.', 'e', 'E', '+') ||
+ (*inspect == '-' && inspect != token.start_);
+ }
+ if (isDouble)
+ return decodeDouble(token, 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;
+ 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 addError("'" + std::string(token.start_, token.end_) +
+ "' is not a number.",
+ token);
+ Value::UInt digit(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;
+ }
+ 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
-Reader::decodeDouble( Token &token )
-{
+bool Reader::decodeDouble(Token &token) {
Value decoded;
- if ( !decodeDouble( token, decoded ) )
- return false;
+ if (!decodeDouble(token, decoded))
+ return false;
currentValue() = decoded;
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
+bool Reader::decodeDouble(Token &token, Value &decoded) {
+ double value = 0;
+ const int bufferSize = 32;
+ int count;
+ int length = int(token.end_ - token.start_);
-bool
-Reader::decodeDouble( Token &token, Value &decoded )
-{
- double value = 0;
- const int bufferSize = 32;
- int count;
- int length = int(token.end_ - token.start_);
+ // Sanity check to avoid buffer overflow exploits.
+ if (length < 0) {
+ return addError("Unable to parse token length", token);
+ }
- // Sanity check to avoid buffer overflow exploits.
- if (length < 0) {
- return addError( "Unable to parse token length", token );
- }
+ // 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";
- // 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_, length);
+ buffer[length] = 0;
+ count = sscanf(buffer, format, &value);
+ } else {
+ std::string buffer(token.start_, token.end_);
+ count = sscanf(buffer.c_str(), format, &value);
+ }
- if ( length <= bufferSize )
- {
- Char buffer[bufferSize+1];
- memcpy( buffer, token.start_, length );
- 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;
+ if (count != 1)
+ 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;
- if ( !decodeString( token, decoded ) )
- return false;
- currentValue() = decoded;
- currentValue().setOffsetStart(token.start_ - begin_);
- currentValue().setOffsetLimit(token.end_ - begin_);
- return true;
+bool Reader::decodeString(Token &token) {
+ std::string decoded;
+ if (!decodeString(token, decoded))
+ return false;
+ currentValue() = decoded;
+ currentValue().setOffsetStart(token.start_ - begin_);
+ currentValue().setOffsetLimit(token.end_ - begin_);
+ return true;
}
+bool Reader::decodeString(Token &token, std::string &decoded) {
+ decoded.reserve(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::decodeString( Token &token, std::string &decoded )
-{
- decoded.reserve( 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 ¤t,
+ 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 ¤t,
+ Location end,
+ unsigned int &unicode) {
+ if (end - current < 4)
+ return addError(
+ "Bad unicode escape sequence in string: four digits expected.",
+ token,
+ current);
+ 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);
+ }
+ return true;
}
bool
-Reader::decodeUnicodeCodePoint( Token &token,
- Location ¤t,
- 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;
+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::decodeUnicodeEscapeSequence( Token &token,
- Location ¤t,
- Location end,
- unsigned int &unicode )
-{
- if ( end - current < 4 )
- return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
- 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 );
- }
- return true;
+bool Reader::recoverFromError(TokenType skipUntilToken) {
+ int errorCount = int(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::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::addErrorAndRecover(const std::string &message,
+ Token &token,
+ TokenType skipUntilToken) {
+ addError(message, token);
+ return recoverFromError(skipUntilToken);
}
+Value &Reader::currentValue() { return *(nodes_.top()); }
-bool
-Reader::recoverFromError( TokenType skipUntilToken )
-{
- int errorCount = int(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;
+Reader::Char Reader::getNextChar() {
+ if (current_ == end_)
+ return 0;
+ return *current_++;
}
-
-bool
-Reader::addErrorAndRecover( const std::string &message,
- Token &token,
- TokenType skipUntilToken )
-{
- addError( message, token );
- return recoverFromError( skipUntilToken );
+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;
}
-
-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];
+std::string Reader::getLocationLineAndColumn(Location location) const {
+ int line, column;
+ getLocationLineAndColumn(location, line, column);
+ char buffer[18 + 16 + 16 + 1];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
- sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+ sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#else
- snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
+ snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#endif
- return buffer;
+ return buffer;
}
-
// Deprecated. Preserved for backward compatibility
-std::string
-Reader::getFormatedErrorMessages() const
-{
- return getFormattedErrorMessages();
+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::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;
+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;
}
+std::istream &operator>>(std::istream &sin, Value &root) {
+ Json::Reader reader;
+ bool ok = reader.parse(sin, root, true);
+ if (!ok) {
+ fprintf(stderr,
+ "Error from reader: %s",
+ reader.getFormattedErrorMessages().c_str());
-std::istream& operator>>( std::istream &sin, Value &root )
-{
- Json::Reader reader;
- bool ok = reader.parse(sin, root, true);
- if (!ok) {
- fprintf(
- stderr,
- "Error from reader: %s",
- reader.getFormattedErrorMessages().c_str());
-
- JSON_FAIL_MESSAGE("reader error");
- }
- return sin;
+ JSON_FAIL_MESSAGE("reader error");
+ }
+ return sin;
}
-
} // namespace Json
// vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_tool.h b/src/lib_json/json_tool.h
index 658031b..c18a768 100644
--- a/src/lib_json/json_tool.h
+++ b/src/lib_json/json_tool.h
@@ -4,7 +4,7 @@
// 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
+#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
/* This header provides common string manipulation support, such as UTF-8,
* portable conversion from/to string...
@@ -15,77 +15,57 @@
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
+static inline std::string codePointToUTF8(unsigned int cp) {
+ std::string result;
- 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] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
- result[0] = 0xE0 | static_cast<char>((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)));
- }
+ // based on description from http://en.wikipedia.org/wiki/UTF-8
- return result;
+ 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] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
+ result[0] = 0xE0 | static_cast<char>((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 [0,32[).
-static inline bool
-isControlCharacter(char ch)
-{
- return ch > 0 && ch <= 0x1F;
-}
+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
+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.
+ * @param current Input/Output string buffer.
* Must have at least uintToStringBufferSize chars free.
*/
-static inline void
-uintToString( LargestUInt value,
- char *¤t )
-{
- *--current = 0;
- do
- {
- *--current = char(value % 10) + '0';
- value /= 10;
- }
- while ( value != 0 );
+static inline void uintToString(LargestUInt value, char *¤t) {
+ *--current = 0;
+ do {
+ *--current = char(value % 10) + '0';
+ value /= 10;
+ } while (value != 0);
}
} // namespace Json {
diff --git a/src/lib_json/json_value.cpp b/src/lib_json/json_value.cpp
index 55a47c9..6f952f6 100644
--- a/src/lib_json/json_value.cpp
+++ b/src/lib_json/json_value.cpp
@@ -4,12 +4,12 @@
// 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>
-# ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
-# include "json_batchallocator.h"
-# endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#include <json/assertions.h>
+#include <json/value.h>
+#include <json/writer.h>
+#ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#include "json_batchallocator.h"
+#endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <math.h>
#include <sstream>
@@ -17,59 +17,54 @@
#include <cstring>
#include <cassert>
#ifdef JSON_USE_CPPTL
-# include <cpptl/conststring.h>
+#include <cpptl/conststring.h>
#endif
-#include <cstddef> // size_t
+#include <cstddef> // size_t
-#define JSON_ASSERT_UNREACHABLE assert( false )
+#define JSON_ASSERT_UNREACHABLE assert(false)
namespace Json {
const Value Value::null;
-const Int Value::minInt = Int( ~(UInt(-1)/2) );
-const Int Value::maxInt = Int( UInt(-1)/2 );
+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 );
+#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 LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2));
+const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2);
const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
-
/// Unknown size marker
static const unsigned int unknown = (unsigned)-1;
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
template <typename T, typename U>
static inline bool InRange(double d, T min, U max) {
- return d >= min && d <= 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);
+#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> 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);
+ 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".
@@ -77,38 +72,33 @@
* computed using strlen(value).
* @return Pointer on the duplicate instance of string.
*/
-static inline char *
-duplicateStringValue( const char *value,
- unsigned int length = unknown )
-{
- if ( length == unknown )
- length = (unsigned int)strlen(value);
+static inline char *duplicateStringValue(const char *value,
+ unsigned int length = unknown) {
+ if (length == unknown)
+ length = (unsigned int)strlen(value);
- // Avoid an integer overflow in the call to malloc below by limiting length
- // to a sane value.
- if (length >= (unsigned)Value::maxInt)
- length = Value::maxInt - 1;
+ // Avoid an integer overflow in the call to malloc below by limiting length
+ // to a sane value.
+ if (length >= (unsigned)Value::maxInt)
+ length = Value::maxInt - 1;
- char *newString = static_cast<char *>( malloc( length + 1 ) );
- JSON_ASSERT_MESSAGE( newString != 0, "in Json::Value::duplicateStringValue(): Failed to allocate string value buffer" );
- memcpy( newString, value, length );
- newString[length] = 0;
- return newString;
+ char *newString = static_cast<char *>(malloc(length + 1));
+ JSON_ASSERT_MESSAGE(newString != 0, "in Json::Value::duplicateStringValue(): "
+ "Failed to allocate string value buffer");
+ memcpy(newString, value, length);
+ newString[length] = 0;
+ return newString;
}
-
/** Free the string duplicated by duplicateStringValue().
*/
-static inline void
-releaseStringValue( char *value )
-{
- if ( value )
- free( value );
+static inline void releaseStringValue(char *value) {
+ if (value)
+ free(value);
}
} // namespace Json
-
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -117,12 +107,12 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_IS_AMALGAMATION)
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
-# include "json_internalarray.inl"
-# include "json_internalmap.inl"
-# endif // JSON_VALUE_USE_INTERNAL_MAP
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+#include "json_internalarray.inl"
+#include "json_internalmap.inl"
+#endif // JSON_VALUE_USE_INTERNAL_MAP
-# include "json_valueiterator.inl"
+#include "json_valueiterator.inl"
#endif // if !defined(JSON_IS_AMALGAMATION)
namespace Json {
@@ -135,31 +125,24 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
+Value::CommentInfo::CommentInfo() : comment_(0) {}
-Value::CommentInfo::CommentInfo()
- : comment_( 0 )
-{
+Value::CommentInfo::~CommentInfo() {
+ if (comment_)
+ releaseStringValue(comment_);
}
-Value::CommentInfo::~CommentInfo()
-{
- if ( comment_ )
- releaseStringValue( comment_ );
+void Value::CommentInfo::setComment(const char *text) {
+ if (comment_)
+ releaseStringValue(comment_);
+ 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);
}
-
-void
-Value::CommentInfo::setComment( const char *text )
-{
- if ( comment_ )
- releaseStringValue( comment_ );
- 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 );
-}
-
-
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -167,93 +150,61 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-# ifndef JSON_VALUE_USE_INTERNAL_MAP
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
// Notes: index_ indicates if the string was allocated when
// a string is stored.
-Value::CZString::CZString( ArrayIndex index )
- : cstr_( 0 )
- , index_( index )
-{
+Value::CZString::CZString(ArrayIndex index) : cstr_(0), index_(index) {}
+
+Value::CZString::CZString(const char *cstr, DuplicationPolicy allocate)
+ : cstr_(allocate == duplicate ? duplicateStringValue(cstr) : cstr),
+ index_(allocate) {}
+
+Value::CZString::CZString(const CZString &other)
+ : cstr_(other.index_ != noDuplication && other.cstr_ != 0
+ ? duplicateStringValue(other.cstr_)
+ : other.cstr_),
+ index_(other.cstr_
+ ? (other.index_ == noDuplication ? noDuplication : duplicate)
+ : other.index_) {}
+
+Value::CZString::~CZString() {
+ if (cstr_ && index_ == duplicate)
+ releaseStringValue(const_cast<char *>(cstr_));
}
-Value::CZString::CZString( const char *cstr, DuplicationPolicy allocate )
- : cstr_( allocate == duplicate ? duplicateStringValue(cstr)
- : cstr )
- , index_( allocate )
-{
+void Value::CZString::swap(CZString &other) {
+ std::swap(cstr_, other.cstr_);
+ std::swap(index_, other.index_);
}
-Value::CZString::CZString( const CZString &other )
-: cstr_( other.index_ != noDuplication && other.cstr_ != 0
- ? duplicateStringValue( other.cstr_ )
- : other.cstr_ )
- , index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
- : other.index_ )
-{
+Value::CZString &Value::CZString::operator=(const CZString &other) {
+ CZString temp(other);
+ swap(temp);
+ return *this;
}
-Value::CZString::~CZString()
-{
- if ( cstr_ && index_ == duplicate )
- releaseStringValue( const_cast<char *>( cstr_ ) );
+bool Value::CZString::operator<(const CZString &other) const {
+ if (cstr_)
+ return strcmp(cstr_, other.cstr_) < 0;
+ return index_ < other.index_;
}
-void
-Value::CZString::swap( CZString &other )
-{
- std::swap( cstr_, other.cstr_ );
- std::swap( index_, other.index_ );
+bool Value::CZString::operator==(const CZString &other) const {
+ if (cstr_)
+ return strcmp(cstr_, other.cstr_) == 0;
+ return index_ == other.index_;
}
-Value::CZString &
-Value::CZString::operator =( const CZString &other )
-{
- CZString temp( other );
- swap( temp );
- return *this;
-}
+ArrayIndex Value::CZString::index() const { return index_; }
-bool
-Value::CZString::operator<( const CZString &other ) const
-{
- if ( cstr_ )
- return strcmp( cstr_, other.cstr_ ) < 0;
- return index_ < other.index_;
-}
+const char *Value::CZString::c_str() const { return cstr_; }
-bool
-Value::CZString::operator==( const CZString &other ) const
-{
- if ( cstr_ )
- return strcmp( cstr_, other.cstr_ ) == 0;
- return index_ == other.index_;
-}
-
-
-ArrayIndex
-Value::CZString::index() const
-{
- return index_;
-}
-
-
-const char *
-Value::CZString::c_str() const
-{
- return cstr_;
-}
-
-bool
-Value::CZString::isStaticString() const
-{
- return index_ == noDuplication;
-}
+bool Value::CZString::isStaticString() const { return index_ == noDuplication; }
#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
-
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -266,1115 +217,906 @@
* memset( this, 0, sizeof(Value) )
* This optimization is used in ValueInternalMap fast allocator.
*/
-Value::Value( ValueType type )
- : type_( type )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(ValueType type)
+ : type_(type), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- switch ( type )
- {
- case nullValue:
- break;
- case intValue:
- case uintValue:
- value_.int_ = 0;
- break;
- case realValue:
- value_.real_ = 0.0;
- break;
- case stringValue:
- value_.string_ = 0;
- break;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ switch (type) {
+ case nullValue:
+ break;
+ case intValue:
+ case uintValue:
+ value_.int_ = 0;
+ break;
+ case realValue:
+ value_.real_ = 0.0;
+ break;
+ case stringValue:
+ value_.string_ = 0;
+ break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- value_.map_ = new ObjectValues();
- break;
+ case arrayValue:
+ case objectValue:
+ value_.map_ = new ObjectValues();
+ break;
#else
- case arrayValue:
- value_.array_ = arrayAllocator()->newArray();
- break;
- case objectValue:
- value_.map_ = mapAllocator()->newMap();
- break;
+ case arrayValue:
+ value_.array_ = arrayAllocator()->newArray();
+ break;
+ case objectValue:
+ value_.map_ = mapAllocator()->newMap();
+ break;
#endif
- case booleanValue:
- value_.bool_ = false;
- break;
- default:
- JSON_ASSERT_UNREACHABLE;
- }
+ case booleanValue:
+ value_.bool_ = false;
+ break;
+ default:
+ JSON_ASSERT_UNREACHABLE;
+ }
}
-
-Value::Value( UInt value )
- : type_( uintValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(UInt value)
+ : type_(uintValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.uint_ = value;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.uint_ = value;
}
-Value::Value( Int value )
- : type_( intValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(Int value)
+ : type_(intValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.int_ = value;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.int_ = value;
}
-
-# if defined(JSON_HAS_INT64)
-Value::Value( Int64 value )
- : type_( intValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+#if defined(JSON_HAS_INT64)
+Value::Value(Int64 value)
+ : type_(intValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.int_ = value;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.int_ = value;
}
-
-Value::Value( UInt64 value )
- : type_( uintValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(UInt64 value)
+ : type_(uintValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.uint_ = value;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.uint_ = value;
}
#endif // defined(JSON_HAS_INT64)
-Value::Value( double value )
- : type_( realValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(double value)
+ : type_(realValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.real_ = value;
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.real_ = value;
}
-Value::Value( const char *value )
- : type_( stringValue )
- , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(const char *value)
+ : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.string_ = duplicateStringValue( value );
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.string_ = duplicateStringValue(value);
}
-
-Value::Value( const char *beginValue,
- const char *endValue )
- : type_( stringValue )
- , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(const char *beginValue, const char *endValue)
+ : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.string_ = duplicateStringValue( beginValue,
- (unsigned int)(endValue - beginValue) );
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.string_ =
+ duplicateStringValue(beginValue, (unsigned int)(endValue - beginValue));
}
-
-Value::Value( const std::string &value )
- : type_( stringValue )
- , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(const std::string &value)
+ : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.string_ = duplicateStringValue( value.c_str(),
- (unsigned int)value.length() );
-
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.string_ =
+ duplicateStringValue(value.c_str(), (unsigned int)value.length());
}
-Value::Value( const StaticString &value )
- : type_( stringValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(const StaticString &value)
+ : type_(stringValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.string_ = const_cast<char *>( value.c_str() );
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.string_ = const_cast<char *>(value.c_str());
}
-
-# ifdef JSON_USE_CPPTL
-Value::Value( const CppTL::ConstString &value )
- : type_( stringValue )
- , allocated_( true )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+#ifdef JSON_USE_CPPTL
+Value::Value(const CppTL::ConstString &value)
+ : type_(stringValue), allocated_(true)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.string_ = duplicateStringValue( value, value.length() );
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.string_ = duplicateStringValue(value, value.length());
}
-# endif
-
-Value::Value( bool value )
- : type_( booleanValue )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
#endif
- , comments_( 0 )
- , start_( 0 )
- , limit_( 0 )
-{
- value_.bool_ = value;
+
+Value::Value(bool value)
+ : type_(booleanValue), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
+#endif
+ ,
+ comments_(0), start_(0), limit_(0) {
+ value_.bool_ = value;
}
-
-Value::Value( const Value &other )
- : type_( other.type_ )
- , allocated_( false )
-# ifdef JSON_VALUE_USE_INTERNAL_MAP
- , itemIsUsed_( 0 )
+Value::Value(const Value &other)
+ : type_(other.type_), allocated_(false)
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+ ,
+ itemIsUsed_(0)
#endif
- , 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_ )
- {
- value_.string_ = duplicateStringValue( other.value_.string_ );
- allocated_ = true;
- }
- else
- {
- value_.string_ = 0;
- allocated_ = false;
- }
- break;
+ ,
+ 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_) {
+ value_.string_ = duplicateStringValue(other.value_.string_);
+ allocated_ = true;
+ } else {
+ value_.string_ = 0;
+ allocated_ = false;
+ }
+ break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- value_.map_ = new ObjectValues( *other.value_.map_ );
- break;
+ case arrayValue:
+ case objectValue:
+ value_.map_ = new ObjectValues(*other.value_.map_);
+ break;
#else
- case arrayValue:
- value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
- break;
- case objectValue:
- value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
- break;
+ case arrayValue:
+ value_.array_ = arrayAllocator()->newArrayCopy(*other.value_.array_);
+ break;
+ case objectValue:
+ value_.map_ = mapAllocator()->newMapCopy(*other.value_.map_);
+ break;
#endif
- 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_ );
- }
- }
+ 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_);
+ }
+ }
}
-
-Value::~Value()
-{
- switch ( type_ )
- {
- case nullValue:
- case intValue:
- case uintValue:
- case realValue:
- case booleanValue:
- break;
- case stringValue:
- if ( allocated_ )
- releaseStringValue( value_.string_ );
- break;
+Value::~Value() {
+ switch (type_) {
+ case nullValue:
+ case intValue:
+ case uintValue:
+ case realValue:
+ case booleanValue:
+ break;
+ case stringValue:
+ if (allocated_)
+ releaseStringValue(value_.string_);
+ break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- delete value_.map_;
- break;
+ case arrayValue:
+ case objectValue:
+ delete value_.map_;
+ break;
#else
- case arrayValue:
- arrayAllocator()->destructArray( value_.array_ );
- break;
- case objectValue:
- mapAllocator()->destructMap( value_.map_ );
- break;
+ case arrayValue:
+ arrayAllocator()->destructArray(value_.array_);
+ break;
+ case objectValue:
+ mapAllocator()->destructMap(value_.map_);
+ break;
#endif
- default:
- JSON_ASSERT_UNREACHABLE;
- }
+ default:
+ JSON_ASSERT_UNREACHABLE;
+ }
- if ( comments_ )
- delete[] comments_;
+ if (comments_)
+ delete[] comments_;
}
-Value &
-Value::operator=( const Value &other )
-{
- Value temp( other );
- swap( temp );
- return *this;
+Value &Value::operator=(const Value &other) {
+ Value temp(other);
+ swap(temp);
+ return *this;
}
-void
-Value::swap( 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;
- std::swap( start_, other.start_ );
- std::swap( limit_, other.limit_ );
+void Value::swap(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;
+ std::swap(start_, other.start_);
+ std::swap(limit_, other.limit_);
}
-ValueType
-Value::type() const
-{
- return type_;
+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;
}
-
-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:
- return ( value_.string_ == 0 && other.value_.string_ )
- || ( other.value_.string_
- && value_.string_
- && strcmp( value_.string_, other.value_.string_ ) < 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:
+ return (value_.string_ == 0 && other.value_.string_) ||
+ (other.value_.string_ && value_.string_ &&
+ strcmp(value_.string_, other.value_.string_) < 0);
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- 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_);
- }
+ 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_);
+ }
#else
- case arrayValue:
- return value_.array_->compare( *(other.value_.array_) ) < 0;
- case objectValue:
- return value_.map_->compare( *(other.value_.map_) ) < 0;
+ case arrayValue:
+ return value_.array_->compare(*(other.value_.array_)) < 0;
+ case objectValue:
+ return value_.map_->compare(*(other.value_.map_)) < 0;
#endif
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- return false; // unreachable
+ 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 !(other < *this); }
-bool
-Value::operator >=( const Value &other ) const
-{
- return !(*this < other);
-}
+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 { 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:
- return ( value_.string_ == other.value_.string_ )
- || ( other.value_.string_
- && value_.string_
- && strcmp( value_.string_, other.value_.string_ ) == 0 );
+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:
+ return (value_.string_ == other.value_.string_) ||
+ (other.value_.string_ && value_.string_ &&
+ strcmp(value_.string_, other.value_.string_) == 0);
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- return value_.map_->size() == other.value_.map_->size()
- && (*value_.map_) == (*other.value_.map_);
+ case arrayValue:
+ case objectValue:
+ return value_.map_->size() == other.value_.map_->size() &&
+ (*value_.map_) == (*other.value_.map_);
#else
- case arrayValue:
- return value_.array_->compare( *(other.value_.array_) ) == 0;
- case objectValue:
- return value_.map_->compare( *(other.value_.map_) ) == 0;
+ case arrayValue:
+ return value_.array_->compare(*(other.value_.array_)) == 0;
+ case objectValue:
+ return value_.map_->compare(*(other.value_.map_)) == 0;
#endif
- default:
- JSON_ASSERT_UNREACHABLE;
- }
- return false; // unreachable
+ default:
+ JSON_ASSERT_UNREACHABLE;
+ }
+ return false; // unreachable
}
-bool
-Value::operator !=( const Value &other ) const
-{
- return !( *this == other );
+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");
+ return value_.string_;
}
-const char *
-Value::asCString() const
-{
- JSON_ASSERT_MESSAGE( type_ == stringValue, "in Json::Value::asCString(): requires stringValue" );
- return value_.string_;
+std::string Value::asString() const {
+ switch (type_) {
+ case nullValue:
+ return "";
+ case stringValue:
+ return value_.string_ ? value_.string_ : "";
+ 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 {
+ return CppTL::ConstString(asString().c_str());
+}
+#endif
-std::string
-Value::asString() const
-{
- switch ( type_ )
- {
- case nullValue:
- return "";
- case stringValue:
- return value_.string_ ? value_.string_ : "";
- 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" );
- }
+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.");
}
-# ifdef JSON_USE_CPPTL
-CppTL::ConstString
-Value::asConstString() const
-{
- return CppTL::ConstString( asString().c_str() );
-}
-# 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::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.");
+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.");
}
-
-# 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)
-
-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
-{
+LargestInt Value::asLargestInt() const {
#if defined(JSON_NO_INT64)
- return asInt();
+ return asInt();
#else
- return asInt64();
+ return asInt64();
#endif
}
-
-LargestUInt
-Value::asLargestUInt() const
-{
+LargestUInt Value::asLargestUInt() const {
#if defined(JSON_NO_INT64)
- return asUInt();
+ return asUInt();
#else
- return asUInt64();
+ return asUInt64();
#endif
}
-
-double
-Value::asDouble() const
-{
- switch ( type_ )
- {
- case intValue:
- return static_cast<double>( value_.int_ );
- case uintValue:
+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_ );
+ 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.");
+ 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:
+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)
- return integerToDouble( value_.uint_ );
+ return static_cast<float>(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 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.");
+ 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:
- return value_.real_ ? true : false;
- default:
- break;
- }
- JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+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:
+ return value_.real_ ? 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;
+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;
+ArrayIndex Value::size() const {
+ switch (type_) {
+ case nullValue:
+ case intValue:
+ case uintValue:
+ case realValue:
+ case booleanValue:
+ case stringValue:
+ return 0;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- 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() );
+ 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());
#else
- case arrayValue:
- return Int( value_.array_->size() );
- case objectValue:
- return Int( value_.map_->size() );
+ case arrayValue:
+ return Int(value_.array_->size());
+ case objectValue:
+ return Int(value_.map_->size());
#endif
- }
- JSON_ASSERT_UNREACHABLE;
- return 0; // unreachable;
+ }
+ JSON_ASSERT_UNREACHABLE;
+ return 0; // unreachable;
}
-
-bool
-Value::empty() const
-{
- if ( isNull() || isArray() || isObject() )
- return size() == 0u;
- else
- return false;
+bool Value::empty() const {
+ if (isNull() || isArray() || isObject())
+ return size() == 0u;
+ else
+ return false;
}
+bool Value::operator!() const { return isNull(); }
-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_ )
- {
+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_) {
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- case objectValue:
- value_.map_->clear();
- break;
+ case arrayValue:
+ case objectValue:
+ value_.map_->clear();
+ break;
#else
- case arrayValue:
- value_.array_->clear();
- break;
- case objectValue:
- value_.map_->clear();
- break;
+ case arrayValue:
+ value_.array_->clear();
+ break;
+ case objectValue:
+ value_.map_->clear();
+ break;
#endif
- default:
- 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 );
+void Value::resize(ArrayIndex newSize) {
+ JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
+ "in Json::Value::resize(): requires arrayValue");
+ if (type_ == nullValue)
+ *this = Value(arrayValue);
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- 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 );
- }
- assert( size() == newSize );
- }
+ 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);
+ }
+ assert(size() == newSize);
+ }
#else
- value_.array_->resize( newSize );
+ value_.array_->resize(newSize);
#endif
}
-
-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 );
+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);
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString key( index );
- ObjectValues::iterator it = value_.map_->lower_bound( key );
- if ( it != value_.map_->end() && (*it).first == key )
- return (*it).second;
+ 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, null );
- it = value_.map_->insert( it, defaultValue );
- return (*it).second;
+ ObjectValues::value_type defaultValue(key, null);
+ it = value_.map_->insert(it, defaultValue);
+ return (*it).second;
#else
- return value_.array_->resolveReference( index );
+ return value_.array_->resolveReference(index);
#endif
}
-
-Value &
-Value::operator[]( int index )
-{
- JSON_ASSERT_MESSAGE( index >= 0, "in Json::Value::operator[](int index): index cannot be negative" );
- return (*this)[ ArrayIndex(index) ];
+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 null;
+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 null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString key( index );
- ObjectValues::const_iterator it = value_.map_->find( key );
- if ( it == value_.map_->end() )
- return null;
- return (*it).second;
+ CZString key(index);
+ ObjectValues::const_iterator it = value_.map_->find(key);
+ if (it == value_.map_->end())
+ return null;
+ return (*it).second;
#else
- Value *value = value_.array_->find( index );
- return value ? *value : null;
+ Value *value = value_.array_->find(index);
+ return value ? *value : null;
#endif
}
-
-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) ];
+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)];
}
-
-Value &
-Value::operator[]( const char *key )
-{
- return resolveReference( key, false );
+Value &Value::operator[](const char *key) {
+ return resolveReference(key, false);
}
-
-Value &
-Value::resolveReference( const char *key,
- bool isStatic )
-{
- JSON_ASSERT_MESSAGE( type_ == nullValue || type_ == objectValue, "in Json::Value::resolveReference(): requires objectValue" );
- if ( type_ == nullValue )
- *this = Value( objectValue );
+Value &Value::resolveReference(const char *key, bool isStatic) {
+ JSON_ASSERT_MESSAGE(
+ type_ == nullValue || type_ == objectValue,
+ "in Json::Value::resolveReference(): requires objectValue");
+ if (type_ == nullValue)
+ *this = Value(objectValue);
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey( key, isStatic ? CZString::noDuplication
- : CZString::duplicateOnCopy );
- ObjectValues::iterator it = value_.map_->lower_bound( actualKey );
- if ( it != value_.map_->end() && (*it).first == actualKey )
- return (*it).second;
+ CZString actualKey(
+ key, isStatic ? CZString::noDuplication : 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, null );
- it = value_.map_->insert( it, defaultValue );
- Value &value = (*it).second;
- return value;
+ ObjectValues::value_type defaultValue(actualKey, null);
+ it = value_.map_->insert(it, defaultValue);
+ Value &value = (*it).second;
+ return value;
#else
- return value_.map_->resolveReference( key, isStatic );
+ return value_.map_->resolveReference(key, isStatic);
#endif
}
-
-Value
-Value::get( ArrayIndex index,
- const Value &defaultValue ) const
-{
- const Value *value = &((*this)[index]);
- return value == &null ? defaultValue : *value;
+Value Value::get(ArrayIndex index, const Value &defaultValue) const {
+ const Value *value = &((*this)[index]);
+ return value == &null ? defaultValue : *value;
}
+bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
-bool
-Value::isValidIndex( ArrayIndex index ) const
-{
- return index < size();
-}
-
-
-
-const Value &
-Value::operator[]( const char *key ) const
-{
- JSON_ASSERT_MESSAGE( type_ == nullValue || type_ == objectValue, "in Json::Value::operator[](char const*)const: requires objectValue" );
- if ( type_ == nullValue )
- return null;
+const Value &Value::operator[](const char *key) const {
+ JSON_ASSERT_MESSAGE(
+ type_ == nullValue || type_ == objectValue,
+ "in Json::Value::operator[](char const*)const: requires objectValue");
+ if (type_ == nullValue)
+ return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey( key, CZString::noDuplication );
- ObjectValues::const_iterator it = value_.map_->find( actualKey );
- if ( it == value_.map_->end() )
- return null;
- return (*it).second;
+ CZString actualKey(key, CZString::noDuplication);
+ ObjectValues::const_iterator it = value_.map_->find(actualKey);
+ if (it == value_.map_->end())
+ return null;
+ return (*it).second;
#else
- const Value *value = value_.map_->find( key );
- return value ? *value : null;
+ const Value *value = value_.map_->find(key);
+ return value ? *value : null;
#endif
}
-
-Value &
-Value::operator[]( const std::string &key )
-{
- return (*this)[ key.c_str() ];
+Value &Value::operator[](const std::string &key) {
+ return (*this)[key.c_str()];
}
-
-const Value &
-Value::operator[]( const std::string &key ) const
-{
- return (*this)[ key.c_str() ];
+const Value &Value::operator[](const std::string &key) const {
+ return (*this)[key.c_str()];
}
-Value &
-Value::operator[]( const StaticString &key )
-{
- return resolveReference( key, true );
+Value &Value::operator[](const StaticString &key) {
+ return resolveReference(key, true);
}
-
-# ifdef JSON_USE_CPPTL
-Value &
-Value::operator[]( const CppTL::ConstString &key )
-{
- return (*this)[ key.c_str() ];
+#ifdef JSON_USE_CPPTL
+Value &Value::operator[](const CppTL::ConstString &key) {
+ return (*this)[key.c_str()];
}
-
-const Value &
-Value::operator[]( const CppTL::ConstString &key ) const
-{
- return (*this)[ key.c_str() ];
+const Value &Value::operator[](const CppTL::ConstString &key) const {
+ return (*this)[key.c_str()];
}
-# endif
+#endif
+Value &Value::append(const Value &value) { return (*this)[size()] = value; }
-Value &
-Value::append( const Value &value )
-{
- return (*this)[size()] = value;
+Value Value::get(const char *key, const Value &defaultValue) const {
+ const Value *value = &((*this)[key]);
+ return value == &null ? defaultValue : *value;
}
-
-Value
-Value::get( const char *key,
- const Value &defaultValue ) const
-{
- const Value *value = &((*this)[key]);
- return value == &null ? defaultValue : *value;
+Value Value::get(const std::string &key, const Value &defaultValue) const {
+ return get(key.c_str(), defaultValue);
}
-
-Value
-Value::get( const std::string &key,
- const Value &defaultValue ) const
-{
- return get( key.c_str(), defaultValue );
-}
-
-Value
-Value::removeMember( const char* key )
-{
- JSON_ASSERT_MESSAGE( type_ == nullValue || type_ == objectValue, "in Json::Value::removeMember(): requires objectValue" );
- if ( type_ == nullValue )
- return null;
+Value Value::removeMember(const char *key) {
+ JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
+ "in Json::Value::removeMember(): requires objectValue");
+ if (type_ == nullValue)
+ return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- CZString actualKey( key, CZString::noDuplication );
- ObjectValues::iterator it = value_.map_->find( actualKey );
- if ( it == value_.map_->end() )
- return null;
- Value old(it->second);
- value_.map_->erase(it);
- return old;
+ CZString actualKey(key, CZString::noDuplication);
+ ObjectValues::iterator it = value_.map_->find(actualKey);
+ if (it == value_.map_->end())
+ return null;
+ Value old(it->second);
+ value_.map_->erase(it);
+ return old;
#else
- Value *value = value_.map_->find( key );
- if (value){
- Value old(*value);
- value_.map_.remove( key );
- return old;
- } else {
- return null;
- }
+ Value *value = value_.map_->find(key);
+ if (value) {
+ Value old(*value);
+ value_.map_.remove(key);
+ return old;
+ } else {
+ return null;
+ }
#endif
}
-Value
-Value::removeMember( const std::string &key )
-{
- return removeMember( key.c_str() );
+Value Value::removeMember(const std::string &key) {
+ return removeMember(key.c_str());
}
-# ifdef JSON_USE_CPPTL
-Value
-Value::get( const CppTL::ConstString &key,
- const Value &defaultValue ) const
-{
- return get( key.c_str(), defaultValue );
-}
-# endif
-
-bool
-Value::isMember( const char *key ) const
-{
- const Value *value = &((*this)[key]);
- return value != &null;
-}
-
-
-bool
-Value::isMember( const std::string &key ) const
-{
- return isMember( key.c_str() );
-}
-
-
-# ifdef JSON_USE_CPPTL
-bool
-Value::isMember( const CppTL::ConstString &key ) const
-{
- return isMember( key.c_str() );
+#ifdef JSON_USE_CPPTL
+Value Value::get(const CppTL::ConstString &key,
+ const Value &defaultValue) const {
+ return get(key.c_str(), defaultValue);
}
#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() );
+bool Value::isMember(const char *key) const {
+ const Value *value = &((*this)[key]);
+ return value != &null;
+}
+
+bool Value::isMember(const std::string &key) const {
+ return isMember(key.c_str());
+}
+
+#ifdef JSON_USE_CPPTL
+bool Value::isMember(const CppTL::ConstString &key) const {
+ return isMember(key.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());
#ifndef JSON_VALUE_USE_INTERNAL_MAP
- ObjectValues::const_iterator it = value_.map_->begin();
- ObjectValues::const_iterator itEnd = value_.map_->end();
- for ( ; it != itEnd; ++it )
- members.push_back( std::string( (*it).first.c_str() ) );
+ ObjectValues::const_iterator it = value_.map_->begin();
+ ObjectValues::const_iterator itEnd = value_.map_->end();
+ for (; it != itEnd; ++it)
+ members.push_back(std::string((*it).first.c_str()));
#else
- ValueInternalMap::IteratorState it;
- ValueInternalMap::IteratorState itEnd;
- value_.map_->makeBeginIterator( it );
- value_.map_->makeEndIterator( itEnd );
- for ( ; !ValueInternalMap::equals( it, itEnd ); ValueInternalMap::increment(it) )
- members.push_back( std::string( ValueInternalMap::key( it ) ) );
+ ValueInternalMap::IteratorState it;
+ ValueInternalMap::IteratorState itEnd;
+ value_.map_->makeBeginIterator(it);
+ value_.map_->makeEndIterator(itEnd);
+ for (; !ValueInternalMap::equals(it, itEnd); ValueInternalMap::increment(it))
+ members.push_back(std::string(ValueInternalMap::key(it)));
#endif
- return members;
+ return members;
}
//
//# ifdef JSON_USE_CPPTL
-//EnumMemberNames
-//Value::enumMemberNames() const
+// EnumMemberNames
+// Value::enumMemberNames() const
//{
// if ( type_ == objectValue )
// {
@@ -1386,11 +1128,11 @@
//}
//
//
-//EnumValues
-//Value::enumValues() const
+// EnumValues
+// Value::enumValues() const
//{
// if ( type_ == objectValue || type_ == arrayValue )
-// return CppTL::Enum::anyValues( *(value_.map_),
+// return CppTL::Enum::anyValues( *(value_.map_),
// CppTL::Type<const Value &>() );
// return EnumValues();
//}
@@ -1402,112 +1144,81 @@
return modf(d, &integral_part) == 0.0;
}
+bool Value::isNull() const { return type_ == nullValue; }
-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::isBool() const
-{
- return type_ == booleanValue;
+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::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::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::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::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::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
-{
+bool Value::isIntegral() const {
#if defined(JSON_HAS_INT64)
return isInt64() || isUInt64();
#else
@@ -1515,466 +1226,309 @@
#endif
}
+bool Value::isDouble() const { return type_ == realValue || isIntegral(); }
-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, CommentPlacement placement) {
+ if (!comments_)
+ comments_ = new CommentInfo[numberOfCommentPlacement];
+ comments_[placement].setComment(comment);
}
-
-bool
-Value::isNumeric() const
-{
- return isIntegral() || isDouble();
+void Value::setComment(const std::string &comment, CommentPlacement placement) {
+ setComment(comment.c_str(), placement);
}
-
-bool
-Value::isString() const
-{
- return type_ == stringValue;
+bool Value::hasComment(CommentPlacement placement) const {
+ return comments_ != 0 && comments_[placement].comment_ != 0;
}
-
-bool
-Value::isArray() const
-{
- return type_ == arrayValue;
+std::string Value::getComment(CommentPlacement placement) const {
+ if (hasComment(placement))
+ return comments_[placement].comment_;
+ return "";
}
+void Value::setOffsetStart(size_t start) { start_ = start; }
-bool
-Value::isObject() const
-{
- return type_ == objectValue;
+void Value::setOffsetLimit(size_t limit) { limit_ = limit; }
+
+size_t Value::getOffsetStart() const { return start_; }
+
+size_t Value::getOffsetLimit() const { return limit_; }
+
+std::string Value::toStyledString() const {
+ StyledWriter writer;
+ return writer.write(*this);
}
-
-void
-Value::setComment( const char *comment,
- CommentPlacement placement )
-{
- if ( !comments_ )
- comments_ = new CommentInfo[numberOfCommentPlacement];
- comments_[placement].setComment( comment );
-}
-
-
-void
-Value::setComment( const std::string &comment,
- CommentPlacement placement )
-{
- setComment( comment.c_str(), placement );
-}
-
-
-bool
-Value::hasComment( CommentPlacement placement ) const
-{
- return comments_ != 0 && comments_[placement].comment_ != 0;
-}
-
-std::string
-Value::getComment( CommentPlacement placement ) const
-{
- if ( hasComment(placement) )
- return comments_[placement].comment_;
- return "";
-}
-
-
-void
-Value::setOffsetStart( size_t start )
-{
- start_ = start;
-}
-
-
-void
-Value::setOffsetLimit( size_t limit )
-{
- limit_ = limit;
-}
-
-
-size_t
-Value::getOffsetStart() const
-{
- return start_;
-}
-
-
-size_t
-Value::getOffsetLimit() const
-{
- return limit_;
-}
-
-
-std::string
-Value::toStyledString() const
-{
- StyledWriter writer;
- return writer.write( *this );
-}
-
-
-Value::const_iterator
-Value::begin() const
-{
- switch ( type_ )
- {
+Value::const_iterator Value::begin() const {
+ switch (type_) {
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if ( value_.array_ )
- {
- ValueInternalArray::IteratorState it;
- value_.array_->makeBeginIterator( it );
- return const_iterator( it );
- }
- break;
- case objectValue:
- if ( value_.map_ )
- {
- ValueInternalMap::IteratorState it;
- value_.map_->makeBeginIterator( it );
- return const_iterator( it );
- }
- break;
+ case arrayValue:
+ if (value_.array_) {
+ ValueInternalArray::IteratorState it;
+ value_.array_->makeBeginIterator(it);
+ return const_iterator(it);
+ }
+ break;
+ case objectValue:
+ if (value_.map_) {
+ ValueInternalMap::IteratorState it;
+ value_.map_->makeBeginIterator(it);
+ return const_iterator(it);
+ }
+ break;
#else
- case arrayValue:
- case objectValue:
- if ( value_.map_ )
- return const_iterator( value_.map_->begin() );
- break;
+ case arrayValue:
+ case objectValue:
+ if (value_.map_)
+ return const_iterator(value_.map_->begin());
+ break;
#endif
- default:
- break;
- }
- return const_iterator();
+ default:
+ break;
+ }
+ return const_iterator();
}
-Value::const_iterator
-Value::end() const
-{
- switch ( type_ )
- {
+Value::const_iterator Value::end() const {
+ switch (type_) {
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if ( value_.array_ )
- {
- ValueInternalArray::IteratorState it;
- value_.array_->makeEndIterator( it );
- return const_iterator( it );
- }
- break;
- case objectValue:
- if ( value_.map_ )
- {
- ValueInternalMap::IteratorState it;
- value_.map_->makeEndIterator( it );
- return const_iterator( it );
- }
- break;
+ case arrayValue:
+ if (value_.array_) {
+ ValueInternalArray::IteratorState it;
+ value_.array_->makeEndIterator(it);
+ return const_iterator(it);
+ }
+ break;
+ case objectValue:
+ if (value_.map_) {
+ ValueInternalMap::IteratorState it;
+ value_.map_->makeEndIterator(it);
+ return const_iterator(it);
+ }
+ break;
#else
- case arrayValue:
- case objectValue:
- if ( value_.map_ )
- return const_iterator( value_.map_->end() );
- break;
+ case arrayValue:
+ case objectValue:
+ if (value_.map_)
+ return const_iterator(value_.map_->end());
+ break;
#endif
- default:
- break;
- }
- return const_iterator();
+ default:
+ break;
+ }
+ return const_iterator();
}
-
-Value::iterator
-Value::begin()
-{
- switch ( type_ )
- {
+Value::iterator Value::begin() {
+ switch (type_) {
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if ( value_.array_ )
- {
- ValueInternalArray::IteratorState it;
- value_.array_->makeBeginIterator( it );
- return iterator( it );
- }
- break;
- case objectValue:
- if ( value_.map_ )
- {
- ValueInternalMap::IteratorState it;
- value_.map_->makeBeginIterator( it );
- return iterator( it );
- }
- break;
+ case arrayValue:
+ if (value_.array_) {
+ ValueInternalArray::IteratorState it;
+ value_.array_->makeBeginIterator(it);
+ return iterator(it);
+ }
+ break;
+ case objectValue:
+ if (value_.map_) {
+ ValueInternalMap::IteratorState it;
+ value_.map_->makeBeginIterator(it);
+ return iterator(it);
+ }
+ break;
#else
- case arrayValue:
- case objectValue:
- if ( value_.map_ )
- return iterator( value_.map_->begin() );
- break;
+ case arrayValue:
+ case objectValue:
+ if (value_.map_)
+ return iterator(value_.map_->begin());
+ break;
#endif
- default:
- break;
- }
- return iterator();
+ default:
+ break;
+ }
+ return iterator();
}
-Value::iterator
-Value::end()
-{
- switch ( type_ )
- {
+Value::iterator Value::end() {
+ switch (type_) {
#ifdef JSON_VALUE_USE_INTERNAL_MAP
- case arrayValue:
- if ( value_.array_ )
- {
- ValueInternalArray::IteratorState it;
- value_.array_->makeEndIterator( it );
- return iterator( it );
- }
- break;
- case objectValue:
- if ( value_.map_ )
- {
- ValueInternalMap::IteratorState it;
- value_.map_->makeEndIterator( it );
- return iterator( it );
- }
- break;
+ case arrayValue:
+ if (value_.array_) {
+ ValueInternalArray::IteratorState it;
+ value_.array_->makeEndIterator(it);
+ return iterator(it);
+ }
+ break;
+ case objectValue:
+ if (value_.map_) {
+ ValueInternalMap::IteratorState it;
+ value_.map_->makeEndIterator(it);
+ return iterator(it);
+ }
+ break;
#else
- case arrayValue:
- case objectValue:
- if ( value_.map_ )
- return iterator( value_.map_->end() );
- break;
+ case arrayValue:
+ case objectValue:
+ if (value_.map_)
+ return iterator(value_.map_->end());
+ break;
#endif
- default:
- break;
- }
- return iterator();
+ default:
+ break;
+ }
+ return iterator();
}
-
// class PathArgument
// //////////////////////////////////////////////////////////////////
-PathArgument::PathArgument()
- : key_()
- , index_()
- , kind_( kindNone )
-{
-}
+PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {}
+PathArgument::PathArgument(ArrayIndex index)
+ : key_(), index_(index), kind_(kindIndex) {}
-PathArgument::PathArgument( ArrayIndex index )
- : key_()
- , index_( index )
- , kind_( kindIndex )
-{
-}
+PathArgument::PathArgument(const char *key)
+ : key_(key), index_(), kind_(kindKey) {}
-
-PathArgument::PathArgument( const char *key )
- : key_( key )
- , index_()
- , kind_( kindKey )
-{
-}
-
-
-PathArgument::PathArgument( const std::string &key )
- : key_( key.c_str() )
- , index_()
- , kind_( kindKey )
-{
-}
+PathArgument::PathArgument(const std::string &key)
+ : key_(key.c_str()), index_(), kind_(kindKey) {}
// class Path
// //////////////////////////////////////////////////////////////////
-Path::Path( const std::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 );
+Path::Path(const std::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 std::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()) );
+void Path::makePath(const std::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);
}
- 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( std::string( beginName, current ) );
- }
- }
+ 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(std::string(beginName, current));
+ }
+ }
}
-
-void
-Path::addPathInArg( const std::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::addPathInArg(const std::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 std::string &/*path*/,
- int /*location*/ )
-{
- // Error: invalid path.
+void Path::invalidPath(const std::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_]);
+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...
}
- 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::null )
- {
- // Error: unable to resolve path (object has no member named '' 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...)
}
- }
- return *node;
+ node = &((*node)[arg.key_]);
+ if (node == &Value::null) {
+ // 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::null )
- return defaultValue;
- }
- }
- 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::null)
+ 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_]);
+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 ...
}
- else if ( arg.kind_ == PathArgument::kindKey )
- {
- if ( !node->isObject() )
- {
- // Error: node is not an object at position...
- }
- node = &((*node)[arg.key_]);
+ node = &((*node)[arg.index_]);
+ } else if (arg.kind_ == PathArgument::kindKey) {
+ if (!node->isObject()) {
+ // Error: node is not an object at position...
}
- }
- return *node;
+ node = &((*node)[arg.key_]);
+ }
+ }
+ return *node;
}
-
} // namespace Json
// vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/lib_json/json_writer.cpp b/src/lib_json/json_writer.cpp
index 3b9027f..cba5d13 100644
--- a/src/lib_json/json_writer.cpp
+++ b/src/lib_json/json_writer.cpp
@@ -4,8 +4,8 @@
// 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"
+#include <json/writer.h>
+#include "json_tool.h"
#endif // if !defined(JSON_IS_AMALGAMATION)
#include <utility>
#include <assert.h>
@@ -14,725 +14,576 @@
#include <sstream>
#include <iomanip>
-#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
-#pragma warning( disable : 4996 ) // disable warning about strdup being deprecated.
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning(disable \
+ : 4996) // disable warning about strdup being deprecated.
#endif
namespace Json {
-static bool containsControlCharacter( const char* str )
-{
- while ( *str )
- {
- if ( isControlCharacter( *(str++) ) )
- return true;
- }
- return false;
+static bool containsControlCharacter(const char *str) {
+ while (*str) {
+ if (isControlCharacter(*(str++)))
+ return true;
+ }
+ return false;
}
-
-std::string valueToString( LargestInt value )
-{
- UIntToStringBuffer buffer;
- char *current = buffer + sizeof(buffer);
- bool isNegative = value < 0;
- if ( isNegative )
- value = -value;
- uintToString( LargestUInt(value), current );
- if ( isNegative )
- *--current = '-';
- assert( current >= buffer );
- return current;
+std::string valueToString(LargestInt value) {
+ UIntToStringBuffer buffer;
+ char *current = buffer + sizeof(buffer);
+ bool isNegative = value < 0;
+ if (isNegative)
+ value = -value;
+ uintToString(LargestUInt(value), current);
+ if (isNegative)
+ *--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;
+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(Int value) {
+ return valueToString(LargestInt(value));
}
-
-std::string valueToString( UInt value )
-{
- return valueToString( LargestUInt(value) );
+std::string valueToString(UInt value) {
+ return valueToString(LargestUInt(value));
}
#endif // # if defined(JSON_HAS_INT64)
+std::string valueToString(double value) {
+ // Allocate a buffer that is more than large enough to store the 16 digits of
+ // precision requested below.
+ char buffer[32];
-std::string valueToString( double value )
-{
- // Allocate a buffer that is more than large enough to store the 16 digits of
- // precision requested below.
- char buffer[32];
-
- // 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 defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning.
- sprintf_s(buffer, sizeof(buffer), "%.16g", value);
+// 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 defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
+ // visual studio 2005 to
+ // avoid warning.
+ sprintf_s(buffer, sizeof(buffer), "%.16g", value);
#else
- snprintf(buffer, sizeof(buffer), "%.16g", value);
+ snprintf(buffer, sizeof(buffer), "%.16g", value);
#endif
- return buffer;
+ return buffer;
}
+std::string valueToString(bool value) { return value ? "true" : "false"; }
-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 ) )
- {
- std::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;
+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)) {
+ std::ostringstream oss;
+ oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
+ << std::setw(4) << static_cast<int>(*c);
+ result += oss.str();
+ } else {
+ result += *c;
}
- }
- result += "\"";
- return result;
+ break;
+ }
+ }
+ result += "\"";
+ return result;
}
// Class Writer
// //////////////////////////////////////////////////////////////////
-Writer::~Writer()
-{
-}
-
+Writer::~Writer() {}
// Class FastWriter
// //////////////////////////////////////////////////////////////////
FastWriter::FastWriter()
- : yamlCompatiblityEnabled_( false ),
- dropNullPlaceholders_( false )
-{
+ : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false) {}
+
+void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }
+
+void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }
+
+std::string FastWriter::write(const Value &root) {
+ document_ = "";
+ writeValue(root);
+ document_ += "\n";
+ return document_;
}
-
-void
-FastWriter::enableYAMLCompatibility()
-{
- yamlCompatiblityEnabled_ = true;
+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:
+ document_ += valueToQuotedString(value.asCString());
+ break;
+ case booleanValue:
+ document_ += valueToString(value.asBool());
+ break;
+ case arrayValue: {
+ document_ += "[";
+ int size = value.size();
+ for (int 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_ += valueToQuotedString(name.c_str());
+ document_ += yamlCompatiblityEnabled_ ? ": " : ":";
+ writeValue(value[name]);
+ }
+ document_ += "}";
+ } break;
+ }
}
-
-void
-FastWriter::dropNullPlaceholders()
-{
- dropNullPlaceholders_ = true;
-}
-
-
-std::string
-FastWriter::write( const Value &root )
-{
- document_ = "";
- writeValue( root );
- 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:
- document_ += valueToQuotedString( value.asCString() );
- break;
- case booleanValue:
- document_ += valueToString( value.asBool() );
- break;
- case arrayValue:
- {
- document_ += "[";
- int size = value.size();
- for ( int 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_ += valueToQuotedString( name.c_str() );
- document_ += yamlCompatiblityEnabled_ ? ": "
- : ":";
- writeValue( value[name] );
- }
- document_ += "}";
- }
- break;
- }
-}
-
-
// Class StyledWriter
// //////////////////////////////////////////////////////////////////
StyledWriter::StyledWriter()
- : rightMargin_( 74 )
- , indentSize_( 3 )
- , addChildValues_()
-{
+ : 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_;
}
-
-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:
- pushValue( valueToQuotedString( value.asCString() ) );
- 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( "}" );
- }
+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:
+ pushValue(valueToQuotedString(value.asCString()));
+ 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);
}
- break;
- }
+ 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( "]" );
+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);
}
- 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_ += " ]";
+ 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 )
-{
- int size = value.size();
- bool isMultiLine = size*3 >= rightMargin_ ;
- childValues_.clear();
- for ( int index =0; index < size && !isMultiLine; ++index )
- {
- const Value &childValue = value[index];
- isMultiLine = isMultiLine ||
- ( (childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0 );
- }
- if ( !isMultiLine ) // check if line length > max line length
- {
- childValues_.reserve( size );
- addChildValues_ = true;
- int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
- for ( int index =0; index < size && !isMultiLine; ++index )
- {
- writeValue( value[index] );
- lineLength += int( childValues_[index].length() );
- isMultiLine = isMultiLine && hasCommentForValue( value[index] );
- }
- addChildValues_ = false;
- isMultiLine = isMultiLine || lineLength >= rightMargin_;
- }
- return isMultiLine;
+bool StyledWriter::isMultineArray(const Value &value) {
+ int size = value.size();
+ bool isMultiLine = size * 3 >= rightMargin_;
+ childValues_.clear();
+ for (int index = 0; index < size && !isMultiLine; ++index) {
+ const Value &childValue = value[index];
+ isMultiLine =
+ isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
+ childValue.size() > 0);
+ }
+ if (!isMultiLine) // check if line length > max line length
+ {
+ childValues_.reserve(size);
+ addChildValues_ = true;
+ int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+ for (int index = 0; index < size && !isMultiLine; ++index) {
+ writeValue(value[index]);
+ lineLength += int(childValues_[index].length());
+ isMultiLine = isMultiLine && hasCommentForValue(value[index]);
+ }
+ 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::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( int(indentString_.size()) >= indentSize_ );
- indentString_.resize( indentString_.size() - indentSize_ );
-}
-
-
-void
-StyledWriter::writeCommentBeforeValue( const Value &root )
-{
- if ( !root.hasComment( commentBefore ) )
+void StyledWriter::writeIndent() {
+ if (!document_.empty()) {
+ char last = document_[document_.length() - 1];
+ if (last == ' ') // already indented
return;
-
- document_ += "\n";
- writeIndent();
- std::string normalizedComment = normalizeEOL( root.getComment( commentBefore ) );
- std::string::const_iterator iter = normalizedComment.begin();
- while ( iter != normalizedComment.end() )
- {
- document_ += *iter;
- if ( *iter == '\n' && *(iter+1) == '/' )
- writeIndent();
- ++iter;
- }
-
- // Comments are stripped of newlines, so add one here
- document_ += "\n";
+ if (last != '\n') // Comments may add new-line
+ document_ += '\n';
+ }
+ document_ += indentString_;
}
-
-void
-StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
- if ( root.hasComment( commentAfterOnSameLine ) )
- document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
-
- if ( root.hasComment( commentAfter ) )
- {
- document_ += "\n";
- document_ += normalizeEOL( root.getComment( commentAfter ) );
- document_ += "\n";
- }
+void StyledWriter::writeWithIndent(const std::string &value) {
+ writeIndent();
+ document_ += value;
}
+void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); }
-bool
-StyledWriter::hasCommentForValue( const Value &value )
-{
- return value.hasComment( commentBefore )
- || value.hasComment( commentAfterOnSameLine )
- || value.hasComment( commentAfter );
+void StyledWriter::unindent() {
+ assert(int(indentString_.size()) >= indentSize_);
+ indentString_.resize(indentString_.size() - indentSize_);
}
+void StyledWriter::writeCommentBeforeValue(const Value &root) {
+ if (!root.hasComment(commentBefore))
+ return;
-std::string
-StyledWriter::normalizeEOL( const std::string &text )
-{
- std::string normalized;
- normalized.reserve( text.length() );
- const char *begin = text.c_str();
- const char *end = begin + text.length();
- const char *current = begin;
- while ( current != end )
- {
- char c = *current++;
- if ( c == '\r' ) // mac or dos EOL
- {
- if ( *current == '\n' ) // convert dos EOL
- ++current;
- normalized += '\n';
- }
- else // handle unix EOL & other char
- normalized += c;
- }
- return normalized;
+ document_ += "\n";
+ writeIndent();
+ std::string normalizedComment = normalizeEOL(root.getComment(commentBefore));
+ std::string::const_iterator iter = normalizedComment.begin();
+ while (iter != normalizedComment.end()) {
+ document_ += *iter;
+ if (*iter == '\n' && *(iter + 1) == '/')
+ writeIndent();
+ ++iter;
+ }
+
+ // Comments are stripped of newlines, so add one here
+ document_ += "\n";
}
+void StyledWriter::writeCommentAfterValueOnSameLine(const Value &root) {
+ if (root.hasComment(commentAfterOnSameLine))
+ document_ += " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
+
+ if (root.hasComment(commentAfter)) {
+ document_ += "\n";
+ document_ += normalizeEOL(root.getComment(commentAfter));
+ document_ += "\n";
+ }
+}
+
+bool StyledWriter::hasCommentForValue(const Value &value) {
+ return value.hasComment(commentBefore) ||
+ value.hasComment(commentAfterOnSameLine) ||
+ value.hasComment(commentAfter);
+}
+
+std::string StyledWriter::normalizeEOL(const std::string &text) {
+ std::string normalized;
+ normalized.reserve(text.length());
+ const char *begin = text.c_str();
+ const char *end = begin + text.length();
+ const char *current = begin;
+ while (current != end) {
+ char c = *current++;
+ if (c == '\r') // mac or dos EOL
+ {
+ if (*current == '\n') // convert dos EOL
+ ++current;
+ normalized += '\n';
+ } else // handle unix EOL & other char
+ normalized += c;
+ }
+ return normalized;
+}
// Class StyledStreamWriter
// //////////////////////////////////////////////////////////////////
-StyledStreamWriter::StyledStreamWriter( std::string indentation )
- : document_(NULL)
- , rightMargin_( 74 )
- , indentation_( indentation )
- , addChildValues_()
-{
+StyledStreamWriter::StyledStreamWriter(std::string indentation)
+ : document_(NULL), rightMargin_(74), indentation_(indentation),
+ addChildValues_() {}
+
+void StyledStreamWriter::write(std::ostream &out, const Value &root) {
+ document_ = &out;
+ addChildValues_ = false;
+ indentString_ = "";
+ writeCommentBeforeValue(root);
+ writeValue(root);
+ writeCommentAfterValueOnSameLine(root);
+ *document_ << "\n";
+ document_ = NULL; // Forget the stream, for safety.
}
-
-void
-StyledStreamWriter::write( std::ostream &out, const Value &root )
-{
- document_ = &out;
- addChildValues_ = false;
- indentString_ = "";
- writeCommentBeforeValue( root );
- 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:
- pushValue( valueToQuotedString( value.asCString() ) );
- 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( "}" );
- }
+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:
+ pushValue(valueToQuotedString(value.asCString()));
+ 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);
}
- break;
- }
+ 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
- {
- writeIndent();
- writeValue( childValue );
- }
- if ( ++index == size )
- {
- writeCommentAfterValueOnSameLine( childValue );
- break;
- }
- *document_ << ",";
- writeCommentAfterValueOnSameLine( childValue );
- }
- unindent();
- writeWithIndent( "]" );
+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 {
+ writeIndent();
+ writeValue(childValue);
+ }
+ if (++index == size) {
+ writeCommentAfterValueOnSameLine(childValue);
+ break;
+ }
+ *document_ << ",";
+ writeCommentAfterValueOnSameLine(childValue);
}
- 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_ << " ]";
+ 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 )
-{
- int size = value.size();
- bool isMultiLine = size*3 >= rightMargin_ ;
- childValues_.clear();
- for ( int index =0; index < size && !isMultiLine; ++index )
- {
- const Value &childValue = value[index];
- isMultiLine = isMultiLine ||
- ( (childValue.isArray() || childValue.isObject()) &&
- childValue.size() > 0 );
- }
- if ( !isMultiLine ) // check if line length > max line length
- {
- childValues_.reserve( size );
- addChildValues_ = true;
- int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
- for ( int index =0; index < size && !isMultiLine; ++index )
- {
- writeValue( value[index] );
- lineLength += int( childValues_[index].length() );
- isMultiLine = isMultiLine && hasCommentForValue( value[index] );
- }
- addChildValues_ = false;
- isMultiLine = isMultiLine || lineLength >= rightMargin_;
- }
- return isMultiLine;
+bool StyledStreamWriter::isMultineArray(const Value &value) {
+ int size = value.size();
+ bool isMultiLine = size * 3 >= rightMargin_;
+ childValues_.clear();
+ for (int index = 0; index < size && !isMultiLine; ++index) {
+ const Value &childValue = value[index];
+ isMultiLine =
+ isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
+ childValue.size() > 0);
+ }
+ if (!isMultiLine) // check if line length > max line length
+ {
+ childValues_.reserve(size);
+ addChildValues_ = true;
+ int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
+ for (int index = 0; index < size && !isMultiLine; ++index) {
+ writeValue(value[index]);
+ lineLength += int(childValues_[index].length());
+ isMultiLine = isMultiLine && hasCommentForValue(value[index]);
+ }
+ 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::pushValue(const std::string &value) {
+ if (addChildValues_)
+ childValues_.push_back(value);
+ else
+ *document_ << value;
}
-
-void
-StyledStreamWriter::writeIndent()
-{
+void StyledStreamWriter::writeIndent() {
/*
Some comments in this method would have been nice. ;-)
@@ -745,98 +596,69 @@
*document_ << '\n';
}
*/
- *document_ << '\n' << indentString_;
+ *document_ << '\n' << indentString_;
}
-
-void
-StyledStreamWriter::writeWithIndent( const std::string &value )
-{
- writeIndent();
- *document_ << value;
+void StyledStreamWriter::writeWithIndent(const std::string &value) {
+ writeIndent();
+ *document_ << value;
}
+void StyledStreamWriter::indent() { indentString_ += indentation_; }
-void
-StyledStreamWriter::indent()
-{
- indentString_ += indentation_;
+void StyledStreamWriter::unindent() {
+ assert(indentString_.size() >= indentation_.size());
+ indentString_.resize(indentString_.size() - indentation_.size());
}
-
-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;
+ *document_ << normalizeEOL(root.getComment(commentBefore));
+ *document_ << "\n";
}
+void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value &root) {
+ if (root.hasComment(commentAfterOnSameLine))
+ *document_ << " " + normalizeEOL(root.getComment(commentAfterOnSameLine));
-void
-StyledStreamWriter::writeCommentBeforeValue( const Value &root )
-{
- if ( !root.hasComment( commentBefore ) )
- return;
- *document_ << normalizeEOL( root.getComment( commentBefore ) );
- *document_ << "\n";
+ if (root.hasComment(commentAfter)) {
+ *document_ << "\n";
+ *document_ << normalizeEOL(root.getComment(commentAfter));
+ *document_ << "\n";
+ }
}
-
-void
-StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
-{
- if ( root.hasComment( commentAfterOnSameLine ) )
- *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
-
- if ( root.hasComment( commentAfter ) )
- {
- *document_ << "\n";
- *document_ << normalizeEOL( root.getComment( commentAfter ) );
- *document_ << "\n";
- }
+bool StyledStreamWriter::hasCommentForValue(const Value &value) {
+ return value.hasComment(commentBefore) ||
+ value.hasComment(commentAfterOnSameLine) ||
+ value.hasComment(commentAfter);
}
-
-bool
-StyledStreamWriter::hasCommentForValue( const Value &value )
-{
- return value.hasComment( commentBefore )
- || value.hasComment( commentAfterOnSameLine )
- || value.hasComment( commentAfter );
+std::string StyledStreamWriter::normalizeEOL(const std::string &text) {
+ std::string normalized;
+ normalized.reserve(text.length());
+ const char *begin = text.c_str();
+ const char *end = begin + text.length();
+ const char *current = begin;
+ while (current != end) {
+ char c = *current++;
+ if (c == '\r') // mac or dos EOL
+ {
+ if (*current == '\n') // convert dos EOL
+ ++current;
+ normalized += '\n';
+ } else // handle unix EOL & other char
+ normalized += c;
+ }
+ return normalized;
}
-
-std::string
-StyledStreamWriter::normalizeEOL( const std::string &text )
-{
- std::string normalized;
- normalized.reserve( text.length() );
- const char *begin = text.c_str();
- const char *end = begin + text.length();
- const char *current = begin;
- while ( current != end )
- {
- char c = *current++;
- if ( c == '\r' ) // mac or dos EOL
- {
- if ( *current == '\n' ) // convert dos EOL
- ++current;
- normalized += '\n';
- }
- else // handle unix EOL & other char
- normalized += c;
- }
- return normalized;
+std::ostream &operator<<(std::ostream &sout, const Value &root) {
+ Json::StyledStreamWriter writer;
+ writer.write(sout, root);
+ return sout;
}
-
-std::ostream& operator<<( std::ostream &sout, const Value &root )
-{
- Json::StyledStreamWriter writer;
- writer.write(sout, root);
- return sout;
-}
-
-
} // namespace Json
// vim: et ts=3 sts=3 sw=3 tw=0
diff --git a/src/test_lib_json/jsontest.cpp b/src/test_lib_json/jsontest.cpp
index c43e7b6..88a49e6 100644
--- a/src/test_lib_json/jsontest.cpp
+++ b/src/test_lib_json/jsontest.cpp
@@ -10,569 +10,435 @@
#if defined(_MSC_VER)
// Used to install a report hook that prevent dialog on assertion and error.
-# include <crtdbg.h>
+#include <crtdbg.h>
#endif // if defined(_MSC_VER)
#if defined(_WIN32)
// Used to prevent dialog on memory fault.
// Limits headers included by Windows.h
-# define WIN32_LEAN_AND_MEAN
-# define NOSERVICE
-# define NOMCX
-# define NOIME
-# define NOSOUND
-# define NOCOMM
-# define NORPC
-# define NOGDI
-# define NOUSER
-# define NODRIVERS
-# define NOLOGERROR
-# define NOPROFILER
-# define NOMEMMGR
-# define NOLFILEIO
-# define NOOPENFILE
-# define NORESOURCE
-# define NOATOM
-# define NOLANGUAGE
-# define NOLSTRING
-# define NODBCS
-# define NOKEYBOARDINFO
-# define NOGDICAPMASKS
-# define NOCOLOR
-# define NOGDIOBJ
-# define NODRAWTEXT
-# define NOTEXTMETRIC
-# define NOSCALABLEFONT
-# define NOBITMAP
-# define NORASTEROPS
-# define NOMETAFILE
-# define NOSYSMETRICS
-# define NOSYSTEMPARAMSINFO
-# define NOMSG
-# define NOWINSTYLES
-# define NOWINOFFSETS
-# define NOSHOWWINDOW
-# define NODEFERWINDOWPOS
-# define NOVIRTUALKEYCODES
-# define NOKEYSTATES
-# define NOWH
-# define NOMENUS
-# define NOSCROLL
-# define NOCLIPBOARD
-# define NOICONS
-# define NOMB
-# define NOSYSCOMMANDS
-# define NOMDI
-# define NOCTLMGR
-# define NOWINMESSAGES
-# include <windows.h>
+#define WIN32_LEAN_AND_MEAN
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#define NOSOUND
+#define NOCOMM
+#define NORPC
+#define NOGDI
+#define NOUSER
+#define NODRIVERS
+#define NOLOGERROR
+#define NOPROFILER
+#define NOMEMMGR
+#define NOLFILEIO
+#define NOOPENFILE
+#define NORESOURCE
+#define NOATOM
+#define NOLANGUAGE
+#define NOLSTRING
+#define NODBCS
+#define NOKEYBOARDINFO
+#define NOGDICAPMASKS
+#define NOCOLOR
+#define NOGDIOBJ
+#define NODRAWTEXT
+#define NOTEXTMETRIC
+#define NOSCALABLEFONT
+#define NOBITMAP
+#define NORASTEROPS
+#define NOMETAFILE
+#define NOSYSMETRICS
+#define NOSYSTEMPARAMSINFO
+#define NOMSG
+#define NOWINSTYLES
+#define NOWINOFFSETS
+#define NOSHOWWINDOW
+#define NODEFERWINDOWPOS
+#define NOVIRTUALKEYCODES
+#define NOKEYSTATES
+#define NOWH
+#define NOMENUS
+#define NOSCROLL
+#define NOCLIPBOARD
+#define NOICONS
+#define NOMB
+#define NOSYSCOMMANDS
+#define NOMDI
+#define NOCTLMGR
+#define NOWINMESSAGES
+#include <windows.h>
#endif // if defined(_WIN32)
namespace JsonTest {
-
// class TestResult
// //////////////////////////////////////////////////////////////////
TestResult::TestResult()
- : predicateId_( 1 )
- , lastUsedPredicateId_( 0 )
- , messageTarget_( 0 )
-{
- // The root predicate has id 0
- rootPredicateNode_.id_ = 0;
- rootPredicateNode_.next_ = 0;
- predicateStackTail_ = &rootPredicateNode_;
+ : predicateId_(1), lastUsedPredicateId_(0), messageTarget_(0) {
+ // The root predicate has id 0
+ rootPredicateNode_.id_ = 0;
+ rootPredicateNode_.next_ = 0;
+ predicateStackTail_ = &rootPredicateNode_;
}
-
-void
-TestResult::setTestName( const std::string &name )
-{
- name_ = name;
-}
+void TestResult::setTestName(const std::string &name) { name_ = name; }
TestResult &
-TestResult::addFailure( const char *file, unsigned int line,
- const char *expr )
-{
- /// Walks the PredicateContext stack adding them to failures_ if not already added.
- unsigned int nestingLevel = 0;
- PredicateContext *lastNode = rootPredicateNode_.next_;
- for ( ; lastNode != 0; lastNode = lastNode->next_ )
- {
- if ( lastNode->id_ > lastUsedPredicateId_ ) // new PredicateContext
- {
- lastUsedPredicateId_ = lastNode->id_;
- addFailureInfo( lastNode->file_, lastNode->line_, lastNode->expr_,
- nestingLevel );
- // Link the PredicateContext to the failure for message target when
- // popping the PredicateContext.
- lastNode->failure_ = &( failures_.back() );
- }
- ++nestingLevel;
- }
+TestResult::addFailure(const char *file, unsigned int line, const char *expr) {
+ /// Walks the PredicateContext stack adding them to failures_ if not already
+ /// added.
+ unsigned int nestingLevel = 0;
+ PredicateContext *lastNode = rootPredicateNode_.next_;
+ for (; lastNode != 0; lastNode = lastNode->next_) {
+ if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
+ {
+ lastUsedPredicateId_ = lastNode->id_;
+ addFailureInfo(
+ lastNode->file_, lastNode->line_, lastNode->expr_, nestingLevel);
+ // Link the PredicateContext to the failure for message target when
+ // popping the PredicateContext.
+ lastNode->failure_ = &(failures_.back());
+ }
+ ++nestingLevel;
+ }
- // Adds the failed assertion
- addFailureInfo( file, line, expr, nestingLevel );
- messageTarget_ = &( failures_.back() );
- return *this;
+ // Adds the failed assertion
+ addFailureInfo(file, line, expr, nestingLevel);
+ messageTarget_ = &(failures_.back());
+ return *this;
}
-
-void
-TestResult::addFailureInfo( const char *file, unsigned int line,
- const char *expr, unsigned int nestingLevel )
-{
- Failure failure;
- failure.file_ = file;
- failure.line_ = line;
- if ( expr )
- {
- failure.expr_ = expr;
- }
- failure.nestingLevel_ = nestingLevel;
- failures_.push_back( failure );
+void TestResult::addFailureInfo(const char *file,
+ unsigned int line,
+ const char *expr,
+ unsigned int nestingLevel) {
+ Failure failure;
+ failure.file_ = file;
+ failure.line_ = line;
+ if (expr) {
+ failure.expr_ = expr;
+ }
+ failure.nestingLevel_ = nestingLevel;
+ failures_.push_back(failure);
}
-
-TestResult &
-TestResult::popPredicateContext()
-{
- PredicateContext *lastNode = &rootPredicateNode_;
- while ( lastNode->next_ != 0 && lastNode->next_->next_ != 0 )
- {
- lastNode = lastNode->next_;
- }
- // Set message target to popped failure
- PredicateContext *tail = lastNode->next_;
- if ( tail != 0 && tail->failure_ != 0 )
- {
- messageTarget_ = tail->failure_;
- }
- // Remove tail from list
- predicateStackTail_ = lastNode;
- lastNode->next_ = 0;
- return *this;
+TestResult &TestResult::popPredicateContext() {
+ PredicateContext *lastNode = &rootPredicateNode_;
+ while (lastNode->next_ != 0 && lastNode->next_->next_ != 0) {
+ lastNode = lastNode->next_;
+ }
+ // Set message target to popped failure
+ PredicateContext *tail = lastNode->next_;
+ if (tail != 0 && tail->failure_ != 0) {
+ messageTarget_ = tail->failure_;
+ }
+ // Remove tail from list
+ predicateStackTail_ = lastNode;
+ lastNode->next_ = 0;
+ return *this;
}
+bool TestResult::failed() const { return !failures_.empty(); }
-bool
-TestResult::failed() const
-{
- return !failures_.empty();
+unsigned int TestResult::getAssertionNestingLevel() const {
+ unsigned int level = 0;
+ const PredicateContext *lastNode = &rootPredicateNode_;
+ while (lastNode->next_ != 0) {
+ lastNode = lastNode->next_;
+ ++level;
+ }
+ return level;
}
+void TestResult::printFailure(bool printTestName) const {
+ if (failures_.empty()) {
+ return;
+ }
-unsigned int
-TestResult::getAssertionNestingLevel() const
-{
- unsigned int level = 0;
- const PredicateContext *lastNode = &rootPredicateNode_;
- while ( lastNode->next_ != 0 )
- {
- lastNode = lastNode->next_;
- ++level;
- }
- return level;
+ if (printTestName) {
+ printf("* Detail of %s test failure:\n", name_.c_str());
+ }
+
+ // Print in reverse to display the callstack in the right order
+ Failures::const_iterator itEnd = failures_.end();
+ for (Failures::const_iterator it = failures_.begin(); it != itEnd; ++it) {
+ const Failure &failure = *it;
+ std::string indent(failure.nestingLevel_ * 2, ' ');
+ if (failure.file_) {
+ printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);
+ }
+ if (!failure.expr_.empty()) {
+ printf("%s\n", failure.expr_.c_str());
+ } else if (failure.file_) {
+ printf("\n");
+ }
+ if (!failure.message_.empty()) {
+ std::string reindented = indentText(failure.message_, indent + " ");
+ printf("%s\n", reindented.c_str());
+ }
+ }
}
-
-void
-TestResult::printFailure( bool printTestName ) const
-{
- if ( failures_.empty() )
- {
- return;
- }
-
- if ( printTestName )
- {
- printf( "* Detail of %s test failure:\n", name_.c_str() );
- }
-
- // Print in reverse to display the callstack in the right order
- Failures::const_iterator itEnd = failures_.end();
- for ( Failures::const_iterator it = failures_.begin(); it != itEnd; ++it )
- {
- const Failure &failure = *it;
- std::string indent( failure.nestingLevel_ * 2, ' ' );
- if ( failure.file_ )
- {
- printf( "%s%s(%d): ", indent.c_str(), failure.file_, failure.line_ );
- }
- if ( !failure.expr_.empty() )
- {
- printf( "%s\n", failure.expr_.c_str() );
- }
- else if ( failure.file_ )
- {
- printf( "\n" );
- }
- if ( !failure.message_.empty() )
- {
- std::string reindented = indentText( failure.message_, indent + " " );
- printf( "%s\n", reindented.c_str() );
- }
- }
+std::string TestResult::indentText(const std::string &text,
+ const std::string &indent) {
+ std::string reindented;
+ std::string::size_type lastIndex = 0;
+ while (lastIndex < text.size()) {
+ std::string::size_type nextIndex = text.find('\n', lastIndex);
+ if (nextIndex == std::string::npos) {
+ nextIndex = text.size() - 1;
+ }
+ reindented += indent;
+ reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
+ lastIndex = nextIndex + 1;
+ }
+ return reindented;
}
-
-std::string
-TestResult::indentText( const std::string &text,
- const std::string &indent )
-{
- std::string reindented;
- std::string::size_type lastIndex = 0;
- while ( lastIndex < text.size() )
- {
- std::string::size_type nextIndex = text.find( '\n', lastIndex );
- if ( nextIndex == std::string::npos )
- {
- nextIndex = text.size() - 1;
- }
- reindented += indent;
- reindented += text.substr( lastIndex, nextIndex - lastIndex + 1 );
- lastIndex = nextIndex + 1;
- }
- return reindented;
+TestResult &TestResult::addToLastFailure(const std::string &message) {
+ if (messageTarget_ != 0) {
+ messageTarget_->message_ += message;
+ }
+ return *this;
}
-
-TestResult &
-TestResult::addToLastFailure( const std::string &message )
-{
- if ( messageTarget_ != 0 )
- {
- messageTarget_->message_ += message;
- }
- return *this;
+TestResult &TestResult::operator<<(Json::Int64 value) {
+ return addToLastFailure(Json::valueToString(value));
}
-TestResult &
-TestResult::operator << ( Json::Int64 value ) {
- return addToLastFailure( Json::valueToString(value) );
+TestResult &TestResult::operator<<(Json::UInt64 value) {
+ return addToLastFailure(Json::valueToString(value));
}
-
-TestResult &
-TestResult::operator << ( Json::UInt64 value ) {
- return addToLastFailure( Json::valueToString(value) );
+TestResult &TestResult::operator<<(bool value) {
+ return addToLastFailure(value ? "true" : "false");
}
-
-TestResult &
-TestResult::operator << ( bool value ) {
- return addToLastFailure(value ? "true" : "false");
-}
-
-
// class TestCase
// //////////////////////////////////////////////////////////////////
-TestCase::TestCase()
- : result_( 0 )
-{
+TestCase::TestCase() : result_(0) {}
+
+TestCase::~TestCase() {}
+
+void TestCase::run(TestResult &result) {
+ result_ = &result;
+ runTestCase();
}
-
-TestCase::~TestCase()
-{
-}
-
-
-void
-TestCase::run( TestResult &result )
-{
- result_ = &result;
- runTestCase();
-}
-
-
-
// class Runner
// //////////////////////////////////////////////////////////////////
-Runner::Runner()
-{
+Runner::Runner() {}
+
+Runner &Runner::add(TestCaseFactory factory) {
+ tests_.push_back(factory);
+ return *this;
}
-
-Runner &
-Runner::add( TestCaseFactory factory )
-{
- tests_.push_back( factory );
- return *this;
+unsigned int Runner::testCount() const {
+ return static_cast<unsigned int>(tests_.size());
}
-
-unsigned int
-Runner::testCount() const
-{
- return static_cast<unsigned int>( tests_.size() );
+std::string Runner::testNameAt(unsigned int index) const {
+ TestCase *test = tests_[index]();
+ std::string name = test->testName();
+ delete test;
+ return name;
}
-
-std::string
-Runner::testNameAt( unsigned int index ) const
-{
- TestCase *test = tests_[index]();
- std::string name = test->testName();
- delete test;
- return name;
-}
-
-
-void
-Runner::runTestAt( unsigned int index, TestResult &result ) const
-{
- TestCase *test = tests_[index]();
- result.setTestName( test->testName() );
- printf( "Testing %s: ", test->testName() );
- fflush( stdout );
+void Runner::runTestAt(unsigned int index, TestResult &result) const {
+ TestCase *test = tests_[index]();
+ result.setTestName(test->testName());
+ printf("Testing %s: ", test->testName());
+ fflush(stdout);
#if JSON_USE_EXCEPTION
- try
- {
+ try {
#endif // if JSON_USE_EXCEPTION
- test->run( result );
+ test->run(result);
#if JSON_USE_EXCEPTION
- }
- catch ( const std::exception &e )
- {
- result.addFailure( __FILE__, __LINE__,
- "Unexpected exception caught:" ) << e.what();
- }
+ }
+ catch (const std::exception &e) {
+ result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
+ << e.what();
+ }
#endif // if JSON_USE_EXCEPTION
- delete test;
- const char *status = result.failed() ? "FAILED"
- : "OK";
- printf( "%s\n", status );
- fflush( stdout );
+ delete test;
+ const char *status = result.failed() ? "FAILED" : "OK";
+ printf("%s\n", status);
+ fflush(stdout);
}
+bool Runner::runAllTest(bool printSummary) const {
+ unsigned int count = testCount();
+ std::deque<TestResult> failures;
+ for (unsigned int index = 0; index < count; ++index) {
+ TestResult result;
+ runTestAt(index, result);
+ if (result.failed()) {
+ failures.push_back(result);
+ }
+ }
-bool
-Runner::runAllTest( bool printSummary ) const
-{
- unsigned int count = testCount();
- std::deque<TestResult> failures;
- for ( unsigned int index = 0; index < count; ++index )
- {
- TestResult result;
- runTestAt( index, result );
- if ( result.failed() )
- {
- failures.push_back( result );
- }
- }
+ if (failures.empty()) {
+ if (printSummary) {
+ printf("All %d tests passed\n", count);
+ }
+ return true;
+ } else {
+ for (unsigned int index = 0; index < failures.size(); ++index) {
+ TestResult &result = failures[index];
+ result.printFailure(count > 1);
+ }
- if ( failures.empty() )
- {
- if ( printSummary )
- {
- printf( "All %d tests passed\n", count );
- }
+ if (printSummary) {
+ unsigned int failedCount = static_cast<unsigned int>(failures.size());
+ unsigned int passedCount = count - failedCount;
+ printf("%d/%d tests passed (%d failure(s))\n",
+ passedCount,
+ count,
+ failedCount);
+ }
+ return false;
+ }
+}
+
+bool Runner::testIndex(const std::string &testName,
+ unsigned int &indexOut) const {
+ unsigned int count = testCount();
+ for (unsigned int index = 0; index < count; ++index) {
+ if (testNameAt(index) == testName) {
+ indexOut = index;
return true;
- }
- else
- {
- for ( unsigned int index = 0; index < failures.size(); ++index )
- {
- TestResult &result = failures[index];
- result.printFailure( count > 1 );
- }
-
- if ( printSummary )
- {
- unsigned int failedCount = static_cast<unsigned int>( failures.size() );
- unsigned int passedCount = count - failedCount;
- printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
- }
- return false;
- }
+ }
+ }
+ return false;
}
-
-bool
-Runner::testIndex( const std::string &testName,
- unsigned int &indexOut ) const
-{
- unsigned int count = testCount();
- for ( unsigned int index = 0; index < count; ++index )
- {
- if ( testNameAt(index) == testName )
- {
- indexOut = index;
- return true;
- }
- }
- return false;
+void Runner::listTests() const {
+ unsigned int count = testCount();
+ for (unsigned int index = 0; index < count; ++index) {
+ printf("%s\n", testNameAt(index).c_str());
+ }
}
-
-void
-Runner::listTests() const
-{
- unsigned int count = testCount();
- for ( unsigned int index = 0; index < count; ++index )
- {
- printf( "%s\n", testNameAt( index ).c_str() );
- }
+int Runner::runCommandLine(int argc, const char *argv[]) const {
+ typedef std::deque<std::string> TestNames;
+ Runner subrunner;
+ for (int index = 1; index < argc; ++index) {
+ std::string opt = argv[index];
+ if (opt == "--list-tests") {
+ listTests();
+ return 0;
+ } else if (opt == "--test-auto") {
+ preventDialogOnCrash();
+ } else if (opt == "--test") {
+ ++index;
+ if (index < argc) {
+ unsigned int testNameIndex;
+ if (testIndex(argv[index], testNameIndex)) {
+ subrunner.add(tests_[testNameIndex]);
+ } else {
+ fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
+ return 2;
+ }
+ } else {
+ printUsage(argv[0]);
+ return 2;
+ }
+ } else {
+ printUsage(argv[0]);
+ return 2;
+ }
+ }
+ bool succeeded;
+ if (subrunner.testCount() > 0) {
+ succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
+ } else {
+ succeeded = runAllTest(true);
+ }
+ return succeeded ? 0 : 1;
}
-
-int
-Runner::runCommandLine( int argc, const char *argv[] ) const
-{
- typedef std::deque<std::string> TestNames;
- Runner subrunner;
- for ( int index = 1; index < argc; ++index )
- {
- std::string opt = argv[index];
- if ( opt == "--list-tests" )
- {
- listTests();
- return 0;
- }
- else if ( opt == "--test-auto" )
- {
- preventDialogOnCrash();
- }
- else if ( opt == "--test" )
- {
- ++index;
- if ( index < argc )
- {
- unsigned int testNameIndex;
- if ( testIndex( argv[index], testNameIndex ) )
- {
- subrunner.add( tests_[testNameIndex] );
- }
- else
- {
- fprintf( stderr, "Test '%s' does not exist!\n", argv[index] );
- return 2;
- }
- }
- else
- {
- printUsage( argv[0] );
- return 2;
- }
- }
- else
- {
- printUsage( argv[0] );
- return 2;
- }
- }
- bool succeeded;
- if ( subrunner.testCount() > 0 )
- {
- succeeded = subrunner.runAllTest( subrunner.testCount() > 1 );
- }
- else
- {
- succeeded = runAllTest( true );
- }
- return succeeded ? 0
- : 1;
-}
-
-
-#if defined(_MSC_VER) && defined(_DEBUG)
+#if defined(_MSC_VER) && defined(_DEBUG)
// Hook MSVCRT assertions to prevent dialog from appearing
-static int
-msvcrtSilentReportHook( int reportType, char *message, int * /*returnValue*/ )
-{
- // The default CRT handling of error and assertion is to display
- // an error dialog to the user.
- // Instead, when an error or an assertion occurs, we force the
- // application to terminate using abort() after display
- // the message on stderr.
- if ( reportType == _CRT_ERROR ||
- reportType == _CRT_ASSERT )
- {
- // calling abort() cause the ReportHook to be called
- // The following is used to detect this case and let's the
- // error handler fallback on its default behaviour (
- // display a warning message)
- static volatile bool isAborting = false;
- if ( isAborting )
- {
- return TRUE;
- }
- isAborting = true;
+static int
+msvcrtSilentReportHook(int reportType, char *message, int * /*returnValue*/) {
+ // The default CRT handling of error and assertion is to display
+ // an error dialog to the user.
+ // Instead, when an error or an assertion occurs, we force the
+ // application to terminate using abort() after display
+ // the message on stderr.
+ if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
+ // calling abort() cause the ReportHook to be called
+ // The following is used to detect this case and let's the
+ // error handler fallback on its default behaviour (
+ // display a warning message)
+ static volatile bool isAborting = false;
+ if (isAborting) {
+ return TRUE;
+ }
+ isAborting = true;
- fprintf( stderr, "CRT Error/Assert:\n%s\n", message );
- fflush( stderr );
- abort();
- }
- // Let's other reportType (_CRT_WARNING) be handled as they would by default
- return FALSE;
+ fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
+ fflush(stderr);
+ abort();
+ }
+ // Let's other reportType (_CRT_WARNING) be handled as they would by default
+ return FALSE;
}
#endif // if defined(_MSC_VER)
-
-void
-Runner::preventDialogOnCrash()
-{
-#if defined(_MSC_VER) && defined(_DEBUG)
- // Install a hook to prevent MSVCRT error and assertion from
- // popping a dialog
- // This function a NO-OP in release configuration
- // (which cause warning since msvcrtSilentReportHook is not referenced)
- _CrtSetReportHook( &msvcrtSilentReportHook );
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
+ // Install a hook to prevent MSVCRT error and assertion from
+ // popping a dialog
+ // This function a NO-OP in release configuration
+ // (which cause warning since msvcrtSilentReportHook is not referenced)
+ _CrtSetReportHook(&msvcrtSilentReportHook);
#endif // if defined(_MSC_VER)
- // @todo investiguate this handler (for buffer overflow)
- // _set_security_error_handler
+// @todo investiguate this handler (for buffer overflow)
+// _set_security_error_handler
#if defined(_WIN32)
- // Prevents the system from popping a dialog for debugging if the
- // application fails due to invalid memory access.
- SetErrorMode( SEM_FAILCRITICALERRORS
- | SEM_NOGPFAULTERRORBOX
- | SEM_NOOPENFILEERRORBOX );
+ // Prevents the system from popping a dialog for debugging if the
+ // application fails due to invalid memory access.
+ SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+ SEM_NOOPENFILEERRORBOX);
#endif // if defined(_WIN32)
}
-void
-Runner::printUsage( const char *appName )
-{
- printf(
- "Usage: %s [options]\n"
- "\n"
- "If --test is not specified, then all the test cases be run.\n"
- "\n"
- "Valid options:\n"
- "--list-tests: print the name of all test cases on the standard\n"
- " output and exit.\n"
- "--test TESTNAME: executes the test case with the specified name.\n"
- " May be repeated.\n"
- "--test-auto: prevent dialog prompting for debugging on crash.\n"
- , appName );
+void Runner::printUsage(const char *appName) {
+ printf("Usage: %s [options]\n"
+ "\n"
+ "If --test is not specified, then all the test cases be run.\n"
+ "\n"
+ "Valid options:\n"
+ "--list-tests: print the name of all test cases on the standard\n"
+ " output and exit.\n"
+ "--test TESTNAME: executes the test case with the specified name.\n"
+ " May be repeated.\n"
+ "--test-auto: prevent dialog prompting for debugging on crash.\n",
+ appName);
}
-
-
// Assertion functions
// //////////////////////////////////////////////////////////////////
-TestResult &
-checkStringEqual( TestResult &result,
- const std::string &expected, const std::string &actual,
- const char *file, unsigned int line, const char *expr )
-{
- if ( expected != actual )
- {
- result.addFailure( file, line, expr );
- result << "Expected: '" << expected << "'\n";
- result << "Actual : '" << actual << "'";
- }
- return result;
+TestResult &checkStringEqual(TestResult &result,
+ const std::string &expected,
+ const std::string &actual,
+ const char *file,
+ unsigned int line,
+ const char *expr) {
+ if (expected != actual) {
+ result.addFailure(file, line, expr);
+ result << "Expected: '" << expected << "'\n";
+ result << "Actual : '" << actual << "'";
+ }
+ return result;
}
-
} // namespace JsonTest
// vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/test_lib_json/jsontest.h b/src/test_lib_json/jsontest.h
index 70a5c2c..6c893a2 100644
--- a/src/test_lib_json/jsontest.h
+++ b/src/test_lib_json/jsontest.h
@@ -4,15 +4,15 @@
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
#ifndef JSONTEST_H_INCLUDED
-# define JSONTEST_H_INCLUDED
+#define JSONTEST_H_INCLUDED
-# include <json/config.h>
-# include <json/value.h>
-# include <json/writer.h>
-# include <stdio.h>
-# include <deque>
-# include <sstream>
-# include <string>
+#include <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include <stdio.h>
+#include <deque>
+#include <sstream>
+#include <string>
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
@@ -20,8 +20,6 @@
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
-
-
/** \brief Unit testing framework.
* \warning: all assertions are non-aborting, test case execution will continue
* even if an assertion namespace.
@@ -30,244 +28,239 @@
*/
namespace JsonTest {
+class Failure {
+public:
+ const char *file_;
+ unsigned int line_;
+ std::string expr_;
+ std::string message_;
+ unsigned int nestingLevel_;
+};
- class Failure
- {
- public:
- const char *file_;
- unsigned int line_;
- std::string expr_;
- std::string message_;
- unsigned int nestingLevel_;
- };
+/// Context used to create the assertion callstack on failure.
+/// Must be a POD to allow inline initialisation without stepping
+/// into the debugger.
+struct PredicateContext {
+ typedef unsigned int Id;
+ Id id_;
+ const char *file_;
+ unsigned int line_;
+ const char *expr_;
+ PredicateContext *next_;
+ /// Related Failure, set when the PredicateContext is converted
+ /// into a Failure.
+ Failure *failure_;
+};
+class TestResult {
+public:
+ TestResult();
- /// Context used to create the assertion callstack on failure.
- /// Must be a POD to allow inline initialisation without stepping
- /// into the debugger.
- struct PredicateContext
- {
- typedef unsigned int Id;
- Id id_;
- const char *file_;
- unsigned int line_;
- const char *expr_;
- PredicateContext *next_;
- /// Related Failure, set when the PredicateContext is converted
- /// into a Failure.
- Failure *failure_;
- };
+ /// \internal Implementation detail for assertion macros
+ /// Not encapsulated to prevent step into when debugging failed assertions
+ /// Incremented by one on assertion predicate entry, decreased by one
+ /// by addPredicateContext().
+ PredicateContext::Id predicateId_;
- class TestResult
- {
- public:
- TestResult();
+ /// \internal Implementation detail for predicate macros
+ PredicateContext *predicateStackTail_;
- /// \internal Implementation detail for assertion macros
- /// Not encapsulated to prevent step into when debugging failed assertions
- /// Incremented by one on assertion predicate entry, decreased by one
- /// by addPredicateContext().
- PredicateContext::Id predicateId_;
+ void setTestName(const std::string &name);
- /// \internal Implementation detail for predicate macros
- PredicateContext *predicateStackTail_;
+ /// Adds an assertion failure.
+ TestResult &
+ addFailure(const char *file, unsigned int line, const char *expr = 0);
- void setTestName( const std::string &name );
+ /// Removes the last PredicateContext added to the predicate stack
+ /// chained list.
+ /// Next messages will be targed at the PredicateContext that was removed.
+ TestResult &popPredicateContext();
- /// Adds an assertion failure.
- TestResult &addFailure( const char *file, unsigned int line,
- const char *expr = 0 );
+ bool failed() const;
- /// Removes the last PredicateContext added to the predicate stack
- /// chained list.
- /// Next messages will be targed at the PredicateContext that was removed.
- TestResult &popPredicateContext();
+ void printFailure(bool printTestName) const;
- bool failed() const;
+ // Generic operator that will work with anything ostream can deal with.
+ template <typename T> TestResult &operator<<(const T &value) {
+ std::ostringstream oss;
+ oss.precision(16);
+ oss.setf(std::ios_base::floatfield);
+ oss << value;
+ return addToLastFailure(oss.str());
+ }
- void printFailure( bool printTestName ) const;
+ // Specialized versions.
+ TestResult &operator<<(bool value);
+ // std:ostream does not support 64bits integers on all STL implementation
+ TestResult &operator<<(Json::Int64 value);
+ TestResult &operator<<(Json::UInt64 value);
- // Generic operator that will work with anything ostream can deal with.
- template <typename T>
- TestResult &operator << ( const T& value ) {
- std::ostringstream oss;
- oss.precision( 16 );
- oss.setf( std::ios_base::floatfield );
- oss << value;
- return addToLastFailure(oss.str());
- }
+private:
+ TestResult &addToLastFailure(const std::string &message);
+ unsigned int getAssertionNestingLevel() const;
+ /// Adds a failure or a predicate context
+ void addFailureInfo(const char *file,
+ unsigned int line,
+ const char *expr,
+ unsigned int nestingLevel);
+ static std::string indentText(const std::string &text,
+ const std::string &indent);
- // Specialized versions.
- TestResult &operator << ( bool value );
- // std:ostream does not support 64bits integers on all STL implementation
- TestResult &operator << ( Json::Int64 value );
- TestResult &operator << ( Json::UInt64 value );
+ typedef std::deque<Failure> Failures;
+ Failures failures_;
+ std::string name_;
+ PredicateContext rootPredicateNode_;
+ PredicateContext::Id lastUsedPredicateId_;
+ /// Failure which is the target of the messages added using operator <<
+ Failure *messageTarget_;
+};
- private:
- TestResult &addToLastFailure( const std::string &message );
- unsigned int getAssertionNestingLevel() const;
- /// Adds a failure or a predicate context
- void addFailureInfo( const char *file, unsigned int line,
- const char *expr, unsigned int nestingLevel );
- static std::string indentText( const std::string &text,
- const std::string &indent );
+class TestCase {
+public:
+ TestCase();
- typedef std::deque<Failure> Failures;
- Failures failures_;
- std::string name_;
- PredicateContext rootPredicateNode_;
- PredicateContext::Id lastUsedPredicateId_;
- /// Failure which is the target of the messages added using operator <<
- Failure *messageTarget_;
- };
+ virtual ~TestCase();
+ void run(TestResult &result);
- class TestCase
- {
- public:
- TestCase();
+ virtual const char *testName() const = 0;
- virtual ~TestCase();
+protected:
+ TestResult *result_;
- void run( TestResult &result );
+private:
+ virtual void runTestCase() = 0;
+};
- virtual const char *testName() const = 0;
+/// Function pointer type for TestCase factory
+typedef TestCase *(*TestCaseFactory)();
- protected:
- TestResult *result_;
+class Runner {
+public:
+ Runner();
- private:
- virtual void runTestCase() = 0;
- };
+ /// Adds a test to the suite
+ Runner &add(TestCaseFactory factory);
- /// Function pointer type for TestCase factory
- typedef TestCase *(*TestCaseFactory)();
+ /// Runs test as specified on the command-line
+ /// If no command-line arguments are provided, run all tests.
+ /// If --list-tests is provided, then print the list of all test cases
+ /// If --test <testname> is provided, then run test testname.
+ int runCommandLine(int argc, const char *argv[]) const;
- class Runner
- {
- public:
- Runner();
+ /// Runs all the test cases
+ bool runAllTest(bool printSummary) const;
- /// Adds a test to the suite
- Runner &add( TestCaseFactory factory );
+ /// Returns the number of test case in the suite
+ unsigned int testCount() const;
- /// Runs test as specified on the command-line
- /// If no command-line arguments are provided, run all tests.
- /// If --list-tests is provided, then print the list of all test cases
- /// If --test <testname> is provided, then run test testname.
- int runCommandLine( int argc, const char *argv[] ) const;
+ /// Returns the name of the test case at the specified index
+ std::string testNameAt(unsigned int index) const;
- /// Runs all the test cases
- bool runAllTest( bool printSummary ) const;
+ /// Runs the test case at the specified index using the specified TestResult
+ void runTestAt(unsigned int index, TestResult &result) const;
- /// Returns the number of test case in the suite
- unsigned int testCount() const;
+ static void printUsage(const char *appName);
- /// Returns the name of the test case at the specified index
- std::string testNameAt( unsigned int index ) const;
+private: // prevents copy construction and assignment
+ Runner(const Runner &other);
+ Runner &operator=(const Runner &other);
- /// Runs the test case at the specified index using the specified TestResult
- void runTestAt( unsigned int index, TestResult &result ) const;
+private:
+ void listTests() const;
+ bool testIndex(const std::string &testName, unsigned int &index) const;
+ static void preventDialogOnCrash();
- static void printUsage( const char *appName );
+private:
+ typedef std::deque<TestCaseFactory> Factories;
+ Factories tests_;
+};
- private: // prevents copy construction and assignment
- Runner( const Runner &other );
- Runner &operator =( const Runner &other );
+template <typename T, typename U>
+TestResult &checkEqual(TestResult &result,
+ const T &expected,
+ const U &actual,
+ const char *file,
+ unsigned int line,
+ const char *expr) {
+ if (static_cast<U>(expected) != actual) {
+ result.addFailure(file, line, expr);
+ result << "Expected: " << static_cast<U>(expected) << "\n";
+ result << "Actual : " << actual;
+ }
+ return result;
+}
- private:
- void listTests() const;
- bool testIndex( const std::string &testName, unsigned int &index ) const;
- static void preventDialogOnCrash();
-
- private:
- typedef std::deque<TestCaseFactory> Factories;
- Factories tests_;
- };
-
- template<typename T, typename U>
- TestResult &
- checkEqual( TestResult &result, const T &expected, const U &actual,
- const char *file, unsigned int line, const char *expr )
- {
- if ( static_cast< U >( expected ) != actual )
- {
- result.addFailure( file, line, expr );
- result << "Expected: " << static_cast< U >( expected ) << "\n";
- result << "Actual : " << actual;
- }
- return result;
- }
-
-
- TestResult &
- checkStringEqual( TestResult &result,
- const std::string &expected, const std::string &actual,
- const char *file, unsigned int line, const char *expr );
+TestResult &checkStringEqual(TestResult &result,
+ const std::string &expected,
+ const std::string &actual,
+ const char *file,
+ unsigned int line,
+ const char *expr);
} // namespace JsonTest
-
/// \brief Asserts that the given expression is true.
/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
/// JSONTEST_ASSERT( x == y );
-#define JSONTEST_ASSERT( expr ) \
- if ( expr ) \
- { \
- } \
- else \
- result_->addFailure( __FILE__, __LINE__, #expr )
+#define JSONTEST_ASSERT(expr) \
+ if (expr) { \
+ } else \
+ result_->addFailure(__FILE__, __LINE__, #expr)
/// \brief Asserts that the given predicate is true.
-/// The predicate may do other assertions and be a member function of the fixture.
-#define JSONTEST_ASSERT_PRED( expr ) \
- { \
- JsonTest::PredicateContext _minitest_Context = { \
- result_->predicateId_, __FILE__, __LINE__, #expr }; \
- result_->predicateStackTail_->next_ = &_minitest_Context; \
- result_->predicateId_ += 1; \
- result_->predicateStackTail_ = &_minitest_Context; \
- (expr); \
- result_->popPredicateContext(); \
- }
+/// The predicate may do other assertions and be a member function of the
+/// fixture.
+#define JSONTEST_ASSERT_PRED(expr) \
+ { \
+ JsonTest::PredicateContext _minitest_Context = { \
+ result_->predicateId_, __FILE__, __LINE__, #expr \
+ }; \
+ result_->predicateStackTail_->next_ = &_minitest_Context; \
+ result_->predicateId_ += 1; \
+ result_->predicateStackTail_ = &_minitest_Context; \
+ (expr); \
+ result_->popPredicateContext(); \
+ }
/// \brief Asserts that two values are equals.
-#define JSONTEST_ASSERT_EQUAL( expected, actual ) \
- JsonTest::checkEqual( *result_, expected, actual, \
- __FILE__, __LINE__, \
- #expected " == " #actual )
+#define JSONTEST_ASSERT_EQUAL(expected, actual) \
+ JsonTest::checkEqual(*result_, \
+ expected, \
+ actual, \
+ __FILE__, \
+ __LINE__, \
+ #expected " == " #actual)
/// \brief Asserts that two values are equals.
-#define JSONTEST_ASSERT_STRING_EQUAL( expected, actual ) \
- JsonTest::checkStringEqual( *result_, \
- std::string(expected), std::string(actual), \
- __FILE__, __LINE__, \
- #expected " == " #actual )
+#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual) \
+ JsonTest::checkStringEqual(*result_, \
+ std::string(expected), \
+ std::string(actual), \
+ __FILE__, \
+ __LINE__, \
+ #expected " == " #actual)
/// \brief Begin a fixture test case.
-#define JSONTEST_FIXTURE( FixtureType, name ) \
- class Test##FixtureType##name : public FixtureType \
- { \
- public: \
- static JsonTest::TestCase *factory() \
- { \
- return new Test##FixtureType##name(); \
- } \
- public: /* overidden from TestCase */ \
- virtual const char *testName() const \
- { \
- return #FixtureType "/" #name; \
- } \
- virtual void runTestCase(); \
- }; \
- \
- void Test##FixtureType##name::runTestCase()
+#define JSONTEST_FIXTURE(FixtureType, name) \
+ class Test##FixtureType##name : public FixtureType { \
+ public: \
+ static JsonTest::TestCase *factory() { \
+ return new Test##FixtureType##name(); \
+ } \
+ \
+ public: /* overidden from TestCase */ \
+ virtual const char *testName() const { return #FixtureType "/" #name; } \
+ virtual void runTestCase(); \
+ }; \
+ \
+ void Test##FixtureType##name::runTestCase()
-#define JSONTEST_FIXTURE_FACTORY( FixtureType, name ) \
- &Test##FixtureType##name::factory
+#define JSONTEST_FIXTURE_FACTORY(FixtureType, name) \
+ &Test##FixtureType##name::factory
-#define JSONTEST_REGISTER_FIXTURE( runner, FixtureType, name ) \
- (runner).add( JSONTEST_FIXTURE_FACTORY( FixtureType, name ) )
+#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name) \
+ (runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
#endif // ifndef JSONTEST_H_INCLUDED
// vim: et ts=4 sts=4 sw=4 tw=0
diff --git a/src/test_lib_json/main.cpp b/src/test_lib_json/main.cpp
index 8eb4996..10810c2 100644
--- a/src/test_lib_json/main.cpp
+++ b/src/test_lib_json/main.cpp
@@ -22,7 +22,6 @@
static const float kfint32max = float(kint32max);
static const float kfuint32max = float(kuint32max);
-
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// Json Library test cases
@@ -30,1629 +29,1557 @@
// //////////////////////////////////////////////////////////////////
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double uint64ToDouble( Json::UInt64 value )
-{
- return static_cast<double>( value );
+static inline double uint64ToDouble(Json::UInt64 value) {
+ return static_cast<double>(value);
}
-#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-static inline double uint64ToDouble( Json::UInt64 value )
-{
- return static_cast<double>( Json::Int64(value/2) ) * 2.0 + Json::Int64(value & 1);
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double uint64ToDouble(Json::UInt64 value) {
+ return static_cast<double>(Json::Int64(value / 2)) * 2.0 +
+ Json::Int64(value & 1);
}
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-struct ValueTest : JsonTest::TestCase
-{
- Json::Value null_;
- Json::Value emptyArray_;
- Json::Value emptyObject_;
- Json::Value integer_;
- Json::Value unsignedInteger_;
- Json::Value smallUnsignedInteger_;
- Json::Value real_;
- Json::Value float_;
- Json::Value array1_;
- Json::Value object1_;
- Json::Value emptyString_;
- Json::Value string1_;
- Json::Value string_;
- Json::Value true_;
- Json::Value false_;
+struct ValueTest : JsonTest::TestCase {
+ Json::Value null_;
+ Json::Value emptyArray_;
+ Json::Value emptyObject_;
+ Json::Value integer_;
+ Json::Value unsignedInteger_;
+ Json::Value smallUnsignedInteger_;
+ Json::Value real_;
+ Json::Value float_;
+ Json::Value array1_;
+ Json::Value object1_;
+ Json::Value emptyString_;
+ Json::Value string1_;
+ Json::Value string_;
+ Json::Value true_;
+ Json::Value false_;
+ ValueTest()
+ : emptyArray_(Json::arrayValue), emptyObject_(Json::objectValue),
+ integer_(123456789), unsignedInteger_(34567890u),
+ smallUnsignedInteger_(Json::Value::UInt(Json::Value::maxInt)),
+ real_(1234.56789), float_(0.00390625f), emptyString_(""), string1_("a"),
+ string_("sometext with space"), true_(true), false_(false) {
+ array1_.append(1234);
+ object1_["id"] = 1234;
+ }
- ValueTest()
- : emptyArray_( Json::arrayValue )
- , emptyObject_( Json::objectValue )
- , integer_( 123456789 )
- , unsignedInteger_( 34567890u )
- , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
- , real_( 1234.56789 )
- , float_( 0.00390625f )
- , emptyString_( "" )
- , string1_( "a" )
- , string_( "sometext with space" )
- , true_( true )
- , false_( false )
- {
- array1_.append( 1234 );
- object1_["id"] = 1234;
- }
+ struct IsCheck {
+ /// Initialize all checks to \c false by default.
+ IsCheck();
- struct IsCheck
- {
- /// Initialize all checks to \c false by default.
- IsCheck();
+ bool isObject_;
+ bool isArray_;
+ bool isBool_;
+ bool isString_;
+ bool isNull_;
- bool isObject_;
- bool isArray_;
- bool isBool_;
- bool isString_;
- bool isNull_;
+ bool isInt_;
+ bool isInt64_;
+ bool isUInt_;
+ bool isUInt64_;
+ bool isIntegral_;
+ bool isDouble_;
+ bool isNumeric_;
+ };
- bool isInt_;
- bool isInt64_;
- bool isUInt_;
- bool isUInt64_;
- bool isIntegral_;
- bool isDouble_;
- bool isNumeric_;
- };
+ void checkConstMemberCount(const Json::Value &value,
+ unsigned int expectedCount);
- void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
+ void checkMemberCount(Json::Value &value, unsigned int expectedCount);
- void checkMemberCount( Json::Value &value, unsigned int expectedCount );
+ void checkIs(const Json::Value &value, const IsCheck &check);
- void checkIs( const Json::Value &value, const IsCheck &check );
+ void checkIsLess(const Json::Value &x, const Json::Value &y);
- void checkIsLess( const Json::Value &x, const Json::Value &y );
+ void checkIsEqual(const Json::Value &x, const Json::Value &y);
- void checkIsEqual( const Json::Value &x, const Json::Value &y );
-
- /// Normalize the representation of floating-point number by stripped leading 0 in exponent.
- static std::string normalizeFloatingPointStr( const std::string &s );
+ /// Normalize the representation of floating-point number by stripped leading
+ /// 0 in exponent.
+ static std::string normalizeFloatingPointStr(const std::string &s);
};
-
-std::string
-ValueTest::normalizeFloatingPointStr( const std::string &s )
-{
- std::string::size_type index = s.find_last_of( "eE" );
- if ( index != std::string::npos )
+std::string ValueTest::normalizeFloatingPointStr(const std::string &s) {
+ std::string::size_type index = s.find_last_of("eE");
+ if (index != std::string::npos) {
+ std::string::size_type hasSign =
+ (s[index + 1] == '+' || s[index + 1] == '-') ? 1 : 0;
+ std::string::size_type exponentStartIndex = index + 1 + hasSign;
+ std::string normalized = s.substr(0, exponentStartIndex);
+ std::string::size_type indexDigit =
+ s.find_first_not_of('0', exponentStartIndex);
+ std::string exponent = "0";
+ if (indexDigit !=
+ std::string::npos) // There is an exponent different from 0
{
- std::string::size_type hasSign = (s[index+1] == '+' || s[index+1] == '-') ? 1 : 0;
- std::string::size_type exponentStartIndex = index + 1 + hasSign;
- std::string normalized = s.substr( 0, exponentStartIndex );
- std::string::size_type indexDigit = s.find_first_not_of( '0', exponentStartIndex );
- std::string exponent = "0";
- if ( indexDigit != std::string::npos ) // There is an exponent different from 0
- {
- exponent = s.substr( indexDigit );
- }
- return normalized + exponent;
+ exponent = s.substr(indexDigit);
}
- return s;
+ return normalized + exponent;
+ }
+ return s;
}
-
-JSONTEST_FIXTURE( ValueTest, checkNormalizeFloatingPointStr )
-{
- JSONTEST_ASSERT_STRING_EQUAL( "0.0", normalizeFloatingPointStr("0.0") );
- JSONTEST_ASSERT_STRING_EQUAL( "0e0", normalizeFloatingPointStr("0e0") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234.0", normalizeFloatingPointStr("1234.0") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234.0e0", normalizeFloatingPointStr("1234.0e0") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234.0e+0", normalizeFloatingPointStr("1234.0e+0") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e-1", normalizeFloatingPointStr("1234e-1") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e10") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e10", normalizeFloatingPointStr("1234e010") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e+10", normalizeFloatingPointStr("1234e+010") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e-10", normalizeFloatingPointStr("1234e-010") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e+100", normalizeFloatingPointStr("1234e+100") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e-100", normalizeFloatingPointStr("1234e-100") );
- JSONTEST_ASSERT_STRING_EQUAL( "1234e+1", normalizeFloatingPointStr("1234e+001") );
+JSONTEST_FIXTURE(ValueTest, checkNormalizeFloatingPointStr) {
+ JSONTEST_ASSERT_STRING_EQUAL("0.0", normalizeFloatingPointStr("0.0"));
+ JSONTEST_ASSERT_STRING_EQUAL("0e0", normalizeFloatingPointStr("0e0"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234.0", normalizeFloatingPointStr("1234.0"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234.0e0",
+ normalizeFloatingPointStr("1234.0e0"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234.0e+0",
+ normalizeFloatingPointStr("1234.0e+0"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e-1", normalizeFloatingPointStr("1234e-1"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e10", normalizeFloatingPointStr("1234e10"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e10",
+ normalizeFloatingPointStr("1234e010"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e+10",
+ normalizeFloatingPointStr("1234e+010"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e-10",
+ normalizeFloatingPointStr("1234e-010"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e+100",
+ normalizeFloatingPointStr("1234e+100"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e-100",
+ normalizeFloatingPointStr("1234e-100"));
+ JSONTEST_ASSERT_STRING_EQUAL("1234e+1",
+ normalizeFloatingPointStr("1234e+001"));
}
-
-JSONTEST_FIXTURE( ValueTest, memberCount )
-{
- JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
- JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
- JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(unsignedInteger_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(smallUnsignedInteger_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
- JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
+JSONTEST_FIXTURE(ValueTest, memberCount) {
+ JSONTEST_ASSERT_PRED(checkMemberCount(emptyArray_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(emptyObject_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(array1_, 1));
+ JSONTEST_ASSERT_PRED(checkMemberCount(object1_, 1));
+ JSONTEST_ASSERT_PRED(checkMemberCount(null_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(integer_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(unsignedInteger_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(smallUnsignedInteger_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(real_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(emptyString_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(string_, 0));
+ JSONTEST_ASSERT_PRED(checkMemberCount(true_, 0));
}
+JSONTEST_FIXTURE(ValueTest, objects) {
+ // Types
+ IsCheck checks;
+ checks.isObject_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(emptyObject_, checks));
+ JSONTEST_ASSERT_PRED(checkIs(object1_, checks));
-JSONTEST_FIXTURE( ValueTest, objects )
-{
- // Types
- IsCheck checks;
- checks.isObject_ = true;
- JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
- JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
+ JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
- JSONTEST_ASSERT_EQUAL(Json::objectValue, emptyObject_.type());
+ // Empty object okay
+ JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
- // Empty object okay
- JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::nullValue));
+ // Non-empty object not okay
+ JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
- // Non-empty object not okay
- JSONTEST_ASSERT(!object1_.isConvertibleTo(Json::nullValue));
+ // Always okay
+ JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
- // Always okay
- JSONTEST_ASSERT(emptyObject_.isConvertibleTo(Json::objectValue));
+ // Never okay
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
- // Never okay
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(!emptyObject_.isConvertibleTo(Json::stringValue));
+ // Access through const reference
+ const Json::Value &constObject = object1_;
- // Access through const reference
- const Json::Value &constObject = object1_;
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), constObject["id"]);
- JSONTEST_ASSERT_EQUAL(Json::Value(), constObject["unknown id"]);
+ // Access through non-const reference
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
- // Access through non-const reference
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), object1_["id"]);
- JSONTEST_ASSERT_EQUAL(Json::Value(), object1_["unknown id"]);
-
- object1_["some other id"] = "foo";
- JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
+ object1_["some other id"] = "foo";
+ JSONTEST_ASSERT_EQUAL(Json::Value("foo"), object1_["some other id"]);
}
+JSONTEST_FIXTURE(ValueTest, arrays) {
+ const unsigned int index0 = 0;
-JSONTEST_FIXTURE( ValueTest, arrays )
-{
- const unsigned int index0 = 0;
+ // Types
+ IsCheck checks;
+ checks.isArray_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(emptyArray_, checks));
+ JSONTEST_ASSERT_PRED(checkIs(array1_, checks));
- // Types
- IsCheck checks;
- checks.isArray_ = true;
- JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
- JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
+ JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
- JSONTEST_ASSERT_EQUAL(Json::arrayValue, array1_.type());
+ // Empty array okay
+ JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
- // Empty array okay
- JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::nullValue));
+ // Non-empty array not okay
+ JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
- // Non-empty array not okay
- JSONTEST_ASSERT(!array1_.isConvertibleTo(Json::nullValue));
+ // Always okay
+ JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
- // Always okay
- JSONTEST_ASSERT(emptyArray_.isConvertibleTo(Json::arrayValue));
+ // Never okay
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
- // Never okay
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(!emptyArray_.isConvertibleTo(Json::stringValue));
+ // Access through const reference
+ const Json::Value &constArray = array1_;
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
- // Access through const reference
- const Json::Value &constArray = array1_;
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[index0]);
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), constArray[0]);
+ // Access through non-const reference
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
- // Access through non-const reference
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[index0]);
- JSONTEST_ASSERT_EQUAL(Json::Value(1234), array1_[0]);
-
- array1_[2] = Json::Value(17);
- JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
- JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
+ array1_[2] = Json::Value(17);
+ JSONTEST_ASSERT_EQUAL(Json::Value(), array1_[1]);
+ JSONTEST_ASSERT_EQUAL(Json::Value(17), array1_[2]);
}
+JSONTEST_FIXTURE(ValueTest, null) {
+ JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
-JSONTEST_FIXTURE( ValueTest, null )
-{
- JSONTEST_ASSERT_EQUAL(Json::nullValue, null_.type());
+ IsCheck checks;
+ checks.isNull_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(null_, checks));
- IsCheck checks;
- checks.isNull_ = true;
- JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(null_.isConvertibleTo(Json::objectValue));
-
- JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
- JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
- JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
- JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
- JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
+ JSONTEST_ASSERT_EQUAL(Json::Int(0), null_.asInt());
+ JSONTEST_ASSERT_EQUAL(Json::LargestInt(0), null_.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(Json::UInt(0), null_.asUInt());
+ JSONTEST_ASSERT_EQUAL(Json::LargestUInt(0), null_.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, null_.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, null_.asFloat());
+ JSONTEST_ASSERT_STRING_EQUAL("", null_.asString());
}
+JSONTEST_FIXTURE(ValueTest, strings) {
+ JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
-JSONTEST_FIXTURE( ValueTest, strings )
-{
- JSONTEST_ASSERT_EQUAL(Json::stringValue, string1_.type());
+ IsCheck checks;
+ checks.isString_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(emptyString_, checks));
+ JSONTEST_ASSERT_PRED(checkIs(string_, checks));
+ JSONTEST_ASSERT_PRED(checkIs(string1_, checks));
- IsCheck checks;
- checks.isString_ = true;
- JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
- JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
- JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
+ // Empty string okay
+ JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
- // Empty string okay
- JSONTEST_ASSERT(emptyString_.isConvertibleTo(Json::nullValue));
+ // Non-empty string not okay
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
- // Non-empty string not okay
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::nullValue));
+ // Always okay
+ JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
- // Always okay
- JSONTEST_ASSERT(string1_.isConvertibleTo(Json::stringValue));
+ // Never okay
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
- // Never okay
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!string1_.isConvertibleTo(Json::realValue));
-
- JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
- JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
+ JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asString());
+ JSONTEST_ASSERT_STRING_EQUAL("a", string1_.asCString());
}
+JSONTEST_FIXTURE(ValueTest, bools) {
+ JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
-JSONTEST_FIXTURE( ValueTest, bools )
-{
- JSONTEST_ASSERT_EQUAL(Json::booleanValue, false_.type());
+ IsCheck checks;
+ checks.isBool_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(false_, checks));
+ JSONTEST_ASSERT_PRED(checkIs(true_, checks));
- IsCheck checks;
- checks.isBool_ = true;
- JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
- JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
+ // False okay
+ JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
- // False okay
- JSONTEST_ASSERT(false_.isConvertibleTo(Json::nullValue));
+ // True not okay
+ JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
- // True not okay
- JSONTEST_ASSERT(!true_.isConvertibleTo(Json::nullValue));
+ // Always okay
+ JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
- // Always okay
- JSONTEST_ASSERT(true_.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(true_.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(true_.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(true_.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(true_.isConvertibleTo(Json::stringValue));
+ // Never okay
+ JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
- // Never okay
- JSONTEST_ASSERT(!true_.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!true_.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT_EQUAL(true, true_.asBool());
+ JSONTEST_ASSERT_EQUAL(1, true_.asInt());
+ JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
+ JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
+ JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
- JSONTEST_ASSERT_EQUAL(true, true_.asBool());
- JSONTEST_ASSERT_EQUAL(1, true_.asInt());
- JSONTEST_ASSERT_EQUAL(1, true_.asLargestInt());
- JSONTEST_ASSERT_EQUAL(1, true_.asUInt());
- JSONTEST_ASSERT_EQUAL(1, true_.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(1.0, true_.asDouble());
- JSONTEST_ASSERT_EQUAL(1.0, true_.asFloat());
-
- JSONTEST_ASSERT_EQUAL(false, false_.asBool());
- JSONTEST_ASSERT_EQUAL(0, false_.asInt());
- JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
- JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, false_.asBool());
+ JSONTEST_ASSERT_EQUAL(0, false_.asInt());
+ JSONTEST_ASSERT_EQUAL(0, false_.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, false_.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, false_.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, false_.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, false_.asFloat());
}
+JSONTEST_FIXTURE(ValueTest, integers) {
+ IsCheck checks;
+ Json::Value val;
-JSONTEST_FIXTURE( ValueTest, integers )
-{
- IsCheck checks;
- Json::Value val;
+ // Conversions that don't depend on the value.
+ JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
- // Conversions that don't depend on the value.
- JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(Json::Value(17).isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!Json::Value(17).isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(Json::Value(17U).isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!Json::Value(17U).isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(Json::Value(17.0).isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!Json::Value(17.0).isConvertibleTo(Json::objectValue));
+ // Default int
+ val = Json::Value(Json::intValue);
- // Default int
- val = Json::Value(Json::intValue);
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ // Default uint
+ val = Json::Value(Json::uintValue);
- // Default uint
- val = Json::Value(Json::uintValue);
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ // Default real
+ val = Json::Value(Json::realValue);
- // Default real
- val = Json::Value(Json::realValue);
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ // Zero (signed constructor arg)
+ val = Json::Value(0);
- // Zero (signed constructor arg)
- val = Json::Value(0);
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ // Zero (unsigned constructor arg)
+ val = Json::Value(0u);
- // Zero (unsigned constructor arg)
- val = Json::Value(0u);
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ // Zero (floating-point constructor arg)
+ val = Json::Value(0.0);
- // Zero (floating-point constructor arg)
- val = Json::Value(0.0);
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
-
- JSONTEST_ASSERT_EQUAL(0, val.asInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(0, val.asUInt());
- JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(false, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
+ JSONTEST_ASSERT_EQUAL(0, val.asInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(0, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(0.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(false, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("0", val.asString());
- // 2^20 (signed constructor arg)
- val = Json::Value(1 << 20);
+ // 2^20 (signed constructor arg)
+ val = Json::Value(1 << 20);
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
- // 2^20 (unsigned constructor arg)
- val = Json::Value(Json::UInt(1 << 20));
+ // 2^20 (unsigned constructor arg)
+ val = Json::Value(Json::UInt(1 << 20));
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1048576", val.asString());
- // 2^20 (floating-point constructor arg)
- val = Json::Value((1 << 20) / 1.0);
+ // 2^20 (floating-point constructor arg)
+ val = Json::Value((1 << 20) / 1.0);
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
- JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1048576", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((1 << 20), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1048576",
+ normalizeFloatingPointStr(val.asString()));
- // -2^20
- val = Json::Value(-(1 << 20));
+ // -2^20
+ val = Json::Value(-(1 << 20));
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
- JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
- JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asInt());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-(1 << 20), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("-1048576", val.asString());
- // int32 max
- val = Json::Value(kint32max);
+ // int32 max
+ val = Json::Value(kint32max);
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
- JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
- JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
- JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(kint32max, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kfint32max, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("2147483647", val.asString());
- // int32 min
- val = Json::Value(kint32min);
+ // int32 min
+ val = Json::Value(kint32min);
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt_ = true;
- checks.isInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt_ = true;
+ checks.isInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
- JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
- JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asInt());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kint32min, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("-2147483648", val.asString());
- // uint32 max
- val = Json::Value(kuint32max);
+ // uint32 max
+ val = Json::Value(kuint32max);
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isUInt_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isUInt_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
#ifndef JSON_NO_INT64
- JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestInt());
#endif
- JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
- JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
- JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(kuint32max, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(kfuint32max, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("4294967295", val.asString());
#ifdef JSON_NO_INT64
- // int64 max
- val = Json::Value(double(kint64max));
+ // int64 max
+ val = Json::Value(double(kint64max));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
+ JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("9.22337e+18", val.asString());
- // int64 min
- val = Json::Value(double(kint64min));
+ // int64 min
+ val = Json::Value(double(kint64min));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
+ JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("-9.22337e+18", val.asString());
- // uint64 max
- val = Json::Value(double(kuint64max));
+ // uint64 max
+ val = Json::Value(double(kuint64max));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
-#else // ifdef JSON_NO_INT64
- // 2^40 (signed constructor arg)
- val = Json::Value(Json::Int64(1) << 40);
+ JSONTEST_ASSERT_EQUAL(double(kuint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kuint64max), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1.84467e+19", val.asString());
+#else // ifdef JSON_NO_INT64
+ // 2^40 (signed constructor arg)
+ val = Json::Value(Json::Int64(1) << 40);
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
- // 2^40 (unsigned constructor arg)
- val = Json::Value(Json::UInt64(1) << 40);
+ // 2^40 (unsigned constructor arg)
+ val = Json::Value(Json::UInt64(1) << 40);
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1099511627776", val.asString());
- // 2^40 (floating-point constructor arg)
- val = Json::Value((Json::Int64(1) << 40) / 1.0);
+ // 2^40 (floating-point constructor arg)
+ val = Json::Value((Json::Int64(1) << 40) / 1.0);
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1099511627776", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asUInt64());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 40), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1099511627776",
+ normalizeFloatingPointStr(val.asString()));
- // -2^40
- val = Json::Value(-(Json::Int64(1) << 40));
+ // -2^40
+ val = Json::Value(-(Json::Int64(1) << 40));
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
- JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
- JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
+ JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asInt64());
+ JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-(Json::Int64(1) << 40), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("-1099511627776", val.asString());
- // int64 max
- val = Json::Value(Json::Int64(kint64max));
+ // int64 max
+ val = Json::Value(Json::Int64(kint64max));
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
- JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
- JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asInt64());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(kint64max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(double(kint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64max), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("9223372036854775807", val.asString());
- // int64 max (floating point constructor). Note that kint64max is not exactly
- // representable as a double, and will be rounded up to be higher.
- val = Json::Value(double(kint64max));
+ // int64 max (floating point constructor). Note that kint64max is not exactly
+ // representable as a double, and will be rounded up to be higher.
+ val = Json::Value(double(kint64max));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
- JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(Json::UInt64(1) << 63, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(uint64ToDouble(Json::UInt64(1) << 63), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(Json::UInt64(1) << 63)),
+ val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("9.223372036854776e+18",
+ normalizeFloatingPointStr(val.asString()));
- // int64 min
- val = Json::Value(Json::Int64(kint64min));
+ // int64 min
+ val = Json::Value(Json::Int64(kint64min));
- JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::intValue, val.type());
- checks = IsCheck();
- checks.isInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ 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(double(kint64min), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
+ JSONTEST_ASSERT_EQUAL(kint64min, val.asInt64());
+ JSONTEST_ASSERT_EQUAL(kint64min, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(double(kint64min), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(kint64min), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("-9223372036854775808", val.asString());
- // int64 min (floating point constructor). Note that kint64min *is* exactly
- // representable as a double.
- val = Json::Value(double(kint64min));
+ // 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());
+ 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 ) );
+ checks = IsCheck();
+ checks.isInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ 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());
- JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18", normalizeFloatingPointStr(val.asString()));
+ 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());
+ JSONTEST_ASSERT_STRING_EQUAL("-9.223372036854776e+18",
+ normalizeFloatingPointStr(val.asString()));
- // 10^19
- const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>( 1e19 );
- val = Json::Value(Json::UInt64(ten_to_19));
+ // 10^19
+ const Json::UInt64 ten_to_19 = static_cast<Json::UInt64>(1e19);
+ val = Json::Value(Json::UInt64(ten_to_19));
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- checks = IsCheck();
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
- JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
+ JSONTEST_ASSERT_EQUAL(ten_to_19, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(ten_to_19, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(uint64ToDouble(ten_to_19), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(ten_to_19)), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("10000000000000000000", val.asString());
- // 10^19 (double constructor). Note that 10^19 is not exactly representable
- // as a double.
- val = Json::Value(uint64ToDouble(ten_to_19));
+ // 10^19 (double constructor). Note that 10^19 is not exactly representable
+ // as a double.
+ val = Json::Value(uint64ToDouble(ten_to_19));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
- JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1e+19", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(1e19, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(1e19, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1e+19",
+ normalizeFloatingPointStr(val.asString()));
- // uint64 max
- val = Json::Value(Json::UInt64(kuint64max));
+ // uint64 max
+ val = Json::Value(Json::UInt64(kuint64max));
- JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::uintValue, val.type());
- checks = IsCheck();
- checks.isUInt64_ = true;
- checks.isIntegral_ = true;
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isUInt64_ = true;
+ checks.isIntegral_ = true;
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
- JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
+ JSONTEST_ASSERT_EQUAL(kuint64max, val.asUInt64());
+ JSONTEST_ASSERT_EQUAL(kuint64max, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(uint64ToDouble(kuint64max), val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(uint64ToDouble(kuint64max)), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("18446744073709551615", val.asString());
- // uint64 max (floating point constructor). Note that kuint64max is not
- // exactly representable as a double, and will be rounded up to be higher.
- val = Json::Value(uint64ToDouble(kuint64max));
+ // uint64 max (floating point constructor). Note that kuint64max is not
+ // exactly representable as a double, and will be rounded up to be higher.
+ val = Json::Value(uint64ToDouble(kuint64max));
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
- JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(18446744073709551616.0, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_STRING_EQUAL("1.844674407370955e+19",
+ normalizeFloatingPointStr(val.asString()));
#endif
}
+JSONTEST_FIXTURE(ValueTest, nonIntegers) {
+ IsCheck checks;
+ Json::Value val;
-JSONTEST_FIXTURE( ValueTest, nonIntegers )
-{
- IsCheck checks;
- Json::Value val;
+ // Small positive number
+ val = Json::Value(1.5);
- // Small positive number
- val = Json::Value(1.5);
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(1, val.asInt());
+ JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(1, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_EQUAL("1.5", val.asString());
- JSONTEST_ASSERT_EQUAL(1.5, val.asDouble());
- JSONTEST_ASSERT_EQUAL(1.5, val.asFloat());
- JSONTEST_ASSERT_EQUAL(1, val.asInt());
- JSONTEST_ASSERT_EQUAL(1, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(1, val.asUInt());
- JSONTEST_ASSERT_EQUAL(1, val.asLargestUInt());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("1.5", val.asString());
+ // Small negative number
+ val = Json::Value(-1.5);
- // Small negative number
- val = Json::Value(-1.5);
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-1, val.asInt());
+ JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
- JSONTEST_ASSERT_EQUAL(-1.5, val.asDouble());
- JSONTEST_ASSERT_EQUAL(-1.5, val.asFloat());
- JSONTEST_ASSERT_EQUAL(-1, val.asInt());
- JSONTEST_ASSERT_EQUAL(-1, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("-1.5", val.asString());
+ // A bit over int32 max
+ val = Json::Value(kint32max + 0.5);
- // A bit over int32 max
- val = Json::Value(kint32max + 0.5);
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
-
- JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
- JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
+ JSONTEST_ASSERT_EQUAL(2147483647.5, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(2147483647.5), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(2147483647U, val.asUInt());
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL(2147483647L, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(2147483647U, val.asLargestUInt());
#endif
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("2147483647.5", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_EQUAL("2147483647.5",
+ normalizeFloatingPointStr(val.asString()));
- // A bit under int32 min
- val = Json::Value(kint32min - 0.5);
+ // A bit under int32 min
+ val = Json::Value(kint32min - 0.5);
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(-2147483648.5, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(-2147483648.5), val.asFloat());
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL(-Json::Int64(1)<< 31, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL(-Json::Int64(1) << 31, val.asLargestInt());
#endif
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("-2147483648.5", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_EQUAL("-2147483648.5",
+ normalizeFloatingPointStr(val.asString()));
- // A bit over uint32 max
- val = Json::Value(kuint32max + 0.5);
+ // A bit over uint32 max
+ val = Json::Value(kuint32max + 0.5);
- JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
+ JSONTEST_ASSERT_EQUAL(Json::realValue, val.type());
- checks = IsCheck();
- checks.isDouble_ = true;
- checks.isNumeric_ = true;
- JSONTEST_ASSERT_PRED( checkIs( val, checks ) );
+ checks = IsCheck();
+ checks.isDouble_ = true;
+ checks.isNumeric_ = true;
+ JSONTEST_ASSERT_PRED(checkIs(val, checks));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
- JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
- JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::realValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::booleanValue));
+ JSONTEST_ASSERT(val.isConvertibleTo(Json::stringValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::nullValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::intValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::uintValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::arrayValue));
+ JSONTEST_ASSERT(!val.isConvertibleTo(Json::objectValue));
- JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
- JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
+ JSONTEST_ASSERT_EQUAL(4294967295.5, val.asDouble());
+ JSONTEST_ASSERT_EQUAL(float(4294967295.5), val.asFloat());
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32)-1, val.asLargestInt());
- JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32)-Json::UInt64(1), val.asLargestUInt());
+ JSONTEST_ASSERT_EQUAL((Json::Int64(1) << 32) - 1, val.asLargestInt());
+ JSONTEST_ASSERT_EQUAL((Json::UInt64(1) << 32) - Json::UInt64(1),
+ val.asLargestUInt());
#endif
- JSONTEST_ASSERT_EQUAL(true, val.asBool());
- JSONTEST_ASSERT_EQUAL("4294967295.5", normalizeFloatingPointStr(val.asString()));
+ JSONTEST_ASSERT_EQUAL(true, val.asBool());
+ JSONTEST_ASSERT_EQUAL("4294967295.5",
+ normalizeFloatingPointStr(val.asString()));
- val = Json::Value(1.2345678901234);
- JSONTEST_ASSERT_STRING_EQUAL( "1.2345678901234", normalizeFloatingPointStr(val.asString()));
+ val = Json::Value(1.2345678901234);
+ JSONTEST_ASSERT_STRING_EQUAL("1.2345678901234",
+ normalizeFloatingPointStr(val.asString()));
- // A 16-digit floating point number.
- val = Json::Value(2199023255552000.0f);
- JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
- JSONTEST_ASSERT_STRING_EQUAL("2199023255552000", normalizeFloatingPointStr(val.asString()));
+ // A 16-digit floating point number.
+ val = Json::Value(2199023255552000.0f);
+ JSONTEST_ASSERT_EQUAL(float(2199023255552000), val.asFloat());
+ JSONTEST_ASSERT_STRING_EQUAL("2199023255552000",
+ normalizeFloatingPointStr(val.asString()));
- // A very large floating point number.
- val = Json::Value(3.402823466385289e38);
- JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
- JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38", normalizeFloatingPointStr(val.asString()));
+ // A very large floating point number.
+ val = Json::Value(3.402823466385289e38);
+ JSONTEST_ASSERT_EQUAL(float(3.402823466385289e38), val.asFloat());
+ JSONTEST_ASSERT_STRING_EQUAL("3.402823466385289e+38",
+ normalizeFloatingPointStr(val.asString()));
- // An even larger floating point number.
- val = Json::Value(1.2345678e300);
- JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
- JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300", normalizeFloatingPointStr(val.asString()));
+ // An even larger floating point number.
+ val = Json::Value(1.2345678e300);
+ JSONTEST_ASSERT_EQUAL(double(1.2345678e300), val.asDouble());
+ JSONTEST_ASSERT_STRING_EQUAL("1.2345678e+300",
+ normalizeFloatingPointStr(val.asString()));
}
-
-void
-ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
-{
- unsigned int count = 0;
- Json::Value::const_iterator itEnd = value.end();
- for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
- {
- ++count;
- }
- JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
+void ValueTest::checkConstMemberCount(const Json::Value &value,
+ unsigned int expectedCount) {
+ unsigned int count = 0;
+ Json::Value::const_iterator itEnd = value.end();
+ for (Json::Value::const_iterator it = value.begin(); it != itEnd; ++it) {
+ ++count;
+ }
+ JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::const_iterator";
}
-void
-ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
-{
- JSONTEST_ASSERT_EQUAL(expectedCount, value.size() );
+void ValueTest::checkMemberCount(Json::Value &value,
+ unsigned int expectedCount) {
+ JSONTEST_ASSERT_EQUAL(expectedCount, value.size());
- unsigned int count = 0;
- Json::Value::iterator itEnd = value.end();
- for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
- {
- ++count;
- }
- JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
+ unsigned int count = 0;
+ Json::Value::iterator itEnd = value.end();
+ for (Json::Value::iterator it = value.begin(); it != itEnd; ++it) {
+ ++count;
+ }
+ JSONTEST_ASSERT_EQUAL(expectedCount, count) << "Json::Value::iterator";
- JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
+ JSONTEST_ASSERT_PRED(checkConstMemberCount(value, expectedCount));
}
-
ValueTest::IsCheck::IsCheck()
- : isObject_( false )
- , isArray_( false )
- , isBool_( false )
- , isString_( false )
- , isNull_( false )
- , isInt_( false )
- , isInt64_( false )
- , isUInt_( false )
- , isUInt64_( false )
- , isIntegral_( false )
- , isDouble_( false )
- , isNumeric_( false )
-{
-}
+ : isObject_(false), isArray_(false), isBool_(false), isString_(false),
+ isNull_(false), isInt_(false), isInt64_(false), isUInt_(false),
+ isUInt64_(false), isIntegral_(false), isDouble_(false),
+ isNumeric_(false) {}
-
-void
-ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
-{
- JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject() );
- JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray() );
- JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool() );
- JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble() );
- JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt() );
- JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt() );
- JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral() );
- JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric() );
- JSONTEST_ASSERT_EQUAL(check.isString_, value.isString() );
- JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull() );
+void ValueTest::checkIs(const Json::Value &value, const IsCheck &check) {
+ JSONTEST_ASSERT_EQUAL(check.isObject_, value.isObject());
+ JSONTEST_ASSERT_EQUAL(check.isArray_, value.isArray());
+ JSONTEST_ASSERT_EQUAL(check.isBool_, value.isBool());
+ JSONTEST_ASSERT_EQUAL(check.isDouble_, value.isDouble());
+ JSONTEST_ASSERT_EQUAL(check.isInt_, value.isInt());
+ JSONTEST_ASSERT_EQUAL(check.isUInt_, value.isUInt());
+ JSONTEST_ASSERT_EQUAL(check.isIntegral_, value.isIntegral());
+ JSONTEST_ASSERT_EQUAL(check.isNumeric_, value.isNumeric());
+ JSONTEST_ASSERT_EQUAL(check.isString_, value.isString());
+ JSONTEST_ASSERT_EQUAL(check.isNull_, value.isNull());
#ifdef JSON_HAS_INT64
- JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64() );
- JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64() );
+ JSONTEST_ASSERT_EQUAL(check.isInt64_, value.isInt64());
+ JSONTEST_ASSERT_EQUAL(check.isUInt64_, value.isUInt64());
#else
- JSONTEST_ASSERT_EQUAL(false, value.isInt64() );
- JSONTEST_ASSERT_EQUAL(false, value.isUInt64() );
+ JSONTEST_ASSERT_EQUAL(false, value.isInt64());
+ JSONTEST_ASSERT_EQUAL(false, value.isUInt64());
#endif
}
-JSONTEST_FIXTURE( ValueTest, compareNull )
-{
- JSONTEST_ASSERT_PRED( checkIsEqual( Json::Value(), Json::Value() ) );
+JSONTEST_FIXTURE(ValueTest, compareNull) {
+ JSONTEST_ASSERT_PRED(checkIsEqual(Json::Value(), Json::Value()));
}
-
-JSONTEST_FIXTURE( ValueTest, compareInt )
-{
- JSONTEST_ASSERT_PRED( checkIsLess( 0, 10 ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( 10, 10 ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( -10, -10 ) );
- JSONTEST_ASSERT_PRED( checkIsLess( -10, 0 ) );
+JSONTEST_FIXTURE(ValueTest, compareInt) {
+ JSONTEST_ASSERT_PRED(checkIsLess(0, 10));
+ JSONTEST_ASSERT_PRED(checkIsEqual(10, 10));
+ JSONTEST_ASSERT_PRED(checkIsEqual(-10, -10));
+ JSONTEST_ASSERT_PRED(checkIsLess(-10, 0));
}
-
-JSONTEST_FIXTURE( ValueTest, compareUInt )
-{
- JSONTEST_ASSERT_PRED( checkIsLess( 0u, 10u ) );
- JSONTEST_ASSERT_PRED( checkIsLess( 0u, Json::Value::maxUInt ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( 10u, 10u ) );
+JSONTEST_FIXTURE(ValueTest, compareUInt) {
+ JSONTEST_ASSERT_PRED(checkIsLess(0u, 10u));
+ JSONTEST_ASSERT_PRED(checkIsLess(0u, Json::Value::maxUInt));
+ JSONTEST_ASSERT_PRED(checkIsEqual(10u, 10u));
}
-
-JSONTEST_FIXTURE( ValueTest, compareDouble )
-{
- JSONTEST_ASSERT_PRED( checkIsLess( 0.0, 10.0 ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( 10.0, 10.0 ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( -10.0, -10.0 ) );
- JSONTEST_ASSERT_PRED( checkIsLess( -10.0, 0.0 ) );
+JSONTEST_FIXTURE(ValueTest, compareDouble) {
+ JSONTEST_ASSERT_PRED(checkIsLess(0.0, 10.0));
+ JSONTEST_ASSERT_PRED(checkIsEqual(10.0, 10.0));
+ JSONTEST_ASSERT_PRED(checkIsEqual(-10.0, -10.0));
+ JSONTEST_ASSERT_PRED(checkIsLess(-10.0, 0.0));
}
-
-JSONTEST_FIXTURE( ValueTest, compareString )
-{
- JSONTEST_ASSERT_PRED( checkIsLess( "", " " ) );
- JSONTEST_ASSERT_PRED( checkIsLess( "", "a" ) );
- JSONTEST_ASSERT_PRED( checkIsLess( "abcd", "zyui" ) );
- JSONTEST_ASSERT_PRED( checkIsLess( "abc", "abcd" ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( "abcd", "abcd" ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( " ", " " ) );
- JSONTEST_ASSERT_PRED( checkIsLess( "ABCD", "abcd" ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( "ABCD", "ABCD" ) );
+JSONTEST_FIXTURE(ValueTest, compareString) {
+ JSONTEST_ASSERT_PRED(checkIsLess("", " "));
+ JSONTEST_ASSERT_PRED(checkIsLess("", "a"));
+ JSONTEST_ASSERT_PRED(checkIsLess("abcd", "zyui"));
+ JSONTEST_ASSERT_PRED(checkIsLess("abc", "abcd"));
+ JSONTEST_ASSERT_PRED(checkIsEqual("abcd", "abcd"));
+ JSONTEST_ASSERT_PRED(checkIsEqual(" ", " "));
+ JSONTEST_ASSERT_PRED(checkIsLess("ABCD", "abcd"));
+ JSONTEST_ASSERT_PRED(checkIsEqual("ABCD", "ABCD"));
}
-
-JSONTEST_FIXTURE( ValueTest, compareBoolean )
-{
- JSONTEST_ASSERT_PRED( checkIsLess( false, true ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( false, false ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( true, true ) );
+JSONTEST_FIXTURE(ValueTest, compareBoolean) {
+ JSONTEST_ASSERT_PRED(checkIsLess(false, true));
+ JSONTEST_ASSERT_PRED(checkIsEqual(false, false));
+ JSONTEST_ASSERT_PRED(checkIsEqual(true, true));
}
-
-JSONTEST_FIXTURE( ValueTest, compareArray )
-{
- // array compare size then content
- Json::Value emptyArray(Json::arrayValue);
- Json::Value l1aArray;
- l1aArray.append( 0 );
- Json::Value l1bArray;
- l1bArray.append( 10 );
- Json::Value l2aArray;
- l2aArray.append( 0 );
- l2aArray.append( 0 );
- Json::Value l2bArray;
- l2bArray.append( 0 );
- l2bArray.append( 10 );
- JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l1aArray ) );
- JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l2aArray ) );
- JSONTEST_ASSERT_PRED( checkIsLess( l1aArray, l2aArray ) );
- JSONTEST_ASSERT_PRED( checkIsLess( l2aArray, l2bArray ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( emptyArray, Json::Value( emptyArray ) ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( l1aArray, Json::Value( l1aArray) ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( l2bArray, Json::Value( l2bArray) ) );
+JSONTEST_FIXTURE(ValueTest, compareArray) {
+ // array compare size then content
+ Json::Value emptyArray(Json::arrayValue);
+ Json::Value l1aArray;
+ l1aArray.append(0);
+ Json::Value l1bArray;
+ l1bArray.append(10);
+ Json::Value l2aArray;
+ l2aArray.append(0);
+ l2aArray.append(0);
+ Json::Value l2bArray;
+ l2bArray.append(0);
+ l2bArray.append(10);
+ JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l1aArray));
+ JSONTEST_ASSERT_PRED(checkIsLess(emptyArray, l2aArray));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1aArray, l2aArray));
+ JSONTEST_ASSERT_PRED(checkIsLess(l2aArray, l2bArray));
+ JSONTEST_ASSERT_PRED(checkIsEqual(emptyArray, Json::Value(emptyArray)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l1aArray, Json::Value(l1aArray)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l2bArray, Json::Value(l2bArray)));
}
-
-JSONTEST_FIXTURE( ValueTest, compareObject )
-{
- // object compare size then content
- Json::Value emptyObject(Json::objectValue);
- Json::Value l1aObject;
- l1aObject["key1"] = 0;
- Json::Value l1bObject;
- l1aObject["key1"] = 10;
- Json::Value l2aObject;
- l2aObject["key1"] = 0;
- l2aObject["key2"] = 0;
- JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l1aObject ) );
- JSONTEST_ASSERT_PRED( checkIsLess( emptyObject, l2aObject ) );
- JSONTEST_ASSERT_PRED( checkIsLess( l1aObject, l2aObject ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( emptyObject, Json::Value( emptyObject ) ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( l1aObject, Json::Value( l1aObject ) ) );
- JSONTEST_ASSERT_PRED( checkIsEqual( l2aObject, Json::Value( l2aObject ) ) );
+JSONTEST_FIXTURE(ValueTest, compareObject) {
+ // object compare size then content
+ Json::Value emptyObject(Json::objectValue);
+ Json::Value l1aObject;
+ l1aObject["key1"] = 0;
+ Json::Value l1bObject;
+ l1aObject["key1"] = 10;
+ Json::Value l2aObject;
+ l2aObject["key1"] = 0;
+ l2aObject["key2"] = 0;
+ JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l1aObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(emptyObject, l2aObject));
+ JSONTEST_ASSERT_PRED(checkIsLess(l1aObject, l2aObject));
+ JSONTEST_ASSERT_PRED(checkIsEqual(emptyObject, Json::Value(emptyObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l1aObject, Json::Value(l1aObject)));
+ JSONTEST_ASSERT_PRED(checkIsEqual(l2aObject, Json::Value(l2aObject)));
}
-
-JSONTEST_FIXTURE( ValueTest, compareType )
-{
- // object of different type are ordered according to their type
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(), Json::Value(1) ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1), Json::Value(1u) ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1u), Json::Value(1.0) ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(1.0), Json::Value("a") ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value("a"), Json::Value(true) ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(true), Json::Value(Json::arrayValue) ) );
- JSONTEST_ASSERT_PRED( checkIsLess( Json::Value(Json::arrayValue), Json::Value(Json::objectValue) ) );
+JSONTEST_FIXTURE(ValueTest, compareType) {
+ // object of different type are ordered according to their type
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(), Json::Value(1)));
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1), Json::Value(1u)));
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1u), Json::Value(1.0)));
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(1.0), Json::Value("a")));
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value("a"), Json::Value(true)));
+ JSONTEST_ASSERT_PRED(
+ checkIsLess(Json::Value(true), Json::Value(Json::arrayValue)));
+ JSONTEST_ASSERT_PRED(checkIsLess(Json::Value(Json::arrayValue),
+ Json::Value(Json::objectValue)));
}
-
-void
-ValueTest::checkIsLess( const Json::Value &x, const Json::Value &y )
-{
- JSONTEST_ASSERT( x < y );
- JSONTEST_ASSERT( y > x );
- JSONTEST_ASSERT( x <= y );
- JSONTEST_ASSERT( y >= x );
- JSONTEST_ASSERT( !(x == y) );
- JSONTEST_ASSERT( !(y == x) );
- JSONTEST_ASSERT( !(x >= y) );
- JSONTEST_ASSERT( !(y <= x) );
- JSONTEST_ASSERT( !(x > y) );
- JSONTEST_ASSERT( !(y < x) );
- JSONTEST_ASSERT( x.compare( y ) < 0 );
- JSONTEST_ASSERT( y.compare( x ) >= 0 );
+void ValueTest::checkIsLess(const Json::Value &x, const Json::Value &y) {
+ JSONTEST_ASSERT(x < y);
+ JSONTEST_ASSERT(y > x);
+ JSONTEST_ASSERT(x <= y);
+ JSONTEST_ASSERT(y >= x);
+ JSONTEST_ASSERT(!(x == y));
+ JSONTEST_ASSERT(!(y == x));
+ JSONTEST_ASSERT(!(x >= y));
+ JSONTEST_ASSERT(!(y <= x));
+ JSONTEST_ASSERT(!(x > y));
+ JSONTEST_ASSERT(!(y < x));
+ JSONTEST_ASSERT(x.compare(y) < 0);
+ JSONTEST_ASSERT(y.compare(x) >= 0);
}
-
-void
-ValueTest::checkIsEqual( const Json::Value &x, const Json::Value &y )
-{
- JSONTEST_ASSERT( x == y );
- JSONTEST_ASSERT( y == x );
- JSONTEST_ASSERT( x <= y );
- JSONTEST_ASSERT( y <= x );
- JSONTEST_ASSERT( x >= y );
- JSONTEST_ASSERT( y >= x );
- JSONTEST_ASSERT( !(x < y) );
- JSONTEST_ASSERT( !(y < x) );
- JSONTEST_ASSERT( !(x > y) );
- JSONTEST_ASSERT( !(y > x) );
- JSONTEST_ASSERT( x.compare( y ) == 0 );
- JSONTEST_ASSERT( y.compare( x ) == 0 );
+void ValueTest::checkIsEqual(const Json::Value &x, const Json::Value &y) {
+ JSONTEST_ASSERT(x == y);
+ JSONTEST_ASSERT(y == x);
+ JSONTEST_ASSERT(x <= y);
+ JSONTEST_ASSERT(y <= x);
+ JSONTEST_ASSERT(x >= y);
+ JSONTEST_ASSERT(y >= x);
+ JSONTEST_ASSERT(!(x < y));
+ JSONTEST_ASSERT(!(y < x));
+ JSONTEST_ASSERT(!(x > y));
+ JSONTEST_ASSERT(!(y > x));
+ JSONTEST_ASSERT(x.compare(y) == 0);
+ JSONTEST_ASSERT(y.compare(x) == 0);
}
-
-JSONTEST_FIXTURE( ValueTest, checkInteger )
-{
+JSONTEST_FIXTURE(ValueTest, checkInteger) {
#if JSON_USE_EXCEPTION
try {
Json::Value x = 1;
x["key"]; // SIGABRT?
// regression for https://sourceforge.net/p/jsoncpp/bugs/67/
- JSONTEST_ASSERT( 0 );
- } catch (std::runtime_error const&) {
- JSONTEST_ASSERT( 1 ); // good
+ JSONTEST_ASSERT(0);
}
-#endif // JSON_USE_EXCEPTION
+ catch (std::runtime_error const &) {
+ JSONTEST_ASSERT(1); // good
+ }
+#endif // JSON_USE_EXCEPTION
}
-
-JSONTEST_FIXTURE( ValueTest, offsetAccessors )
-{
- Json::Value x;
- JSONTEST_ASSERT( x.getOffsetStart() == 0 );
- JSONTEST_ASSERT( x.getOffsetLimit() == 0 );
- x.setOffsetStart(10);
- x.setOffsetLimit(20);
- JSONTEST_ASSERT( x.getOffsetStart() == 10 );
- JSONTEST_ASSERT( x.getOffsetLimit() == 20 );
- Json::Value y(x);
- JSONTEST_ASSERT( y.getOffsetStart() == 10 );
- JSONTEST_ASSERT( y.getOffsetLimit() == 20 );
- Json::Value z;
- z.swap(y);
- JSONTEST_ASSERT( z.getOffsetStart() == 10 );
- JSONTEST_ASSERT( z.getOffsetLimit() == 20 );
- JSONTEST_ASSERT( y.getOffsetStart() == 0 );
- JSONTEST_ASSERT( y.getOffsetLimit() == 0 );
+JSONTEST_FIXTURE(ValueTest, offsetAccessors) {
+ Json::Value x;
+ JSONTEST_ASSERT(x.getOffsetStart() == 0);
+ JSONTEST_ASSERT(x.getOffsetLimit() == 0);
+ x.setOffsetStart(10);
+ x.setOffsetLimit(20);
+ JSONTEST_ASSERT(x.getOffsetStart() == 10);
+ JSONTEST_ASSERT(x.getOffsetLimit() == 20);
+ Json::Value y(x);
+ JSONTEST_ASSERT(y.getOffsetStart() == 10);
+ JSONTEST_ASSERT(y.getOffsetLimit() == 20);
+ Json::Value z;
+ z.swap(y);
+ JSONTEST_ASSERT(z.getOffsetStart() == 10);
+ JSONTEST_ASSERT(z.getOffsetLimit() == 20);
+ JSONTEST_ASSERT(y.getOffsetStart() == 0);
+ JSONTEST_ASSERT(y.getOffsetLimit() == 0);
}
-struct WriterTest : JsonTest::TestCase
-{
-};
+struct WriterTest : JsonTest::TestCase {};
+JSONTEST_FIXTURE(WriterTest, dropNullPlaceholders) {
+ Json::FastWriter writer;
+ Json::Value nullValue;
+ JSONTEST_ASSERT(writer.write(nullValue) == "null\n");
-JSONTEST_FIXTURE( WriterTest, dropNullPlaceholders )
-{
- Json::FastWriter writer;
- Json::Value nullValue;
- JSONTEST_ASSERT( writer.write(nullValue) == "null\n" );
-
- writer.dropNullPlaceholders();
- JSONTEST_ASSERT( writer.write(nullValue) == "\n" );
+ writer.dropNullPlaceholders();
+ JSONTEST_ASSERT(writer.write(nullValue) == "\n");
}
+struct ReaderTest : JsonTest::TestCase {};
-struct ReaderTest : JsonTest::TestCase
-{
-};
-
-
-JSONTEST_FIXTURE( ReaderTest, parseWithNoErrors )
-{
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse(
- "{ \"property\" : \"value\" }",
- root);
- JSONTEST_ASSERT( ok );
- JSONTEST_ASSERT( reader.getFormattedErrorMessages().size() == 0 );
- JSONTEST_ASSERT( reader.getStructuredErrors().size() == 0 );
+JSONTEST_FIXTURE(ReaderTest, parseWithNoErrors) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("{ \"property\" : \"value\" }", root);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
+ JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
}
-
-JSONTEST_FIXTURE( ReaderTest, parseWithNoErrorsTestingOffsets )
-{
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse(
- "{ \"property\" : [\"value\", \"value2\"], \"obj\" : { \"nested\" : 123, \"bool\" : true}, \"null\" : null, \"false\" : false }",
- root);
- JSONTEST_ASSERT( ok );
- JSONTEST_ASSERT( reader.getFormattedErrorMessages().size() == 0 );
- JSONTEST_ASSERT( reader.getStructuredErrors().size() == 0 );
- JSONTEST_ASSERT( root["property"].getOffsetStart() == 15 );
- JSONTEST_ASSERT( root["property"].getOffsetLimit() == 34 );
- JSONTEST_ASSERT( root["property"][0].getOffsetStart() == 16 );
- JSONTEST_ASSERT( root["property"][0].getOffsetLimit() == 23 );
- JSONTEST_ASSERT( root["property"][1].getOffsetStart() == 25 );
- JSONTEST_ASSERT( root["property"][1].getOffsetLimit() == 33 );
- JSONTEST_ASSERT( root["obj"].getOffsetStart() == 44 );
- JSONTEST_ASSERT( root["obj"].getOffsetLimit() == 76 );
- JSONTEST_ASSERT( root["obj"]["nested"].getOffsetStart() == 57 );
- JSONTEST_ASSERT( root["obj"]["nested"].getOffsetLimit() == 60 );
- JSONTEST_ASSERT( root["obj"]["bool"].getOffsetStart() == 71 );
- JSONTEST_ASSERT( root["obj"]["bool"].getOffsetLimit() == 75 );
- JSONTEST_ASSERT( root["null"].getOffsetStart() == 87 );
- JSONTEST_ASSERT( root["null"].getOffsetLimit() == 91 );
- JSONTEST_ASSERT( root["false"].getOffsetStart() == 103 );
- JSONTEST_ASSERT( root["false"].getOffsetLimit() == 108 );
- JSONTEST_ASSERT( root.getOffsetStart() == 0 );
- JSONTEST_ASSERT( root.getOffsetLimit() == 110 );
+JSONTEST_FIXTURE(ReaderTest, parseWithNoErrorsTestingOffsets) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("{ \"property\" : [\"value\", \"value2\"], \"obj\" : "
+ "{ \"nested\" : 123, \"bool\" : true}, \"null\" : "
+ "null, \"false\" : false }",
+ root);
+ JSONTEST_ASSERT(ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages().size() == 0);
+ JSONTEST_ASSERT(reader.getStructuredErrors().size() == 0);
+ JSONTEST_ASSERT(root["property"].getOffsetStart() == 15);
+ JSONTEST_ASSERT(root["property"].getOffsetLimit() == 34);
+ JSONTEST_ASSERT(root["property"][0].getOffsetStart() == 16);
+ JSONTEST_ASSERT(root["property"][0].getOffsetLimit() == 23);
+ JSONTEST_ASSERT(root["property"][1].getOffsetStart() == 25);
+ JSONTEST_ASSERT(root["property"][1].getOffsetLimit() == 33);
+ JSONTEST_ASSERT(root["obj"].getOffsetStart() == 44);
+ JSONTEST_ASSERT(root["obj"].getOffsetLimit() == 76);
+ JSONTEST_ASSERT(root["obj"]["nested"].getOffsetStart() == 57);
+ JSONTEST_ASSERT(root["obj"]["nested"].getOffsetLimit() == 60);
+ JSONTEST_ASSERT(root["obj"]["bool"].getOffsetStart() == 71);
+ JSONTEST_ASSERT(root["obj"]["bool"].getOffsetLimit() == 75);
+ JSONTEST_ASSERT(root["null"].getOffsetStart() == 87);
+ JSONTEST_ASSERT(root["null"].getOffsetLimit() == 91);
+ JSONTEST_ASSERT(root["false"].getOffsetStart() == 103);
+ JSONTEST_ASSERT(root["false"].getOffsetLimit() == 108);
+ JSONTEST_ASSERT(root.getOffsetStart() == 0);
+ JSONTEST_ASSERT(root.getOffsetLimit() == 110);
}
-
-JSONTEST_FIXTURE( ReaderTest, parseWithOneError )
-{
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse(
- "{ \"property\" :: \"value\" }",
- root);
- JSONTEST_ASSERT( !ok );
- JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
- "* Line 1, Column 15\n Syntax error: value, object or array expected.\n" );
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT( errors.size() == 1 );
- JSONTEST_ASSERT( errors.at(0).offset_start == 14 );
- JSONTEST_ASSERT( errors.at(0).offset_limit == 15 );
- JSONTEST_ASSERT( errors.at(0).message ==
- "Syntax error: value, object or array expected." );
+JSONTEST_FIXTURE(ReaderTest, parseWithOneError) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("{ \"property\" :: \"value\" }", root);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ "* Line 1, Column 15\n Syntax error: value, object or array "
+ "expected.\n");
+ std::vector<Json::Reader::StructuredError> errors =
+ reader.getStructuredErrors();
+ JSONTEST_ASSERT(errors.size() == 1);
+ JSONTEST_ASSERT(errors.at(0).offset_start == 14);
+ JSONTEST_ASSERT(errors.at(0).offset_limit == 15);
+ JSONTEST_ASSERT(errors.at(0).message ==
+ "Syntax error: value, object or array expected.");
}
-
-JSONTEST_FIXTURE( ReaderTest, parseChineseWithOneError )
-{
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse(
- "{ \"pr佐藤erty\" :: \"value\" }",
- root);
- JSONTEST_ASSERT( !ok );
- JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
- "* Line 1, Column 19\n Syntax error: value, object or array expected.\n" );
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT( errors.size() == 1 );
- JSONTEST_ASSERT( errors.at(0).offset_start == 18 );
- JSONTEST_ASSERT( errors.at(0).offset_limit == 19 );
- JSONTEST_ASSERT( errors.at(0).message ==
- "Syntax error: value, object or array expected." );
+JSONTEST_FIXTURE(ReaderTest, parseChineseWithOneError) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("{ \"pr佐藤erty\" :: \"value\" }", root);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ "* Line 1, Column 19\n Syntax error: value, object or array "
+ "expected.\n");
+ std::vector<Json::Reader::StructuredError> errors =
+ reader.getStructuredErrors();
+ JSONTEST_ASSERT(errors.size() == 1);
+ JSONTEST_ASSERT(errors.at(0).offset_start == 18);
+ JSONTEST_ASSERT(errors.at(0).offset_limit == 19);
+ JSONTEST_ASSERT(errors.at(0).message ==
+ "Syntax error: value, object or array expected.");
}
-
-JSONTEST_FIXTURE( ReaderTest, parseWithDetailError )
-{
- Json::Reader reader;
- Json::Value root;
- bool ok = reader.parse(
- "{ \"property\" : \"v\\alue\" }",
- root);
- JSONTEST_ASSERT( !ok );
- JSONTEST_ASSERT( reader.getFormattedErrorMessages() ==
- "* Line 1, Column 16\n Bad escape sequence in string\nSee Line 1, Column 20 for detail.\n" );
- std::vector<Json::Reader::StructuredError> errors =
- reader.getStructuredErrors();
- JSONTEST_ASSERT( errors.size() == 1 );
- JSONTEST_ASSERT( errors.at(0).offset_start == 15 );
- JSONTEST_ASSERT( errors.at(0).offset_limit == 23 );
- JSONTEST_ASSERT( errors.at(0).message ==
- "Bad escape sequence in string" );
+JSONTEST_FIXTURE(ReaderTest, parseWithDetailError) {
+ Json::Reader reader;
+ Json::Value root;
+ bool ok = reader.parse("{ \"property\" : \"v\\alue\" }", root);
+ JSONTEST_ASSERT(!ok);
+ JSONTEST_ASSERT(reader.getFormattedErrorMessages() ==
+ "* Line 1, Column 16\n Bad escape sequence in string\nSee "
+ "Line 1, Column 20 for detail.\n");
+ std::vector<Json::Reader::StructuredError> errors =
+ reader.getStructuredErrors();
+ JSONTEST_ASSERT(errors.size() == 1);
+ JSONTEST_ASSERT(errors.at(0).offset_start == 15);
+ JSONTEST_ASSERT(errors.at(0).offset_limit == 23);
+ JSONTEST_ASSERT(errors.at(0).message == "Bad escape sequence in string");
}
+int main(int argc, const char *argv[]) {
+ JsonTest::Runner runner;
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, memberCount);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, objects);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, arrays);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, null);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, strings);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, bools);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, integers);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, nonIntegers);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareNull);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareInt);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareUInt);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareDouble);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareString);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareBoolean);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareArray);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareObject);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, compareType);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkInteger);
+ JSONTEST_REGISTER_FIXTURE(runner, ValueTest, offsetAccessors);
-int main( int argc, const char *argv[] )
-{
- JsonTest::Runner runner;
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkNormalizeFloatingPointStr );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, memberCount );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, objects );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, arrays );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, null );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, strings );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, bools );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, integers );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, nonIntegers );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareNull );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareInt );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareUInt );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareDouble );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareString );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareBoolean );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareArray );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareObject );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, compareType );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, checkInteger );
- JSONTEST_REGISTER_FIXTURE( runner, ValueTest, offsetAccessors );
+ JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithNoErrors);
+ JSONTEST_REGISTER_FIXTURE(
+ runner, ReaderTest, parseWithNoErrorsTestingOffsets);
+ JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithOneError);
+ JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseChineseWithOneError);
+ JSONTEST_REGISTER_FIXTURE(runner, ReaderTest, parseWithDetailError);
- JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithNoErrors );
- JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithNoErrorsTestingOffsets );
- JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithOneError );
- JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseChineseWithOneError );
- JSONTEST_REGISTER_FIXTURE( runner, ReaderTest, parseWithDetailError );
-
- JSONTEST_REGISTER_FIXTURE( runner, WriterTest, dropNullPlaceholders );
- return runner.runCommandLine( argc, argv );
+ JSONTEST_REGISTER_FIXTURE(runner, WriterTest, dropNullPlaceholders);
+ return runner.runCommandLine(argc, argv);
}
// vim: et ts=4 sts=4 sw=4 tw=0