rroonga 4.0.3-x86-mingw32 → 4.0.4-x86-mingw32

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

@@ -29,8 +29,18 @@ namespace msgpack {
 
 inline float& operator>> (object o, float& v)
 {
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = (float)o.via.dec;
+	if(o.type == type::DOUBLE) {
+		v = (float)o.via.dec;
+	}
+	else if (o.type == type::POSITIVE_INTEGER) {
+		v = (float)o.via.u64;
+	}
+	else if (o.type == type::NEGATIVE_INTEGER) {
+		v = (float)o.via.i64;
+	}
+	else {
+		throw type_error();
+	}
 	return v;
 }
 
@@ -44,8 +54,18 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
 
 inline double& operator>> (object o, double& v)
 {
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = o.via.dec;
+	if(o.type == type::DOUBLE) {
+		v = o.via.dec;
+	}
+	else if (o.type == type::POSITIVE_INTEGER) {
+		v = (double)o.via.u64;
+	}
+	else if (o.type == type::NEGATIVE_INTEGER) {
+		v = (double)o.via.i64;
+	}
+	else {
+		throw type_error();
+	}
 	return v;
 }
 

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

@@ -57,15 +57,69 @@ namespace detail {
 		}
 	};
 
+	template <typename T>
+	struct is_signed {
+		static const bool value = std::numeric_limits<T>::is_signed;
+	};
+
 	template <typename T>
 	static inline T convert_integer(object o)
 	{
-		return detail::convert_integer_sign<T, std::numeric_limits<T>::is_signed>::convert(o);
+		return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
+	}
+
+	template <bool Signed>
+	struct pack_char_sign;
+
+	template <>
+	struct pack_char_sign<true> {
+		template <typename Stream>
+		static inline packer<Stream>& pack(packer<Stream>& o, char v) {
+			o.pack_int8(v); return o;
+		}
+	};
+
+	template <>
+	struct pack_char_sign<false> {
+		template <typename Stream>
+		static inline packer<Stream>& pack(packer<Stream>& o, char v) {
+			o.pack_uint8(v); return o;
+		}
+	};
+
+	template <typename Stream>
+	static inline packer<Stream>& pack_char(packer<Stream>& o, char v) {
+		return pack_char_sign<is_signed<char>::value>::pack(o, v);
+	}
+
+	template <bool Signed>
+	struct object_char_sign;
+
+	template <>
+	struct object_char_sign<true> {
+		static inline void make(object& o, char v) {
+			v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v
+				: o.type = type::POSITIVE_INTEGER, o.via.u64 = v;
+		}
+	};
+
+	template <>
+	struct object_char_sign<false> {
+		static inline void make(object& o, char v) {
+			o.type = type::POSITIVE_INTEGER, o.via.u64 = v;
+		}
+	};
+
+	static inline void object_char(object& o, char v) {
+		return object_char_sign<is_signed<char>::value>::make(o, v);
 	}
 
 }  // namespace detail
 }  // namespace type
 
+inline char& operator>> (object const& o, char& v)
+	{ v = type::detail::convert_integer<char>(o); return v; }
+
 
 inline signed char& operator>> (object o, signed char& v)
 	{ v = type::detail::convert_integer<signed char>(o); return v; }
@@ -98,49 +152,56 @@ inline unsigned long& operator>> (object o, unsigned long& v)
 inline unsigned long long& operator>> (object o, unsigned long long& v)
 	{ v = type::detail::convert_integer<unsigned long long>(o); return v; }
 
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, char v)
+	{ return type::detail::pack_char(o, v); }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed char& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, signed char v)
 	{ o.pack_int8(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed short& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, signed short v)
 	{ o.pack_short(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed int& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, signed int v)
 	{ o.pack_int(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed long& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, signed long v)
 	{ o.pack_long(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed long long& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, signed long long v)
 	{ o.pack_long_long(v); return o; }
 
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned char& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, unsigned char v)
 	{ o.pack_uint8(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned short& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, unsigned short v)
 	{ o.pack_unsigned_short(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned int& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, unsigned int v)
 	{ o.pack_unsigned_int(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, unsigned long v)
 	{ o.pack_unsigned_long(v); return o; }
 
 template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long long& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, unsigned long long v)
 	{ o.pack_unsigned_long_long(v); return o; }
 
 
+inline void operator<< (object& o, char v)
+	{ type::detail::object_char(o, v); }
+
+
 inline void operator<< (object& o, signed char v)
 	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
 
@@ -173,6 +234,10 @@ inline void operator<< (object& o, unsigned long long v)
 	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
 
 
+inline void operator<< (object::with_zone& o, char v)
+	{ static_cast<object&>(o) << v; }
+
+
 inline void operator<< (object::with_zone& o, signed char v)
 	{ static_cast<object&>(o) << v; }
 
@@ -185,7 +250,7 @@ inline void operator<< (object::with_zone& o, signed int v)
 inline void operator<< (object::with_zone& o, signed long v)
 	{ static_cast<object&>(o) << v; }
 
-inline void operator<< (object::with_zone& o, signed long long v)
+inline void operator<< (object::with_zone& o, const signed long long& v)
 	{ static_cast<object&>(o) << v; }
 
 
@@ -201,7 +266,7 @@ inline void operator<< (object::with_zone& o, unsigned int v)
 inline void operator<< (object::with_zone& o, unsigned long v)
 	{ static_cast<object&>(o) << v; }
 
-inline void operator<< (object::with_zone& o, unsigned long long v)
+inline void operator<< (object::with_zone& o, const unsigned long long& v)
 	{ static_cast<object&>(o) << v; }
 
 

data/vendor/local/include/msgpack/type/tr1/unordered_map.hpp

@@ -19,13 +19,32 @@
 #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__
 
 #include "msgpack/object.hpp"
+
+#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#define MSGPACK_HAS_STD_UNOURDERED_MAP
+#include <unordered_map>
+#define MSGPACK_STD_TR1 std
+
+#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if __GNUC__ >= 4
+
+#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP
+
 #include <tr1/unordered_map>
+#define MSGPACK_STD_TR1 std::tr1
+
+#endif // __GNUC__ >= 4
+
+#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
 
 namespace msgpack {
 
 
 template <typename K, typename V>
-inline std::tr1::unordered_map<K, V> operator>> (object o, std::tr1::unordered_map<K, V>& v)
+inline MSGPACK_STD_TR1::unordered_map<K, V> operator>> (object o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
 {
 	if(o.type != type::MAP) { throw type_error(); }
 	object_kv* p(o.via.map.ptr);
@@ -39,10 +58,10 @@ inline std::tr1::unordered_map<K, V> operator>> (object o, std::tr1::unordered_m
 }
 
 template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_map<K,V>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
 {
 	o.pack_map(v.size());
-	for(typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(it->first);
 		o.pack(it->second);
@@ -51,7 +70,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename K, typename V>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
 {
 	o.type = type::MAP;
 	if(v.empty()) {
@@ -62,7 +81,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
-		typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin());
+		typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin());
 		do {
 			p->key = object(it->first, o.zone);
 			p->val = object(it->second, o.zone);
@@ -74,7 +93,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>
 
 
 template <typename K, typename V>
-inline std::tr1::unordered_multimap<K, V> operator>> (object o, std::tr1::unordered_multimap<K, V>& v)
+inline MSGPACK_STD_TR1::unordered_multimap<K, V> operator>> (object o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
 {
 	if(o.type != type::MAP) { throw type_error(); }
 	object_kv* p(o.via.map.ptr);
@@ -89,10 +108,10 @@ inline std::tr1::unordered_multimap<K, V> operator>> (object o, std::tr1::unorde
 }
 
 template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multimap<K,V>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
 {
 	o.pack_map(v.size());
-	for(typename std::tr1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(it->first);
 		o.pack(it->second);
@@ -101,7 +120,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename K, typename V>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap<K,V>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
 {
 	o.type = type::MAP;
 	if(v.empty()) {
@@ -112,7 +131,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
-		typename std::tr1::unordered_multimap<K,V>::const_iterator it(v.begin());
+		typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin());
 		do {
 			p->key = object(it->first, o.zone);
 			p->val = object(it->second, o.zone);
@@ -125,5 +144,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap
 
 }  // namespace msgpack
 
+#undef MSGPACK_STD_TR1
+
 #endif /* msgpack/type/map.hpp */
 

data/vendor/local/include/msgpack/type/tr1/unordered_set.hpp

@@ -19,13 +19,31 @@
 #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__
 
 #include "msgpack/object.hpp"
+
+#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#define MSGPACK_HAS_STD_UNOURDERED_SET
+#include <unordered_set>
+#define MSGPACK_STD_TR1 std
+
+#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if __GNUC__ >= 4
+
+#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET
+
 #include <tr1/unordered_set>
+#define MSGPACK_STD_TR1 std::tr1
+
+#endif // __GNUC__ >= 4
+
+#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
 
 namespace msgpack {
 
 
 template <typename T>
-inline std::tr1::unordered_set<T>& operator>> (object o, std::tr1::unordered_set<T>& v)
+inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	object* p = o.via.array.ptr + o.via.array.size;
@@ -38,10 +56,10 @@ inline std::tr1::unordered_set<T>& operator>> (object o, std::tr1::unordered_set
 }
 
 template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_set<T>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	o.pack_array(v.size());
-	for(typename std::tr1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(*it);
 	}
@@ -49,7 +67,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename T>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	o.type = type::ARRAY;
 	if(v.empty()) {
@@ -60,7 +78,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>&
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
-		typename std::tr1::unordered_set<T>::const_iterator it(v.begin());
+		typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin());
 		do {
 			*p = object(*it, o.zone);
 			++p;
@@ -71,7 +89,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>&
 
 
 template <typename T>
-inline std::tr1::unordered_multiset<T>& operator>> (object o, std::tr1::unordered_multiset<T>& v)
+inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	object* p = o.via.array.ptr + o.via.array.size;
@@ -84,10 +102,10 @@ inline std::tr1::unordered_multiset<T>& operator>> (object o, std::tr1::unordere
 }
 
 template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multiset<T>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	o.pack_array(v.size());
-	for(typename std::tr1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(*it);
 	}
@@ -95,7 +113,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename T>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset<T>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	o.type = type::ARRAY;
 	if(v.empty()) {
@@ -106,7 +124,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
-		typename std::tr1::unordered_multiset<T>::const_iterator it(v.begin());
+		typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin());
 		do {
 			*p = object(*it, o.zone);
 			++p;
@@ -118,5 +136,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset
 
 }  // namespace msgpack
 
+#undef MSGPACK_STD_TR1
+
 #endif /* msgpack/type/set.hpp */
 

data/vendor/local/include/msgpack/unpack.h

@@ -194,45 +194,45 @@ bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac);
 
 bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size);
 
-bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
+static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
 {
 	if(mpac->free >= size) { return true; }
 	return msgpack_unpacker_expand_buffer(mpac, size);
 }
 
-char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
+static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
 {
 	return mpac->buffer + mpac->used;
 }
 
-size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
+static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
 {
 	return mpac->free;
 }
 
-void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size)
+static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size)
 {
 	mpac->used += size;
 	mpac->free -= size;
 }
 
-size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
+static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
 {
 	return mpac->parsed - mpac->off + mpac->used;
 }
 
-size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac)
+static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac)
 {
 	return mpac->parsed;
 }
 
 
-void msgpack_unpacked_init(msgpack_unpacked* result)
+static inline void msgpack_unpacked_init(msgpack_unpacked* result)
 {
 	memset(result, 0, sizeof(msgpack_unpacked));
 }
 
-void msgpack_unpacked_destroy(msgpack_unpacked* result)
+static inline void msgpack_unpacked_destroy(msgpack_unpacked* result)
 {
 	if(result->zone != NULL) {
 		msgpack_zone_free(result->zone);
@@ -241,7 +241,7 @@ void msgpack_unpacked_destroy(msgpack_unpacked* result)
 	}
 }
 
-msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result)
+static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result)
 {
 	if(result->zone != NULL) {
 		msgpack_zone* z = result->zone;