mirror of
https://github.com/RetroDECK/ES-DE.git
synced 2024-12-04 20:05:38 +00:00
152 lines
6.1 KiB
C++
152 lines
6.1 KiB
C++
// Hello World example
|
|
// This example shows basic usage of DOM-style API.
|
|
|
|
#include "rapidjson/document.h" // rapidjson's DOM-style API
|
|
#include "rapidjson/prettywriter.h" // for stringify JSON
|
|
#include <cstdio>
|
|
|
|
using namespace rapidjson;
|
|
using namespace std;
|
|
|
|
int main(int, char*[]) {
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// 1. Parse a JSON text string to a document.
|
|
|
|
const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
|
|
printf("Original JSON:\n %s\n", json);
|
|
|
|
Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator.
|
|
|
|
#if 0
|
|
// "normal" parsing, decode strings to new buffers. Can use other input stream via ParseStream().
|
|
if (document.Parse(json).HasParseError())
|
|
return 1;
|
|
#else
|
|
// In-situ parsing, decode strings directly in the source string. Source must be string.
|
|
char buffer[sizeof(json)];
|
|
memcpy(buffer, json, sizeof(json));
|
|
if (document.ParseInsitu(buffer).HasParseError())
|
|
return 1;
|
|
#endif
|
|
|
|
printf("\nParsing to document succeeded.\n");
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// 2. Access values in document.
|
|
|
|
printf("\nAccess values in document:\n");
|
|
assert(document.IsObject()); // Document is a JSON value represents the root of DOM. Root can be either an object or array.
|
|
|
|
assert(document.HasMember("hello"));
|
|
assert(document["hello"].IsString());
|
|
printf("hello = %s\n", document["hello"].GetString());
|
|
|
|
// Since version 0.2, you can use single lookup to check the existing of member and its value:
|
|
Value::MemberIterator hello = document.FindMember("hello");
|
|
assert(hello != document.MemberEnd());
|
|
assert(hello->value.IsString());
|
|
assert(strcmp("world", hello->value.GetString()) == 0);
|
|
(void)hello;
|
|
|
|
assert(document["t"].IsBool()); // JSON true/false are bool. Can also uses more specific function IsTrue().
|
|
printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
|
|
|
|
assert(document["f"].IsBool());
|
|
printf("f = %s\n", document["f"].GetBool() ? "true" : "false");
|
|
|
|
printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
|
|
|
|
assert(document["i"].IsNumber()); // Number is a JSON type, but C++ needs more specific type.
|
|
assert(document["i"].IsInt()); // In this case, IsUint()/IsInt64()/IsUint64() also return true.
|
|
printf("i = %d\n", document["i"].GetInt()); // Alternative (int)document["i"]
|
|
|
|
assert(document["pi"].IsNumber());
|
|
assert(document["pi"].IsDouble());
|
|
printf("pi = %g\n", document["pi"].GetDouble());
|
|
|
|
{
|
|
const Value& a = document["a"]; // Using a reference for consecutive access is handy and faster.
|
|
assert(a.IsArray());
|
|
for (SizeType i = 0; i < a.Size(); i++) // rapidjson uses SizeType instead of size_t.
|
|
printf("a[%d] = %d\n", i, a[i].GetInt());
|
|
|
|
int y = a[0].GetInt();
|
|
(void)y;
|
|
|
|
// Iterating array with iterators
|
|
printf("a = ");
|
|
for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
|
|
printf("%d ", itr->GetInt());
|
|
printf("\n");
|
|
}
|
|
|
|
// Iterating object members
|
|
static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
|
|
for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
|
|
printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// 3. Modify values in document.
|
|
|
|
// Change i to a bigger number
|
|
{
|
|
uint64_t f20 = 1; // compute factorial of 20
|
|
for (uint64_t j = 1; j <= 20; j++)
|
|
f20 *= j;
|
|
document["i"] = f20; // Alternate form: document["i"].SetUint64(f20)
|
|
assert(!document["i"].IsInt()); // No longer can be cast as int or uint.
|
|
}
|
|
|
|
// Adding values to array.
|
|
{
|
|
Value& a = document["a"]; // This time we uses non-const reference.
|
|
Document::AllocatorType& allocator = document.GetAllocator();
|
|
for (int i = 5; i <= 10; i++)
|
|
a.PushBack(i, allocator); // May look a bit strange, allocator is needed for potentially realloc. We normally uses the document's.
|
|
|
|
// Fluent API
|
|
a.PushBack("Lua", allocator).PushBack("Mio", allocator);
|
|
}
|
|
|
|
// Making string values.
|
|
|
|
// This version of SetString() just store the pointer to the string.
|
|
// So it is for literal and string that exists within value's life-cycle.
|
|
{
|
|
document["hello"] = "rapidjson"; // This will invoke strlen()
|
|
// Faster version:
|
|
// document["hello"].SetString("rapidjson", 9);
|
|
}
|
|
|
|
// This version of SetString() needs an allocator, which means it will allocate a new buffer and copy the the string into the buffer.
|
|
Value author;
|
|
{
|
|
char buffer2[10];
|
|
int len = sprintf(buffer2, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string.
|
|
|
|
author.SetString(buffer2, static_cast<SizeType>(len), document.GetAllocator());
|
|
// Shorter but slower version:
|
|
// document["hello"].SetString(buffer, document.GetAllocator());
|
|
|
|
// Constructor version:
|
|
// Value author(buffer, len, document.GetAllocator());
|
|
// Value author(buffer, document.GetAllocator());
|
|
memset(buffer2, 0, sizeof(buffer2)); // For demonstration purpose.
|
|
}
|
|
// Variable 'buffer' is unusable now but 'author' has already made a copy.
|
|
document.AddMember("author", author, document.GetAllocator());
|
|
|
|
assert(author.IsNull()); // Move semantic for assignment. After this variable is assigned as a member, the variable becomes null.
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// 4. Stringify JSON
|
|
|
|
printf("\nModified JSON with reformatting:\n");
|
|
StringBuffer sb;
|
|
PrettyWriter<StringBuffer> writer(sb);
|
|
document.Accept(writer); // Accept() traverses the DOM and generates Handler events.
|
|
puts(sb.GetString());
|
|
|
|
return 0;
|
|
}
|