rroonga 9.0.3-x64-mingw32 → 9.0.7-x64-mingw32

data/vendor/local/share/doc/RapidJSON/examples/messagereader/messagereader.cpp

@@ -0,0 +1,105 @@
+// Reading a message JSON with Reader (SAX-style API).
+// The JSON should be an object with key-string pairs.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/error/en.h"
+#include <iostream>
+#include <string>
+#include <map>
+
+using namespace std;
+using namespace rapidjson;
+
+typedef map<string, string> MessageMap;
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+#endif
+
+struct MessageHandler
+    : public BaseReaderHandler<UTF8<>, MessageHandler> {
+    MessageHandler() : messages_(), state_(kExpectObjectStart), name_() {}
+
+    bool StartObject() {
+        switch (state_) {
+        case kExpectObjectStart:
+            state_ = kExpectNameOrObjectEnd;
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool String(const char* str, SizeType length, bool) {
+        switch (state_) {
+        case kExpectNameOrObjectEnd:
+            name_ = string(str, length);
+            state_ = kExpectValue;
+            return true;
+        case kExpectValue:
+            messages_.insert(MessageMap::value_type(name_, string(str, length)));
+            state_ = kExpectNameOrObjectEnd;
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool EndObject(SizeType) { return state_ == kExpectNameOrObjectEnd; }
+
+    bool Default() { return false; } // All other events are invalid.
+
+    MessageMap messages_;
+    enum State {
+        kExpectObjectStart,
+        kExpectNameOrObjectEnd,
+        kExpectValue
+    }state_;
+    std::string name_;
+};
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+static void ParseMessages(const char* json, MessageMap& messages) {
+    Reader reader;
+    MessageHandler handler;
+    StringStream ss(json);
+    if (reader.Parse(ss, handler))
+        messages.swap(handler.messages_);   // Only change it if success.
+    else {
+        ParseErrorCode e = reader.GetParseErrorCode();
+        size_t o = reader.GetErrorOffset();
+        cout << "Error: " << GetParseError_En(e) << endl;;
+        cout << " at offset " << o << " near '" << string(json).substr(o, 10) << "...'" << endl;
+    }
+}
+
+int main() {
+    MessageMap messages;
+
+    const char* json1 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\" }";
+    cout << json1 << endl;
+    ParseMessages(json1, messages);
+
+    for (MessageMap::const_iterator itr = messages.begin(); itr != messages.end(); ++itr)
+        cout << itr->first << ": " << itr->second << endl;
+
+    cout << endl << "Parse a JSON with invalid schema." << endl;
+    const char* json2 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\", \"foo\" : {} }";
+    cout << json2 << endl;
+    ParseMessages(json2, messages);
+
+    return 0;
+}

data/vendor/local/share/doc/RapidJSON/examples/parsebyparts/parsebyparts.cpp

@@ -0,0 +1,173 @@
+// Example of parsing JSON to document by parts.
+
+// Using C++11 threads
+// Temporarily disable for clang (older version) due to incompatibility with libstdc++
+#if (__cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700)) && !defined(__clang__)
+
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/ostreamwrapper.h"
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <thread>
+
+using namespace rapidjson;
+
+template<unsigned parseFlags = kParseDefaultFlags>
+class AsyncDocumentParser {
+public:
+    AsyncDocumentParser(Document& d)
+        : stream_(*this)
+        , d_(d)
+        , parseThread_(&AsyncDocumentParser::Parse, this)
+        , mutex_()
+        , notEmpty_()
+        , finish_()
+        , completed_()
+    {}
+
+    ~AsyncDocumentParser() {
+        if (!parseThread_.joinable())
+            return;
+
+        {        
+            std::unique_lock<std::mutex> lock(mutex_);
+
+            // Wait until the buffer is read up (or parsing is completed)
+            while (!stream_.Empty() && !completed_)
+                finish_.wait(lock);
+
+            // Automatically append '\0' as the terminator in the stream.
+            static const char terminator[] = "";
+            stream_.src_ = terminator;
+            stream_.end_ = terminator + 1;
+            notEmpty_.notify_one(); // unblock the AsyncStringStream
+        }
+
+        parseThread_.join();
+    }
+
+    void ParsePart(const char* buffer, size_t length) {
+        std::unique_lock<std::mutex> lock(mutex_);
+        
+        // Wait until the buffer is read up (or parsing is completed)
+        while (!stream_.Empty() && !completed_)
+            finish_.wait(lock);
+
+        // Stop further parsing if the parsing process is completed.
+        if (completed_)
+            return;
+
+        // Set the buffer to stream and unblock the AsyncStringStream
+        stream_.src_ = buffer;
+        stream_.end_ = buffer + length;
+        notEmpty_.notify_one();
+    }
+
+private:
+    void Parse() {
+        d_.ParseStream<parseFlags>(stream_);
+
+        // The stream may not be fully read, notify finish anyway to unblock ParsePart()
+        std::unique_lock<std::mutex> lock(mutex_);
+        completed_ = true;      // Parsing process is completed
+        finish_.notify_one();   // Unblock ParsePart() or destructor if they are waiting.
+    }
+
+    struct AsyncStringStream {
+        typedef char Ch;
+
+        AsyncStringStream(AsyncDocumentParser& parser) : parser_(parser), src_(), end_(), count_() {}
+
+        char Peek() const {
+            std::unique_lock<std::mutex> lock(parser_.mutex_);
+
+            // If nothing in stream, block to wait.
+            while (Empty())
+                parser_.notEmpty_.wait(lock);
+
+            return *src_;
+        }
+
+        char Take() {
+            std::unique_lock<std::mutex> lock(parser_.mutex_);
+
+            // If nothing in stream, block to wait.
+            while (Empty())
+                parser_.notEmpty_.wait(lock);
+
+            count_++;
+            char c = *src_++;
+
+            // If all stream is read up, notify that the stream is finish.
+            if (Empty())
+                parser_.finish_.notify_one();
+
+            return c;
+        }
+
+        size_t Tell() const { return count_; }
+
+        // Not implemented
+        char* PutBegin() { return 0; }
+        void Put(char) {}
+        void Flush() {}
+        size_t PutEnd(char*) { return 0; }
+
+        bool Empty() const { return src_ == end_; }
+
+        AsyncDocumentParser& parser_;
+        const char* src_;     //!< Current read position.
+        const char* end_;     //!< End of buffer
+        size_t count_;        //!< Number of characters taken so far.
+    };
+
+    AsyncStringStream stream_;
+    Document& d_;
+    std::thread parseThread_;
+    std::mutex mutex_;
+    std::condition_variable notEmpty_;
+    std::condition_variable finish_;
+    bool completed_;
+};
+
+int main() {
+    Document d;
+
+    {
+        AsyncDocumentParser<> parser(d);
+
+        const char json1[] = " { \"hello\" : \"world\", \"t\" : tr";
+        //const char json1[] = " { \"hello\" : \"world\", \"t\" : trX"; // Fot test parsing error
+        const char json2[] = "ue, \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.14";
+        const char json3[] = "16, \"a\":[1, 2, 3, 4] } ";
+
+        parser.ParsePart(json1, sizeof(json1) - 1);
+        parser.ParsePart(json2, sizeof(json2) - 1);
+        parser.ParsePart(json3, sizeof(json3) - 1);
+    }
+
+    if (d.HasParseError()) {
+        std::cout << "Error at offset " << d.GetErrorOffset() << ": " << GetParseError_En(d.GetParseError()) << std::endl;
+        return EXIT_FAILURE;
+    }
+    
+    // Stringify the JSON to cout
+    OStreamWrapper os(std::cout);
+    Writer<OStreamWrapper> writer(os);
+    d.Accept(writer);
+    std::cout << std::endl;
+
+    return EXIT_SUCCESS;
+}
+
+#else // Not supporting C++11 
+
+#include <iostream>
+int main() {
+    std::cout << "This example requires C++11 compiler" << std::endl;
+}
+
+#endif

data/vendor/local/share/doc/RapidJSON/examples/pretty/pretty.cpp

@@ -0,0 +1,30 @@
+// JSON pretty formatting example
+// This example can only handle UTF-8. For handling other encodings, see prettyauto example.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/error/en.h"
+
+using namespace rapidjson;
+
+int main(int, char*[]) {
+    // Prepare reader and input stream.
+    Reader reader;
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+
+    // Prepare writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+    PrettyWriter<FileWriteStream> writer(os);
+
+    // JSON reader parse from the input stream and let writer generate the output.
+    if (!reader.Parse<kParseValidateEncodingFlag>(is, writer)) {
+        fprintf(stderr, "\nError(%u): %s\n", static_cast<unsigned>(reader.GetErrorOffset()), GetParseError_En(reader.GetParseErrorCode()));
+        return 1;
+    }
+
+    return 0;
+}

data/vendor/local/share/doc/RapidJSON/examples/prettyauto/prettyauto.cpp

@@ -0,0 +1,56 @@
+// JSON pretty formatting example
+// This example can handle UTF-8/UTF-16LE/UTF-16BE/UTF-32LE/UTF-32BE.
+// The input firstly convert to UTF8, and then write to the original encoding with pretty formatting.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/encodedstream.h"    // NEW
+#include "rapidjson/error/en.h"
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#endif
+
+using namespace rapidjson;
+
+int main(int, char*[]) {
+#ifdef _WIN32
+    // Prevent Windows converting between CR+LF and LF
+    _setmode(_fileno(stdin), _O_BINARY);    // NEW
+    _setmode(_fileno(stdout), _O_BINARY);   // NEW
+#endif
+
+    // Prepare reader and input stream.
+    //Reader reader;
+    GenericReader<AutoUTF<unsigned>, UTF8<> > reader;       // CHANGED
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+    AutoUTFInputStream<unsigned, FileReadStream> eis(is);   // NEW
+
+    // Prepare writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+
+#if 1
+    // Use the same Encoding of the input. Also use BOM according to input.
+    typedef AutoUTFOutputStream<unsigned, FileWriteStream> OutputStream;    // NEW
+    OutputStream eos(os, eis.GetType(), eis.HasBOM());                      // NEW
+    PrettyWriter<OutputStream, UTF8<>, AutoUTF<unsigned> > writer(eos);     // CHANGED
+#else
+    // You may also use static bound encoding type, such as output to UTF-16LE with BOM
+    typedef EncodedOutputStream<UTF16LE<>,FileWriteStream> OutputStream;    // NEW
+    OutputStream eos(os, true);                                             // NEW
+    PrettyWriter<OutputStream, UTF8<>, UTF16LE<> > writer(eos);             // CHANGED
+#endif
+
+    // JSON reader parse from the input stream and let writer generate the output.
+    //if (!reader.Parse<kParseValidateEncodingFlag>(is, writer)) {
+    if (!reader.Parse<kParseValidateEncodingFlag>(eis, writer)) {   // CHANGED
+        fprintf(stderr, "\nError(%u): %s\n", static_cast<unsigned>(reader.GetErrorOffset()), GetParseError_En(reader.GetParseErrorCode()));
+        return 1;
+    }
+
+    return 0;
+}

data/vendor/local/share/doc/RapidJSON/examples/schemavalidator/schemavalidator.cpp

@@ -0,0 +1,72 @@
+// Schema Validator example
+
+// The example validates JSON text from stdin with a JSON schema specified in the argument.
+
+#include "rapidjson/error/en.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/schema.h"
+#include "rapidjson/stringbuffer.h"
+
+using namespace rapidjson;
+
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: schemavalidator schema.json < input.json\n");
+        return EXIT_FAILURE;
+    }
+
+    // Read a JSON schema from file into Document
+    Document d;
+    char buffer[4096];
+
+    {
+        FILE *fp = fopen(argv[1], "r");
+        if (!fp) {
+            printf("Schema file '%s' not found\n", argv[1]);
+            return -1;
+        }
+        FileReadStream fs(fp, buffer, sizeof(buffer));
+        d.ParseStream(fs);
+        if (d.HasParseError()) {
+            fprintf(stderr, "Schema file '%s' is not a valid JSON\n", argv[1]);
+            fprintf(stderr, "Error(offset %u): %s\n",
+                static_cast<unsigned>(d.GetErrorOffset()),
+                GetParseError_En(d.GetParseError()));
+            fclose(fp);
+            return EXIT_FAILURE;
+        }
+        fclose(fp);
+    }
+    
+    // Then convert the Document into SchemaDocument
+    SchemaDocument sd(d);
+
+    // Use reader to parse the JSON in stdin, and forward SAX events to validator
+    SchemaValidator validator(sd);
+    Reader reader;
+    FileReadStream is(stdin, buffer, sizeof(buffer));
+    if (!reader.Parse(is, validator) && reader.GetParseErrorCode() != kParseErrorTermination) {
+        // Schema validator error would cause kParseErrorTermination, which will handle it in next step.
+        fprintf(stderr, "Input is not a valid JSON\n");
+        fprintf(stderr, "Error(offset %u): %s\n",
+            static_cast<unsigned>(reader.GetErrorOffset()),
+            GetParseError_En(reader.GetParseErrorCode()));
+    }
+
+    // Check the validation result
+    if (validator.IsValid()) {
+        printf("Input JSON is valid.\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("Input JSON is invalid.\n");
+        StringBuffer sb;
+        validator.GetInvalidSchemaPointer().StringifyUriFragment(sb);
+        fprintf(stderr, "Invalid schema: %s\n", sb.GetString());
+        fprintf(stderr, "Invalid keyword: %s\n", validator.GetInvalidSchemaKeyword());
+        sb.Clear();
+        validator.GetInvalidDocumentPointer().StringifyUriFragment(sb);
+        fprintf(stderr, "Invalid document: %s\n", sb.GetString());
+        return EXIT_FAILURE;
+    }
+}

data/vendor/local/share/doc/RapidJSON/examples/serialize/serialize.cpp

@@ -0,0 +1,173 @@
+// Serialize example
+// This example shows writing JSON string with writer directly.
+
+#include "rapidjson/prettywriter.h" // for stringify JSON
+#include <cstdio>
+#include <string>
+#include <vector>
+
+using namespace rapidjson;
+
+class Person {
+public:
+    Person(const std::string& name, unsigned age) : name_(name), age_(age) {}
+    Person(const Person& rhs) : name_(rhs.name_), age_(rhs.age_) {}
+    virtual ~Person();
+
+    Person& operator=(const Person& rhs) {
+        name_ = rhs.name_;
+        age_ = rhs.age_;
+        return *this;
+    }
+
+protected:
+    template <typename Writer>
+    void Serialize(Writer& writer) const {
+        // This base class just write out name-value pairs, without wrapping within an object.
+        writer.String("name");
+#if RAPIDJSON_HAS_STDSTRING
+        writer.String(name_);
+#else
+        writer.String(name_.c_str(), static_cast<SizeType>(name_.length())); // Supplying length of string is faster.
+#endif
+        writer.String("age");
+        writer.Uint(age_);
+    }
+
+private:
+    std::string name_;
+    unsigned age_;
+};
+
+Person::~Person() {
+}
+
+class Education {
+public:
+    Education(const std::string& school, double GPA) : school_(school), GPA_(GPA) {}
+    Education(const Education& rhs) : school_(rhs.school_), GPA_(rhs.GPA_) {}
+
+    template <typename Writer>
+    void Serialize(Writer& writer) const {
+        writer.StartObject();
+        
+        writer.String("school");
+#if RAPIDJSON_HAS_STDSTRING
+        writer.String(school_);
+#else
+        writer.String(school_.c_str(), static_cast<SizeType>(school_.length()));
+#endif
+
+        writer.String("GPA");
+        writer.Double(GPA_);
+
+        writer.EndObject();
+    }
+
+private:
+    std::string school_;
+    double GPA_;
+};
+
+class Dependent : public Person {
+public:
+    Dependent(const std::string& name, unsigned age, Education* education = 0) : Person(name, age), education_(education) {}
+    Dependent(const Dependent& rhs) : Person(rhs), education_(0) { education_ = (rhs.education_ == 0) ? 0 : new Education(*rhs.education_); }
+    virtual ~Dependent();
+
+    Dependent& operator=(const Dependent& rhs) {
+        if (this == &rhs)
+            return *this;
+        delete education_;
+        education_ = (rhs.education_ == 0) ? 0 : new Education(*rhs.education_);
+        return *this;
+    }
+
+    template <typename Writer>
+    void Serialize(Writer& writer) const {
+        writer.StartObject();
+
+        Person::Serialize(writer);
+
+        writer.String("education");
+        if (education_)
+            education_->Serialize(writer);
+        else
+            writer.Null();
+
+        writer.EndObject();
+    }
+
+private:
+
+    Education *education_;
+};
+
+Dependent::~Dependent() {
+    delete education_; 
+}
+
+class Employee : public Person {
+public:
+    Employee(const std::string& name, unsigned age, bool married) : Person(name, age), dependents_(), married_(married) {}
+    Employee(const Employee& rhs) : Person(rhs), dependents_(rhs.dependents_), married_(rhs.married_) {}
+    virtual ~Employee();
+
+    Employee& operator=(const Employee& rhs) {
+        static_cast<Person&>(*this) = rhs;
+        dependents_ = rhs.dependents_;
+        married_ = rhs.married_;
+        return *this;
+    }
+
+    void AddDependent(const Dependent& dependent) {
+        dependents_.push_back(dependent);
+    }
+
+    template <typename Writer>
+    void Serialize(Writer& writer) const {
+        writer.StartObject();
+
+        Person::Serialize(writer);
+
+        writer.String("married");
+        writer.Bool(married_);
+
+        writer.String(("dependents"));
+        writer.StartArray();
+        for (std::vector<Dependent>::const_iterator dependentItr = dependents_.begin(); dependentItr != dependents_.end(); ++dependentItr)
+            dependentItr->Serialize(writer);
+        writer.EndArray();
+
+        writer.EndObject();
+    }
+
+private:
+    std::vector<Dependent> dependents_;
+    bool married_;
+};
+
+Employee::~Employee() {
+}
+
+int main(int, char*[]) {
+    std::vector<Employee> employees;
+
+    employees.push_back(Employee("Milo YIP", 34, true));
+    employees.back().AddDependent(Dependent("Lua YIP", 3, new Education("Happy Kindergarten", 3.5)));
+    employees.back().AddDependent(Dependent("Mio YIP", 1));
+
+    employees.push_back(Employee("Percy TSE", 30, false));
+
+    StringBuffer sb;
+    PrettyWriter<StringBuffer> writer(sb);
+
+    writer.StartArray();
+    for (std::vector<Employee>::const_iterator employeeItr = employees.begin(); employeeItr != employees.end(); ++employeeItr)
+        employeeItr->Serialize(writer);
+    writer.EndArray();
+
+    puts(sb.GetString());
+
+    return 0;
+}