@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/external/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;
-}

package/external/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

package/external/rapidjson/example/messagereader/messagereader.cpp

@@ -1,105 +0,0 @@
-// 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;
-}