rroonga 9.0.3-x64-mingw32 → 9.0.7-x64-mingw32

data/vendor/local/share/doc/RapidJSON/examples/simpledom/simpledom.cpp

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

data/vendor/local/share/doc/RapidJSON/examples/simplereader/simplereader.cpp

@@ -0,0 +1,42 @@
+#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;
+}

data/vendor/local/share/doc/RapidJSON/examples/simplewriter/simplewriter.cpp

@@ -0,0 +1,36 @@
+#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;
+}

data/vendor/local/share/doc/RapidJSON/examples/tutorial/tutorial.cpp

@@ -0,0 +1,151 @@
+// Hello World example
+// This example shows basic usage of DOM-style API.
+
+#include "rapidjson/document.h"     // rapidjson's DOM-style API
+#include "rapidjson/prettywriter.h" // for stringify JSON
+#include <cstdio>
+
+using namespace rapidjson;
+using namespace std;
+
+int main(int, char*[]) {
+    ////////////////////////////////////////////////////////////////////////////
+    // 1. Parse a JSON text string to a document.
+
+    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
+    printf("Original JSON:\n %s\n", json);
+
+    Document document;  // Default template parameter uses UTF8 and MemoryPoolAllocator.
+
+#if 0
+    // "normal" parsing, decode strings to new buffers. Can use other input stream via ParseStream().
+    if (document.Parse(json).HasParseError())
+        return 1;
+#else
+    // In-situ parsing, decode strings directly in the source string. Source must be string.
+    char buffer[sizeof(json)];
+    memcpy(buffer, json, sizeof(json));
+    if (document.ParseInsitu(buffer).HasParseError())
+        return 1;
+#endif
+
+    printf("\nParsing to document succeeded.\n");
+
+    ////////////////////////////////////////////////////////////////////////////
+    // 2. Access values in document. 
+
+    printf("\nAccess values in document:\n");
+    assert(document.IsObject());    // Document is a JSON value represents the root of DOM. Root can be either an object or array.
+
+    assert(document.HasMember("hello"));
+    assert(document["hello"].IsString());
+    printf("hello = %s\n", document["hello"].GetString());
+
+    // Since version 0.2, you can use single lookup to check the existing of member and its value:
+    Value::MemberIterator hello = document.FindMember("hello");
+    assert(hello != document.MemberEnd());
+    assert(hello->value.IsString());
+    assert(strcmp("world", hello->value.GetString()) == 0);
+    (void)hello;
+
+    assert(document["t"].IsBool());     // JSON true/false are bool. Can also uses more specific function IsTrue().
+    printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
+
+    assert(document["f"].IsBool());
+    printf("f = %s\n", document["f"].GetBool() ? "true" : "false");
+
+    printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
+
+    assert(document["i"].IsNumber());   // Number is a JSON type, but C++ needs more specific type.
+    assert(document["i"].IsInt());      // In this case, IsUint()/IsInt64()/IsUInt64() also return true.
+    printf("i = %d\n", document["i"].GetInt()); // Alternative (int)document["i"]
+
+    assert(document["pi"].IsNumber());
+    assert(document["pi"].IsDouble());
+    printf("pi = %g\n", document["pi"].GetDouble());
+
+    {
+        const Value& a = document["a"]; // Using a reference for consecutive access is handy and faster.
+        assert(a.IsArray());
+        for (SizeType i = 0; i < a.Size(); i++) // rapidjson uses SizeType instead of size_t.
+            printf("a[%d] = %d\n", i, a[i].GetInt());
+        
+        int y = a[0].GetInt();
+        (void)y;
+
+        // Iterating array with iterators
+        printf("a = ");
+        for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
+            printf("%d ", itr->GetInt());
+        printf("\n");
+    }
+
+    // Iterating object members
+    static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
+    for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
+        printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);
+
+    ////////////////////////////////////////////////////////////////////////////
+    // 3. Modify values in document.
+
+    // Change i to a bigger number
+    {
+        uint64_t f20 = 1;   // compute factorial of 20
+        for (uint64_t j = 1; j <= 20; j++)
+            f20 *= j;
+        document["i"] = f20;    // Alternate form: document["i"].SetUint64(f20)
+        assert(!document["i"].IsInt()); // No longer can be cast as int or uint.
+    }
+
+    // Adding values to array.
+    {
+        Value& a = document["a"];   // This time we uses non-const reference.
+        Document::AllocatorType& allocator = document.GetAllocator();
+        for (int i = 5; i <= 10; i++)
+            a.PushBack(i, allocator);   // May look a bit strange, allocator is needed for potentially realloc. We normally uses the document's.
+
+        // Fluent API
+        a.PushBack("Lua", allocator).PushBack("Mio", allocator);
+    }
+
+    // Making string values.
+
+    // This version of SetString() just store the pointer to the string.
+    // So it is for literal and string that exists within value's life-cycle.
+    {
+        document["hello"] = "rapidjson";    // This will invoke strlen()
+        // Faster version:
+        // document["hello"].SetString("rapidjson", 9);
+    }
+
+    // This version of SetString() needs an allocator, which means it will allocate a new buffer and copy the the string into the buffer.
+    Value author;
+    {
+        char buffer2[10];
+        int len = sprintf(buffer2, "%s %s", "Milo", "Yip");  // synthetic example of dynamically created string.
+
+        author.SetString(buffer2, static_cast<SizeType>(len), document.GetAllocator());
+        // Shorter but slower version:
+        // document["hello"].SetString(buffer, document.GetAllocator());
+
+        // Constructor version: 
+        // Value author(buffer, len, document.GetAllocator());
+        // Value author(buffer, document.GetAllocator());
+        memset(buffer2, 0, sizeof(buffer2)); // For demonstration purpose.
+    }
+    // Variable 'buffer' is unusable now but 'author' has already made a copy.
+    document.AddMember("author", author, document.GetAllocator());
+
+    assert(author.IsNull());        // Move semantic for assignment. After this variable is assigned as a member, the variable becomes null.
+
+    ////////////////////////////////////////////////////////////////////////////
+    // 4. Stringify JSON
+
+    printf("\nModified JSON with reformatting:\n");
+    StringBuffer sb;
+    PrettyWriter<StringBuffer> writer(sb);
+    document.Accept(writer);    // Accept() traverses the DOM and generates Handler events.
+    puts(sb.GetString());
+
+    return 0;
+}

data/vendor/local/share/doc/RapidJSON/readme.md

@@ -0,0 +1,160 @@
+![](doc/logo/rapidjson.png)
+
+![](https://img.shields.io/badge/release-v1.1.0-blue.png)
+
+## A fast JSON parser/generator for C++ with both SAX/DOM style API 
+
+Tencent is pleased to support the open source community by making RapidJSON available.
+
+Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+
+* [RapidJSON GitHub](https://github.com/miloyip/rapidjson/)
+* RapidJSON Documentation
+  * [English](http://rapidjson.org/)
+  * [简体中文](http://rapidjson.org/zh-cn/)
+  * [GitBook](https://www.gitbook.com/book/miloyip/rapidjson/) with downloadable PDF/EPUB/MOBI, without API reference.
+
+## Build status
+
+| [Linux][lin-link] | [Windows][win-link] | [Coveralls][cov-link] |
+| :---------------: | :-----------------: | :-------------------: |
+| ![lin-badge]      | ![win-badge]        | ![cov-badge]          |
+
+[lin-badge]: https://travis-ci.org/miloyip/rapidjson.png?branch=master "Travis build status"
+[lin-link]:  https://travis-ci.org/miloyip/rapidjson "Travis build status"
+[win-badge]: https://ci.appveyor.com/api/projects/status/u658dcuwxo14a8m9/branch/master "AppVeyor build status"
+[win-link]:  https://ci.appveyor.com/project/miloyip/rapidjson/branch/master "AppVeyor build status"
+[cov-badge]: https://coveralls.io/repos/miloyip/rapidjson/badge.png?branch=master
+[cov-link]:  https://coveralls.io/r/miloyip/rapidjson?branch=master
+
+## Introduction
+
+RapidJSON is a JSON parser and generator for C++. It was inspired by [RapidXml](http://rapidxml.sourceforge.net/).
+
+* RapidJSON is **small** but **complete**. It supports both SAX and DOM style API. The SAX parser is only a half thousand lines of code.
+
+* RapidJSON is **fast**. Its performance can be comparable to `strlen()`. It also optionally supports SSE2/SSE4.2 for acceleration.
+
+* RapidJSON is **self-contained** and **header-only**. It does not depend on external libraries such as BOOST. It even does not depend on STL.
+
+* RapidJSON is **memory-friendly**. Each JSON value occupies exactly 16 bytes for most 32/64-bit machines (excluding text string). By default it uses a fast memory allocator, and the parser allocates memory compactly during parsing.
+
+* RapidJSON is **Unicode-friendly**. It supports UTF-8, UTF-16, UTF-32 (LE & BE), and their detection, validation and transcoding internally. For example, you can read a UTF-8 file and let RapidJSON transcode the JSON strings into UTF-16 in the DOM. It also supports surrogates and "\u0000" (null character).
+
+More features can be read [here](doc/features.md).
+
+JSON(JavaScript Object Notation) is a light-weight data exchange format. RapidJSON should be in fully compliance with RFC7159/ECMA-404, with optional support of relaxed syntax. More information about JSON can be obtained at
+* [Introducing JSON](http://json.org/)
+* [RFC7159: The JavaScript Object Notation (JSON) Data Interchange Format](http://www.ietf.org/rfc/rfc7159.txt)
+* [Standard ECMA-404: The JSON Data Interchange Format](http://www.ecma-international.org/publications/standards/Ecma-404.htm)
+
+## Highlights in v1.1 (2016-8-25)
+
+* Added [JSON Pointer](doc/pointer.md)
+* Added [JSON Schema](doc/schema.md)
+* Added [relaxed JSON syntax](doc/dom.md) (comment, trailing comma, NaN/Infinity)
+* Iterating array/object with [C++11 Range-based for loop](doc/tutorial.md)
+* Reduce memory overhead of each `Value` from 24 bytes to 16 bytes in x86-64 architecture.
+
+For other changes please refer to [change log](CHANGELOG.md).
+
+## Compatibility
+
+RapidJSON is cross-platform. Some platform/compiler combinations which have been tested are shown as follows.
+* Visual C++ 2008/2010/2013 on Windows (32/64-bit)
+* GNU C++ 3.8.x on Cygwin
+* Clang 3.4 on Mac OS X (32/64-bit) and iOS
+* Clang 3.4 on Android NDK
+
+Users can build and run the unit tests on their platform/compiler.
+
+## Installation
+
+RapidJSON is a header-only C++ library. Just copy the `include/rapidjson` folder to system or project's include path.
+
+RapidJSON uses following software as its dependencies:
+* [CMake](https://cmake.org/) as a general build tool
+* (optional)[Doxygen](http://www.doxygen.org) to build documentation
+* (optional)[googletest](https://github.com/google/googletest) for unit and performance testing
+
+To generate user documentation and run tests please proceed with the steps below:
+
+1. Execute `git submodule update --init` to get the files of thirdparty submodules (google test).
+2. Create directory called `build` in rapidjson source directory.
+3. Change to `build` directory and run `cmake ..` command to configure your build. Windows users can do the same with cmake-gui application.
+4. On Windows, build the solution found in the build directory. On Linux, run `make` from the build directory.
+
+On successfull build you will find compiled test and example binaries in `bin`
+directory. The generated documentation will be available in `doc/html`
+directory of the build tree. To run tests after finished build please run `make
+test` or `ctest` from your build tree. You can get detailed output using `ctest
+-V` command.
+
+It is possible to install library system-wide by running `make install` command
+from the build tree with administrative privileges. This will install all files
+according to system preferences.  Once RapidJSON is installed, it is possible
+to use it from other CMake projects by adding `find_package(RapidJSON)` line to
+your CMakeLists.txt.
+
+## Usage at a glance
+
+This simple example parses a JSON string into a document (DOM), make a simple modification of the DOM, and finally stringify the DOM to a JSON string.
+
+~~~~~~~~~~cpp
+// rapidjson/example/simpledom/simpledom.cpp`
+#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;
+}
+~~~~~~~~~~
+
+Note that this example did not handle potential errors.
+
+The following diagram shows the process.
+
+![simpledom](doc/diagram/simpledom.png)
+
+More [examples](https://github.com/miloyip/rapidjson/tree/master/example) are available:
+
+* DOM API
+ * [tutorial](https://github.com/miloyip/rapidjson/blob/master/example/tutorial/tutorial.cpp): Basic usage of DOM API.
+
+* SAX API
+ * [simplereader](https://github.com/miloyip/rapidjson/blob/master/example/simplereader/simplereader.cpp): Dumps all SAX events while parsing a JSON by `Reader`.
+ * [condense](https://github.com/miloyip/rapidjson/blob/master/example/condense/condense.cpp): A command line tool to rewrite a JSON, with all whitespaces removed.
+ * [pretty](https://github.com/miloyip/rapidjson/blob/master/example/pretty/pretty.cpp): A command line tool to rewrite a JSON with indents and newlines by `PrettyWriter`.
+ * [capitalize](https://github.com/miloyip/rapidjson/blob/master/example/capitalize/capitalize.cpp): A command line tool to capitalize strings in JSON.
+ * [messagereader](https://github.com/miloyip/rapidjson/blob/master/example/messagereader/messagereader.cpp): Parse a JSON message with SAX API.
+ * [serialize](https://github.com/miloyip/rapidjson/blob/master/example/serialize/serialize.cpp): Serialize a C++ object into JSON with SAX API.
+ * [jsonx](https://github.com/miloyip/rapidjson/blob/master/example/jsonx/jsonx.cpp): Implements a `JsonxWriter` which stringify SAX events into [JSONx](https://www-01.ibm.com/support/knowledgecenter/SS9H2Y_7.1.0/com.ibm.dp.doc/json_jsonx.html) (a kind of XML) format. The example is a command line tool which converts input JSON into JSONx format.
+
+* Schema
+ * [schemavalidator](https://github.com/miloyip/rapidjson/blob/master/example/schemavalidator/schemavalidator.cpp) : A command line tool to validate a JSON with a JSON schema.
+ 
+* Advanced
+ * [prettyauto](https://github.com/miloyip/rapidjson/blob/master/example/prettyauto/prettyauto.cpp): A modified version of [pretty](https://github.com/miloyip/rapidjson/blob/master/example/pretty/pretty.cpp) to automatically handle JSON with any UTF encodings.
+ * [parsebyparts](https://github.com/miloyip/rapidjson/blob/master/example/parsebyparts/parsebyparts.cpp): Implements an `AsyncDocumentParser` which can parse JSON in parts, using C++11 thread.
+ * [filterkey](https://github.com/miloyip/rapidjson/blob/master/example/filterkey/filterkey.cpp): A command line tool to remove all values with user-specified key.
+ * [filterkeydom](https://github.com/miloyip/rapidjson/blob/master/example/filterkeydom/filterkeydom.cpp): Same tool as above, but it demonstrates how to use a generator to populate a `Document`.

data/vendor/local/share/doc/groonga/en/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 7ebb4518a47f78800c01cf2e196ddb69
+config: dc7ed0c13b4eedfa4d25b637689cf4c8
 tags: 645f666f9bcd5a90fca523b33c5a78b7

data/vendor/local/share/doc/groonga/en/html/_static/documentation_options.js

@@ -1,6 +1,6 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
-    VERSION: '9.0.2',
+    VERSION: '9.0.6',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     FILE_SUFFIX: '.html',

data/vendor/local/share/doc/groonga/en/html/characteristic.html

@@ -5,7 +5,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
   <head>
     <meta charset="utf-8" />
-    <title>1. Characteristics of Groonga &#8212; Groonga v9.0.2 documentation</title>
+    <title>1. Characteristics of Groonga &#8212; Groonga v9.0.6 documentation</title>
     <link rel="stylesheet" href="_static/groonga.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
@@ -50,7 +50,7 @@
         <li class="right" >
           <a href="index.html" title="Groonga documentation"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Groonga v9.0.2 documentation</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Groonga v9.0.6 documentation</a> &#187;</li> 
       </ul>
     </div>  
 
@@ -162,7 +162,7 @@
         <li class="right" >
           <a href="index.html" title="Groonga documentation"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">Groonga v9.0.2 documentation</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">Groonga v9.0.6 documentation</a> &#187;</li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">