ruco-cpp 0.2.1

data/data/ruco/picojson/Changes

@@ -0,0 +1,14 @@
+Revision history for picojson
+
+1.1.1 2014-06-25 10:35:00+0900
+	- tweaks to suppress compiler errors / warning (#38 #39)
+	- clarify the licenses of the files in exmaple/ (#42)
+
+1.1 2014-06-16 12:57:00+0900
+	- added experimental support for int64 type (#34)
+	- by default, throw std::runtime_error instead of using assert for runtime errors (#33)
+	- refine compatibility regarding the use of isinf/isnan (#29, #36)
+	- remove `.get<int>()` (#35)
+
+1.0 2014-06-05 12:54:00+0900
+	- initial release with a version number

data/data/ruco/picojson/LICENSE

@@ -0,0 +1,25 @@
+Copyright 2009-2010 Cybozu Labs, Inc.
+Copyright 2011-2014 Kazuho Oku
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/data/ruco/picojson/Makefile

@@ -0,0 +1,8 @@
+test:
+	$(MAKE) test-core
+	$(MAKE) test-core TEST_OPTS=-DPICOJSON_USE_INT64
+
+test-core:
+	$(CXX) -o test-core -Wall $(TEST_OPTS) -DTEST_PICOJSON -x c++ - < picojson.h && ./test-core
+
+.PHONY: test test-core

data/data/ruco/picojson/README.mkdn

@@ -0,0 +1,183 @@
+# PicoJSON - a C++ JSON parser / serializer
+
+Copyright © 2009-2010 Cybozu Labs, Inc.
+Copyright © 2011-2014 Kazuho Oku
+
+Licensed under [2-clause BSD license](http://opensource.org/licenses/BSD-2-Clause)
+
+## Version
+
+1.1.2-dev [![Build Status](https://travis-ci.org/kazuho/picojson.svg?branch=master)](https://travis-ci.org/kazuho/picojson)
+
+## Introduction
+
+PicoJSON is a tiny JSON parser / serializer for C++ with following properties:
+
+- header-file only
+- no external dependencies (only uses standard C++ libraries)
+- STL-frendly (arrays are represented by using std::vector, objects are std::map)
+- provides both pull interface and streaming (event-based) interface
+
+## Reading JSON using the pull interface
+
+There are two ways to use the pull (DOM-like) interface of picojson.  One is to use operator<<, and the other is by specifying a set of iterators specifying the range from where the JSON stream should be read.
+
+<pre>
+picojson::value v;
+std::cin &gt;&gt; v;
+std::string err = picojson::get_last_error();
+if (! err.empty()) {
+  std::cerr &lt;&lt; err &lt;&lt; std::endl;
+}
+</pre>
+
+<pre>
+std::istream_iterator input(cin);
+picojson::value v;
+std::string err;
+input = picojson::parse(v, input, std::istream_iterator(), &err);
+if (! err.empty()) {
+  std::cerr &lt;&lt; err &lt;&lt; std::endl;
+}
+</pre>
+
+<pre>
+const char* json = "{\"a\":1}";
+picojson::value v;
+std::string err;
+picojson::parse(v, json, json + strlen(json), &err);
+if (! err.empty()) {
+  std::cerr &lt;&lt; err &lt;&lt; std::endl;
+}
+</pre>
+
+## Accessing the values
+
+Values of a JSON object is represented as instances of picojson::value class.
+
+<pre>
+namespace picojson {
+
+  class value {
+    ...
+
+  public:
+
+    typedef std::vector&lt;value&gt; array;
+    typedef std::map&lt;std::string, value&gt; object;
+
+    value();                               // create a null object
+    explicit value(bool b);                // create a boolean object
+    explicit value(double n);              // create a number object
+    explicit value(const std::string& s);  // create a string object
+    explicit value(const array& a);        // create an array object
+    explicit value(const object& o);       // create an "object"
+
+    bool is&lt;picojson::null&gt;() const;       // check if the object is "null"
+
+    bool is&lt;bool&gt;() const;                 // check if the object is a boolean
+    const bool& get&lt;bool&gt;() const;         // const accessor (usable only if the object is a boolean)
+    bool& get&lt;bool&gt;();                     // non-const accessor (usable only if the object is a boolean)
+
+    bool is&lt;double&gt;() const;               // check if the object is a number
+    const double& get&lt;double&gt;() const;     // const accessor (usable only if the object is a number)
+    double& get&lt;double&gt;();                 // non-const accessor (usable only if the object is a number)
+
+    bool is&lt;std::string&gt;() const;          // check if the object is a string
+    const std::string& get&lt;std::string&gt;() const;
+                                           // const accessor (usable only if the object is a string)
+    std::string& get&lt;std::string&gt;();       // non-const accessor (usable only if the object is a string)
+
+    bool is&lt;array&gt;() const;                // check if the object is an array
+    const array& get&lt;array&gt;() const;       // const accessor (usable only if the object is an array)
+    array& get&lt;array&gt;();                   // non-const accessor (usable only if the object is an array)
+
+    bool is&lt;object&gt;() const;               // check if the object is an "object"
+    const object& get&lt;object&gt;() const;     // const accessor (usable only if the object is an object)
+    object& get&lt;object&gt;();                 // non-const accessor (usable only if the object is an array)
+
+    bool evaluate_as_boolean() const;      // evaluates the object as a boolean
+
+    std::string serialize() const;         // returns the object in JSON representation
+    template<typename Iter> void serialize(Iter os) const;
+                                           // serializes the object in JSON representation through an output iterator
+
+    std::string to_str() const;            // returns the object in string (for casual use)
+
+  };
+
+}
+</pre>
+
+The code below parses a JSON string and prints the contents of the object.
+
+<pre>
+picojson::value v;
+
+// parse the input
+std::cin &gt;&gt; v;
+std::string err = picojson::get_last_error();
+if (! err.empty()) {
+  std::cerr &lt;&lt; err &lt;&lt; std::endl;
+  exit(1);
+}
+
+// check if the type of the value is "object"
+if (! v.is&lt;picojson::object&gt;()) {
+  std::cerr &lt;&lt; "JSON is not an object" &lt;&lt; std::endl;
+  exit(2);
+}
+
+// obtain a const reference to the map, and print the contents
+const picojson::value::object& obj = v.get&lt;picojson::object&gt;();
+for (picojson::value::object::const_iterator i = obj.begin();
+     i != obj.end();
+     ++i) {
+  std::cout &lt;&lt; i-&gt;first &lt;&lt; ': ' &lt;&lt; i-&gt;second.to_str() &lt;&lt; std::endl;
+}
+</pre>
+
+Please note that the type check is mandatory; do not forget to check the type of the object by calling is&lt;type&gt;() before accessing the value by calling get&lt;type&gt;().
+
+## Reading JSON using the streaming (event-driven) interface
+
+Please refer to the implementation of picojson::default_parse_context and picojson::null_parse_context.  There is also an example (examples/streaming.cc) .
+
+## Serializing to JSON
+
+Instances of the picojson::value class can be serialized in three ways, to ostream, to std::string, or to an output iterator.
+
+<pre>
+picojson::value v;
+...
+std::cout &lt;&lt; v;
+</pre>
+
+<pre>
+picojson::value v;
+...
+std::string json = v.serialize();
+</pre>
+
+<pre>
+picojson::value v;
+...
+v.serialize(std::ostream_iterator(std::cout));
+</pre>
+
+## Experimental support for int64_t
+
+Experimental suport for int64_t becomes available if the code is compiled with preprocessor macro `PICOJSON_USE_INT64`.
+
+Turning on the feature will cause following changes to picojson:
+- new constructor `picojson::value(int64_t)` is defined
+- `is<int64_t>()` and `get<int64_t>()` become available
+- numerics in JSON within the bounds of int64_t and not using `.` nor `e`/`E` are considered as int64 type
+ - the values are also avaliable as `double`s as well (i.e. all values which are `.is<int64_t>() == true` are also `.is<double>() == true`)
+- int64 values are converted to double once `get<double>()` is called
+
+Enabling the feature should not cause compatibility problem with code that do not use the feature.
+
+## Further reading
+
+Examples can be found in the <i>examples</i> directory, and on the [Wiki](https://github.com/kazuho/picojson/wiki).  Please add your favorite examples to the Wiki.

data/data/ruco/picojson/examples/github-issues.cc

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2009-2010 Cybozu Labs, Inc.
+ * Copyright 2011-2014 Kazuho Oku
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <curl/curl.h>
+#include "../picojson.h"
+
+typedef struct {
+  char* data;   // response data from server
+  size_t size;  // response size of data
+} MEMFILE;
+
+MEMFILE*
+memfopen() {
+  MEMFILE* mf = (MEMFILE*) malloc(sizeof(MEMFILE));
+  mf->data = NULL;
+  mf->size = 0;
+  return mf;
+}
+
+void
+memfclose(MEMFILE* mf) {
+  if (mf->data) free(mf->data);
+  free(mf);
+}
+
+size_t
+memfwrite(char* ptr, size_t size, size_t nmemb, void* stream) {
+  MEMFILE* mf = (MEMFILE*) stream;
+  int block = size * nmemb;
+  if (!mf->data)
+    mf->data = (char*) malloc(block);
+  else
+    mf->data = (char*) realloc(mf->data, mf->size + block);
+  if (mf->data) {
+    memcpy(mf->data + mf->size, ptr, block);
+    mf->size += block;
+  }
+  return block;
+}
+
+char*
+memfstrdup(MEMFILE* mf) {
+  char* buf = (char*)malloc(mf->size + 1);
+  memcpy(buf, mf->data, mf->size);
+  buf[mf->size] = 0;
+  return buf;
+}
+
+using namespace std;
+using namespace picojson;
+
+int
+main(int argc, char* argv[]) {
+  char error[256];
+
+  MEMFILE* mf = memfopen();
+  CURL* curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_URL, "https://api.github.com/repos/kazuho/picojson/issues");
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl");
+  curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, memfwrite);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, mf);
+  if (curl_easy_perform(curl) != CURLE_OK) {
+    cerr << error << endl;
+  } else {
+    value v;
+    string err;
+    parse(v, mf->data, mf->data + mf->size, &err);
+    if (err.empty()) {
+      array arr = v.get<array>();
+      array::iterator it;
+      for (it = arr.begin(); it != arr.end(); it++) {
+        object obj = it->get<object>();
+        cout << "#" << obj["number"].to_str() << ": " << obj["title"].to_str() << endl;
+        cout << "  " << obj["html_url"].to_str() << endl << endl;
+      }
+    } else {
+      cerr << err << endl;
+    }
+  }
+  curl_easy_cleanup(curl);
+  memfclose(mf);
+
+  return 0;
+}

data/data/ruco/picojson/examples/iostream.cc

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2010 Cybozu Labs, Inc.
+ * Copyright 2011-2014 Kazuho Oku
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "../picojson.h"
+
+int main(void)
+{
+  picojson::value v;
+  
+  // read json value from stream
+  std::cin >> v;
+  if (std::cin.fail()) {
+    std::cerr << picojson::get_last_error() << std::endl;
+    return 1;
+  }
+  
+  // dump json object
+  std::cout << "---- dump input ----" << std::endl;
+  std::cout << v << std::endl;
+
+  // accessors
+  std::cout << "---- analyzing input ----" << std::endl;
+  if (v.is<picojson::null>()) {
+    std::cout << "input is null" << std::endl;
+  } else if (v.is<bool>()) {
+    std::cout << "input is " << (v.get<bool>() ? "true" : "false") << std::endl;
+  } else if (v.is<double>()) {
+    std::cout << "input is " << v.get<double>() << std::endl;
+  } else if (v.is<std::string>()) {
+    std::cout << "input is " << v.get<std::string>() << std::endl;
+  } else if (v.is<picojson::array>()) {
+    std::cout << "input is an array" << std::endl;
+    const picojson::array& a = v.get<picojson::array>();
+    for (picojson::array::const_iterator i = a.begin(); i != a.end(); ++i) {
+      std::cout << "  " << *i << std::endl;
+    }
+  } else if (v.is<picojson::object>()) {
+    std::cout << "input is an object" << std::endl;
+    const picojson::object& o = v.get<picojson::object>();
+    for (picojson::object::const_iterator i = o.begin(); i != o.end(); ++i) {
+      std::cout << i->first << "  " << i->second << std::endl;
+    }
+  }
+  
+  return 0;
+}

data/data/ruco/picojson/examples/streaming.cc

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2010 Cybozu Labs, Inc.
+ * Copyright 2011-2014 Kazuho Oku
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <iostream>
+#include <iterator>
+#include "../picojson.h"
+
+// this example reads a array of hashes (each item representing a 2D point),
+// and prints the x and y values to stdout
+
+namespace {
+  
+  class root_context : public picojson::deny_parse_context {
+  public:
+    bool parse_array_start() {
+      return true; // only allow array as root
+    }
+    template <typename Iter> bool parse_array_item(picojson::input<Iter>& in, size_t) {
+      picojson::value item;
+      // parse the array item
+      picojson::default_parse_context ctx(&item);
+      if (! picojson::_parse(ctx, in)) {
+	return false;
+      }
+      // assert that the array item is a hash
+      if (! item.is<picojson::object>()) {
+	return false;
+      }
+      // print x and y
+      std::cout << item.get("x") << ',' << item.get("y").to_str()
+		<< std::endl;
+      return true;
+    }
+  };
+  
+}
+
+int main(void)
+{
+  root_context ctx;
+  std::string err;
+  
+  picojson::_parse(ctx, std::istream_iterator<char>(std::cin),
+		   std::istream_iterator<char>(), &err);
+  
+  if (! err.empty()) {
+    std::cerr << err << std::endl;
+    return 1;
+  }
+  
+  return 0;
+}