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

package/external/rapidjson/example/parsebyparts/parsebyparts.cpp

@@ -1,176 +0,0 @@
-// 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_()
-        , mutex_()
-        , notEmpty_()
-        , finish_()
-        , completed_()
-    {
-        // Create and execute thread after all member variables are initialized.
-        parseThread_ = std::thread(&AsyncDocumentParser::Parse, this);
-    }
-
-    ~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"; // For 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

package/external/rapidjson/example/pretty/pretty.cpp

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

package/external/rapidjson/example/prettyauto/prettyauto.cpp

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

package/external/rapidjson/example/schemavalidator/schemavalidator.cpp

@@ -1,78 +0,0 @@
-// 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"
-#include "rapidjson/prettywriter.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());
-        // Detailed violation report is available as a JSON value
-        sb.Clear();
-        PrettyWriter<StringBuffer> w(sb);
-        validator.GetError().Accept(w);
-        fprintf(stderr, "Error report:\n%s\n", sb.GetString());
-        return EXIT_FAILURE;
-    }
-}

package/external/rapidjson/example/serialize/serialize.cpp

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

package/external/rapidjson/example/simpledom/simpledom.cpp

@@ -1,29 +0,0 @@
-// JSON simple example
-// This example does not handle errors.
-
-#include "rapidjson/document.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-
-int main() {
-    // 1. Parse a JSON string into DOM.
-    const char* json = "{\"project\":\"rapidjson\",\"stars\":10}";
-    Document d;
-    d.Parse(json);
-
-    // 2. Modify it by DOM.
-    Value& s = d["stars"];
-    s.SetInt(s.GetInt() + 1);
-
-    // 3. Stringify the DOM
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    d.Accept(writer);
-
-    // Output {"project":"rapidjson","stars":11}
-    std::cout << buffer.GetString() << std::endl;
-    return 0;
-}

package/external/rapidjson/example/simplepullreader/simplepullreader.cpp

@@ -1,53 +0,0 @@
-#include "rapidjson/reader.h"
-#include <iostream>
-#include <sstream>
-
-using namespace rapidjson;
-using namespace std;
-
-// If you can require C++11, you could use std::to_string here
-template <typename T> std::string stringify(T x) {
-    std::stringstream ss;
-    ss << x;
-    return ss.str();
-}
-
-struct MyHandler {
-    const char* type;
-    std::string data;
-    
-    MyHandler() : type(), data() {}
-
-    bool Null() { type = "Null"; data.clear(); return true; }
-    bool Bool(bool b) { type = "Bool:"; data = b? "true": "false"; return true; }
-    bool Int(int i) { type = "Int:"; data = stringify(i); return true; }
-    bool Uint(unsigned u) { type = "Uint:"; data = stringify(u); return true; }
-    bool Int64(int64_t i) { type = "Int64:"; data = stringify(i); return true; }
-    bool Uint64(uint64_t u) { type = "Uint64:"; data = stringify(u); return true; }
-    bool Double(double d) { type = "Double:"; data = stringify(d); return true; }
-    bool RawNumber(const char* str, SizeType length, bool) { type = "Number:"; data = std::string(str, length); return true; }
-    bool String(const char* str, SizeType length, bool) { type = "String:"; data = std::string(str, length); return true; }
-    bool StartObject() { type = "StartObject"; data.clear(); return true; }
-    bool Key(const char* str, SizeType length, bool) { type = "Key:"; data = std::string(str, length); return true; }
-    bool EndObject(SizeType memberCount) { type = "EndObject:"; data = stringify(memberCount); return true; }
-    bool StartArray() { type = "StartArray"; data.clear(); return true; }
-    bool EndArray(SizeType elementCount) { type = "EndArray:"; data = stringify(elementCount); return true; }
-private:
-    MyHandler(const MyHandler& noCopyConstruction);
-    MyHandler& operator=(const MyHandler& noAssignment);
-};
-
-int main() {
-    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
-
-    MyHandler handler;
-    Reader reader;
-    StringStream ss(json);
-    reader.IterativeParseInit();
-    while (!reader.IterativeParseComplete()) {
-        reader.IterativeParseNext<kParseDefaultFlags>(ss, handler);
-        cout << handler.type << handler.data << endl;
-    }
-
-    return 0;
-}

package/external/rapidjson/example/simplereader/simplereader.cpp

@@ -1,42 +0,0 @@
-#include "rapidjson/reader.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-struct MyHandler {
-    bool Null() { cout << "Null()" << endl; return true; }
-    bool Bool(bool b) { cout << "Bool(" << boolalpha << b << ")" << endl; return true; }
-    bool Int(int i) { cout << "Int(" << i << ")" << endl; return true; }
-    bool Uint(unsigned u) { cout << "Uint(" << u << ")" << endl; return true; }
-    bool Int64(int64_t i) { cout << "Int64(" << i << ")" << endl; return true; }
-    bool Uint64(uint64_t u) { cout << "Uint64(" << u << ")" << endl; return true; }
-    bool Double(double d) { cout << "Double(" << d << ")" << endl; return true; }
-    bool RawNumber(const char* str, SizeType length, bool copy) { 
-        cout << "Number(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool String(const char* str, SizeType length, bool copy) { 
-        cout << "String(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool StartObject() { cout << "StartObject()" << endl; return true; }
-    bool Key(const char* str, SizeType length, bool copy) {
-        cout << "Key(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool EndObject(SizeType memberCount) { cout << "EndObject(" << memberCount << ")" << endl; return true; }
-    bool StartArray() { cout << "StartArray()" << endl; return true; }
-    bool EndArray(SizeType elementCount) { cout << "EndArray(" << elementCount << ")" << endl; return true; }
-};
-
-int main() {
-    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
-
-    MyHandler handler;
-    Reader reader;
-    StringStream ss(json);
-    reader.Parse(ss, handler);
-
-    return 0;
-}

package/external/rapidjson/example/simplewriter/simplewriter.cpp

@@ -1,36 +0,0 @@
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-int main() {
-    StringBuffer s;
-    Writer<StringBuffer> writer(s);
-    
-    writer.StartObject();               // Between StartObject()/EndObject(), 
-    writer.Key("hello");                // output a key,
-    writer.String("world");             // follow by a value.
-    writer.Key("t");
-    writer.Bool(true);
-    writer.Key("f");
-    writer.Bool(false);
-    writer.Key("n");
-    writer.Null();
-    writer.Key("i");
-    writer.Uint(123);
-    writer.Key("pi");
-    writer.Double(3.1416);
-    writer.Key("a");
-    writer.StartArray();                // Between StartArray()/EndArray(),
-    for (unsigned i = 0; i < 4; i++)
-        writer.Uint(i);                 // all values are elements of the array.
-    writer.EndArray();
-    writer.EndObject();
-
-    // {"hello":"world","t":true,"f":false,"n":null,"i":123,"pi":3.1416,"a":[0,1,2,3]}
-    cout << s.GetString() << endl;
-
-    return 0;
-}