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

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

@@ -0,0 +1,32 @@
+// JSON condenser example
+
+// This example parses JSON text from stdin with validation, 
+// and re-output the JSON content to stdout without whitespace.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/error/en.h"
+
+using namespace rapidjson;
+
+int main(int, char*[]) {
+    // Prepare JSON reader and input stream.
+    Reader reader;
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+
+    // Prepare JSON writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+    Writer<FileWriteStream> writer(os);
+
+    // JSON reader parse from the input stream and let writer generate the output.
+    if (!reader.Parse(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/filterkey/filterkey.cpp

@@ -0,0 +1,135 @@
+// JSON filterkey example with SAX-style API.
+
+// This example parses JSON text from stdin with validation.
+// During parsing, specified key will be filtered using a SAX handler.
+// It re-output the JSON content to stdout without whitespace.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/error/en.h"
+#include <stack>
+
+using namespace rapidjson;
+
+// This handler forwards event into an output handler, with filtering the descendent events of specified key.
+template <typename OutputHandler>
+class FilterKeyHandler {
+public:
+    typedef char Ch;
+
+    FilterKeyHandler(OutputHandler& outputHandler, const Ch* keyString, SizeType keyLength) : 
+        outputHandler_(outputHandler), keyString_(keyString), keyLength_(keyLength), filterValueDepth_(), filteredKeyCount_()
+    {}
+
+    bool Null()             { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Null()    && EndValue(); }
+    bool Bool(bool b)       { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Bool(b)   && EndValue(); }
+    bool Int(int i)         { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Int(i)    && EndValue(); }
+    bool Uint(unsigned u)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Uint(u)   && EndValue(); }
+    bool Int64(int64_t i)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Int64(i)  && EndValue(); }
+    bool Uint64(uint64_t u) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Uint64(u) && EndValue(); }
+    bool Double(double d)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Double(d) && EndValue(); }
+    bool RawNumber(const Ch* str, SizeType len, bool copy) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.RawNumber(str, len, copy) && EndValue(); }
+    bool String   (const Ch* str, SizeType len, bool copy) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.String   (str, len, copy) && EndValue(); }
+    
+    bool StartObject() { 
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_++;
+            return true;
+        }
+        else {
+            filteredKeyCount_.push(0);
+            return outputHandler_.StartObject();
+        }
+    }
+    
+    bool Key(const Ch* str, SizeType len, bool copy) { 
+        if (filterValueDepth_ > 0) 
+            return true;
+        else if (len == keyLength_ && std::memcmp(str, keyString_, len) == 0) {
+            filterValueDepth_ = 1;
+            return true;
+        }
+        else {
+            ++filteredKeyCount_.top();
+            return outputHandler_.Key(str, len, copy);
+        }
+    }
+
+    bool EndObject(SizeType) {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_--;
+            return EndValue();
+        }
+        else {
+            // Use our own filtered memberCount
+            SizeType memberCount = filteredKeyCount_.top();
+            filteredKeyCount_.pop();
+            return outputHandler_.EndObject(memberCount) && EndValue();
+        }
+    }
+
+    bool StartArray() {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_++;
+            return true;
+        }
+        else
+            return outputHandler_.StartArray();
+    }
+
+    bool EndArray(SizeType elementCount) {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_--;
+            return EndValue();
+        }
+        else
+            return outputHandler_.EndArray(elementCount) && EndValue();
+    }
+
+private:
+    FilterKeyHandler(const FilterKeyHandler&);
+    FilterKeyHandler& operator=(const FilterKeyHandler&);
+
+    bool EndValue() {
+        if (filterValueDepth_ == 1) // Just at the end of value after filtered key
+            filterValueDepth_ = 0;
+        return true;
+    }
+    
+    OutputHandler& outputHandler_;
+    const char* keyString_;
+    const SizeType keyLength_;
+    unsigned filterValueDepth_;
+    std::stack<SizeType> filteredKeyCount_;
+};
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "filterkey key < input.json > output.json\n");
+        return 1;
+    }
+
+    // Prepare JSON reader and input stream.
+    Reader reader;
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+
+    // Prepare JSON writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+    Writer<FileWriteStream> writer(os);
+
+    // Prepare Filter
+    FilterKeyHandler<Writer<FileWriteStream> > filter(writer, argv[1], static_cast<SizeType>(strlen(argv[1])));
+
+    // JSON reader parse from the input stream, filter handler filters the events, and forward to writer.
+    // i.e. the events flow is: reader -> filter -> writer
+    if (!reader.Parse(is, filter)) {
+        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/filterkeydom/filterkeydom.cpp

@@ -0,0 +1,170 @@
+// JSON filterkey example which populates filtered SAX events into a Document.
+
+// This example parses JSON text from stdin with validation.
+// During parsing, specified key will be filtered using a SAX handler.
+// And finally the filtered events are used to populate a Document.
+// As an example, the document is written to standard output.
+
+#include "rapidjson/document.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/error/en.h"
+#include <stack>
+
+using namespace rapidjson;
+
+// This handler forwards event into an output handler, with filtering the descendent events of specified key.
+template <typename OutputHandler>
+class FilterKeyHandler {
+public:
+    typedef char Ch;
+
+    FilterKeyHandler(OutputHandler& outputHandler, const Ch* keyString, SizeType keyLength) : 
+        outputHandler_(outputHandler), keyString_(keyString), keyLength_(keyLength), filterValueDepth_(), filteredKeyCount_()
+    {}
+
+    bool Null()             { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Null()    && EndValue(); }
+    bool Bool(bool b)       { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Bool(b)   && EndValue(); }
+    bool Int(int i)         { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Int(i)    && EndValue(); }
+    bool Uint(unsigned u)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Uint(u)   && EndValue(); }
+    bool Int64(int64_t i)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Int64(i)  && EndValue(); }
+    bool Uint64(uint64_t u) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Uint64(u) && EndValue(); }
+    bool Double(double d)   { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.Double(d) && EndValue(); }
+    bool RawNumber(const Ch* str, SizeType len, bool copy) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.RawNumber(str, len, copy) && EndValue(); }
+    bool String   (const Ch* str, SizeType len, bool copy) { return filterValueDepth_ > 0 ? EndValue() : outputHandler_.String   (str, len, copy) && EndValue(); }
+    
+    bool StartObject() { 
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_++;
+            return true;
+        }
+        else {
+            filteredKeyCount_.push(0);
+            return outputHandler_.StartObject();
+        }
+    }
+    
+    bool Key(const Ch* str, SizeType len, bool copy) { 
+        if (filterValueDepth_ > 0) 
+            return true;
+        else if (len == keyLength_ && std::memcmp(str, keyString_, len) == 0) {
+            filterValueDepth_ = 1;
+            return true;
+        }
+        else {
+            ++filteredKeyCount_.top();
+            return outputHandler_.Key(str, len, copy);
+        }
+    }
+
+    bool EndObject(SizeType) {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_--;
+            return EndValue();
+        }
+        else {
+            // Use our own filtered memberCount
+            SizeType memberCount = filteredKeyCount_.top();
+            filteredKeyCount_.pop();
+            return outputHandler_.EndObject(memberCount) && EndValue();
+        }
+    }
+
+    bool StartArray() {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_++;
+            return true;
+        }
+        else
+            return outputHandler_.StartArray();
+    }
+
+    bool EndArray(SizeType elementCount) {
+        if (filterValueDepth_ > 0) {
+            filterValueDepth_--;
+            return EndValue();
+        }
+        else
+            return outputHandler_.EndArray(elementCount) && EndValue();
+    }
+
+private:
+    FilterKeyHandler(const FilterKeyHandler&);
+    FilterKeyHandler& operator=(const FilterKeyHandler&);
+
+    bool EndValue() {
+        if (filterValueDepth_ == 1) // Just at the end of value after filtered key
+            filterValueDepth_ = 0;
+        return true;
+    }
+
+    OutputHandler& outputHandler_;
+    const char* keyString_;
+    const SizeType keyLength_;
+    unsigned filterValueDepth_;
+    std::stack<SizeType> filteredKeyCount_;
+};
+
+// Implements a generator for Document::Populate()
+template <typename InputStream>
+class FilterKeyReader {
+public:
+    typedef char Ch;
+
+    FilterKeyReader(InputStream& is, const Ch* keyString, SizeType keyLength) : 
+        is_(is), keyString_(keyString), keyLength_(keyLength), parseResult_()
+    {}
+
+    // SAX event flow: reader -> filter -> handler
+    template <typename Handler>
+    bool operator()(Handler& handler) {
+        FilterKeyHandler<Handler> filter(handler, keyString_, keyLength_);
+        Reader reader;
+        parseResult_ = reader.Parse(is_, filter);
+        return parseResult_;
+    }
+
+    const ParseResult& GetParseResult() const { return parseResult_; }
+
+private:
+    FilterKeyReader(const FilterKeyReader&);
+    FilterKeyReader& operator=(const FilterKeyReader&);
+
+    InputStream& is_;
+    const char* keyString_;
+    const SizeType keyLength_;
+    ParseResult parseResult_;
+};
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "filterkeydom key < input.json > output.json\n");
+        return 1;
+    }
+
+    // Prepare input stream.
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+
+    // Prepare Filter
+    FilterKeyReader<FileReadStream> reader(is, argv[1], static_cast<SizeType>(strlen(argv[1])));
+
+    // Populates the filtered events from reader
+    Document document;
+    document.Populate(reader);
+    ParseResult pr = reader.GetParseResult();
+    if (!pr) {
+        fprintf(stderr, "\nError(%u): %s\n", static_cast<unsigned>(pr.Offset()), GetParseError_En(pr.Code()));
+        return 1;
+    }
+
+    // Prepare JSON writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+    Writer<FileWriteStream> writer(os);
+
+    // Write the document to standard output
+    document.Accept(writer);
+    return 0;
+}

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

@@ -0,0 +1,207 @@
+// JSON to JSONx conversion exmaple, using SAX API.
+// JSONx is an IBM standard format to represent JSON as XML.
+// https://www-01.ibm.com/support/knowledgecenter/SS9H2Y_7.1.0/com.ibm.dp.doc/json_jsonx.html
+// This example parses JSON text from stdin with validation, 
+// and convert to JSONx format to stdout.
+// Need compile with -D__STDC_FORMAT_MACROS for defining PRId64 and PRIu64 macros.
+
+#include "rapidjson/reader.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/filereadstream.h"
+#include "rapidjson/filewritestream.h"
+#include "rapidjson/error/en.h"
+#include <cstdio>
+
+using namespace rapidjson;
+
+// For simplicity, this example only read/write in UTF-8 encoding
+template <typename OutputStream>
+class JsonxWriter {
+public:
+    JsonxWriter(OutputStream& os) : os_(os), name_(), level_(0), hasName_(false) {
+    }
+
+    bool Null() {
+        return WriteStartElement("null", true);
+    }
+    
+    bool Bool(bool b) {
+        return 
+            WriteStartElement("boolean") &&
+            WriteString(b ? "true" : "false") &&
+            WriteEndElement("boolean");
+    }
+    
+    bool Int(int i) {
+        char buffer[12];
+        return WriteNumberElement(buffer, sprintf(buffer, "%d", i));
+    }
+    
+    bool Uint(unsigned i) {
+        char buffer[11];
+        return WriteNumberElement(buffer, sprintf(buffer, "%u", i));
+    }
+    
+    bool Int64(int64_t i) {
+        char buffer[21];
+        return WriteNumberElement(buffer, sprintf(buffer, "%" PRId64, i));
+    }
+    
+    bool Uint64(uint64_t i) {
+        char buffer[21];
+        return WriteNumberElement(buffer, sprintf(buffer, "%" PRIu64, i));
+    }
+    
+    bool Double(double d) {
+        char buffer[30];
+        return WriteNumberElement(buffer, sprintf(buffer, "%.17g", d));
+    }
+
+    bool RawNumber(const char* str, SizeType length, bool) {
+        return
+            WriteStartElement("number") &&
+            WriteEscapedText(str, length) &&
+            WriteEndElement("number");
+    }
+
+    bool String(const char* str, SizeType length, bool) {
+        return
+            WriteStartElement("string") &&
+            WriteEscapedText(str, length) &&
+            WriteEndElement("string");
+    }
+
+    bool StartObject() {
+        return WriteStartElement("object");
+    }
+
+    bool Key(const char* str, SizeType length, bool) {
+        // backup key to name_
+        name_.Clear();
+        for (SizeType i = 0; i < length; i++)
+            name_.Put(str[i]);
+        hasName_ = true;
+        return true;
+    }
+
+    bool EndObject(SizeType) {
+        return WriteEndElement("object");
+    }
+
+    bool StartArray() {
+        return WriteStartElement("array");
+    }
+
+    bool EndArray(SizeType) {
+        return WriteEndElement("array");
+    }
+
+private:
+    bool WriteString(const char* s) {
+        while (*s)
+            os_.Put(*s++);
+        return true;
+    }
+
+    bool WriteEscapedAttributeValue(const char* s, size_t length) {
+        for (size_t i = 0; i < length; i++) {
+            switch (s[i]) {
+                case '&': WriteString("&amp;"); break;
+                case '<': WriteString("&lt;"); break;
+                case '"': WriteString("&quot;"); break;
+                default: os_.Put(s[i]); break;
+            }
+        }
+        return true;
+    }
+
+    bool WriteEscapedText(const char* s, size_t length) {
+        for (size_t i = 0; i < length; i++) {
+            switch (s[i]) {
+                case '&': WriteString("&amp;"); break;
+                case '<': WriteString("&lt;"); break;
+                default: os_.Put(s[i]); break;
+            }
+        }
+        return true;
+    }
+
+    bool WriteStartElement(const char* type, bool emptyElement = false) {
+        if (level_ == 0)
+            if (!WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"))
+                return false;
+
+        if (!WriteString("<json:") || !WriteString(type))
+            return false;
+
+        // For root element, need to add declarations
+        if (level_ == 0) {
+            if (!WriteString(
+                " xsi:schemaLocation=\"http://www.datapower.com/schemas/json jsonx.xsd\""
+                " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                " xmlns:json=\"http://www.ibm.com/xmlns/prod/2009/jsonx\""))
+                return false;
+        }
+
+        if (hasName_) {
+            hasName_ = false;
+            if (!WriteString(" name=\"") ||
+                !WriteEscapedAttributeValue(name_.GetString(), name_.GetSize()) ||
+                !WriteString("\""))
+                return false;
+        }
+
+        if (emptyElement)
+            return WriteString("/>");
+        else {
+            level_++;
+            return WriteString(">");
+        }
+    }
+
+    bool WriteEndElement(const char* type) {
+        if (!WriteString("</json:") ||
+            !WriteString(type) ||
+            !WriteString(">"))
+            return false;
+
+        // For the last end tag, flush the output stream.
+        if (--level_ == 0)
+            os_.Flush();
+
+        return true;
+    }
+
+    bool WriteNumberElement(const char* buffer, int length) {
+        if (!WriteStartElement("number"))
+            return false;
+        for (int j = 0; j < length; j++)
+            os_.Put(buffer[j]);
+        return WriteEndElement("number");
+    }
+
+    OutputStream& os_;
+    StringBuffer name_;
+    unsigned level_;
+    bool hasName_;
+};
+
+int main(int, char*[]) {
+    // Prepare JSON reader and input stream.
+    Reader reader;
+    char readBuffer[65536];
+    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
+
+    // Prepare JSON writer and output stream.
+    char writeBuffer[65536];
+    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
+    JsonxWriter<FileWriteStream> writer(os);
+
+    // JSON reader parse from the input stream and let writer generate the output.
+    if (!reader.Parse(is, writer)) {
+        fprintf(stderr, "\nError(%u): %s\n", static_cast<unsigned>(reader.GetErrorOffset()), GetParseError_En(reader.GetParseErrorCode()));
+        return 1;
+    }
+
+    return 0;
+}