The term "SAX" originated from Simple API for XML. We borrowed this term for JSON parsing and generation.
Reader (typedef of
GenericReader<...>) is the SAX-style parser for JSON, and
Writer (typedef of
GenericWriter<...>) is the SAX-style generator for JSON.
Reader parses a JSON from a stream. While it reads characters from the stream, it analyzes the characters according to the syntax of JSON, and publishes events to a handler.
For example, here is a JSON.
Reader parses this JSON, it publishes the following events to the handler sequentially:
These events can be easily matched with the JSON, but some event parameters need further explanation. Let's see the
simplereader example which produces exactly the same output as above:
Note that RapidJSON uses templates to statically bind the
Reader type and the handler type, instead of using classes with virtual functions. This paradigm can improve performance by inlining functions.
As shown in the previous example, the user needs to implement a handler which consumes the events (via function calls) from the
Reader. The handler must contain the following member functions.
Null() is called when the
Reader encounters a JSON null value.
Bool(bool) is called when the
Reader encounters a JSON true or false value.
Reader encounters a JSON number, it chooses a suitable C++ type mapping. And then it calls one function out of
kParseNumbersAsStrings is enabled,
Reader will always calls
String(const char* str, SizeType length, bool copy) is called when the
Reader encounters a string. The first parameter is pointer to the string. The second parameter is the length of the string (excluding the null terminator). Note that RapidJSON supports null character
\0 inside a string. If such situation happens,
strlen(str) < length. The last
copy indicates whether the handler needs to make a copy of the string. For normal parsing,
copy = true. Only when insitu parsing is used,
copy = false. And be aware that the character type depends on the target encoding, which will be explained later.
Reader encounters the beginning of an object, it calls
StartObject(). An object in JSON is a set of name-value pairs. If the object contains members it first calls
Key() for the name of member, and then calls functions depending on the type of the value. These calls of name-value pairs repeat until calling
EndObject(SizeType memberCount). Note that the
memberCount parameter is just an aid for the handler; users who do not need this parameter may ignore it.
Arrays are similar to objects, but simpler. At the beginning of an array, the
BeginArary(). If there is elements, it calls functions according to the types of element. Similarly, in the last call
EndArray(SizeType elementCount), the parameter
elementCount is just an aid for the handler.
Every handler function returns a
bool. Normally it should return
true. If the handler encounters an error, it can return
false to notify the event publisher to stop further processing.
For example, when we parse a JSON with
Reader and the handler detects that the JSON does not conform to the required schema, the handler can return
false and let the
Reader stop further parsing. This will place the
Reader in an error state, with error code
As mentioned before,
Reader is a typedef of a template class
Reader uses UTF-8 as both source and target encoding. The source encoding means the encoding in the JSON stream. The target encoding means the encoding of the
str parameter in
String() calls. For example, to parse a UTF-8 stream and output UTF-16 string events, you can define a reader by:
Note that, the default character type of
wchar_t. So this
reader needs to call
String(const wchar_t*, SizeType, bool) of the handler.
The third template parameter
Allocator is the allocator type for internal data structure (actually a stack).
The main function of
Reader is used to parse JSON.
If an error occurs during parsing, it will return
false. User can also call
ParseErrorCode GetParseErrorCode() and
size_t GetErrorOffset() to obtain the error states. In fact,
Document uses these
Reader functions to obtain parse errors. Please refer to DOM for details about parse errors.
Some users may wish to parse a JSON input stream a single token at a time, instead of immediately parsing an entire document without stopping. To parse JSON this way, instead of calling
Parse, you can use the
IterativeParse set of functions:
Here is an example of iteratively parsing JSON, token by token:
Reader converts (parses) JSON into events.
Writer does exactly the opposite. It converts events into JSON.
Writer is very easy to use. If your application only need to converts some data into JSON, it may be a good choice to use
Writer directly, instead of building a
Document and then stringifying it with a
simplewriter example, we do exactly the reverse of
There are two
Key() overloads. One is the same as defined in handler concept with 3 parameters. It can handle string with null characters. Another one is the simpler version used in the above example.
Note that, the example code does not pass any parameters in
SizeType can be passed but it will be simply ignored by
You may doubt that, why not just using
std::stringstream to build a JSON?
There are various reasons:
Writermust output a well-formed JSON. If there is incorrect event sequence (e.g.
StartObject()), it generates assertion fail in debug mode.
Writer::String()can handle string escaping (e.g. converting code point
\n) and Unicode transcoding.
Writerhandles number output consistently.
Writerimplements the event handler concept. It can be used to handle events from
Documentor other event publisher.
Writercan be optimized for different platforms.
Writer API is even simpler than generating a JSON by ad hoc methods.
Writer has a minor design difference to
Writer is a template class, not a typedef. There is no
GenericWriter. The following is the declaration.
OutputStream template parameter is the type of output stream. It cannot be deduced and must be specified by user.
SourceEncoding template parameter specifies the encoding to be used in
String(const Ch*, ...).
TargetEncoding template parameter specifies the encoding in the output stream.
Allocator is the type of allocator, which is used for allocating internal data structure (a stack).
writeFlags are combination of the following bit-flags:
|No flag is set.|
|Default write flags. It is equal to macro |
|Validate encoding of JSON strings.|
|Allow writing of |
Besides, the constructor of
Writer has a
levelDepth parameter. This parameter affects the initial memory allocated for storing information per hierarchy level.
While the output of
Writer is the most condensed JSON without white-spaces, suitable for network transfer or storage, it is not easily readable by human.
Therefore, RapidJSON provides a
PrettyWriter, which adds indentation and line feeds in the output.
The usage of
PrettyWriter is exactly the same as
Writer, expect that
PrettyWriter provides a
SetIndent(Ch indentChar, unsigned indentCharCount) function. The default is 4 spaces.
Writer can only output a single JSON, which can be any JSON type at the root. Once the singular event for root (e.g.
String()), or the last matching
EndArray() event, is handled, the output JSON is well-formed and complete. User can detect this state by calling
When a JSON is complete, the
Writer cannot accept any new events. Otherwise the output will be invalid (i.e. having more than one root). To reuse the
Writer object, user can call
Writer::Reset(OutputStream& os) to reset all internal states of the
Writer with a new output stream.