diff --git a/3rdParty/rapidjson/Makefile b/3rdParty/rapidjson/Makefile new file mode 100755 index 0000000..f498fb1 --- /dev/null +++ b/3rdParty/rapidjson/Makefile @@ -0,0 +1,8 @@ + + +test: main.cpp + g++ -I. -Os main.cpp -o test -std=c++11 + +# ./test > res2.txt ; diff res.txt res2.txt + + diff --git a/3rdParty/rapidjson/Makefile b/3rdParty/rapidjson/Makefile new file mode 100755 index 0000000..f498fb1 --- /dev/null +++ b/3rdParty/rapidjson/Makefile @@ -0,0 +1,8 @@ + + +test: main.cpp + g++ -I. -Os main.cpp -o test -std=c++11 + +# ./test > res2.txt ; diff res.txt res2.txt + + diff --git a/3rdParty/rapidjson/main.cpp b/3rdParty/rapidjson/main.cpp new file mode 100644 index 0000000..0022f1f --- /dev/null +++ b/3rdParty/rapidjson/main.cpp @@ -0,0 +1,377 @@ +// Hello World example +// This example shows basic usage of DOM-style API. + +#include "document.h" // rapidjson's DOM-style API +#include "prettywriter.h" // for stringify JSON +#include + +#include +#include +#include + + +// Wrapper around a RapidJSON value +class JsonValue +{ +public: + JsonValue() : m_value(m_null) {} + JsonValue(rapidjson::Value& a_value) : m_value(a_value) {} + + JsonValue& operator=(const JsonValue& a_other) + { + m_value = a_other.m_value; + } + + enum ValueType { + // RapidJSON types + kNullType = 0, //!< null + kFalseType = 1, //!< false + kTrueType = 2, //!< true + kObjectType = 3, //!< object + kArrayType = 4, //!< array + kStringType = 5, //!< string + kNumberType = 6 //!< number + // JsonCpp types + /* + nullValue, + intValue, + uintValue, + realValue, + stringValue, + booleanValue, + arrayValue, + objectValue + */ + }; + + ValueType type() const { return (ValueType)m_value.GetType(); } + bool isNull() const { return type() == kObjectType; } + bool isBool() const { return type() == kFalseType || type() == kTrueType; } + bool isNumber() const { return type() == kNumberType; } + bool isString() const { return type() == kStringType; } + bool isArray() const { return type() == kArrayType; } + bool isObject() const { return type() == kObjectType; } + + bool asBool() const { return type() == kTrueType; } + int asInt() const { return (type() == kNumberType) ? m_value.GetInt() : 0; } + double asDouble() const { return (type() == kNumberType) ? m_value.GetDouble() : 0.0; } + std::string asString() const { return (type() == kStringType) ? m_value.GetString() : ""; } + + size_t size() const { return (isArray() || isObject()) ? m_value.Size() : 1; } + JsonValue operator[](size_t a_index) const { return (type() == kArrayType) ? m_value[a_index] : *this; } // TODO: or JsonValue(m_null) + JsonValue operator[](const char* a_key) const { return (type() == kObjectType && m_value.HasMember(a_key)) ? m_value[a_key] : *this; } + + std::string prettyPrint() const { + rapidjson::StringBuffer sb; + rapidjson::PrettyWriter wr(sb); + m_value.Accept(wr); + return sb.GetString(); + } +private: + rapidjson::Value& m_value; + static rapidjson::Value m_null; +}; + +rapidjson::Value JsonValue::m_null; + + +// Wrapper around a RapidJSON document +class JsonReader +{ +public: + JsonReader() {} + ~JsonReader() {} + bool ParseString(const char* a_string, JsonValue& a_value) + { + rapidjson::Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator. + if (document.Parse(a_string).HasParseError()) + return false; + a_value = JsonValue(document); + return true; + } + bool ParseFile(const char* a_fileName, JsonValue& a_value) + { + std::ifstream inFile(a_fileName); + if (inFile) { + /* + std::streambuf *pbuf = inFile.rdbuf(); + std::streamsize size = pbuf->pubseekoff(0, istr.end); + pbuf->pubseekoff(0, istr.beg); + char* contents = new char[size]; // Leaked. Need to keep around while any ref to a_value or its children + pbuf->sgetn(contents, size); + inFile.close(); + rapidjson::Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator. + if (document.ParseInsitu(contents).HasParseError()) + return false; + a_value = JsonValue(document); + return true; + */ + std::stringstream strStream; + strStream << inFile.rdbuf(); + inFile.close(); + return ParseString(strStream.str().c_str(), a_value); + } + return false; + } +}; + + +int my_tutorial(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); + + JsonReader reader; + JsonValue value; + + if (!reader.ParseString(json, value)) + return 1; + + printf("\nParsing to document succeeded.\n"); + + //////////////////////////////////////////////////////////////////////////// + // 2. Access values in document. + + printf("hello = %s\n", value["hello"].asString().c_str()); + printf("t = %s\n", value["t"].asBool() ? "true" : "false"); + printf("f = %s\n", value["f"].asBool() ? "true" : "false"); + printf("n = %s\n", value["n"].isNull() ? "null" : "?"); + printf("i = %d\n", value["i"].asInt()); // Alternative (int)document["i"] + printf("pi = %g\n", value["pi"].asDouble()); + + { + const JsonValue& a = value["a"]; // Using a reference for consecutive access is handy and faster. + assert(a.isArray()); + for (size_t i = 0; i < a.size(); i++) // rapidjson uses SizeType instead of size_t. + printf("a[%d] = %d\n", int(i), a[i].asInt()); + 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; + value["i"] = f20; // Alternate form: document["i"].SetUint64(f20) + assert(!value["i"].isInt()); // No longer can be cast as int or uint. + } + + // Adding values to array. + { + JsonValue& a = value["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. + { + value["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. + JsonValue author; + { + char buffer[10]; + int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string. + + author.SetString(buffer, static_cast(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(buffer, 0, sizeof(buffer)); // 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"); + puts(value.prettyPrint().c_str()); + + return 0; +} + +using namespace rapidjson; +using namespace std; + + + +int rapid_tutorial(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 buffer[10]; + int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string. + + author.SetString(buffer, static_cast(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(buffer, 0, sizeof(buffer)); // 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 writer(sb); + document.Accept(writer); // Accept() traverses the DOM and generates Handler events. + puts(sb.GetString()); + + return 0; +} + + + + + + + +int main(int a, char*b[]) +{ + rapid_tutorial(a,b); + return my_tutorial(a,b); +} + diff --git a/3rdParty/rapidjson/Makefile b/3rdParty/rapidjson/Makefile new file mode 100755 index 0000000..f498fb1 --- /dev/null +++ b/3rdParty/rapidjson/Makefile @@ -0,0 +1,8 @@ + + +test: main.cpp + g++ -I. -Os main.cpp -o test -std=c++11 + +# ./test > res2.txt ; diff res.txt res2.txt + + diff --git a/3rdParty/rapidjson/main.cpp b/3rdParty/rapidjson/main.cpp new file mode 100644 index 0000000..0022f1f --- /dev/null +++ b/3rdParty/rapidjson/main.cpp @@ -0,0 +1,377 @@ +// Hello World example +// This example shows basic usage of DOM-style API. + +#include "document.h" // rapidjson's DOM-style API +#include "prettywriter.h" // for stringify JSON +#include + +#include +#include +#include + + +// Wrapper around a RapidJSON value +class JsonValue +{ +public: + JsonValue() : m_value(m_null) {} + JsonValue(rapidjson::Value& a_value) : m_value(a_value) {} + + JsonValue& operator=(const JsonValue& a_other) + { + m_value = a_other.m_value; + } + + enum ValueType { + // RapidJSON types + kNullType = 0, //!< null + kFalseType = 1, //!< false + kTrueType = 2, //!< true + kObjectType = 3, //!< object + kArrayType = 4, //!< array + kStringType = 5, //!< string + kNumberType = 6 //!< number + // JsonCpp types + /* + nullValue, + intValue, + uintValue, + realValue, + stringValue, + booleanValue, + arrayValue, + objectValue + */ + }; + + ValueType type() const { return (ValueType)m_value.GetType(); } + bool isNull() const { return type() == kObjectType; } + bool isBool() const { return type() == kFalseType || type() == kTrueType; } + bool isNumber() const { return type() == kNumberType; } + bool isString() const { return type() == kStringType; } + bool isArray() const { return type() == kArrayType; } + bool isObject() const { return type() == kObjectType; } + + bool asBool() const { return type() == kTrueType; } + int asInt() const { return (type() == kNumberType) ? m_value.GetInt() : 0; } + double asDouble() const { return (type() == kNumberType) ? m_value.GetDouble() : 0.0; } + std::string asString() const { return (type() == kStringType) ? m_value.GetString() : ""; } + + size_t size() const { return (isArray() || isObject()) ? m_value.Size() : 1; } + JsonValue operator[](size_t a_index) const { return (type() == kArrayType) ? m_value[a_index] : *this; } // TODO: or JsonValue(m_null) + JsonValue operator[](const char* a_key) const { return (type() == kObjectType && m_value.HasMember(a_key)) ? m_value[a_key] : *this; } + + std::string prettyPrint() const { + rapidjson::StringBuffer sb; + rapidjson::PrettyWriter wr(sb); + m_value.Accept(wr); + return sb.GetString(); + } +private: + rapidjson::Value& m_value; + static rapidjson::Value m_null; +}; + +rapidjson::Value JsonValue::m_null; + + +// Wrapper around a RapidJSON document +class JsonReader +{ +public: + JsonReader() {} + ~JsonReader() {} + bool ParseString(const char* a_string, JsonValue& a_value) + { + rapidjson::Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator. + if (document.Parse(a_string).HasParseError()) + return false; + a_value = JsonValue(document); + return true; + } + bool ParseFile(const char* a_fileName, JsonValue& a_value) + { + std::ifstream inFile(a_fileName); + if (inFile) { + /* + std::streambuf *pbuf = inFile.rdbuf(); + std::streamsize size = pbuf->pubseekoff(0, istr.end); + pbuf->pubseekoff(0, istr.beg); + char* contents = new char[size]; // Leaked. Need to keep around while any ref to a_value or its children + pbuf->sgetn(contents, size); + inFile.close(); + rapidjson::Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator. + if (document.ParseInsitu(contents).HasParseError()) + return false; + a_value = JsonValue(document); + return true; + */ + std::stringstream strStream; + strStream << inFile.rdbuf(); + inFile.close(); + return ParseString(strStream.str().c_str(), a_value); + } + return false; + } +}; + + +int my_tutorial(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); + + JsonReader reader; + JsonValue value; + + if (!reader.ParseString(json, value)) + return 1; + + printf("\nParsing to document succeeded.\n"); + + //////////////////////////////////////////////////////////////////////////// + // 2. Access values in document. + + printf("hello = %s\n", value["hello"].asString().c_str()); + printf("t = %s\n", value["t"].asBool() ? "true" : "false"); + printf("f = %s\n", value["f"].asBool() ? "true" : "false"); + printf("n = %s\n", value["n"].isNull() ? "null" : "?"); + printf("i = %d\n", value["i"].asInt()); // Alternative (int)document["i"] + printf("pi = %g\n", value["pi"].asDouble()); + + { + const JsonValue& a = value["a"]; // Using a reference for consecutive access is handy and faster. + assert(a.isArray()); + for (size_t i = 0; i < a.size(); i++) // rapidjson uses SizeType instead of size_t. + printf("a[%d] = %d\n", int(i), a[i].asInt()); + 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; + value["i"] = f20; // Alternate form: document["i"].SetUint64(f20) + assert(!value["i"].isInt()); // No longer can be cast as int or uint. + } + + // Adding values to array. + { + JsonValue& a = value["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. + { + value["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. + JsonValue author; + { + char buffer[10]; + int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string. + + author.SetString(buffer, static_cast(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(buffer, 0, sizeof(buffer)); // 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"); + puts(value.prettyPrint().c_str()); + + return 0; +} + +using namespace rapidjson; +using namespace std; + + + +int rapid_tutorial(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 buffer[10]; + int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string. + + author.SetString(buffer, static_cast(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(buffer, 0, sizeof(buffer)); // 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 writer(sb); + document.Accept(writer); // Accept() traverses the DOM and generates Handler events. + puts(sb.GetString()); + + return 0; +} + + + + + + + +int main(int a, char*b[]) +{ + rapid_tutorial(a,b); + return my_tutorial(a,b); +} + diff --git a/3rdParty/rapidjson/res2.txt b/3rdParty/rapidjson/res2.txt deleted file mode 100644 index e69de29..0000000 --- a/3rdParty/rapidjson/res2.txt +++ /dev/null