rj_schema 0.2.3 → 0.2.4

data/ext/rj_schema/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;
-}

data/ext/rj_schema/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

data/ext/rj_schema/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;
-}

data/ext/rj_schema/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;
-}

data/ext/rj_schema/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;
-    }
-}