rj_schema 0.2.3 → 0.2.4

data/ext/rj_schema/rapidjson/example/filterkeydom/filterkeydom.cpp

@@ -1,170 +0,0 @@
-// 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/ext/rj_schema/rapidjson/example/jsonx/jsonx.cpp

@@ -1,207 +0,0 @@
-// JSON to JSONx conversion example, 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;
-}

data/ext/rj_schema/rapidjson/example/lookaheadparser/lookaheadparser.cpp

@@ -1,350 +0,0 @@
-#include "rapidjson/reader.h"
-#include "rapidjson/document.h"
-#include <iostream>
-
-RAPIDJSON_DIAG_PUSH
-#ifdef __GNUC__
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-// This example demonstrates JSON token-by-token parsing with an API that is
-// more direct; you don't need to design your logic around a handler object and
-// callbacks. Instead, you retrieve values from the JSON stream by calling
-// GetInt(), GetDouble(), GetString() and GetBool(), traverse into structures
-// by calling EnterObject() and EnterArray(), and skip over unwanted data by
-// calling SkipValue(). When you know your JSON's structure, this can be quite
-// convenient.
-//
-// If you aren't sure of what's next in the JSON data, you can use PeekType() and
-// PeekValue() to look ahead to the next object before reading it.
-//
-// If you call the wrong retrieval method--e.g. GetInt when the next JSON token is
-// not an int, EnterObject or EnterArray when there isn't actually an object or array
-// to read--the stream parsing will end immediately and no more data will be delivered.
-//
-// After calling EnterObject, you retrieve keys via NextObjectKey() and values via
-// the normal getters. When NextObjectKey() returns null, you have exited the
-// object, or you can call SkipObject() to skip to the end of the object
-// immediately. If you fetch the entire object (i.e. NextObjectKey() returned  null),
-// you should not call SkipObject().
-//
-// After calling EnterArray(), you must alternate between calling NextArrayValue()
-// to see if the array has more data, and then retrieving values via the normal
-// getters. You can call SkipArray() to skip to the end of the array immediately.
-// If you fetch the entire array (i.e. NextArrayValue() returned null),
-// you should not call SkipArray().
-//
-// This parser uses in-situ strings, so the JSON buffer will be altered during the
-// parse.
-
-using namespace rapidjson;
-
-
-class LookaheadParserHandler {
-public:
-    bool Null() { st_ = kHasNull; v_.SetNull(); return true; }
-    bool Bool(bool b) { st_ = kHasBool; v_.SetBool(b); return true; }
-    bool Int(int i) { st_ = kHasNumber; v_.SetInt(i); return true; }
-    bool Uint(unsigned u) { st_ = kHasNumber; v_.SetUint(u); return true; }
-    bool Int64(int64_t i) { st_ = kHasNumber; v_.SetInt64(i); return true; }
-    bool Uint64(uint64_t u) { st_ = kHasNumber; v_.SetUint64(u); return true; }
-    bool Double(double d) { st_ = kHasNumber; v_.SetDouble(d); return true; }
-    bool RawNumber(const char*, SizeType, bool) { return false; }
-    bool String(const char* str, SizeType length, bool) { st_ = kHasString; v_.SetString(str, length); return true; }
-    bool StartObject() { st_ = kEnteringObject; return true; }
-    bool Key(const char* str, SizeType length, bool) { st_ = kHasKey; v_.SetString(str, length); return true; }
-    bool EndObject(SizeType) { st_ = kExitingObject; return true; }
-    bool StartArray() { st_ = kEnteringArray; return true; }
-    bool EndArray(SizeType) { st_ = kExitingArray; return true; }
-
-protected:
-    LookaheadParserHandler(char* str);
-    void ParseNext();
-
-protected:
-    enum LookaheadParsingState {
-        kInit,
-        kError,
-        kHasNull,
-        kHasBool,
-        kHasNumber,
-        kHasString,
-        kHasKey,
-        kEnteringObject,
-        kExitingObject,
-        kEnteringArray,
-        kExitingArray
-    };
-    
-    Value v_;
-    LookaheadParsingState st_;
-    Reader r_;
-    InsituStringStream ss_;
-    
-    static const int parseFlags = kParseDefaultFlags | kParseInsituFlag;
-};
-
-LookaheadParserHandler::LookaheadParserHandler(char* str) : v_(), st_(kInit), r_(), ss_(str) {
-    r_.IterativeParseInit();
-    ParseNext();
-}
-
-void LookaheadParserHandler::ParseNext() {
-    if (r_.HasParseError()) {
-        st_ = kError;
-        return;
-    }
-    
-    r_.IterativeParseNext<parseFlags>(ss_, *this);
-}
-
-class LookaheadParser : protected LookaheadParserHandler {
-public:
-    LookaheadParser(char* str) : LookaheadParserHandler(str) {}
-    
-    bool EnterObject();
-    bool EnterArray();
-    const char* NextObjectKey();
-    bool NextArrayValue();
-    int GetInt();
-    double GetDouble();
-    const char* GetString();
-    bool GetBool();
-    void GetNull();
-
-    void SkipObject();
-    void SkipArray();
-    void SkipValue();
-    Value* PeekValue();
-    int PeekType(); // returns a rapidjson::Type, or -1 for no value (at end of object/array)
-    
-    bool IsValid() { return st_ != kError; }
-    
-protected:
-    void SkipOut(int depth);
-};
-
-bool LookaheadParser::EnterObject() {
-    if (st_ != kEnteringObject) {
-        st_  = kError;
-        return false;
-    }
-    
-    ParseNext();
-    return true;
-}
-
-bool LookaheadParser::EnterArray() {
-    if (st_ != kEnteringArray) {
-        st_  = kError;
-        return false;
-    }
-    
-    ParseNext();
-    return true;
-}
-
-const char* LookaheadParser::NextObjectKey() {
-    if (st_ == kHasKey) {
-        const char* result = v_.GetString();
-        ParseNext();
-        return result;
-    }
-    
-    if (st_ != kExitingObject) {
-        st_ = kError;
-        return 0;
-    }
-    
-    ParseNext();
-    return 0;
-}
-
-bool LookaheadParser::NextArrayValue() {
-    if (st_ == kExitingArray) {
-        ParseNext();
-        return false;
-    }
-    
-    if (st_ == kError || st_ == kExitingObject || st_ == kHasKey) {
-        st_ = kError;
-        return false;
-    }
-
-    return true;
-}
-
-int LookaheadParser::GetInt() {
-    if (st_ != kHasNumber || !v_.IsInt()) {
-        st_ = kError;
-        return 0;
-    }
-
-    int result = v_.GetInt();
-    ParseNext();
-    return result;
-}
-
-double LookaheadParser::GetDouble() {
-    if (st_ != kHasNumber) {
-        st_  = kError;
-        return 0.;
-    }
-    
-    double result = v_.GetDouble();
-    ParseNext();
-    return result;
-}
-
-bool LookaheadParser::GetBool() {
-    if (st_ != kHasBool) {
-        st_  = kError;
-        return false;
-    }
-    
-    bool result = v_.GetBool();
-    ParseNext();
-    return result;
-}
-
-void LookaheadParser::GetNull() {
-    if (st_ != kHasNull) {
-        st_  = kError;
-        return;
-    }
-
-    ParseNext();
-}
-
-const char* LookaheadParser::GetString() {
-    if (st_ != kHasString) {
-        st_  = kError;
-        return 0;
-    }
-    
-    const char* result = v_.GetString();
-    ParseNext();
-    return result;
-}
-
-void LookaheadParser::SkipOut(int depth) {
-    do {
-        if (st_ == kEnteringArray || st_ == kEnteringObject) {
-            ++depth;
-        }
-        else if (st_ == kExitingArray || st_ == kExitingObject) {
-            --depth;
-        }
-        else if (st_ == kError) {
-            return;
-        }
-
-        ParseNext();
-    }
-    while (depth > 0);
-}
-
-void LookaheadParser::SkipValue() {
-    SkipOut(0);
-}
-
-void LookaheadParser::SkipArray() {
-    SkipOut(1);
-}
-
-void LookaheadParser::SkipObject() {
-    SkipOut(1);
-}
-
-Value* LookaheadParser::PeekValue() {
-    if (st_ >= kHasNull && st_ <= kHasKey) {
-        return &v_;
-    }
-    
-    return 0;
-}
-
-int LookaheadParser::PeekType() {
-    if (st_ >= kHasNull && st_ <= kHasKey) {
-        return v_.GetType();
-    }
-    
-    if (st_ == kEnteringArray) {
-        return kArrayType;
-    }
-    
-    if (st_ == kEnteringObject) {
-        return kObjectType;
-    }
-
-    return -1;
-}
-
-//-------------------------------------------------------------------------
-
-int main() {
-    using namespace std;
-
-    char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null,"
-        "\"i\":123, \"pi\": 3.1416, \"a\":[-1, 2, 3, 4, \"array\", []], \"skipArrays\":[1, 2, [[[3]]]], "
-        "\"skipObject\":{ \"i\":0, \"t\":true, \"n\":null, \"d\":123.45 }, "
-        "\"skipNested\":[[[[{\"\":0}, {\"\":[-9.87]}]]], [], []], "
-        "\"skipString\":\"zzz\", \"reachedEnd\":null, \"t\":true }";
-
-    LookaheadParser r(json);
-    
-    RAPIDJSON_ASSERT(r.PeekType() == kObjectType);
-
-    r.EnterObject();
-    while (const char* key = r.NextObjectKey()) {
-        if (0 == strcmp(key, "hello")) {
-            RAPIDJSON_ASSERT(r.PeekType() == kStringType);
-            cout << key << ":" << r.GetString() << endl;
-        }
-        else if (0 == strcmp(key, "t") || 0 == strcmp(key, "f")) {
-            RAPIDJSON_ASSERT(r.PeekType() == kTrueType || r.PeekType() == kFalseType);
-            cout << key << ":" << r.GetBool() << endl;
-            continue;
-        }
-        else if (0 == strcmp(key, "n")) {
-            RAPIDJSON_ASSERT(r.PeekType() == kNullType);
-            r.GetNull();
-            cout << key << endl;
-            continue;
-        }
-        else if (0 == strcmp(key, "pi")) {
-            RAPIDJSON_ASSERT(r.PeekType() == kNumberType);
-            cout << key << ":" << r.GetDouble() << endl;
-            continue;
-        }
-        else if (0 == strcmp(key, "a")) {
-            RAPIDJSON_ASSERT(r.PeekType() == kArrayType);
-            
-            r.EnterArray();
-            
-            cout << key << ":[ ";
-            while (r.NextArrayValue()) {
-                if (r.PeekType() == kNumberType) {
-                    cout << r.GetDouble() << " ";
-                }
-                else if (r.PeekType() == kStringType) {
-                    cout << r.GetString() << " ";
-                }
-                else {
-                    r.SkipArray();
-                    break;
-                }
-            }
-            
-            cout << "]" << endl;
-        }
-        else {
-            cout << key << ":skipped" << endl;
-            r.SkipValue();
-        }
-    }
-    
-    return 0;
-}
-
-RAPIDJSON_DIAG_POP