rj_schema 0.2.4 → 0.2.5

data/ext/rj_schema/rapidjson/docker/debian/Dockerfile

@@ -0,0 +1,8 @@
+# BUILD:  docker build -t rapidjson-debian .
+# RUN:    docker run -it -v "$PWD"/../..:/rapidjson rapidjson-debian
+
+FROM debian:jessie
+
+RUN apt-get update && apt-get install -y g++ cmake doxygen valgrind
+
+ENTRYPOINT ["/bin/bash"]

data/ext/rj_schema/rapidjson/example/CMakeLists.txt

@@ -0,0 +1,46 @@
+cmake_minimum_required(VERSION 2.8)
+
+if(POLICY CMP0054)
+  cmake_policy(SET CMP0054 NEW)
+endif()
+
+set(EXAMPLES
+    capitalize
+    condense
+    filterkey
+    filterkeydom
+    jsonx
+    lookaheadparser
+    messagereader
+    parsebyparts
+    pretty
+    prettyauto
+    schemavalidator
+    serialize
+    simpledom
+    simplereader
+    simplepullreader
+    simplewriter
+    sortkeys
+    tutorial)
+    
+include_directories("../include/")
+
+add_definitions(-D__STDC_FORMAT_MACROS)
+set_property(DIRECTORY PROPERTY COMPILE_OPTIONS ${EXTRA_CXX_FLAGS})
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+endif()
+
+add_executable(archivertest archiver/archiver.cpp archiver/archivertest.cpp)
+
+foreach (example ${EXAMPLES})
+    add_executable(${example} ${example}/${example}.cpp)
+endforeach()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_link_libraries(parsebyparts pthread)
+endif()
+
+add_custom_target(examples ALL DEPENDS ${EXAMPLES})

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

@@ -0,0 +1,292 @@
+#include "archiver.h"
+#include <cassert>
+#include <stack>
+#include "rapidjson/document.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/stringbuffer.h"
+
+using namespace rapidjson;
+
+struct JsonReaderStackItem {
+    enum State {
+        BeforeStart,    //!< An object/array is in the stack but it is not yet called by StartObject()/StartArray().
+        Started,        //!< An object/array is called by StartObject()/StartArray().
+        Closed          //!< An array is closed after read all element, but before EndArray().
+    };
+
+    JsonReaderStackItem(const Value* value, State state) : value(value), state(state), index() {}
+
+    const Value* value;
+    State state;
+    SizeType index;   // For array iteration
+};
+
+typedef std::stack<JsonReaderStackItem> JsonReaderStack;
+
+#define DOCUMENT reinterpret_cast<Document*>(mDocument)
+#define STACK (reinterpret_cast<JsonReaderStack*>(mStack))
+#define TOP (STACK->top())
+#define CURRENT (*TOP.value)
+
+JsonReader::JsonReader(const char* json) : mDocument(), mStack(), mError(false) {
+    mDocument = new Document;
+    DOCUMENT->Parse(json);
+    if (DOCUMENT->HasParseError())
+        mError = true;
+    else {
+        mStack = new JsonReaderStack;
+        STACK->push(JsonReaderStackItem(DOCUMENT, JsonReaderStackItem::BeforeStart));
+    }
+}
+
+JsonReader::~JsonReader() {
+    delete DOCUMENT;
+    delete STACK;
+}
+
+// Archive concept
+JsonReader& JsonReader::StartObject() {
+    if (!mError) {
+        if (CURRENT.IsObject() && TOP.state == JsonReaderStackItem::BeforeStart)
+            TOP.state = JsonReaderStackItem::Started;
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::EndObject() {
+    if (!mError) {
+        if (CURRENT.IsObject() && TOP.state == JsonReaderStackItem::Started)
+            Next();
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::Member(const char* name) {
+    if (!mError) {
+        if (CURRENT.IsObject() && TOP.state == JsonReaderStackItem::Started) {
+            Value::ConstMemberIterator memberItr = CURRENT.FindMember(name);
+            if (memberItr != CURRENT.MemberEnd()) 
+                STACK->push(JsonReaderStackItem(&memberItr->value, JsonReaderStackItem::BeforeStart));
+            else
+                mError = true;
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+bool JsonReader::HasMember(const char* name) const {
+    if (!mError && CURRENT.IsObject() && TOP.state == JsonReaderStackItem::Started)
+        return CURRENT.HasMember(name);
+    return false;
+}
+
+JsonReader& JsonReader::StartArray(size_t* size) {
+    if (!mError) {
+        if (CURRENT.IsArray() && TOP.state == JsonReaderStackItem::BeforeStart) {
+            TOP.state = JsonReaderStackItem::Started;
+            if (size)
+                *size = CURRENT.Size();
+
+            if (!CURRENT.Empty()) {
+                const Value* value = &CURRENT[TOP.index];
+                STACK->push(JsonReaderStackItem(value, JsonReaderStackItem::BeforeStart));
+            }
+            else
+                TOP.state = JsonReaderStackItem::Closed;
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::EndArray() {
+    if (!mError) {
+        if (CURRENT.IsArray() && TOP.state == JsonReaderStackItem::Closed)
+            Next();
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::operator&(bool& b) {
+    if (!mError) {
+        if (CURRENT.IsBool()) {
+            b = CURRENT.GetBool();
+            Next();
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::operator&(unsigned& u) {
+    if (!mError) {
+        if (CURRENT.IsUint()) {
+            u = CURRENT.GetUint();
+            Next();
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::operator&(int& i) {
+    if (!mError) {
+        if (CURRENT.IsInt()) {
+            i = CURRENT.GetInt();
+            Next();
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::operator&(double& d) {
+    if (!mError) {
+        if (CURRENT.IsNumber()) {
+            d = CURRENT.GetDouble();
+            Next();
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::operator&(std::string& s) {
+    if (!mError) {
+        if (CURRENT.IsString()) {
+            s = CURRENT.GetString();
+            Next();
+        }
+        else
+            mError = true;
+    }
+    return *this;
+}
+
+JsonReader& JsonReader::SetNull() {
+    // This function is for JsonWriter only.
+    mError = true;
+    return *this;
+}
+
+void JsonReader::Next() {
+    if (!mError) {
+        assert(!STACK->empty());
+        STACK->pop();
+
+        if (!STACK->empty() && CURRENT.IsArray()) {
+            if (TOP.state == JsonReaderStackItem::Started) { // Otherwise means reading array item pass end
+                if (TOP.index < CURRENT.Size() - 1) {
+                    const Value* value = &CURRENT[++TOP.index];
+                    STACK->push(JsonReaderStackItem(value, JsonReaderStackItem::BeforeStart));
+                }
+                else
+                    TOP.state = JsonReaderStackItem::Closed;
+            }
+            else
+                mError = true;
+        }
+    }
+}
+
+#undef DOCUMENT
+#undef STACK
+#undef TOP
+#undef CURRENT
+
+////////////////////////////////////////////////////////////////////////////////
+// JsonWriter
+
+#define WRITER reinterpret_cast<PrettyWriter<StringBuffer>*>(mWriter)
+#define STREAM reinterpret_cast<StringBuffer*>(mStream)
+
+JsonWriter::JsonWriter() : mWriter(), mStream() {
+    mStream = new StringBuffer;
+    mWriter = new PrettyWriter<StringBuffer>(*STREAM);
+}
+
+JsonWriter::~JsonWriter() { 
+    delete WRITER;
+    delete STREAM;
+}
+
+const char* JsonWriter::GetString() const {
+    return STREAM->GetString();
+}
+
+JsonWriter& JsonWriter::StartObject() {
+    WRITER->StartObject();
+    return *this;
+}
+
+JsonWriter& JsonWriter::EndObject() {
+    WRITER->EndObject();
+    return *this;
+}
+
+JsonWriter& JsonWriter::Member(const char* name) {
+    WRITER->String(name, static_cast<SizeType>(strlen(name)));
+    return *this;
+}
+
+bool JsonWriter::HasMember(const char*) const {
+    // This function is for JsonReader only.
+    assert(false);
+    return false;
+}
+
+JsonWriter& JsonWriter::StartArray(size_t*) {
+    WRITER->StartArray();   
+    return *this;
+}
+
+JsonWriter& JsonWriter::EndArray() {
+    WRITER->EndArray();
+    return *this;
+}
+
+JsonWriter& JsonWriter::operator&(bool& b) {
+    WRITER->Bool(b);
+    return *this;
+}
+
+JsonWriter& JsonWriter::operator&(unsigned& u) {
+    WRITER->Uint(u);
+    return *this;
+}
+
+JsonWriter& JsonWriter::operator&(int& i) {
+    WRITER->Int(i);
+    return *this;
+}
+
+JsonWriter& JsonWriter::operator&(double& d) {
+    WRITER->Double(d);
+    return *this;
+}
+
+JsonWriter& JsonWriter::operator&(std::string& s) {
+    WRITER->String(s.c_str(), static_cast<SizeType>(s.size()));
+    return *this;
+}
+
+JsonWriter& JsonWriter::SetNull() {
+    WRITER->Null();
+    return *this;
+}
+
+#undef STREAM
+#undef WRITER

data/ext/rj_schema/rapidjson/example/archiver/archiver.h

@@ -0,0 +1,145 @@
+#ifndef ARCHIVER_H_
+#define ARCHIVER_H_
+
+#include <cstddef>
+#include <string>
+
+/**
+\class Archiver
+\brief Archiver concept
+
+Archiver can be a reader or writer for serialization or deserialization respectively.
+
+class Archiver {
+public:
+    /// \returns true if the archiver is in normal state. false if it has errors.
+    operator bool() const;
+
+    /// Starts an object
+    Archiver& StartObject();
+    
+    /// After calling StartObject(), assign a member with a name
+    Archiver& Member(const char* name);
+
+    /// After calling StartObject(), check if a member presents
+    bool HasMember(const char* name) const;
+
+    /// Ends an object
+    Archiver& EndObject();
+
+    /// Starts an array
+    /// \param size If Archiver::IsReader is true, the size of array is written.
+    Archiver& StartArray(size_t* size = 0);
+
+    /// Ends an array
+    Archiver& EndArray();
+
+    /// Read/Write primitive types.
+    Archiver& operator&(bool& b);
+    Archiver& operator&(unsigned& u);
+    Archiver& operator&(int& i);
+    Archiver& operator&(double& d);
+    Archiver& operator&(std::string& s);
+
+    /// Write primitive types.
+    Archiver& SetNull();
+
+    //! Whether it is a reader.
+    static const bool IsReader;
+
+    //! Whether it is a writer.
+    static const bool IsWriter;
+};
+*/
+
+/// Represents a JSON reader which implements Archiver concept.
+class JsonReader {
+public:
+    /// Constructor.
+    /**
+        \param json A non-const source json string for in-situ parsing.
+        \note in-situ means the source JSON string will be modified after parsing.
+    */
+    JsonReader(const char* json);
+
+    /// Destructor.
+    ~JsonReader();
+
+    // Archive concept
+
+    operator bool() const { return !mError; }
+
+    JsonReader& StartObject();
+    JsonReader& Member(const char* name);
+    bool HasMember(const char* name) const;
+    JsonReader& EndObject();
+
+    JsonReader& StartArray(size_t* size = 0);
+    JsonReader& EndArray();
+
+    JsonReader& operator&(bool& b);
+    JsonReader& operator&(unsigned& u);
+    JsonReader& operator&(int& i);
+    JsonReader& operator&(double& d);
+    JsonReader& operator&(std::string& s);
+
+    JsonReader& SetNull();
+
+    static const bool IsReader = true;
+    static const bool IsWriter = !IsReader;
+
+private:
+    JsonReader(const JsonReader&);
+    JsonReader& operator=(const JsonReader&);
+
+    void Next();
+
+    // PIMPL
+    void* mDocument;              ///< DOM result of parsing.
+    void* mStack;                 ///< Stack for iterating the DOM
+    bool mError;                  ///< Whether an error has occurred.
+};
+
+class JsonWriter {
+public:
+    /// Constructor.
+    JsonWriter();
+
+    /// Destructor.
+    ~JsonWriter();
+
+    /// Obtains the serialized JSON string.
+    const char* GetString() const;
+
+    // Archive concept
+
+    operator bool() const { return true; }
+
+    JsonWriter& StartObject();
+    JsonWriter& Member(const char* name);
+    bool HasMember(const char* name) const;
+    JsonWriter& EndObject();
+
+    JsonWriter& StartArray(size_t* size = 0);
+    JsonWriter& EndArray();
+
+    JsonWriter& operator&(bool& b);
+    JsonWriter& operator&(unsigned& u);
+    JsonWriter& operator&(int& i);
+    JsonWriter& operator&(double& d);
+    JsonWriter& operator&(std::string& s);
+    JsonWriter& SetNull();
+
+    static const bool IsReader = false;
+    static const bool IsWriter = !IsReader;
+
+private:
+    JsonWriter(const JsonWriter&);
+    JsonWriter& operator=(const JsonWriter&);
+
+    // PIMPL idiom
+    void* mWriter;      ///< JSON writer.
+    void* mStream;      ///< Stream buffer.
+};
+
+#endif // ARCHIVER_H__