From cd10fbc1fe39308045f0b7bf9cce5f8153f25f1d Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sat, 6 Feb 2010 20:09:41 +0900 Subject: removed symbolic links --- cpp/msgpack | 1 - cpp/msgpack/object.hpp | 329 +++++++++++++++++++++++++++++++++ cpp/msgpack/pack.hpp | 252 +++++++++++++++++++++++++ cpp/msgpack/sbuffer.hpp | 103 +++++++++++ cpp/msgpack/type.hpp | 15 ++ cpp/msgpack/type/bool.hpp | 46 +++++ cpp/msgpack/type/define.hpp.erb | 98 ++++++++++ cpp/msgpack/type/deque.hpp | 56 ++++++ cpp/msgpack/type/float.hpp | 63 +++++++ cpp/msgpack/type/int.hpp | 147 +++++++++++++++ cpp/msgpack/type/list.hpp | 56 ++++++ cpp/msgpack/type/map.hpp | 139 ++++++++++++++ cpp/msgpack/type/nil.hpp | 49 +++++ cpp/msgpack/type/pair.hpp | 50 +++++ cpp/msgpack/type/raw.hpp | 84 +++++++++ cpp/msgpack/type/set.hpp | 80 ++++++++ cpp/msgpack/type/string.hpp | 46 +++++ cpp/msgpack/type/tr1/unordered_map.hpp | 85 +++++++++ cpp/msgpack/type/tr1/unordered_set.hpp | 80 ++++++++ cpp/msgpack/type/tuple.hpp.erb | 171 +++++++++++++++++ cpp/msgpack/type/vector.hpp | 60 ++++++ cpp/msgpack/unpack.hpp | 301 ++++++++++++++++++++++++++++++ cpp/msgpack/vrefbuffer.hpp | 92 +++++++++ cpp/msgpack/zone.hpp.erb | 149 +++++++++++++++ cpp/object.hpp | 329 --------------------------------- cpp/pack.hpp | 252 ------------------------- cpp/sbuffer.hpp | 103 ----------- cpp/type.hpp | 15 -- cpp/type/bool.hpp | 46 ----- cpp/type/define.hpp.erb | 98 ---------- cpp/type/deque.hpp | 56 ------ cpp/type/float.hpp | 63 ------- cpp/type/int.hpp | 147 --------------- cpp/type/list.hpp | 56 ------ cpp/type/map.hpp | 139 -------------- cpp/type/nil.hpp | 49 ----- cpp/type/pair.hpp | 50 ----- cpp/type/raw.hpp | 84 --------- cpp/type/set.hpp | 80 -------- cpp/type/string.hpp | 46 ----- cpp/type/tr1/unordered_map.hpp | 85 --------- cpp/type/tr1/unordered_set.hpp | 80 -------- cpp/type/tuple.hpp.erb | 171 ----------------- cpp/type/vector.hpp | 60 ------ cpp/unpack.hpp | 301 ------------------------------ cpp/vrefbuffer.hpp | 92 --------- cpp/zone.hpp.erb | 149 --------------- 47 files changed, 2551 insertions(+), 2552 deletions(-) delete mode 120000 cpp/msgpack create mode 100644 cpp/msgpack/object.hpp create mode 100644 cpp/msgpack/pack.hpp create mode 100644 cpp/msgpack/sbuffer.hpp create mode 100644 cpp/msgpack/type.hpp create mode 100644 cpp/msgpack/type/bool.hpp create mode 100644 cpp/msgpack/type/define.hpp.erb create mode 100644 cpp/msgpack/type/deque.hpp create mode 100644 cpp/msgpack/type/float.hpp create mode 100644 cpp/msgpack/type/int.hpp create mode 100644 cpp/msgpack/type/list.hpp create mode 100644 cpp/msgpack/type/map.hpp create mode 100644 cpp/msgpack/type/nil.hpp create mode 100644 cpp/msgpack/type/pair.hpp create mode 100644 cpp/msgpack/type/raw.hpp create mode 100644 cpp/msgpack/type/set.hpp create mode 100644 cpp/msgpack/type/string.hpp create mode 100644 cpp/msgpack/type/tr1/unordered_map.hpp create mode 100644 cpp/msgpack/type/tr1/unordered_set.hpp create mode 100644 cpp/msgpack/type/tuple.hpp.erb create mode 100644 cpp/msgpack/type/vector.hpp create mode 100644 cpp/msgpack/unpack.hpp create mode 100644 cpp/msgpack/vrefbuffer.hpp create mode 100644 cpp/msgpack/zone.hpp.erb delete mode 100644 cpp/object.hpp delete mode 100644 cpp/pack.hpp delete mode 100644 cpp/sbuffer.hpp delete mode 100644 cpp/type.hpp delete mode 100644 cpp/type/bool.hpp delete mode 100644 cpp/type/define.hpp.erb delete mode 100644 cpp/type/deque.hpp delete mode 100644 cpp/type/float.hpp delete mode 100644 cpp/type/int.hpp delete mode 100644 cpp/type/list.hpp delete mode 100644 cpp/type/map.hpp delete mode 100644 cpp/type/nil.hpp delete mode 100644 cpp/type/pair.hpp delete mode 100644 cpp/type/raw.hpp delete mode 100644 cpp/type/set.hpp delete mode 100644 cpp/type/string.hpp delete mode 100644 cpp/type/tr1/unordered_map.hpp delete mode 100644 cpp/type/tr1/unordered_set.hpp delete mode 100644 cpp/type/tuple.hpp.erb delete mode 100644 cpp/type/vector.hpp delete mode 100644 cpp/unpack.hpp delete mode 100644 cpp/vrefbuffer.hpp delete mode 100644 cpp/zone.hpp.erb (limited to 'cpp') diff --git a/cpp/msgpack b/cpp/msgpack deleted file mode 120000 index 945c9b4..0000000 --- a/cpp/msgpack +++ /dev/null @@ -1 +0,0 @@ -. \ No newline at end of file diff --git a/cpp/msgpack/object.hpp b/cpp/msgpack/object.hpp new file mode 100644 index 0000000..ed2e290 --- /dev/null +++ b/cpp/msgpack/object.hpp @@ -0,0 +1,329 @@ +// +// 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_OBJECT_HPP__ +#define MSGPACK_OBJECT_HPP__ + +#include "msgpack/object.h" +#include "msgpack/pack.hpp" +#include +#include +#include +#include +#include + +namespace msgpack { + + +class type_error : public std::bad_cast { }; + + +namespace type { + enum object_type { + NIL = 0x01, + BOOLEAN = 0x02, + POSITIVE_INTEGER = 0x03, + NEGATIVE_INTEGER = 0x04, + DOUBLE = 0x05, + RAW = 0x06, + ARRAY = 0x07, + MAP = 0x08, + }; +} + + +struct object; +struct object_kv; + +struct object_array { + uint32_t size; + object* ptr; +}; + +struct object_map { + uint32_t size; + object_kv* ptr; +}; + +struct object_raw { + uint32_t size; + const char* ptr; +}; + +struct object { + union union_type { + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + object_array array; + object_map map; + object_raw raw; + object_raw ref; // obsolete + }; + + type::object_type type; + union_type via; + + bool is_nil() const { return type == type::NIL; } + + template + T as() const; + + template + void convert(T* v) const; + + object(); + object(msgpack_object obj); + operator msgpack_object(); + +private: + struct implicit_type; + +public: + implicit_type convert() const; +}; + +struct object_kv { + object key; + object val; +}; + +bool operator==(const object x, const object y); +bool operator!=(const object x, const object y); + +std::ostream& operator<< (std::ostream& s, const object o); + + +template +packer& operator<< (packer& o, const T& v); + +template +T& operator>> (object o, T& v); + + +struct object::implicit_type { + implicit_type(object o) : obj(o) { } + ~implicit_type() { } + + template + operator T() { return obj.as(); } + +private: + object obj; +}; + + +// obsolete +template +class define : public Type { +public: + typedef Type msgpack_type; + typedef define define_type; + + define() {} + define(const msgpack_type& v) : msgpack_type(v) {} + + template + void msgpack_pack(Packer& o) const + { + o << static_cast(*this); + } + + void msgpack_unpack(object o) + { + o >> static_cast(*this); + } +}; + + +template +template +inline packer& packer::pack(const T& v) +{ + *this << v; + return *this; +} + +inline object& operator>> (object o, object& v) +{ + v = o; + return v; +} + +template +inline T& operator>> (object o, T& v) +{ + v.msgpack_unpack(o.convert()); + return v; +} + +template +inline packer& operator<< (packer& o, const T& v) +{ + v.msgpack_pack(o); + return o; +} + + +inline bool operator!=(const object x, const object y) +{ return !(x == y); } + + +inline object::object() { } + +inline object::object(msgpack_object obj) +{ + // FIXME beter way? + ::memcpy(this, &obj, sizeof(obj)); +} + +inline object::operator msgpack_object() +{ + // FIXME beter way? + msgpack_object obj; + ::memcpy(&obj, this, sizeof(obj)); + return obj; +} + + +inline object::implicit_type object::convert() const +{ + return implicit_type(*this); +} + +template +inline void object::convert(T* v) const +{ + *this >> *v; +} + +template +inline T object::as() const +{ + T v; + convert(&v); + return v; +} + + +// obsolete +template +inline void convert(T& v, object o) +{ + o.convert(&v); +} + +// obsolete +template +inline void pack(packer& o, const T& v) +{ + o.pack(v); +} + +// obsolete +template +inline void pack_copy(packer& o, T v) +{ + pack(o, v); +} + + +template +packer& operator<< (packer& o, const object& v) +{ + switch(v.type) { + case type::NIL: + o.pack_nil(); + return o; + + case type::BOOLEAN: + if(v.via.boolean) { + o.pack_true(); + } else { + o.pack_false(); + } + return o; + + case type::POSITIVE_INTEGER: + if(v.via.u64 <= (uint64_t)std::numeric_limits::max()) { + if(v.via.u64 <= (uint16_t)std::numeric_limits::max()) { + o.pack_uint8(v.via.u64); + } else { + o.pack_uint16(v.via.u64); + } + } else { + if(v.via.u64 <= (uint64_t)std::numeric_limits::max()) { + o.pack_uint32(v.via.u64); + } else { + o.pack_uint64(v.via.u64); + } + } + return o; + + case type::NEGATIVE_INTEGER: + if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { + if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { + o.pack_int8(v.via.i64); + } else { + o.pack_int16(v.via.i64); + } + } else { + if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { + o.pack_int64(v.via.i64); + } else { + o.pack_int64(v.via.i64); + } + } + return o; + + case type::RAW: + o.pack_raw(v.via.raw.size); + o.pack_raw_body(v.via.raw.ptr, v.via.raw.size); + return o; + + case type::ARRAY: + o.pack_array(v.via.array.size); + for(object* p(v.via.array.ptr), + * const pend(v.via.array.ptr + v.via.array.size); + p < pend; ++p) { + o << *p; + } + return o; + + case type::MAP: + o.pack_map(v.via.map.size); + for(object_kv* p(v.via.map.ptr), + * const pend(v.via.map.ptr + v.via.map.size); + p < pend; ++p) { + o << p->key; + o << p->val; + } + return o; + + default: + throw type_error(); + } +} + + +} // namespace msgpack + +#include "msgpack/type.hpp" + +#endif /* msgpack/object.hpp */ + diff --git a/cpp/msgpack/pack.hpp b/cpp/msgpack/pack.hpp new file mode 100644 index 0000000..9c291c1 --- /dev/null +++ b/cpp/msgpack/pack.hpp @@ -0,0 +1,252 @@ +// +// MessagePack for C++ serializing 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_PACK_HPP__ +#define MSGPACK_PACK_HPP__ + +#include "msgpack/pack_define.h" +#include +#include + +namespace msgpack { + + +template +class packer { +public: + packer(Stream& s); + ~packer(); + +public: + template + packer& pack(const T& v); + + packer& pack_uint8(uint8_t d); + packer& pack_uint16(uint16_t d); + packer& pack_uint32(uint32_t d); + packer& pack_uint64(uint64_t d); + packer& pack_int8(uint8_t d); + packer& pack_int16(uint16_t d); + packer& pack_int32(uint32_t d); + packer& pack_int64(uint64_t d); + + packer& pack_short(int d); + packer& pack_int(int d); + packer& pack_long(long d); + packer& pack_long_long(long long d); + packer& pack_unsigned_short(unsigned short d); + packer& pack_unsigned_int(unsigned int d); + packer& pack_unsigned_long(unsigned long d); + packer& pack_unsigned_long_long(unsigned long long d); + + packer& pack_float(float d); + packer& pack_double(double d); + + packer& pack_nil(); + packer& pack_true(); + packer& pack_false(); + + packer& pack_array(unsigned int n); + + packer& pack_map(unsigned int n); + + packer& pack_raw(size_t l); + packer& pack_raw_body(const char* b, size_t l); + +private: + static void _pack_uint8(Stream& x, uint8_t d); + static void _pack_uint16(Stream& x, uint16_t d); + static void _pack_uint32(Stream& x, uint32_t d); + static void _pack_uint64(Stream& x, uint64_t d); + static void _pack_int8(Stream& x, int8_t d); + static void _pack_int16(Stream& x, int16_t d); + static void _pack_int32(Stream& x, int32_t d); + static void _pack_int64(Stream& x, int64_t d); + + static void _pack_short(Stream& x, short d); + static void _pack_int(Stream& x, int d); + static void _pack_long(Stream& x, long d); + static void _pack_long_long(Stream& x, long long d); + static void _pack_unsigned_short(Stream& x, unsigned short d); + static void _pack_unsigned_int(Stream& x, unsigned int d); + static void _pack_unsigned_long(Stream& x, unsigned long d); + static void _pack_unsigned_long_long(Stream& x, unsigned long long d); + + static void _pack_float(Stream& x, float d); + static void _pack_double(Stream& x, double d); + + static void _pack_nil(Stream& x); + static void _pack_true(Stream& x); + static void _pack_false(Stream& x); + + static void _pack_array(Stream& x, unsigned int n); + + static void _pack_map(Stream& x, unsigned int n); + + static void _pack_raw(Stream& x, size_t l); + static void _pack_raw_body(Stream& x, const void* b, size_t l); + + static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len) + { x.write((const char*)buf, len); } + +private: + Stream& m_stream; + +private: + packer(); +}; + + +template +inline void pack(Stream& s, const T& v) +{ + packer(s).pack(v); +} + + +#define msgpack_pack_inline_func(name) \ + template \ + inline void packer::_pack ## name + +#define msgpack_pack_inline_func_cint(name) \ + template \ + inline void packer::_pack ## name + +#define msgpack_pack_user Stream& + +#define msgpack_pack_append_buffer append_buffer + +#include "msgpack/pack_template.h" + + +template +packer::packer(Stream& s) : m_stream(s) { } + +template +packer::~packer() { } + +template +inline packer& packer::pack_uint8(uint8_t d) +{ _pack_uint8(m_stream, d); return *this; } + +template +inline packer& packer::pack_uint16(uint16_t d) +{ _pack_uint16(m_stream, d); return *this; } + +template +inline packer& packer::pack_uint32(uint32_t d) +{ _pack_uint32(m_stream, d); return *this; } + +template +inline packer& packer::pack_uint64(uint64_t d) +{ _pack_uint64(m_stream, d); return *this; } + +template +inline packer& packer::pack_int8(uint8_t d) +{ _pack_int8(m_stream, d); return *this; } + +template +inline packer& packer::pack_int16(uint16_t d) +{ _pack_int16(m_stream, d); return *this; } + +template +inline packer& packer::pack_int32(uint32_t d) +{ _pack_int32(m_stream, d); return *this; } + +template +inline packer& packer::pack_int64(uint64_t d) +{ _pack_int64(m_stream, d); return *this;} + + +template +inline packer& packer::pack_short(int d) +{ _pack_short(m_stream, d); return *this; } + +template +inline packer& packer::pack_int(int d) +{ _pack_int(m_stream, d); return *this; } + +template +inline packer& packer::pack_long(long d) +{ _pack_long(m_stream, d); return *this; } + +template +inline packer& packer::pack_long_long(long long d) +{ _pack_long_long(m_stream, d); return *this; } + +template +inline packer& packer::pack_unsigned_short(unsigned short d) +{ _pack_unsigned_short(m_stream, d); return *this; } + +template +inline packer& packer::pack_unsigned_int(unsigned int d) +{ _pack_unsigned_int(m_stream, d); return *this; } + +template +inline packer& packer::pack_unsigned_long(unsigned long d) +{ _pack_unsigned_long(m_stream, d); return *this; } + +template +inline packer& packer::pack_unsigned_long_long(unsigned long long d) +{ _pack_unsigned_long_long(m_stream, d); return *this; } + + +template +inline packer& packer::pack_float(float d) +{ _pack_float(m_stream, d); return *this; } + +template +inline packer& packer::pack_double(double d) +{ _pack_double(m_stream, d); return *this; } + + +template +inline packer& packer::pack_nil() +{ _pack_nil(m_stream); return *this; } + +template +inline packer& packer::pack_true() +{ _pack_true(m_stream); return *this; } + +template +inline packer& packer::pack_false() +{ _pack_false(m_stream); return *this; } + + +template +inline packer& packer::pack_array(unsigned int n) +{ _pack_array(m_stream, n); return *this; } + + +template +inline packer& packer::pack_map(unsigned int n) +{ _pack_map(m_stream, n); return *this; } + + +template +inline packer& packer::pack_raw(size_t l) +{ _pack_raw(m_stream, l); return *this; } + +template +inline packer& packer::pack_raw_body(const char* b, size_t l) +{ _pack_raw_body(m_stream, b, l); return *this; } + + +} // namespace msgpack + +#endif /* msgpack/pack.hpp */ + diff --git a/cpp/msgpack/sbuffer.hpp b/cpp/msgpack/sbuffer.hpp new file mode 100644 index 0000000..ca06884e --- /dev/null +++ b/cpp/msgpack/sbuffer.hpp @@ -0,0 +1,103 @@ +// +// MessagePack for C++ simple buffer implementation +// +// 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_SBUFFER_HPP__ +#define MSGPACK_SBUFFER_HPP__ + +#include "msgpack/sbuffer.h" +#include + +namespace msgpack { + + +class sbuffer : public msgpack_sbuffer { +public: + sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE) + { + base::data = (char*)::malloc(initsz); + if(!base::data) { + throw std::bad_alloc(); + } + + base::size = 0; + base::alloc = initsz; + } + + ~sbuffer() + { + ::free(base::data); + } + +public: + void write(const char* buf, unsigned int len) + { + if(base::alloc - base::size < len) { + expand_buffer(len); + } + memcpy(base::data + base::size, buf, len); + base::size += len; + } + + char* data() + { + return base::data; + } + + const char* data() const + { + return base::data; + } + + size_t size() const + { + return base::size; + } + + char* release() + { + return msgpack_sbuffer_release(this); + } + +private: + void expand_buffer(size_t len) + { + size_t nsize = (base::alloc) ? + base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + + while(nsize < base::size + len) { nsize *= 2; } + + void* tmp = realloc(base::data, nsize); + if(!tmp) { + throw std::bad_alloc(); + } + + base::data = (char*)tmp; + base::alloc = nsize; + } + +private: + typedef msgpack_sbuffer base; + +private: + sbuffer(const sbuffer&); +}; + + +} // namespace msgpack + +#endif /* msgpack/sbuffer.hpp */ + diff --git a/cpp/msgpack/type.hpp b/cpp/msgpack/type.hpp new file mode 100644 index 0000000..fafa674 --- /dev/null +++ b/cpp/msgpack/type.hpp @@ -0,0 +1,15 @@ +#include "msgpack/type/bool.hpp" +#include "msgpack/type/float.hpp" +#include "msgpack/type/int.hpp" +#include "msgpack/type/list.hpp" +#include "msgpack/type/deque.hpp" +#include "msgpack/type/map.hpp" +#include "msgpack/type/nil.hpp" +#include "msgpack/type/pair.hpp" +#include "msgpack/type/raw.hpp" +#include "msgpack/type/set.hpp" +#include "msgpack/type/string.hpp" +#include "msgpack/type/vector.hpp" +#include "msgpack/type/tuple.hpp" +#include "msgpack/type/define.hpp" + diff --git a/cpp/msgpack/type/bool.hpp b/cpp/msgpack/type/bool.hpp new file mode 100644 index 0000000..b945d85 --- /dev/null +++ b/cpp/msgpack/type/bool.hpp @@ -0,0 +1,46 @@ +// +// 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_BOOL_HPP__ +#define MSGPACK_TYPE_BOOL_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +inline bool& operator>> (object o, bool& v) +{ + if(o.type != type::BOOLEAN) { throw type_error(); } + v = o.via.boolean; + return v; +} + +template +inline packer& operator<< (packer& o, const bool& v) +{ + if(v) { o.pack_true(); } + else { o.pack_false(); } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/bool.hpp */ + diff --git a/cpp/msgpack/type/define.hpp.erb b/cpp/msgpack/type/define.hpp.erb new file mode 100644 index 0000000..2eac4f4 --- /dev/null +++ b/cpp/msgpack/type/define.hpp.erb @@ -0,0 +1,98 @@ +// +// 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_DEFINE_HPP__ +#define MSGPACK_TYPE_DEFINE_HPP__ + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + } + +namespace msgpack { +namespace type { + + +<% GENERATION_LIMIT = 31 %> +template , typename A<%=i%> = void<%}%>> +struct define; + + +template <> +struct define<> { + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(1); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } +}; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct define, A<%=j%><%}%>> { + typedef define, A<%=j%><%}%>> value_type; + typedef tuple, A<%=j%><%}%>> tuple_type; + define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + pk.pack(a<%=j%>);<%}%> + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + <%0.upto(i) {|j|%> + if(size <= <%=j%>) { return; } o.via.array.ptr[<%=j%>].convert(&a<%=j%>);<%}%> + } + <%0.upto(i) {|j|%> + A<%=j%>& a<%=j%>;<%}%> +}; +<%}%> + +inline define<> make_define() +{ + return define<>(); +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>) +{ + return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); +} +<%}%> + +} // namespace type +} // namespace msgpack + + +#endif /* msgpack/type/define.hpp */ + diff --git a/cpp/msgpack/type/deque.hpp b/cpp/msgpack/type/deque.hpp new file mode 100644 index 0000000..d34d243 --- /dev/null +++ b/cpp/msgpack/type/deque.hpp @@ -0,0 +1,56 @@ +// +// 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_DEQUE_HPP__ +#define MSGPACK_TYPE_DEQUE_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +template +inline std::deque& operator>> (object o, std::deque& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::deque::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(&*it); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::deque& v) +{ + o.pack_array(v.size()); + for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/deque.hpp */ + diff --git a/cpp/msgpack/type/float.hpp b/cpp/msgpack/type/float.hpp new file mode 100644 index 0000000..390e340 --- /dev/null +++ b/cpp/msgpack/type/float.hpp @@ -0,0 +1,63 @@ +// +// 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_FLOAT_HPP__ +#define MSGPACK_TYPE_FLOAT_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +// FIXME check overflow, underflow + + +inline float& operator>> (object o, float& v) +{ + if(o.type != type::DOUBLE) { throw type_error(); } + v = o.via.dec; + return v; +} + +template +inline packer& operator<< (packer& o, const float& v) +{ + o.pack_float(v); + return o; +} + + +inline double& operator>> (object o, double& v) +{ + if(o.type != type::DOUBLE) { throw type_error(); } + v = o.via.dec; + return v; +} + +template +inline packer& operator<< (packer& o, const double& v) +{ + o.pack_double(v); + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/float.hpp */ + diff --git a/cpp/msgpack/type/int.hpp b/cpp/msgpack/type/int.hpp new file mode 100644 index 0000000..03500f7 --- /dev/null +++ b/cpp/msgpack/type/int.hpp @@ -0,0 +1,147 @@ +// +// 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_INT_HPP__ +#define MSGPACK_TYPE_INT_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +namespace type { +namespace detail { + template + struct convert_integer_sign; + + template + struct convert_integer_sign { + static inline T convert(object o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > (uint64_t)std::numeric_limits::max()) + { throw type_error(); } + return o.via.u64; + } else if(o.type == type::NEGATIVE_INTEGER) { + if(o.via.i64 < (int64_t)std::numeric_limits::min()) + { throw type_error(); } + return o.via.i64; + } + throw type_error(); + } + }; + + template + struct convert_integer_sign { + static inline T convert(object o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > (uint64_t)std::numeric_limits::max()) + { throw type_error(); } + return o.via.u64; + } + throw type_error(); + } + }; + + template + static inline T convert_integer(object o) + { + return detail::convert_integer_sign::is_signed>::convert(o); + } + +} // namespace detail +} // namespace type + + +inline signed char& operator>> (object o, signed char& v) + { v = type::detail::convert_integer(o); return v; } + +inline signed short& operator>> (object o, signed short& v) + { v = type::detail::convert_integer(o); return v; } + +inline signed int& operator>> (object o, signed int& v) + { v = type::detail::convert_integer(o); return v; } + +inline signed long& operator>> (object o, signed long& v) + { v = type::detail::convert_integer(o); return v; } + +inline signed long long& operator>> (object o, signed long long& v) + { v = type::detail::convert_integer(o); return v; } + + +inline unsigned char& operator>> (object o, unsigned char& v) + { v = type::detail::convert_integer(o); return v; } + +inline unsigned short& operator>> (object o, unsigned short& v) + { v = type::detail::convert_integer(o); return v; } + +inline unsigned int& operator>> (object o, unsigned int& v) + { v = type::detail::convert_integer(o); return v; } + +inline unsigned long& operator>> (object o, unsigned long& v) + { v = type::detail::convert_integer(o); return v; } + +inline unsigned long long& operator>> (object o, unsigned long long& v) + { v = type::detail::convert_integer(o); return v; } + + +template +inline packer& operator<< (packer& o, const signed char& v) + { o.pack_int8(v); return o; } + +template +inline packer& operator<< (packer& o, const signed short& v) + { o.pack_short(v); return o; } + +template +inline packer& operator<< (packer& o, const signed int& v) + { o.pack_int(v); return o; } + +template +inline packer& operator<< (packer& o, const signed long& v) + { o.pack_long(v); return o; } + +template +inline packer& operator<< (packer& o, const signed long long& v) + { o.pack_long_long(v); return o; } + + +template +inline packer& operator<< (packer& o, const unsigned char& v) + { o.pack_uint8(v); return o; } + +template +inline packer& operator<< (packer& o, const unsigned short& v) + { o.pack_unsigned_short(v); return o; } + +template +inline packer& operator<< (packer& o, const unsigned int& v) + { o.pack_unsigned_int(v); return o; } + +template +inline packer& operator<< (packer& o, const unsigned long& v) + { o.pack_unsigned_long(v); return o; } + +template +inline packer& operator<< (packer& o, const unsigned long long& v) + { o.pack_unsigned_long_long(v); return o; } + + +} // namespace msgpack + +#endif /* msgpack/type/int.hpp */ + diff --git a/cpp/msgpack/type/list.hpp b/cpp/msgpack/type/list.hpp new file mode 100644 index 0000000..6ecc02f --- /dev/null +++ b/cpp/msgpack/type/list.hpp @@ -0,0 +1,56 @@ +// +// 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_LIST_HPP__ +#define MSGPACK_TYPE_LIST_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +template +inline std::list& operator>> (object o, std::list& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::list::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(&*it); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::list& v) +{ + o.pack_array(v.size()); + for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/list.hpp */ + diff --git a/cpp/msgpack/type/map.hpp b/cpp/msgpack/type/map.hpp new file mode 100644 index 0000000..552de57 --- /dev/null +++ b/cpp/msgpack/type/map.hpp @@ -0,0 +1,139 @@ +// +// 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 +#include +#include + +namespace msgpack { + + +namespace type { + +template +class assoc_vector : public std::vector< std::pair > {}; + +namespace detail { + template + struct pair_first_less { + bool operator() (const std::pair& x, const std::pair& y) const + { return x.first < y.first; } + }; +} + +} //namespace type + + +template +inline type::assoc_vector& operator>> (object o, type::assoc_vector& 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* 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()); + return v; +} + +template +inline packer& operator<< (packer& o, const type::assoc_vector& v) +{ + o.pack_map(v.size()); + for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + + +template +inline std::map operator>> (object o, std::map& 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::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(key, val)); + } + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::map& v) +{ + o.pack_map(v.size()); + for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + + +template +inline std::multimap operator>> (object o, std::multimap& 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 value; + p->key.convert(&value.first); + p->val.convert(&value.second); + v.insert(value); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::multimap& v) +{ + o.pack_map(v.size()); + for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/map.hpp */ + diff --git a/cpp/msgpack/type/nil.hpp b/cpp/msgpack/type/nil.hpp new file mode 100644 index 0000000..93e66ff --- /dev/null +++ b/cpp/msgpack/type/nil.hpp @@ -0,0 +1,49 @@ +// +// 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 +inline packer& operator<< (packer& o, const type::nil& v) +{ + o.pack_nil(); + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/nil.hpp */ + diff --git a/cpp/msgpack/type/pair.hpp b/cpp/msgpack/type/pair.hpp new file mode 100644 index 0000000..ba72c1f --- /dev/null +++ b/cpp/msgpack/type/pair.hpp @@ -0,0 +1,50 @@ +// +// 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 + +namespace msgpack { + + +template +inline std::pair& operator>> (object o, std::pair& 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 +inline packer& operator<< (packer& o, const std::pair& v) +{ + o.pack_array(2); + o.pack(v.first); + o.pack(v.second); + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/pair.hpp */ + diff --git a/cpp/msgpack/type/raw.hpp b/cpp/msgpack/type/raw.hpp new file mode 100644 index 0000000..8c68aba --- /dev/null +++ b/cpp/msgpack/type/raw.hpp @@ -0,0 +1,84 @@ +// +// 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 +#include + +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() { return std::string(ptr, size); } + + bool operator== (const raw_ref& x) + { + return size == x.size && memcmp(ptr, x.ptr, size) == 0; + } + + bool operator!= (const raw_ref& x) + { + return !(*this != x); + } + + bool operator< (const raw_ref& x) + { + if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; } + else { return size < x.size; } + } + + bool operator> (const raw_ref& x) + { + 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 +inline packer& operator<< (packer& o, const type::raw_ref& v) +{ + o.pack_raw(v.size); + o.pack_raw_body(v.ptr, v.size); + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/raw.hpp */ + diff --git a/cpp/msgpack/type/set.hpp b/cpp/msgpack/type/set.hpp new file mode 100644 index 0000000..f2c5bfb --- /dev/null +++ b/cpp/msgpack/type/set.hpp @@ -0,0 +1,80 @@ +// +// 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 + +namespace msgpack { + + +template +inline std::set& operator>> (object o, std::set& 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()); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::set& v) +{ + o.pack_array(v.size()); + for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +template +inline std::multiset& operator>> (object o, std::multiset& 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()); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::multiset& v) +{ + o.pack_array(v.size()); + for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/set.hpp */ + diff --git a/cpp/msgpack/type/string.hpp b/cpp/msgpack/type/string.hpp new file mode 100644 index 0000000..a085d53 --- /dev/null +++ b/cpp/msgpack/type/string.hpp @@ -0,0 +1,46 @@ +// +// 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 + +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 +inline packer& operator<< (packer& o, const std::string& v) +{ + o.pack_raw(v.size()); + o.pack_raw_body(v.data(), v.size()); + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/string.hpp */ + diff --git a/cpp/msgpack/type/tr1/unordered_map.hpp b/cpp/msgpack/type/tr1/unordered_map.hpp new file mode 100644 index 0000000..1996cfd --- /dev/null +++ b/cpp/msgpack/type/tr1/unordered_map.hpp @@ -0,0 +1,85 @@ +// +// 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_TR1_UNORDERED_MAP_HPP__ +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +template +inline std::tr1::unordered_map operator>> (object o, std::tr1::unordered_map& 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); + p->val.convert(&v[key]); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::tr1::unordered_map& v) +{ + o.pack_map(v.size()); + for(typename std::tr1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + + +template +inline std::tr1::unordered_multimap operator>> (object o, std::tr1::unordered_multimap& 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 value; + p->key.convert(&value.first); + p->val.convert(&value.second); + v.insert(value); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::tr1::unordered_multimap& v) +{ + o.pack_map(v.size()); + for(typename std::tr1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/map.hpp */ + diff --git a/cpp/msgpack/type/tr1/unordered_set.hpp b/cpp/msgpack/type/tr1/unordered_set.hpp new file mode 100644 index 0000000..eb127b5 --- /dev/null +++ b/cpp/msgpack/type/tr1/unordered_set.hpp @@ -0,0 +1,80 @@ +// +// 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_TR1_UNORDERED_SET_HPP__ +#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +template +inline std::tr1::unordered_set& operator>> (object o, std::tr1::unordered_set& 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()); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::tr1::unordered_set& v) +{ + o.pack_array(v.size()); + for(typename std::tr1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +template +inline std::tr1::unordered_multiset& operator>> (object o, std::tr1::unordered_multiset& 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()); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::tr1::unordered_multiset& v) +{ + o.pack_array(v.size()); + for(typename std::tr1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/set.hpp */ + diff --git a/cpp/msgpack/type/tuple.hpp.erb b/cpp/msgpack/type/tuple.hpp.erb new file mode 100644 index 0000000..2930ae0 --- /dev/null +++ b/cpp/msgpack/type/tuple.hpp.erb @@ -0,0 +1,171 @@ +// +// 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_TUPLE_HPP__ +#define MSGPACK_TYPE_TUPLE_HPP__ + +#include "msgpack/object.hpp" + +namespace msgpack { + +namespace type { + +// FIXME operator== +// FIXME operator!= +<% GENERATION_LIMIT = 31 %> + +template , typename A<%=i%> = void<%}%>> +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type { + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { + tuple_element(tuple, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {} + typename tuple_type>::reference get() { return _x; } + typename tuple_type>::const_reference get() const { return _x; } +private: + typename tuple_type>::reference _x; +}; +<%}%> +<%}%> + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { + const_tuple_element(const tuple, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {} + typename tuple_type>::const_reference get() const { return _x; } +private: + typename tuple_type>::const_reference _x; +}; +<%}%> +<%}%> + +template <> +struct tuple<> { + tuple() {} + tuple(object o) { o.convert(this); } + typedef tuple<> value_type; +}; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct tuple, A<%=j%><%}%>> { + typedef tuple, A<%=j%><%}%>> value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + tuple(object o) { o.convert(this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + <%0.upto(i) {|j|%> + A<%=j%> a<%=j%>;<%}%> +}; +<%}%> + +inline tuple<> make_tuple() +{ + return tuple<>(); +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) +{ + return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); +} +<%}%> + +} // namespace type + + +inline type::tuple<>& operator>> ( + object o, + type::tuple<>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + return v; +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +type::tuple, A<%=j%><%}%>>& operator>> ( + object o, + type::tuple, A<%=j%><%}%>>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < <%=i+1%>) { throw type_error(); } + <%0.upto(i) {|j|%> + o.via.array.ptr[<%=j%>].convert>(&v.template get<<%=j%>>());<%}%> + return v; +} +<%}%> + +template +const packer& operator<< ( + packer& o, + const type::tuple<>& v) { + o.pack_array(0); + return o; +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +const packer& operator<< ( + packer& o, + const type::tuple, A<%=j%><%}%>>& v) { + o.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + o.pack(v.template get<<%=j%>>());<%}%> + return o; +} +<%}%> + +} // namespace msgpack + +#endif /* msgpack/type/tuple.hpp */ + diff --git a/cpp/msgpack/type/vector.hpp b/cpp/msgpack/type/vector.hpp new file mode 100644 index 0000000..385d070 --- /dev/null +++ b/cpp/msgpack/type/vector.hpp @@ -0,0 +1,60 @@ +// +// 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_VECTOR_HPP__ +#define MSGPACK_TYPE_VECTOR_HPP__ + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + + +template +inline std::vector& operator>> (object o, std::vector& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + if(o.via.array.size > 0) { + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + T* it = &v[0]; + do { + p->convert(it); + ++p; + ++it; + } while(p < pend); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::vector& v) +{ + o.pack_array(v.size()); + for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + + +} // namespace msgpack + +#endif /* msgpack/type/vector.hpp */ + diff --git a/cpp/msgpack/unpack.hpp b/cpp/msgpack/unpack.hpp new file mode 100644 index 0000000..324111a --- /dev/null +++ b/cpp/msgpack/unpack.hpp @@ -0,0 +1,301 @@ +// +// MessagePack for C++ deserializing 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_UNPACK_HPP__ +#define MSGPACK_UNPACK_HPP__ + +#include "msgpack/unpack.h" +#include "msgpack/object.hpp" +#include "msgpack/zone.hpp" +#include +#include + +#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE +#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE (32*1024) +#endif + +namespace msgpack { + + +struct unpack_error : public std::runtime_error { + unpack_error(const std::string& msg) : + std::runtime_error(msg) { } +}; + + +class unpacker : public msgpack_unpacker { +public: + unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE); + ~unpacker(); + +public: + /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ + void reserve_buffer(size_t size); + + /*! 2. read data to the buffer() up to buffer_capacity() bytes */ + char* buffer(); + size_t buffer_capacity() const; + + /*! 3. specify the number of bytes actually copied */ + void buffer_consumed(size_t size); + + /*! 4. repeat execute() until it retunrs false */ + bool execute(); + + /*! 5.1. if execute() returns true, take out the parsed object */ + object data(); + + /*! 5.2. the object is valid until the zone is deleted */ + // Note that once release_zone() from unpacker, you must delete it + // otherwise the memrory will leak. + zone* release_zone(); + + /*! 5.2. this method is equivalence to `delete release_zone()` */ + void reset_zone(); + + /*! 5.3. after release_zone(), re-initialize unpacker */ + void reset(); + + /*! 6. check if the size of message doesn't exceed assumption. */ + size_t message_size() const; + + + // Basic usage of the unpacker is as following: + // + // msgpack::unpacker pac; + // + // while( /* readable */ ) { + // + // // 1. + // pac.reserve(1024); + // + // // 2. + // ssize_t bytes = + // read(the_source, pac.buffer(), pac.buffer_capacity()); + // + // // error handling ... + // + // // 3. + // pac.buffer_consumed(bytes); + // + // // 4. + // while(pac.execute()) { + // // 5.1 + // object o = pac.data(); + // + // // 5.2 + // std::auto_ptr olife( pac.release_zone() ); + // + // // boost::shared_ptr is also usable: + // // boost::shared_ptr olife( pac.release_zone() ); + // + // // 5.3 + // pac.reset(); + // + // // do some with the object with the old zone. + // do_something(o, olife); + // } + // } + // + +public: + // These functions are usable when non-MessagePack message follows after + // MessagePack message. + size_t parsed_size() const; + + /*! get address of the buffer that is not parsed */ + char* nonparsed_buffer(); + size_t nonparsed_size() const; + + /*! skip specified size of non-parsed buffer, leaving the buffer */ + // Note that the `size' argument must be smaller than nonparsed_size() + void skip_nonparsed_buffer(size_t size); + + /*! remove unparsed buffer from unpacker */ + // Note that reset() leaves non-parsed buffer. + void remove_nonparsed_buffer(); + +private: + typedef msgpack_unpacker base; + +private: + unpacker(const unpacker&); +}; + + +typedef enum { + UNPACK_SUCCESS = 2, + UNPACK_EXTRA_BYTES = 1, + UNPACK_CONTINUE = 0, + UNPACK_PARSE_ERROR = -1, +} unpack_return; + +static unpack_return unpack(const char* data, size_t len, size_t* off, + zone* z, object* result); + + +// obsolete +static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); + + +inline unpacker::unpacker(size_t initial_buffer_size) +{ + if(!msgpack_unpacker_init(this, initial_buffer_size)) { + throw std::bad_alloc(); + } +} + +inline unpacker::~unpacker() +{ + msgpack_unpacker_destroy(this); +} + + +inline void unpacker::reserve_buffer(size_t size) +{ + if(!msgpack_unpacker_reserve_buffer(this, size)) { + throw std::bad_alloc(); + } +} + +inline char* unpacker::buffer() +{ + return msgpack_unpacker_buffer(this); +} + +inline size_t unpacker::buffer_capacity() const +{ + return msgpack_unpacker_buffer_capacity(this); +} + +inline void unpacker::buffer_consumed(size_t size) +{ + return msgpack_unpacker_buffer_consumed(this, size); +} + + +inline bool unpacker::execute() +{ + int ret = msgpack_unpacker_execute(this); + if(ret < 0) { + throw unpack_error("parse error"); + } else if(ret == 0) { + return false; + } else { + return true; + } +} + +inline object unpacker::data() +{ + return msgpack_unpacker_data(this); +} + +inline zone* unpacker::release_zone() +{ + if(!msgpack_unpacker_flush_zone(this)) { + throw std::bad_alloc(); + } + + zone* r = new zone(); + + msgpack_zone old = *base::z; + *base::z = *r; + *static_cast(r) = old; + + return r; +} + +inline void unpacker::reset_zone() +{ + msgpack_unpacker_reset_zone(this); +} + +inline void unpacker::reset() +{ + msgpack_unpacker_reset(this); +} + +inline size_t unpacker::message_size() const +{ + return msgpack_unpacker_message_size(this); +} + + +inline size_t unpacker::parsed_size() const +{ + return msgpack_unpacker_parsed_size(this); +} + +inline char* unpacker::nonparsed_buffer() +{ + return base::buffer + base::off; +} + +inline size_t unpacker::nonparsed_size() const +{ + return base::used - base::off; +} + +inline void unpacker::skip_nonparsed_buffer(size_t size) +{ + base::off += size; +} + +inline void unpacker::remove_nonparsed_buffer() +{ + base::used = base::off; +} + + +inline unpack_return unpack(const char* data, size_t len, size_t* off, + zone* z, object* result) +{ + return (unpack_return)msgpack_unpack(data, len, off, + z, reinterpret_cast(result)); +} + +// obsolete +inline object unpack(const char* data, size_t len, zone& z, size_t* off) +{ + object result; + + switch( msgpack::unpack(data, len, off, &z, &result) ) { + case UNPACK_SUCCESS: + return result; + + case UNPACK_EXTRA_BYTES: + if(off) { + return result; + } else { + throw unpack_error("extra bytes"); + } + + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); + + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } +} + + +} // namespace msgpack + +#endif /* msgpack/unpack.hpp */ + diff --git a/cpp/msgpack/vrefbuffer.hpp b/cpp/msgpack/vrefbuffer.hpp new file mode 100644 index 0000000..c8eca7b --- /dev/null +++ b/cpp/msgpack/vrefbuffer.hpp @@ -0,0 +1,92 @@ +// +// MessagePack for C++ zero-copy buffer implementation +// +// 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_VREFBUFFER_HPP__ +#define MSGPACK_VREFBUFFER_HPP__ + +#include "msgpack/vrefbuffer.h" +#include + +namespace msgpack { + + +class vrefbuffer : public msgpack_vrefbuffer { +public: + vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, + size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) + { + msgpack_vrefbuffer_init(this, ref_size, chunk_size); + } + + ~vrefbuffer() + { + msgpack_vrefbuffer_destroy(this); + } + +public: + void write(const char* buf, unsigned int len) + { + if(len < base::ref_size) { + append_copy(buf, len); + } else { + append_ref(buf, len); + } + } + + void append_ref(const char* buf, size_t len) + { + if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) { + throw std::bad_alloc(); + } + } + + void append_copy(const char* buf, size_t len) + { + if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) { + throw std::bad_alloc(); + } + } + + const struct iovec* vector() const + { + return msgpack_vrefbuffer_vec(this); + } + + size_t vector_size() const + { + return msgpack_vrefbuffer_veclen(this); + } + + void migrate(vrefbuffer* to) + { + if(msgpack_vrefbuffer_migrate(this, to) < 0) { + throw std::bad_alloc(); + } + } + +private: + typedef msgpack_vrefbuffer base; + +private: + vrefbuffer(const vrefbuffer&); +}; + + +} // namespace msgpack + +#endif /* msgpack/vrefbuffer.hpp */ + diff --git a/cpp/msgpack/zone.hpp.erb b/cpp/msgpack/zone.hpp.erb new file mode 100644 index 0000000..48988ab --- /dev/null +++ b/cpp/msgpack/zone.hpp.erb @@ -0,0 +1,149 @@ +// +// MessagePack for C++ memory pool +// +// 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_ZONE_HPP__ +#define MSGPACK_ZONE_HPP__ + +#include "msgpack/object.hpp" +#include "msgpack/zone.h" +#include +#include +#include + +<% GENERATION_LIMIT = 15 %> +namespace msgpack { + + +class zone : public msgpack_zone { +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); + ~zone(); + +public: + void* malloc(size_t size); + void* malloc_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(std::auto_ptr obj); + + void clear(); + + <%0.upto(GENERATION_LIMIT) {|i|%> + template , typename A<%=j%><%}%>> + T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); + <%}%> + +private: + void undo_malloc(size_t size); + + template + static void object_destructor(void* obj); + + typedef msgpack_zone base; + +private: + zone(const zone&); +}; + + + +inline zone::zone(size_t chunk_size) +{ + msgpack_zone_init(this, chunk_size); +} + +inline zone::~zone() +{ + msgpack_zone_destroy(this); +} + +inline void* zone::malloc(size_t size) +{ + void* ptr = msgpack_zone_malloc(this, size); + if(!ptr) { + throw std::bad_alloc(); + } + return ptr; +} + +inline void* zone::malloc_no_align(size_t size) +{ + void* ptr = msgpack_zone_malloc_no_align(this, size); + if(!ptr) { + throw std::bad_alloc(); + } + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + if(!msgpack_zone_push_finalizer(this, func, data)) { + throw std::bad_alloc(); + } +} + +template +inline void zone::push_finalizer(std::auto_ptr obj) +{ + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { + throw std::bad_alloc(); + } + obj.release(); +} + +inline void zone::clear() +{ + msgpack_zone_clear(this); +} + +template +void zone::object_destructor(void* obj) +{ + reinterpret_cast(obj)->~T(); +} + +inline void zone::undo_malloc(size_t size) +{ + base::chunk_list.ptr -= size; + base::chunk_list.free += size; +} + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) +{ + void* x = malloc(sizeof(T)); + if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { + undo_malloc(sizeof(T)); + throw std::bad_alloc(); + } + try { + return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); + } catch (...) { + --base::finalizer_array.tail; + undo_malloc(sizeof(T)); + throw; + } +} +<%}%> + +} // namespace msgpack + +#endif /* msgpack/zone.hpp */ + diff --git a/cpp/object.hpp b/cpp/object.hpp deleted file mode 100644 index ed2e290..0000000 --- a/cpp/object.hpp +++ /dev/null @@ -1,329 +0,0 @@ -// -// 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_OBJECT_HPP__ -#define MSGPACK_OBJECT_HPP__ - -#include "msgpack/object.h" -#include "msgpack/pack.hpp" -#include -#include -#include -#include -#include - -namespace msgpack { - - -class type_error : public std::bad_cast { }; - - -namespace type { - enum object_type { - NIL = 0x01, - BOOLEAN = 0x02, - POSITIVE_INTEGER = 0x03, - NEGATIVE_INTEGER = 0x04, - DOUBLE = 0x05, - RAW = 0x06, - ARRAY = 0x07, - MAP = 0x08, - }; -} - - -struct object; -struct object_kv; - -struct object_array { - uint32_t size; - object* ptr; -}; - -struct object_map { - uint32_t size; - object_kv* ptr; -}; - -struct object_raw { - uint32_t size; - const char* ptr; -}; - -struct object { - union union_type { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - object_array array; - object_map map; - object_raw raw; - object_raw ref; // obsolete - }; - - type::object_type type; - union_type via; - - bool is_nil() const { return type == type::NIL; } - - template - T as() const; - - template - void convert(T* v) const; - - object(); - object(msgpack_object obj); - operator msgpack_object(); - -private: - struct implicit_type; - -public: - implicit_type convert() const; -}; - -struct object_kv { - object key; - object val; -}; - -bool operator==(const object x, const object y); -bool operator!=(const object x, const object y); - -std::ostream& operator<< (std::ostream& s, const object o); - - -template -packer& operator<< (packer& o, const T& v); - -template -T& operator>> (object o, T& v); - - -struct object::implicit_type { - implicit_type(object o) : obj(o) { } - ~implicit_type() { } - - template - operator T() { return obj.as(); } - -private: - object obj; -}; - - -// obsolete -template -class define : public Type { -public: - typedef Type msgpack_type; - typedef define define_type; - - define() {} - define(const msgpack_type& v) : msgpack_type(v) {} - - template - void msgpack_pack(Packer& o) const - { - o << static_cast(*this); - } - - void msgpack_unpack(object o) - { - o >> static_cast(*this); - } -}; - - -template -template -inline packer& packer::pack(const T& v) -{ - *this << v; - return *this; -} - -inline object& operator>> (object o, object& v) -{ - v = o; - return v; -} - -template -inline T& operator>> (object o, T& v) -{ - v.msgpack_unpack(o.convert()); - return v; -} - -template -inline packer& operator<< (packer& o, const T& v) -{ - v.msgpack_pack(o); - return o; -} - - -inline bool operator!=(const object x, const object y) -{ return !(x == y); } - - -inline object::object() { } - -inline object::object(msgpack_object obj) -{ - // FIXME beter way? - ::memcpy(this, &obj, sizeof(obj)); -} - -inline object::operator msgpack_object() -{ - // FIXME beter way? - msgpack_object obj; - ::memcpy(&obj, this, sizeof(obj)); - return obj; -} - - -inline object::implicit_type object::convert() const -{ - return implicit_type(*this); -} - -template -inline void object::convert(T* v) const -{ - *this >> *v; -} - -template -inline T object::as() const -{ - T v; - convert(&v); - return v; -} - - -// obsolete -template -inline void convert(T& v, object o) -{ - o.convert(&v); -} - -// obsolete -template -inline void pack(packer& o, const T& v) -{ - o.pack(v); -} - -// obsolete -template -inline void pack_copy(packer& o, T v) -{ - pack(o, v); -} - - -template -packer& operator<< (packer& o, const object& v) -{ - switch(v.type) { - case type::NIL: - o.pack_nil(); - return o; - - case type::BOOLEAN: - if(v.via.boolean) { - o.pack_true(); - } else { - o.pack_false(); - } - return o; - - case type::POSITIVE_INTEGER: - if(v.via.u64 <= (uint64_t)std::numeric_limits::max()) { - if(v.via.u64 <= (uint16_t)std::numeric_limits::max()) { - o.pack_uint8(v.via.u64); - } else { - o.pack_uint16(v.via.u64); - } - } else { - if(v.via.u64 <= (uint64_t)std::numeric_limits::max()) { - o.pack_uint32(v.via.u64); - } else { - o.pack_uint64(v.via.u64); - } - } - return o; - - case type::NEGATIVE_INTEGER: - if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { - if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { - o.pack_int8(v.via.i64); - } else { - o.pack_int16(v.via.i64); - } - } else { - if(v.via.i64 >= (int64_t)std::numeric_limits::min()) { - o.pack_int64(v.via.i64); - } else { - o.pack_int64(v.via.i64); - } - } - return o; - - case type::RAW: - o.pack_raw(v.via.raw.size); - o.pack_raw_body(v.via.raw.ptr, v.via.raw.size); - return o; - - case type::ARRAY: - o.pack_array(v.via.array.size); - for(object* p(v.via.array.ptr), - * const pend(v.via.array.ptr + v.via.array.size); - p < pend; ++p) { - o << *p; - } - return o; - - case type::MAP: - o.pack_map(v.via.map.size); - for(object_kv* p(v.via.map.ptr), - * const pend(v.via.map.ptr + v.via.map.size); - p < pend; ++p) { - o << p->key; - o << p->val; - } - return o; - - default: - throw type_error(); - } -} - - -} // namespace msgpack - -#include "msgpack/type.hpp" - -#endif /* msgpack/object.hpp */ - diff --git a/cpp/pack.hpp b/cpp/pack.hpp deleted file mode 100644 index 9c291c1..0000000 --- a/cpp/pack.hpp +++ /dev/null @@ -1,252 +0,0 @@ -// -// MessagePack for C++ serializing 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_PACK_HPP__ -#define MSGPACK_PACK_HPP__ - -#include "msgpack/pack_define.h" -#include -#include - -namespace msgpack { - - -template -class packer { -public: - packer(Stream& s); - ~packer(); - -public: - template - packer& pack(const T& v); - - packer& pack_uint8(uint8_t d); - packer& pack_uint16(uint16_t d); - packer& pack_uint32(uint32_t d); - packer& pack_uint64(uint64_t d); - packer& pack_int8(uint8_t d); - packer& pack_int16(uint16_t d); - packer& pack_int32(uint32_t d); - packer& pack_int64(uint64_t d); - - packer& pack_short(int d); - packer& pack_int(int d); - packer& pack_long(long d); - packer& pack_long_long(long long d); - packer& pack_unsigned_short(unsigned short d); - packer& pack_unsigned_int(unsigned int d); - packer& pack_unsigned_long(unsigned long d); - packer& pack_unsigned_long_long(unsigned long long d); - - packer& pack_float(float d); - packer& pack_double(double d); - - packer& pack_nil(); - packer& pack_true(); - packer& pack_false(); - - packer& pack_array(unsigned int n); - - packer& pack_map(unsigned int n); - - packer& pack_raw(size_t l); - packer& pack_raw_body(const char* b, size_t l); - -private: - static void _pack_uint8(Stream& x, uint8_t d); - static void _pack_uint16(Stream& x, uint16_t d); - static void _pack_uint32(Stream& x, uint32_t d); - static void _pack_uint64(Stream& x, uint64_t d); - static void _pack_int8(Stream& x, int8_t d); - static void _pack_int16(Stream& x, int16_t d); - static void _pack_int32(Stream& x, int32_t d); - static void _pack_int64(Stream& x, int64_t d); - - static void _pack_short(Stream& x, short d); - static void _pack_int(Stream& x, int d); - static void _pack_long(Stream& x, long d); - static void _pack_long_long(Stream& x, long long d); - static void _pack_unsigned_short(Stream& x, unsigned short d); - static void _pack_unsigned_int(Stream& x, unsigned int d); - static void _pack_unsigned_long(Stream& x, unsigned long d); - static void _pack_unsigned_long_long(Stream& x, unsigned long long d); - - static void _pack_float(Stream& x, float d); - static void _pack_double(Stream& x, double d); - - static void _pack_nil(Stream& x); - static void _pack_true(Stream& x); - static void _pack_false(Stream& x); - - static void _pack_array(Stream& x, unsigned int n); - - static void _pack_map(Stream& x, unsigned int n); - - static void _pack_raw(Stream& x, size_t l); - static void _pack_raw_body(Stream& x, const void* b, size_t l); - - static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len) - { x.write((const char*)buf, len); } - -private: - Stream& m_stream; - -private: - packer(); -}; - - -template -inline void pack(Stream& s, const T& v) -{ - packer(s).pack(v); -} - - -#define msgpack_pack_inline_func(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_inline_func_cint(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_user Stream& - -#define msgpack_pack_append_buffer append_buffer - -#include "msgpack/pack_template.h" - - -template -packer::packer(Stream& s) : m_stream(s) { } - -template -packer::~packer() { } - -template -inline packer& packer::pack_uint8(uint8_t d) -{ _pack_uint8(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint16(uint16_t d) -{ _pack_uint16(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint32(uint32_t d) -{ _pack_uint32(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint64(uint64_t d) -{ _pack_uint64(m_stream, d); return *this; } - -template -inline packer& packer::pack_int8(uint8_t d) -{ _pack_int8(m_stream, d); return *this; } - -template -inline packer& packer::pack_int16(uint16_t d) -{ _pack_int16(m_stream, d); return *this; } - -template -inline packer& packer::pack_int32(uint32_t d) -{ _pack_int32(m_stream, d); return *this; } - -template -inline packer& packer::pack_int64(uint64_t d) -{ _pack_int64(m_stream, d); return *this;} - - -template -inline packer& packer::pack_short(int d) -{ _pack_short(m_stream, d); return *this; } - -template -inline packer& packer::pack_int(int d) -{ _pack_int(m_stream, d); return *this; } - -template -inline packer& packer::pack_long(long d) -{ _pack_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_long_long(long long d) -{ _pack_long_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_short(unsigned short d) -{ _pack_unsigned_short(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_int(unsigned int d) -{ _pack_unsigned_int(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_long(unsigned long d) -{ _pack_unsigned_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_long_long(unsigned long long d) -{ _pack_unsigned_long_long(m_stream, d); return *this; } - - -template -inline packer& packer::pack_float(float d) -{ _pack_float(m_stream, d); return *this; } - -template -inline packer& packer::pack_double(double d) -{ _pack_double(m_stream, d); return *this; } - - -template -inline packer& packer::pack_nil() -{ _pack_nil(m_stream); return *this; } - -template -inline packer& packer::pack_true() -{ _pack_true(m_stream); return *this; } - -template -inline packer& packer::pack_false() -{ _pack_false(m_stream); return *this; } - - -template -inline packer& packer::pack_array(unsigned int n) -{ _pack_array(m_stream, n); return *this; } - - -template -inline packer& packer::pack_map(unsigned int n) -{ _pack_map(m_stream, n); return *this; } - - -template -inline packer& packer::pack_raw(size_t l) -{ _pack_raw(m_stream, l); return *this; } - -template -inline packer& packer::pack_raw_body(const char* b, size_t l) -{ _pack_raw_body(m_stream, b, l); return *this; } - - -} // namespace msgpack - -#endif /* msgpack/pack.hpp */ - diff --git a/cpp/sbuffer.hpp b/cpp/sbuffer.hpp deleted file mode 100644 index ca06884e..0000000 --- a/cpp/sbuffer.hpp +++ /dev/null @@ -1,103 +0,0 @@ -// -// MessagePack for C++ simple buffer implementation -// -// 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_SBUFFER_HPP__ -#define MSGPACK_SBUFFER_HPP__ - -#include "msgpack/sbuffer.h" -#include - -namespace msgpack { - - -class sbuffer : public msgpack_sbuffer { -public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE) - { - base::data = (char*)::malloc(initsz); - if(!base::data) { - throw std::bad_alloc(); - } - - base::size = 0; - base::alloc = initsz; - } - - ~sbuffer() - { - ::free(base::data); - } - -public: - void write(const char* buf, unsigned int len) - { - if(base::alloc - base::size < len) { - expand_buffer(len); - } - memcpy(base::data + base::size, buf, len); - base::size += len; - } - - char* data() - { - return base::data; - } - - const char* data() const - { - return base::data; - } - - size_t size() const - { - return base::size; - } - - char* release() - { - return msgpack_sbuffer_release(this); - } - -private: - void expand_buffer(size_t len) - { - size_t nsize = (base::alloc) ? - base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - - while(nsize < base::size + len) { nsize *= 2; } - - void* tmp = realloc(base::data, nsize); - if(!tmp) { - throw std::bad_alloc(); - } - - base::data = (char*)tmp; - base::alloc = nsize; - } - -private: - typedef msgpack_sbuffer base; - -private: - sbuffer(const sbuffer&); -}; - - -} // namespace msgpack - -#endif /* msgpack/sbuffer.hpp */ - diff --git a/cpp/type.hpp b/cpp/type.hpp deleted file mode 100644 index fafa674..0000000 --- a/cpp/type.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#include "msgpack/type/bool.hpp" -#include "msgpack/type/float.hpp" -#include "msgpack/type/int.hpp" -#include "msgpack/type/list.hpp" -#include "msgpack/type/deque.hpp" -#include "msgpack/type/map.hpp" -#include "msgpack/type/nil.hpp" -#include "msgpack/type/pair.hpp" -#include "msgpack/type/raw.hpp" -#include "msgpack/type/set.hpp" -#include "msgpack/type/string.hpp" -#include "msgpack/type/vector.hpp" -#include "msgpack/type/tuple.hpp" -#include "msgpack/type/define.hpp" - diff --git a/cpp/type/bool.hpp b/cpp/type/bool.hpp deleted file mode 100644 index b945d85..0000000 --- a/cpp/type/bool.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// 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_BOOL_HPP__ -#define MSGPACK_TYPE_BOOL_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -inline bool& operator>> (object o, bool& v) -{ - if(o.type != type::BOOLEAN) { throw type_error(); } - v = o.via.boolean; - return v; -} - -template -inline packer& operator<< (packer& o, const bool& v) -{ - if(v) { o.pack_true(); } - else { o.pack_false(); } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/bool.hpp */ - diff --git a/cpp/type/define.hpp.erb b/cpp/type/define.hpp.erb deleted file mode 100644 index 2eac4f4..0000000 --- a/cpp/type/define.hpp.erb +++ /dev/null @@ -1,98 +0,0 @@ -// -// 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_DEFINE_HPP__ -#define MSGPACK_TYPE_DEFINE_HPP__ - -#define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - } - -namespace msgpack { -namespace type { - - -<% GENERATION_LIMIT = 31 %> -template , typename A<%=i%> = void<%}%>> -struct define; - - -template <> -struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(1); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } -}; -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -struct define, A<%=j%><%}%>> { - typedef define, A<%=j%><%}%>> value_type; - typedef tuple, A<%=j%><%}%>> tuple_type; - define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - pk.pack(a<%=j%>);<%}%> - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - <%0.upto(i) {|j|%> - if(size <= <%=j%>) { return; } o.via.array.ptr[<%=j%>].convert(&a<%=j%>);<%}%> - } - <%0.upto(i) {|j|%> - A<%=j%>& a<%=j%>;<%}%> -}; -<%}%> - -inline define<> make_define() -{ - return define<>(); -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>) -{ - return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); -} -<%}%> - -} // namespace type -} // namespace msgpack - - -#endif /* msgpack/type/define.hpp */ - diff --git a/cpp/type/deque.hpp b/cpp/type/deque.hpp deleted file mode 100644 index d34d243..0000000 --- a/cpp/type/deque.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// -// 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_DEQUE_HPP__ -#define MSGPACK_TYPE_DEQUE_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::deque& operator>> (object o, std::deque& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::deque::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(&*it); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::deque& v) -{ - o.pack_array(v.size()); - for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/deque.hpp */ - diff --git a/cpp/type/float.hpp b/cpp/type/float.hpp deleted file mode 100644 index 390e340..0000000 --- a/cpp/type/float.hpp +++ /dev/null @@ -1,63 +0,0 @@ -// -// 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_FLOAT_HPP__ -#define MSGPACK_TYPE_FLOAT_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -// FIXME check overflow, underflow - - -inline float& operator>> (object o, float& v) -{ - if(o.type != type::DOUBLE) { throw type_error(); } - v = o.via.dec; - return v; -} - -template -inline packer& operator<< (packer& o, const float& v) -{ - o.pack_float(v); - return o; -} - - -inline double& operator>> (object o, double& v) -{ - if(o.type != type::DOUBLE) { throw type_error(); } - v = o.via.dec; - return v; -} - -template -inline packer& operator<< (packer& o, const double& v) -{ - o.pack_double(v); - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/float.hpp */ - diff --git a/cpp/type/int.hpp b/cpp/type/int.hpp deleted file mode 100644 index 03500f7..0000000 --- a/cpp/type/int.hpp +++ /dev/null @@ -1,147 +0,0 @@ -// -// 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_INT_HPP__ -#define MSGPACK_TYPE_INT_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -namespace type { -namespace detail { - template - struct convert_integer_sign; - - template - struct convert_integer_sign { - static inline T convert(object o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) - { throw type_error(); } - return o.via.u64; - } else if(o.type == type::NEGATIVE_INTEGER) { - if(o.via.i64 < (int64_t)std::numeric_limits::min()) - { throw type_error(); } - return o.via.i64; - } - throw type_error(); - } - }; - - template - struct convert_integer_sign { - static inline T convert(object o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) - { throw type_error(); } - return o.via.u64; - } - throw type_error(); - } - }; - - template - static inline T convert_integer(object o) - { - return detail::convert_integer_sign::is_signed>::convert(o); - } - -} // namespace detail -} // namespace type - - -inline signed char& operator>> (object o, signed char& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed short& operator>> (object o, signed short& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed int& operator>> (object o, signed int& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed long& operator>> (object o, signed long& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed long long& operator>> (object o, signed long long& v) - { v = type::detail::convert_integer(o); return v; } - - -inline unsigned char& operator>> (object o, unsigned char& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned short& operator>> (object o, unsigned short& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned int& operator>> (object o, unsigned int& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned long& operator>> (object o, unsigned long& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned long long& operator>> (object o, unsigned long long& v) - { v = type::detail::convert_integer(o); return v; } - - -template -inline packer& operator<< (packer& o, const signed char& v) - { o.pack_int8(v); return o; } - -template -inline packer& operator<< (packer& o, const signed short& v) - { o.pack_short(v); return o; } - -template -inline packer& operator<< (packer& o, const signed int& v) - { o.pack_int(v); return o; } - -template -inline packer& operator<< (packer& o, const signed long& v) - { o.pack_long(v); return o; } - -template -inline packer& operator<< (packer& o, const signed long long& v) - { o.pack_long_long(v); return o; } - - -template -inline packer& operator<< (packer& o, const unsigned char& v) - { o.pack_uint8(v); return o; } - -template -inline packer& operator<< (packer& o, const unsigned short& v) - { o.pack_unsigned_short(v); return o; } - -template -inline packer& operator<< (packer& o, const unsigned int& v) - { o.pack_unsigned_int(v); return o; } - -template -inline packer& operator<< (packer& o, const unsigned long& v) - { o.pack_unsigned_long(v); return o; } - -template -inline packer& operator<< (packer& o, const unsigned long long& v) - { o.pack_unsigned_long_long(v); return o; } - - -} // namespace msgpack - -#endif /* msgpack/type/int.hpp */ - diff --git a/cpp/type/list.hpp b/cpp/type/list.hpp deleted file mode 100644 index 6ecc02f..0000000 --- a/cpp/type/list.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// -// 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_LIST_HPP__ -#define MSGPACK_TYPE_LIST_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::list& operator>> (object o, std::list& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::list::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(&*it); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::list& v) -{ - o.pack_array(v.size()); - for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/list.hpp */ - diff --git a/cpp/type/map.hpp b/cpp/type/map.hpp deleted file mode 100644 index 552de57..0000000 --- a/cpp/type/map.hpp +++ /dev/null @@ -1,139 +0,0 @@ -// -// 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 -#include -#include - -namespace msgpack { - - -namespace type { - -template -class assoc_vector : public std::vector< std::pair > {}; - -namespace detail { - template - struct pair_first_less { - bool operator() (const std::pair& x, const std::pair& y) const - { return x.first < y.first; } - }; -} - -} //namespace type - - -template -inline type::assoc_vector& operator>> (object o, type::assoc_vector& 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* 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()); - return v; -} - -template -inline packer& operator<< (packer& o, const type::assoc_vector& v) -{ - o.pack_map(v.size()); - for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - - -template -inline std::map operator>> (object o, std::map& 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::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(key, val)); - } - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::map& v) -{ - o.pack_map(v.size()); - for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - - -template -inline std::multimap operator>> (object o, std::multimap& 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 value; - p->key.convert(&value.first); - p->val.convert(&value.second); - v.insert(value); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::multimap& v) -{ - o.pack_map(v.size()); - for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/map.hpp */ - diff --git a/cpp/type/nil.hpp b/cpp/type/nil.hpp deleted file mode 100644 index 93e66ff..0000000 --- a/cpp/type/nil.hpp +++ /dev/null @@ -1,49 +0,0 @@ -// -// 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 -inline packer& operator<< (packer& o, const type::nil& v) -{ - o.pack_nil(); - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/nil.hpp */ - diff --git a/cpp/type/pair.hpp b/cpp/type/pair.hpp deleted file mode 100644 index ba72c1f..0000000 --- a/cpp/type/pair.hpp +++ /dev/null @@ -1,50 +0,0 @@ -// -// 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 - -namespace msgpack { - - -template -inline std::pair& operator>> (object o, std::pair& 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 -inline packer& operator<< (packer& o, const std::pair& v) -{ - o.pack_array(2); - o.pack(v.first); - o.pack(v.second); - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/pair.hpp */ - diff --git a/cpp/type/raw.hpp b/cpp/type/raw.hpp deleted file mode 100644 index 8c68aba..0000000 --- a/cpp/type/raw.hpp +++ /dev/null @@ -1,84 +0,0 @@ -// -// 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 -#include - -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() { return std::string(ptr, size); } - - bool operator== (const raw_ref& x) - { - return size == x.size && memcmp(ptr, x.ptr, size) == 0; - } - - bool operator!= (const raw_ref& x) - { - return !(*this != x); - } - - bool operator< (const raw_ref& x) - { - if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; } - else { return size < x.size; } - } - - bool operator> (const raw_ref& x) - { - 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 -inline packer& operator<< (packer& o, const type::raw_ref& v) -{ - o.pack_raw(v.size); - o.pack_raw_body(v.ptr, v.size); - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/raw.hpp */ - diff --git a/cpp/type/set.hpp b/cpp/type/set.hpp deleted file mode 100644 index f2c5bfb..0000000 --- a/cpp/type/set.hpp +++ /dev/null @@ -1,80 +0,0 @@ -// -// 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 - -namespace msgpack { - - -template -inline std::set& operator>> (object o, std::set& 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()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::set& v) -{ - o.pack_array(v.size()); - for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -template -inline std::multiset& operator>> (object o, std::multiset& 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()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::multiset& v) -{ - o.pack_array(v.size()); - for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/set.hpp */ - diff --git a/cpp/type/string.hpp b/cpp/type/string.hpp deleted file mode 100644 index a085d53..0000000 --- a/cpp/type/string.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// 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 - -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 -inline packer& operator<< (packer& o, const std::string& v) -{ - o.pack_raw(v.size()); - o.pack_raw_body(v.data(), v.size()); - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/string.hpp */ - diff --git a/cpp/type/tr1/unordered_map.hpp b/cpp/type/tr1/unordered_map.hpp deleted file mode 100644 index 1996cfd..0000000 --- a/cpp/type/tr1/unordered_map.hpp +++ /dev/null @@ -1,85 +0,0 @@ -// -// 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_TR1_UNORDERED_MAP_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::tr1::unordered_map operator>> (object o, std::tr1::unordered_map& 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); - p->val.convert(&v[key]); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::tr1::unordered_map& v) -{ - o.pack_map(v.size()); - for(typename std::tr1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - - -template -inline std::tr1::unordered_multimap operator>> (object o, std::tr1::unordered_multimap& 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 value; - p->key.convert(&value.first); - p->val.convert(&value.second); - v.insert(value); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::tr1::unordered_multimap& v) -{ - o.pack_map(v.size()); - for(typename std::tr1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/map.hpp */ - diff --git a/cpp/type/tr1/unordered_set.hpp b/cpp/type/tr1/unordered_set.hpp deleted file mode 100644 index eb127b5..0000000 --- a/cpp/type/tr1/unordered_set.hpp +++ /dev/null @@ -1,80 +0,0 @@ -// -// 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_TR1_UNORDERED_SET_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::tr1::unordered_set& operator>> (object o, std::tr1::unordered_set& 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()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::tr1::unordered_set& v) -{ - o.pack_array(v.size()); - for(typename std::tr1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -template -inline std::tr1::unordered_multiset& operator>> (object o, std::tr1::unordered_multiset& 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()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::tr1::unordered_multiset& v) -{ - o.pack_array(v.size()); - for(typename std::tr1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/set.hpp */ - diff --git a/cpp/type/tuple.hpp.erb b/cpp/type/tuple.hpp.erb deleted file mode 100644 index 2930ae0..0000000 --- a/cpp/type/tuple.hpp.erb +++ /dev/null @@ -1,171 +0,0 @@ -// -// 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_TUPLE_HPP__ -#define MSGPACK_TYPE_TUPLE_HPP__ - -#include "msgpack/object.hpp" - -namespace msgpack { - -namespace type { - -// FIXME operator== -// FIXME operator!= -<% GENERATION_LIMIT = 31 %> - -template , typename A<%=i%> = void<%}%>> -struct tuple; - -template -struct tuple_element; - -template -struct const_tuple_element; - -template -struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -<%0.upto(GENERATION_LIMIT) {|i|%> -<%0.upto(i) {|j|%> -template , typename A<%=k%><%}%>> -struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - tuple_element(tuple, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::reference get() { return _x; } - typename tuple_type>::const_reference get() const { return _x; } -private: - typename tuple_type>::reference _x; -}; -<%}%> -<%}%> - -<%0.upto(GENERATION_LIMIT) {|i|%> -<%0.upto(i) {|j|%> -template , typename A<%=k%><%}%>> -struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - const_tuple_element(const tuple, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::const_reference get() const { return _x; } -private: - typename tuple_type>::const_reference _x; -}; -<%}%> -<%}%> - -template <> -struct tuple<> { - tuple() {} - tuple(object o) { o.convert(this); } - typedef tuple<> value_type; -}; -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -struct tuple, A<%=j%><%}%>> { - typedef tuple, A<%=j%><%}%>> value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - <%0.upto(i) {|j|%> - A<%=j%> a<%=j%>;<%}%> -}; -<%}%> - -inline tuple<> make_tuple() -{ - return tuple<>(); -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) -{ - return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); -} -<%}%> - -} // namespace type - - -inline type::tuple<>& operator>> ( - object o, - type::tuple<>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - return v; -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -type::tuple, A<%=j%><%}%>>& operator>> ( - object o, - type::tuple, A<%=j%><%}%>>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < <%=i+1%>) { throw type_error(); } - <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>].convert>(&v.template get<<%=j%>>());<%}%> - return v; -} -<%}%> - -template -const packer& operator<< ( - packer& o, - const type::tuple<>& v) { - o.pack_array(0); - return o; -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -const packer& operator<< ( - packer& o, - const type::tuple, A<%=j%><%}%>>& v) { - o.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - o.pack(v.template get<<%=j%>>());<%}%> - return o; -} -<%}%> - -} // namespace msgpack - -#endif /* msgpack/type/tuple.hpp */ - diff --git a/cpp/type/vector.hpp b/cpp/type/vector.hpp deleted file mode 100644 index 385d070..0000000 --- a/cpp/type/vector.hpp +++ /dev/null @@ -1,60 +0,0 @@ -// -// 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_VECTOR_HPP__ -#define MSGPACK_TYPE_VECTOR_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::vector& operator>> (object o, std::vector& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - if(o.via.array.size > 0) { - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - T* it = &v[0]; - do { - p->convert(it); - ++p; - ++it; - } while(p < pend); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::vector& v) -{ - o.pack_array(v.size()); - for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - - -} // namespace msgpack - -#endif /* msgpack/type/vector.hpp */ - diff --git a/cpp/unpack.hpp b/cpp/unpack.hpp deleted file mode 100644 index 324111a..0000000 --- a/cpp/unpack.hpp +++ /dev/null @@ -1,301 +0,0 @@ -// -// MessagePack for C++ deserializing 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_UNPACK_HPP__ -#define MSGPACK_UNPACK_HPP__ - -#include "msgpack/unpack.h" -#include "msgpack/object.hpp" -#include "msgpack/zone.hpp" -#include -#include - -#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE -#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE (32*1024) -#endif - -namespace msgpack { - - -struct unpack_error : public std::runtime_error { - unpack_error(const std::string& msg) : - std::runtime_error(msg) { } -}; - - -class unpacker : public msgpack_unpacker { -public: - unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE); - ~unpacker(); - -public: - /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ - void reserve_buffer(size_t size); - - /*! 2. read data to the buffer() up to buffer_capacity() bytes */ - char* buffer(); - size_t buffer_capacity() const; - - /*! 3. specify the number of bytes actually copied */ - void buffer_consumed(size_t size); - - /*! 4. repeat execute() until it retunrs false */ - bool execute(); - - /*! 5.1. if execute() returns true, take out the parsed object */ - object data(); - - /*! 5.2. the object is valid until the zone is deleted */ - // Note that once release_zone() from unpacker, you must delete it - // otherwise the memrory will leak. - zone* release_zone(); - - /*! 5.2. this method is equivalence to `delete release_zone()` */ - void reset_zone(); - - /*! 5.3. after release_zone(), re-initialize unpacker */ - void reset(); - - /*! 6. check if the size of message doesn't exceed assumption. */ - size_t message_size() const; - - - // Basic usage of the unpacker is as following: - // - // msgpack::unpacker pac; - // - // while( /* readable */ ) { - // - // // 1. - // pac.reserve(1024); - // - // // 2. - // ssize_t bytes = - // read(the_source, pac.buffer(), pac.buffer_capacity()); - // - // // error handling ... - // - // // 3. - // pac.buffer_consumed(bytes); - // - // // 4. - // while(pac.execute()) { - // // 5.1 - // object o = pac.data(); - // - // // 5.2 - // std::auto_ptr olife( pac.release_zone() ); - // - // // boost::shared_ptr is also usable: - // // boost::shared_ptr olife( pac.release_zone() ); - // - // // 5.3 - // pac.reset(); - // - // // do some with the object with the old zone. - // do_something(o, olife); - // } - // } - // - -public: - // These functions are usable when non-MessagePack message follows after - // MessagePack message. - size_t parsed_size() const; - - /*! get address of the buffer that is not parsed */ - char* nonparsed_buffer(); - size_t nonparsed_size() const; - - /*! skip specified size of non-parsed buffer, leaving the buffer */ - // Note that the `size' argument must be smaller than nonparsed_size() - void skip_nonparsed_buffer(size_t size); - - /*! remove unparsed buffer from unpacker */ - // Note that reset() leaves non-parsed buffer. - void remove_nonparsed_buffer(); - -private: - typedef msgpack_unpacker base; - -private: - unpacker(const unpacker&); -}; - - -typedef enum { - UNPACK_SUCCESS = 2, - UNPACK_EXTRA_BYTES = 1, - UNPACK_CONTINUE = 0, - UNPACK_PARSE_ERROR = -1, -} unpack_return; - -static unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result); - - -// obsolete -static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); - - -inline unpacker::unpacker(size_t initial_buffer_size) -{ - if(!msgpack_unpacker_init(this, initial_buffer_size)) { - throw std::bad_alloc(); - } -} - -inline unpacker::~unpacker() -{ - msgpack_unpacker_destroy(this); -} - - -inline void unpacker::reserve_buffer(size_t size) -{ - if(!msgpack_unpacker_reserve_buffer(this, size)) { - throw std::bad_alloc(); - } -} - -inline char* unpacker::buffer() -{ - return msgpack_unpacker_buffer(this); -} - -inline size_t unpacker::buffer_capacity() const -{ - return msgpack_unpacker_buffer_capacity(this); -} - -inline void unpacker::buffer_consumed(size_t size) -{ - return msgpack_unpacker_buffer_consumed(this, size); -} - - -inline bool unpacker::execute() -{ - int ret = msgpack_unpacker_execute(this); - if(ret < 0) { - throw unpack_error("parse error"); - } else if(ret == 0) { - return false; - } else { - return true; - } -} - -inline object unpacker::data() -{ - return msgpack_unpacker_data(this); -} - -inline zone* unpacker::release_zone() -{ - if(!msgpack_unpacker_flush_zone(this)) { - throw std::bad_alloc(); - } - - zone* r = new zone(); - - msgpack_zone old = *base::z; - *base::z = *r; - *static_cast(r) = old; - - return r; -} - -inline void unpacker::reset_zone() -{ - msgpack_unpacker_reset_zone(this); -} - -inline void unpacker::reset() -{ - msgpack_unpacker_reset(this); -} - -inline size_t unpacker::message_size() const -{ - return msgpack_unpacker_message_size(this); -} - - -inline size_t unpacker::parsed_size() const -{ - return msgpack_unpacker_parsed_size(this); -} - -inline char* unpacker::nonparsed_buffer() -{ - return base::buffer + base::off; -} - -inline size_t unpacker::nonparsed_size() const -{ - return base::used - base::off; -} - -inline void unpacker::skip_nonparsed_buffer(size_t size) -{ - base::off += size; -} - -inline void unpacker::remove_nonparsed_buffer() -{ - base::used = base::off; -} - - -inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result) -{ - return (unpack_return)msgpack_unpack(data, len, off, - z, reinterpret_cast(result)); -} - -// obsolete -inline object unpack(const char* data, size_t len, zone& z, size_t* off) -{ - object result; - - switch( msgpack::unpack(data, len, off, &z, &result) ) { - case UNPACK_SUCCESS: - return result; - - case UNPACK_EXTRA_BYTES: - if(off) { - return result; - } else { - throw unpack_error("extra bytes"); - } - - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); - - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } -} - - -} // namespace msgpack - -#endif /* msgpack/unpack.hpp */ - diff --git a/cpp/vrefbuffer.hpp b/cpp/vrefbuffer.hpp deleted file mode 100644 index c8eca7b..0000000 --- a/cpp/vrefbuffer.hpp +++ /dev/null @@ -1,92 +0,0 @@ -// -// MessagePack for C++ zero-copy buffer implementation -// -// 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_VREFBUFFER_HPP__ -#define MSGPACK_VREFBUFFER_HPP__ - -#include "msgpack/vrefbuffer.h" -#include - -namespace msgpack { - - -class vrefbuffer : public msgpack_vrefbuffer { -public: - vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, - size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - { - msgpack_vrefbuffer_init(this, ref_size, chunk_size); - } - - ~vrefbuffer() - { - msgpack_vrefbuffer_destroy(this); - } - -public: - void write(const char* buf, unsigned int len) - { - if(len < base::ref_size) { - append_copy(buf, len); - } else { - append_ref(buf, len); - } - } - - void append_ref(const char* buf, size_t len) - { - if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) { - throw std::bad_alloc(); - } - } - - void append_copy(const char* buf, size_t len) - { - if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) { - throw std::bad_alloc(); - } - } - - const struct iovec* vector() const - { - return msgpack_vrefbuffer_vec(this); - } - - size_t vector_size() const - { - return msgpack_vrefbuffer_veclen(this); - } - - void migrate(vrefbuffer* to) - { - if(msgpack_vrefbuffer_migrate(this, to) < 0) { - throw std::bad_alloc(); - } - } - -private: - typedef msgpack_vrefbuffer base; - -private: - vrefbuffer(const vrefbuffer&); -}; - - -} // namespace msgpack - -#endif /* msgpack/vrefbuffer.hpp */ - diff --git a/cpp/zone.hpp.erb b/cpp/zone.hpp.erb deleted file mode 100644 index 48988ab..0000000 --- a/cpp/zone.hpp.erb +++ /dev/null @@ -1,149 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// 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_ZONE_HPP__ -#define MSGPACK_ZONE_HPP__ - -#include "msgpack/object.hpp" -#include "msgpack/zone.h" -#include -#include -#include - -<% GENERATION_LIMIT = 15 %> -namespace msgpack { - - -class zone : public msgpack_zone { -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); - ~zone(); - -public: - void* malloc(size_t size); - void* malloc_no_align(size_t size); - - void push_finalizer(void (*func)(void*), void* data); - - template - void push_finalizer(std::auto_ptr obj); - - void clear(); - - <%0.upto(GENERATION_LIMIT) {|i|%> - template , typename A<%=j%><%}%>> - T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); - <%}%> - -private: - void undo_malloc(size_t size); - - template - static void object_destructor(void* obj); - - typedef msgpack_zone base; - -private: - zone(const zone&); -}; - - - -inline zone::zone(size_t chunk_size) -{ - msgpack_zone_init(this, chunk_size); -} - -inline zone::~zone() -{ - msgpack_zone_destroy(this); -} - -inline void* zone::malloc(size_t size) -{ - void* ptr = msgpack_zone_malloc(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void* zone::malloc_no_align(size_t size) -{ - void* ptr = msgpack_zone_malloc_no_align(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void zone::push_finalizer(void (*func)(void*), void* data) -{ - if(!msgpack_zone_push_finalizer(this, func, data)) { - throw std::bad_alloc(); - } -} - -template -inline void zone::push_finalizer(std::auto_ptr obj) -{ - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { - throw std::bad_alloc(); - } - obj.release(); -} - -inline void zone::clear() -{ - msgpack_zone_clear(this); -} - -template -void zone::object_destructor(void* obj) -{ - reinterpret_cast(obj)->~T(); -} - -inline void zone::undo_malloc(size_t size) -{ - base::chunk_list.ptr -= size; - base::chunk_list.free += size; -} - -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} -<%}%> - -} // namespace msgpack - -#endif /* msgpack/zone.hpp */ - -- cgit v1.2.1