RapidJSON configuration

Configuration macros for library features. More...


 Major version of RapidJSON in integer.
 Minor version of RapidJSON in integer.
 Patch version of RapidJSON in integer.
 Version of RapidJSON in "<major>.<minor>.<patch>" string format.
#define RAPIDJSON_NAMESPACE   rapidjson
 provide custom rapidjson namespace More...
 Enable RapidJSON support for std::string. More...
 Use external 64-bit integer types. More...
 Endianness of the machine. More...
#define RAPIDJSON_ALIGN(x)   (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
 Data alignment of the machine. More...
 Use only lower 48-bit address for some pointers. More...
 Enable SSE2/SSE4.2/Neon optimization. More...
 User-provided SizeType definition. More...
#define RAPIDJSON_ASSERT(x)   assert(x)
 Assertion. More...
#define RAPIDJSON_LIKELY(x)   (x)
 Compiler branching hint for expression with high probability to be true. More...
#define RAPIDJSON_UNLIKELY(x)   (x)
 Compiler branching hint for expression with low probability to be true. More...
 Assertion (in non-throwing contexts). More...
 User-defined kParseDefaultFlags definition. More...
 User-defined kWriteDefaultFlags definition. More...

Detailed Description

Configuration macros for library features.

Some RapidJSON features are configurable to adapt the library to a wide variety of platforms, environments and usage scenarios. Most of the features can be configured in terms of overridden or predefined preprocessor macros at compile-time.

Some additional customization is available in the RapidJSON error handling APIs.

These macros should be given on the compiler command-line (where applicable) to avoid inconsistent values when compiling different translation units of a single application.

Macro Definition Documentation



Use only lower 48-bit address for some pointers.

This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address. The higher 16-bit can be used for storing other data. GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.


#define RAPIDJSON_ALIGN (   x)    (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))

Data alignment of the machine.

xpointer to align

Some machines require strict data alignment. The default is 8 bytes. User can customize by defining the RAPIDJSON_ALIGN function macro.


#define RAPIDJSON_ASSERT (   x)    assert(x)


By default, rapidjson uses C assert() for internal assertions. User can override it by defining RAPIDJSON_ASSERT(x) macro.

Parsing errors are handled and can be customized by the RapidJSON error handling APIs.



Endianness of the machine.

GCC 4.6 provided macro for detecting endianness of the target machine. But other compilers may not have this. User can define RAPIDJSON_ENDIAN to either RAPIDJSON_LITTLEENDIAN or RAPIDJSON_BIGENDIAN.

Default detection implemented with reference to



Enable RapidJSON support for std::string.

By defining this preprocessor symbol to 1, several convenience functions for using rapidjson::GenericValue with std::string are enabled, especially for construction and comparison.


#define RAPIDJSON_LIKELY (   x)    (x)

Compiler branching hint for expression with high probability to be true.

xBoolean expression likely to be true.


#define RAPIDJSON_NAMESPACE   rapidjson

provide custom rapidjson namespace

In order to avoid symbol clashes and/or "One Definition Rule" errors between multiple inclusions of (different versions of) RapidJSON in a single binary, users can customize the name of the main RapidJSON namespace.

In case of a single nesting level, defining RAPIDJSON_NAMESPACE to a custom name (e.g. MyRapidJSON) is sufficient. If multiple levels are needed, both RAPIDJSON_NAMESPACE_BEGIN and RAPIDJSON_NAMESPACE_END need to be defined as well:

// in some .cpp file
#define RAPIDJSON_NAMESPACE my::rapidjson
#define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
#include "rapidjson/..."
See also



Use external 64-bit integer types.

RapidJSON requires the 64-bit integer types int64_t and uint64_t types to be available at global scope.

If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to prevent RapidJSON from defining its own types.



User-provided SizeType definition.

In order to avoid using 32-bit size types for indexing strings and arrays, define this preprocessor symbol and provide the type rapidjson::SizeType before including RapidJSON:

namespace rapidjson { typedef ::std::size_t SizeType; }
#include "rapidjson/..."
See also



Assertion (in non-throwing contexts).

Some functions provide a noexcept guarantee, if the compiler supports it. In these cases, the RAPIDJSON_ASSERT macro cannot be overridden to throw an exception. This macro adds a separate customization point for such cases.

Defaults to C assert() (as RAPIDJSON_ASSERT), if noexcept is supported, and to RAPIDJSON_ASSERT otherwise.



User-defined kParseDefaultFlags definition.

User can define this as any ParseFlag combinations.



Enable SSE2/SSE4.2/Neon optimization.

RapidJSON supports optimized implementations for some parsing operations based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel or ARM compatible processors.

To enable these optimizations, three different symbols can be defined;

// Enable SSE2 optimization.
// Enable SSE4.2 optimization.

Enable ARM Neon optimization. #define RAPIDJSON_NEON

RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.

If any of these symbols is defined, RapidJSON defines the macro RAPIDJSON_SIMD to indicate the availability of the optimized code.


#define RAPIDJSON_UNLIKELY (   x)    (x)

Compiler branching hint for expression with low probability to be true.

xBoolean expression unlikely to be true.



User-defined kWriteDefaultFlags definition.

User can define this as any WriteFlag combinations.