rroonga 1.3.1-x86-mingw32 → 2.0.0-x86-mingw32

data/vendor/local/include/msgpack/type/map.hpp

@@ -0,0 +1,205 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_MAP_HPP__
+#define MSGPACK_TYPE_MAP_HPP__
+
+#include "msgpack/object.hpp"
+#include <map>
+#include <vector>
+#include <algorithm>
+
+namespace msgpack {
+
+
+namespace type {
+
+template <typename K, typename V>
+class assoc_vector : public std::vector< std::pair<K, V> > {};
+
+namespace detail {
+	template <typename K, typename V>
+	struct pair_first_less {
+		bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
+			{ return x.first < y.first; }
+	};
+}
+
+}  //namespace type
+
+
+template <typename K, typename V>
+inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	v.resize(o.via.map.size);
+	object_kv* p = o.via.map.ptr;
+	object_kv* const pend = o.via.map.ptr + o.via.map.size;
+	std::pair<K, V>* it(&v.front());
+	for(; p < pend; ++p, ++it) {
+		p->key.convert(&it->first);
+		p->val.convert(&it->second);
+	}
+	std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::assoc_vector<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename type::assoc_vector<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename type::assoc_vector<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename K, typename V>
+inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		K key;
+		p->key.convert(&key);
+		typename std::map<K,V>::iterator it(v.lower_bound(key));
+		if(it != v.end() && !(key < it->first)) {
+			p->val.convert(&it->second);
+		} else {
+			V val;
+			p->val.convert(&val);
+			v.insert(it, std::pair<K,V>(key, val));
+		}
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::map<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::map<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename K, typename V>
+inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		std::pair<K, V> value;
+		p->key.convert(&value.first);
+		p->val.convert(&value.second);
+		v.insert(value);
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::multimap<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/map.hpp */
+

data/vendor/local/include/msgpack/type/nil.hpp

@@ -0,0 +1,65 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_NIL_HPP__
+#define MSGPACK_TYPE_NIL_HPP__
+
+#include "msgpack/object.hpp"
+
+namespace msgpack {
+
+namespace type {
+
+struct nil { };
+
+}  // namespace type
+
+
+inline type::nil& operator>> (object o, type::nil& v)
+{
+	if(o.type != type::NIL) { throw type_error(); }
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
+{
+	o.pack_nil();
+	return o;
+}
+
+inline void operator<< (object& o, type::nil v)
+{
+	o.type = type::NIL;
+}
+
+inline void operator<< (object::with_zone& o, type::nil v)
+	{ static_cast<object&>(o) << v; }
+
+
+template <>
+inline void object::as<void>() const
+{
+	msgpack::type::nil v;
+	convert(&v);
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/nil.hpp */
+

data/vendor/local/include/msgpack/type/pair.hpp

@@ -0,0 +1,61 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_PAIR_HPP__
+#define MSGPACK_TYPE_PAIR_HPP__
+
+#include "msgpack/object.hpp"
+#include <utility>
+
+namespace msgpack {
+
+
+template <typename T1, typename T2>
+inline std::pair<T1, T2>& operator>> (object o, std::pair<T1, T2>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	if(o.via.array.size != 2) { throw type_error(); }
+	o.via.array.ptr[0].convert(&v.first);
+	o.via.array.ptr[1].convert(&v.second);
+	return v;
+}
+
+template <typename Stream, typename T1, typename T2>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::pair<T1, T2>& v)
+{
+	o.pack_array(2);
+	o.pack(v.first);
+	o.pack(v.second);
+	return o;
+}
+
+template <typename T1, typename T2>
+inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
+{
+	o.type = type::ARRAY;
+	object* p = (object*)o.zone->malloc(sizeof(object)*2);
+	o.via.array.ptr = p;
+	o.via.array.size = 2;
+	p[0] = object(v.first, o.zone);
+	p[1] = object(v.second, o.zone);
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/pair.hpp */
+

data/vendor/local/include/msgpack/type/raw.hpp

@@ -0,0 +1,94 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_RAW_HPP__
+#define MSGPACK_TYPE_RAW_HPP__
+
+#include "msgpack/object.hpp"
+#include <string.h>
+#include <string>
+
+namespace msgpack {
+
+namespace type {
+
+struct raw_ref {
+	raw_ref() : size(0), ptr(NULL) {}
+	raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
+
+	uint32_t size;
+	const char* ptr;
+
+	std::string str() const { return std::string(ptr, size); }
+
+	bool operator== (const raw_ref& x) const
+	{
+		return size == x.size && memcmp(ptr, x.ptr, size) == 0;
+	}
+
+	bool operator!= (const raw_ref& x) const
+	{
+		return !(*this != x);
+	}
+
+	bool operator< (const raw_ref& x) const
+	{
+		if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; }
+		else { return size < x.size; }
+	}
+
+	bool operator> (const raw_ref& x) const
+	{
+		if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; }
+		else { return size > x.size; }
+	}
+};
+
+}  // namespace type
+
+
+inline type::raw_ref& operator>> (object o, type::raw_ref& v)
+{
+	if(o.type != type::RAW) { throw type_error(); }
+	v.ptr  = o.via.raw.ptr;
+	v.size = o.via.raw.size;
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
+{
+	o.pack_raw(v.size);
+	o.pack_raw_body(v.ptr, v.size);
+	return o;
+}
+
+inline void operator<< (object& o, const type::raw_ref& v)
+{
+	o.type = type::RAW;
+	o.via.raw.ptr = v.ptr;
+	o.via.raw.size = v.size;
+}
+
+inline void operator<< (object::with_zone& o, const type::raw_ref& v)
+	{ static_cast<object&>(o) << v; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/raw.hpp */
+

data/vendor/local/include/msgpack/type/set.hpp

@@ -0,0 +1,122 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_SET_HPP__
+#define MSGPACK_TYPE_SET_HPP__
+
+#include "msgpack/object.hpp"
+#include <set>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::set<T>& operator>> (object o, std::set<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::set<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::set<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::set<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename T>
+inline std::multiset<T>& operator>> (object o, std::multiset<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::multiset<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::multiset<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/set.hpp */
+

data/vendor/local/include/msgpack/type/string.hpp

@@ -0,0 +1,62 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_STRING_HPP__
+#define MSGPACK_TYPE_STRING_HPP__
+
+#include "msgpack/object.hpp"
+#include <string>
+
+namespace msgpack {
+
+
+inline std::string& operator>> (object o, std::string& v)
+{
+	if(o.type != type::RAW) { throw type_error(); }
+	v.assign(o.via.raw.ptr, o.via.raw.size);
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
+{
+	o.pack_raw(v.size());
+	o.pack_raw_body(v.data(), v.size());
+	return o;
+}
+
+inline void operator<< (object::with_zone& o, const std::string& v)
+{
+	o.type = type::RAW;
+	char* ptr = (char*)o.zone->malloc(v.size());
+	o.via.raw.ptr = ptr;
+	o.via.raw.size = (uint32_t)v.size();
+	memcpy(ptr, v.data(), v.size());
+}
+
+inline void operator<< (object& o, const std::string& v)
+{
+	o.type = type::RAW;
+	o.via.raw.ptr = v.data();
+	o.via.raw.size = (uint32_t)v.size();
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/string.hpp */
+