| // | |
| // MessagePack for C++ static resolution routine | |
| // | |
| // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi | |
| // | |
| // Distributed under the Boost Software License, Version 1.0. | |
| // (See accompanying file LICENSE_1_0.txt or copy at | |
| // http://www.boost.org/LICENSE_1_0.txt) | |
| // | |
| #ifndef MSGPACK_OBJECT_HPP | |
| #define MSGPACK_OBJECT_HPP | |
| #include "msgpack/versioning.hpp" | |
| #include "msgpack/pack.hpp" | |
| #include "msgpack/zone.hpp" | |
| #include "msgpack/adaptor/adaptor_base.hpp" | |
| #include <cstring> | |
| #include <stdexcept> | |
| #include <typeinfo> | |
| #include <limits> | |
| #include <ostream> | |
| #include <typeinfo> | |
| #include <iomanip> | |
| namespace msgpack { | |
| /// @cond | |
| MSGPACK_API_VERSION_NAMESPACE(v1) { | |
| /// @endcond | |
| /// The class holds object and zone | |
| class object_handle { | |
| public: | |
| /// Constructor that creates nil object and null zone. | |
| object_handle() {} | |
| /// Constructor that creates an object_handle holding object `obj` and zone `z`. | |
| /** | |
| * @param obj object | |
| * @param z zone | |
| */ | |
| object_handle(msgpack::object const& obj, msgpack::unique_ptr<msgpack::zone> z) : | |
| m_obj(obj), m_zone(msgpack::move(z)) { } | |
| // obsolete | |
| void set(msgpack::object const& obj) | |
| { m_obj = obj; } | |
| /// Get object reference | |
| /** | |
| * @return object | |
| */ | |
| const msgpack::object& get() const | |
| { return m_obj; } | |
| /// Get unique_ptr reference of zone. | |
| /** | |
| * @return unique_ptr reference of zone | |
| */ | |
| msgpack::unique_ptr<msgpack::zone>& zone() | |
| { return m_zone; } | |
| /// Get unique_ptr const reference of zone. | |
| /** | |
| * @return unique_ptr const reference of zone | |
| */ | |
| const msgpack::unique_ptr<msgpack::zone>& zone() const | |
| { return m_zone; } | |
| #if defined(MSGPACK_USE_CPP03) | |
| struct object_handle_ref { | |
| object_handle_ref(object_handle* oh):m_oh(oh) {} | |
| object_handle* m_oh; | |
| }; | |
| object_handle(object_handle& other): | |
| m_obj(other.m_obj), | |
| m_zone(msgpack::move(other.m_zone)) { | |
| } | |
| object_handle(object_handle_ref ref): | |
| m_obj(ref.m_oh->m_obj), | |
| m_zone(msgpack::move(ref.m_oh->m_zone)) { | |
| } | |
| object_handle& operator=(object_handle& other) { | |
| m_obj = other.m_obj; | |
| m_zone = msgpack::move(other.m_zone); | |
| return *this; | |
| } | |
| object_handle& operator=(object_handle_ref ref) { | |
| m_obj = ref.m_oh->m_obj; | |
| m_zone = msgpack::move(ref.m_oh->m_zone); | |
| return *this; | |
| } | |
| operator object_handle_ref() { | |
| return object_handle_ref(this); | |
| } | |
| #endif // defined(MSGPACK_USE_CPP03) | |
| private: | |
| msgpack::object m_obj; | |
| msgpack::unique_ptr<msgpack::zone> m_zone; | |
| }; | |
| namespace detail { | |
| template <std::size_t N> | |
| inline std::size_t add_ext_type_size(std::size_t size) { | |
| return size + 1; | |
| } | |
| template <> | |
| inline std::size_t add_ext_type_size<4>(std::size_t size) { | |
| return size == 0xffffffff ? size : size + 1; | |
| } | |
| } // namespace detail | |
| inline std::size_t aligned_zone_size(msgpack::object const& obj) { | |
| std::size_t s = 0; | |
| switch (obj.type) { | |
| case msgpack::type::ARRAY: | |
| s += sizeof(msgpack::object) * obj.via.array.size; | |
| for (uint32_t i = 0; i < obj.via.array.size; ++i) { | |
| s += msgpack::aligned_zone_size(obj.via.array.ptr[i]); | |
| } | |
| break; | |
| case msgpack::type::MAP: | |
| s += sizeof(msgpack::object_kv) * obj.via.map.size; | |
| for (uint32_t i = 0; i < obj.via.map.size; ++i) { | |
| s += msgpack::aligned_zone_size(obj.via.map.ptr[i].key); | |
| s += msgpack::aligned_zone_size(obj.via.map.ptr[i].val); | |
| } | |
| break; | |
| case msgpack::type::EXT: | |
| s += msgpack::aligned_size( | |
| detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size)); | |
| break; | |
| case msgpack::type::STR: | |
| s += msgpack::aligned_size(obj.via.str.size); | |
| break; | |
| case msgpack::type::BIN: | |
| s += msgpack::aligned_size(obj.via.bin.size); | |
| break; | |
| default: | |
| break; | |
| } | |
| return s; | |
| } | |
| /// clone object | |
| /** | |
| * Clone (deep copy) object. | |
| * The copied object is located on newly allocated zone. | |
| * @param obj copy source object | |
| * | |
| * @return object_handle that holds deep copied object and zone. | |
| */ | |
| inline object_handle clone(msgpack::object const& obj) { | |
| std::size_t size = msgpack::aligned_zone_size(obj); | |
| msgpack::unique_ptr<msgpack::zone> z(size == 0 ? nullptr : new msgpack::zone(size)); | |
| msgpack::object newobj = z.get() ? msgpack::object(obj, *z) : obj; | |
| return object_handle(newobj, msgpack::move(z)); | |
| } | |
| struct object::implicit_type { | |
| implicit_type(object const& o) : obj(o) { } | |
| ~implicit_type() { } | |
| template <typename T> | |
| operator T() { return obj.as<T>(); } | |
| private: | |
| msgpack::object const& obj; | |
| }; | |
| namespace detail { | |
| template <typename Stream, typename T> | |
| struct packer_serializer { | |
| static msgpack::packer<Stream>& pack(msgpack::packer<Stream>& o, const T& v) { | |
| v.msgpack_pack(o); | |
| return o; | |
| } | |
| }; | |
| } // namespace detail | |
| // Adaptor functors' member functions definitions. | |
| template <typename T, typename Enabler> | |
| inline | |
| msgpack::object const& | |
| msgpack::adaptor::convert<T, Enabler>::operator()(msgpack::object const& o, T& v) const { | |
| v.msgpack_unpack(o.convert()); | |
| return o; | |
| } | |
| template <typename T, typename Enabler> | |
| template <typename Stream> | |
| inline | |
| msgpack::packer<Stream>& | |
| msgpack::adaptor::pack<T, Enabler>::operator()(msgpack::packer<Stream>& o, T const& v) const { | |
| return msgpack::detail::packer_serializer<Stream, T>::pack(o, v); | |
| } | |
| template <typename T, typename Enabler> | |
| inline | |
| void | |
| msgpack::adaptor::object_with_zone<T, Enabler>::operator()(msgpack::object::with_zone& o, T const& v) const { | |
| v.msgpack_object(static_cast<msgpack::object*>(&o), o.zone); | |
| } | |
| // Adaptor functor specialization to object | |
| namespace adaptor { | |
| template <> | |
| struct convert<msgpack::object> { | |
| msgpack::object const& operator()(msgpack::object const& o, msgpack::object& v) const { | |
| v = o; | |
| return o; | |
| } | |
| }; | |
| template <> | |
| struct pack<msgpack::object> { | |
| template <typename Stream> | |
| msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, msgpack::object const& v) const { | |
| switch(v.type) { | |
| case msgpack::type::NIL: | |
| o.pack_nil(); | |
| return o; | |
| case msgpack::type::BOOLEAN: | |
| if(v.via.boolean) { | |
| o.pack_true(); | |
| } else { | |
| o.pack_false(); | |
| } | |
| return o; | |
| case msgpack::type::POSITIVE_INTEGER: | |
| o.pack_uint64(v.via.u64); | |
| return o; | |
| case msgpack::type::NEGATIVE_INTEGER: | |
| o.pack_int64(v.via.i64); | |
| return o; | |
| case msgpack::type::FLOAT: | |
| o.pack_double(v.via.f64); | |
| return o; | |
| case msgpack::type::STR: | |
| o.pack_str(v.via.str.size); | |
| o.pack_str_body(v.via.str.ptr, v.via.str.size); | |
| return o; | |
| case msgpack::type::BIN: | |
| o.pack_bin(v.via.bin.size); | |
| o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); | |
| return o; | |
| case msgpack::type::EXT: | |
| o.pack_ext(v.via.ext.size, v.via.ext.type()); | |
| o.pack_ext_body(v.via.ext.data(), v.via.ext.size); | |
| return o; | |
| case msgpack::type::ARRAY: | |
| o.pack_array(v.via.array.size); | |
| for(msgpack::object* p(v.via.array.ptr), | |
| * const pend(v.via.array.ptr + v.via.array.size); | |
| p < pend; ++p) { | |
| msgpack::operator<<(o, *p); | |
| } | |
| return o; | |
| case msgpack::type::MAP: | |
| o.pack_map(v.via.map.size); | |
| for(msgpack::object_kv* p(v.via.map.ptr), | |
| * const pend(v.via.map.ptr + v.via.map.size); | |
| p < pend; ++p) { | |
| msgpack::operator<<(o, p->key); | |
| msgpack::operator<<(o, p->val); | |
| } | |
| return o; | |
| default: | |
| throw msgpack::type_error(); | |
| } | |
| } | |
| }; | |
| template <> | |
| struct object_with_zone<msgpack::object> { | |
| void operator()(msgpack::object::with_zone& o, msgpack::object const& v) const { | |
| o.type = v.type; | |
| switch(v.type) { | |
| case msgpack::type::NIL: | |
| case msgpack::type::BOOLEAN: | |
| case msgpack::type::POSITIVE_INTEGER: | |
| case msgpack::type::NEGATIVE_INTEGER: | |
| case msgpack::type::FLOAT: | |
| std::memcpy(&o.via, &v.via, sizeof(v.via)); | |
| return; | |
| case msgpack::type::STR: { | |
| char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size)); | |
| o.via.str.ptr = ptr; | |
| o.via.str.size = v.via.str.size; | |
| std::memcpy(ptr, v.via.str.ptr, v.via.str.size); | |
| return; | |
| } | |
| case msgpack::type::BIN: { | |
| char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size)); | |
| o.via.bin.ptr = ptr; | |
| o.via.bin.size = v.via.bin.size; | |
| std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size); | |
| return; | |
| } | |
| case msgpack::type::EXT: { | |
| char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1)); | |
| o.via.ext.ptr = ptr; | |
| o.via.ext.size = v.via.ext.size; | |
| std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1); | |
| return; | |
| } | |
| case msgpack::type::ARRAY: | |
| o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * v.via.array.size)); | |
| o.via.array.size = v.via.array.size; | |
| for (msgpack::object | |
| * po(o.via.array.ptr), | |
| * pv(v.via.array.ptr), | |
| * const pvend(v.via.array.ptr + v.via.array.size); | |
| pv < pvend; | |
| ++po, ++pv) { | |
| new (po) msgpack::object(*pv, o.zone); | |
| } | |
| return; | |
| case msgpack::type::MAP: | |
| o.via.map.ptr = (msgpack::object_kv*)o.zone.allocate_align(sizeof(msgpack::object_kv) * v.via.map.size); | |
| o.via.map.size = v.via.map.size; | |
| for(msgpack::object_kv | |
| * po(o.via.map.ptr), | |
| * pv(v.via.map.ptr), | |
| * const pvend(v.via.map.ptr + v.via.map.size); | |
| pv < pvend; | |
| ++po, ++pv) { | |
| msgpack::object_kv* kv = new (po) msgpack::object_kv; | |
| new (&kv->key) msgpack::object(pv->key, o.zone); | |
| new (&kv->val) msgpack::object(pv->val, o.zone); | |
| } | |
| return; | |
| default: | |
| throw msgpack::type_error(); | |
| } | |
| } | |
| }; | |
| // Adaptor functor specialization to object::with_zone | |
| template <> | |
| struct object_with_zone<msgpack::object::with_zone> { | |
| void operator()( | |
| msgpack::object::with_zone& o, | |
| msgpack::object::with_zone const& v) const { | |
| o << static_cast<msgpack::object const&>(v); | |
| } | |
| }; | |
| } // namespace adaptor | |
| // obsolete | |
| template <typename Type> | |
| class define : public Type { | |
| public: | |
| typedef Type msgpack_type; | |
| typedef define<Type> define_type; | |
| define() {} | |
| define(const msgpack_type& v) : msgpack_type(v) {} | |
| template <typename Packer> | |
| void msgpack_pack(Packer& o) const | |
| { | |
| msgpack::operator<<(o, static_cast<const msgpack_type&>(*this)); | |
| } | |
| void msgpack_unpack(object const& o) | |
| { | |
| msgpack::operator>>(o, static_cast<msgpack_type&>(*this)); | |
| } | |
| }; | |
| // deconvert operator | |
| template <typename Stream> | |
| template <typename T> | |
| inline msgpack::packer<Stream>& packer<Stream>::pack(const T& v) | |
| { | |
| msgpack::operator<<(*this, v); | |
| return *this; | |
| } | |
| inline bool operator==(const msgpack::object& x, const msgpack::object& y) | |
| { | |
| if(x.type != y.type) { return false; } | |
| switch(x.type) { | |
| case msgpack::type::NIL: | |
| return true; | |
| case msgpack::type::BOOLEAN: | |
| return x.via.boolean == y.via.boolean; | |
| case msgpack::type::POSITIVE_INTEGER: | |
| return x.via.u64 == y.via.u64; | |
| case msgpack::type::NEGATIVE_INTEGER: | |
| return x.via.i64 == y.via.i64; | |
| case msgpack::type::FLOAT: | |
| return x.via.f64 == y.via.f64; | |
| case msgpack::type::STR: | |
| return x.via.str.size == y.via.str.size && | |
| std::memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; | |
| case msgpack::type::BIN: | |
| return x.via.bin.size == y.via.bin.size && | |
| std::memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; | |
| case msgpack::type::EXT: | |
| return x.via.ext.size == y.via.ext.size && | |
| std::memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; | |
| case msgpack::type::ARRAY: | |
| if(x.via.array.size != y.via.array.size) { | |
| return false; | |
| } else if(x.via.array.size == 0) { | |
| return true; | |
| } else { | |
| msgpack::object* px = x.via.array.ptr; | |
| msgpack::object* const pxend = x.via.array.ptr + x.via.array.size; | |
| msgpack::object* py = y.via.array.ptr; | |
| do { | |
| if(!(*px == *py)) { | |
| return false; | |
| } | |
| ++px; | |
| ++py; | |
| } while(px < pxend); | |
| return true; | |
| } | |
| case msgpack::type::MAP: | |
| if(x.via.map.size != y.via.map.size) { | |
| return false; | |
| } else if(x.via.map.size == 0) { | |
| return true; | |
| } else { | |
| msgpack::object_kv* px = x.via.map.ptr; | |
| msgpack::object_kv* const pxend = x.via.map.ptr + x.via.map.size; | |
| msgpack::object_kv* py = y.via.map.ptr; | |
| do { | |
| if(!(px->key == py->key) || !(px->val == py->val)) { | |
| return false; | |
| } | |
| ++px; | |
| ++py; | |
| } while(px < pxend); | |
| return true; | |
| } | |
| default: | |
| return false; | |
| } | |
| } | |
| template <typename T> | |
| inline bool operator==(const msgpack::object& x, const T& y) | |
| try { | |
| return x == msgpack::object(y); | |
| } catch (msgpack::type_error&) { | |
| return false; | |
| } | |
| inline bool operator!=(const msgpack::object& x, const msgpack::object& y) | |
| { return !(x == y); } | |
| template <typename T> | |
| inline bool operator==(const T& y, const msgpack::object& x) | |
| { return x == y; } | |
| template <typename T> | |
| inline bool operator!=(const msgpack::object& x, const T& y) | |
| { return !(x == y); } | |
| template <typename T> | |
| inline bool operator!=(const T& y, const msgpack::object& x) | |
| { return x != y; } | |
| inline msgpack::object::implicit_type object::convert() const | |
| { | |
| return msgpack::object::implicit_type(*this); | |
| } | |
| template <typename T> | |
| inline T& object::convert(T& v) const | |
| { | |
| msgpack::operator>>(*this, v); | |
| return v; | |
| } | |
| #if !defined(MSGPACK_DISABLE_LEGACY_CONVERT) | |
| template <typename T> | |
| inline T* object::convert(T* v) const | |
| { | |
| convert(*v); | |
| return v; | |
| } | |
| #endif // !defined(MSGPACK_DISABLE_LEGACY_CONVERT) | |
| template <typename T> | |
| inline bool object::convert_if_not_nil(T& v) const | |
| { | |
| if (is_nil()) { | |
| return false; | |
| } | |
| convert(v); | |
| return true; | |
| } | |
| #if defined(MSGPACK_USE_CPP03) | |
| template <typename T> | |
| inline T object::as() const | |
| { | |
| T v; | |
| convert(v); | |
| return v; | |
| } | |
| #else // defined(MSGPACK_USE_CPP03) | |
| template <typename T> | |
| inline typename std::enable_if<msgpack::has_as<T>::value, T>::type object::as() const { | |
| return msgpack::adaptor::as<T>()(*this); | |
| } | |
| template <typename T> | |
| inline typename std::enable_if<!msgpack::has_as<T>::value, T>::type object::as() const { | |
| T v; | |
| convert(v); | |
| return v; | |
| } | |
| #endif // defined(MSGPACK_USE_CPP03) | |
| inline object::object() | |
| { | |
| type = msgpack::type::NIL; | |
| } | |
| template <typename T> | |
| inline object::object(const T& v) | |
| { | |
| msgpack::operator<<(*this, v); | |
| } | |
| template <typename T> | |
| inline object& object::operator=(const T& v) | |
| { | |
| *this = object(v); | |
| return *this; | |
| } | |
| template <typename T> | |
| object::object(const T& v, msgpack::zone& z) | |
| { | |
| with_zone oz(z); | |
| msgpack::operator<<(oz, v); | |
| type = oz.type; | |
| via = oz.via; | |
| } | |
| template <typename T> | |
| object::object(const T& v, msgpack::zone* z) | |
| { | |
| with_zone oz(*z); | |
| msgpack::operator<<(oz, v); | |
| type = oz.type; | |
| via = oz.via; | |
| } | |
| inline object::object(const msgpack_object& o) | |
| { | |
| // FIXME beter way? | |
| std::memcpy(this, &o, sizeof(o)); | |
| } | |
| inline void operator<< (msgpack::object& o, const msgpack_object& v) | |
| { | |
| // FIXME beter way? | |
| std::memcpy(&o, &v, sizeof(v)); | |
| } | |
| inline object::operator msgpack_object() const | |
| { | |
| // FIXME beter way? | |
| msgpack_object obj; | |
| std::memcpy(&obj, this, sizeof(obj)); | |
| return obj; | |
| } | |
| // obsolete | |
| template <typename T> | |
| inline void convert(T& v, msgpack::object const& o) | |
| { | |
| o.convert(v); | |
| } | |
| // obsolete | |
| template <typename Stream, typename T> | |
| inline void pack(msgpack::packer<Stream>& o, const T& v) | |
| { | |
| o.pack(v); | |
| } | |
| // obsolete | |
| template <typename Stream, typename T> | |
| inline void pack_copy(msgpack::packer<Stream>& o, T v) | |
| { | |
| pack(o, v); | |
| } | |
| template <typename Stream> | |
| inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v) | |
| { | |
| switch(v.type) { | |
| case msgpack::type::NIL: | |
| o.pack_nil(); | |
| return o; | |
| case msgpack::type::BOOLEAN: | |
| if(v.via.boolean) { | |
| o.pack_true(); | |
| } else { | |
| o.pack_false(); | |
| } | |
| return o; | |
| case msgpack::type::POSITIVE_INTEGER: | |
| o.pack_uint64(v.via.u64); | |
| return o; | |
| case msgpack::type::NEGATIVE_INTEGER: | |
| o.pack_int64(v.via.i64); | |
| return o; | |
| case msgpack::type::FLOAT: | |
| o.pack_double(v.via.f64); | |
| return o; | |
| case msgpack::type::STR: | |
| o.pack_str(v.via.str.size); | |
| o.pack_str_body(v.via.str.ptr, v.via.str.size); | |
| return o; | |
| case msgpack::type::BIN: | |
| o.pack_bin(v.via.bin.size); | |
| o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); | |
| return o; | |
| case msgpack::type::EXT: | |
| o.pack_ext(v.via.ext.size, v.via.ext.type()); | |
| o.pack_ext_body(v.via.ext.data(), v.via.ext.size); | |
| return o; | |
| case msgpack::type::ARRAY: | |
| o.pack_array(v.via.array.size); | |
| for(msgpack::object* p(v.via.array.ptr), | |
| * const pend(v.via.array.ptr + v.via.array.size); | |
| p < pend; ++p) { | |
| msgpack::operator<<(o, *p); | |
| } | |
| return o; | |
| case msgpack::type::MAP: | |
| o.pack_map(v.via.map.size); | |
| for(msgpack::object_kv* p(v.via.map.ptr), | |
| * const pend(v.via.map.ptr + v.via.map.size); | |
| p < pend; ++p) { | |
| msgpack::operator<<(o, p->key); | |
| msgpack::operator<<(o, p->val); | |
| } | |
| return o; | |
| default: | |
| throw msgpack::type_error(); | |
| } | |
| } | |
| template <typename Stream> | |
| msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v) | |
| { | |
| return o << static_cast<msgpack::object>(v); | |
| } | |
| inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o) | |
| { | |
| switch(o.type) { | |
| case msgpack::type::NIL: | |
| s << "nil"; | |
| break; | |
| case msgpack::type::BOOLEAN: | |
| s << (o.via.boolean ? "true" : "false"); | |
| break; | |
| case msgpack::type::POSITIVE_INTEGER: | |
| s << o.via.u64; | |
| break; | |
| case msgpack::type::NEGATIVE_INTEGER: | |
| s << o.via.i64; | |
| break; | |
| case msgpack::type::FLOAT: | |
| s << o.via.f64; | |
| break; | |
| case msgpack::type::STR: | |
| s << '"'; | |
| for (uint32_t i = 0; i < o.via.str.size; ++i) { | |
| char c = o.via.str.ptr[i]; | |
| switch (c) { | |
| case '\\': | |
| s << "\\\\"; | |
| break; | |
| case '"': | |
| s << "\\\""; | |
| break; | |
| case '/': | |
| s << "\\/"; | |
| break; | |
| case '\b': | |
| s << "\\b"; | |
| break; | |
| case '\f': | |
| s << "\\f"; | |
| break; | |
| case '\n': | |
| s << "\\n"; | |
| break; | |
| case '\r': | |
| s << "\\r"; | |
| break; | |
| case '\t': | |
| s << "\\t"; | |
| break; | |
| default: { | |
| unsigned int code = static_cast<unsigned int>(c); | |
| if (code < 0x20 || code == 0x7f) { | |
| s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff); | |
| } | |
| else { | |
| s << c; | |
| } | |
| } break; | |
| } | |
| } | |
| s << '"'; | |
| break; | |
| case msgpack::type::BIN: | |
| (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; | |
| break; | |
| case msgpack::type::EXT: | |
| s << "EXT"; | |
| break; | |
| case msgpack::type::ARRAY: | |
| s << "["; | |
| if(o.via.array.size != 0) { | |
| msgpack::object* p(o.via.array.ptr); | |
| s << *p; | |
| ++p; | |
| for(msgpack::object* const pend(o.via.array.ptr + o.via.array.size); | |
| p < pend; ++p) { | |
| s << ", " << *p; | |
| } | |
| } | |
| s << "]"; | |
| break; | |
| case msgpack::type::MAP: | |
| s << "{"; | |
| if(o.via.map.size != 0) { | |
| msgpack::object_kv* p(o.via.map.ptr); | |
| s << p->key << ':' << p->val; | |
| ++p; | |
| for(msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); | |
| p < pend; ++p) { | |
| s << ", " << p->key << ':' << p->val; | |
| } | |
| } | |
| s << "}"; | |
| break; | |
| default: | |
| // FIXME | |
| s << "#<UNKNOWN " << static_cast<uint16_t>(o.type) << ">"; | |
| } | |
| return s; | |
| } | |
| /// @cond | |
| } // MSGPACK_API_VERSION_NAMESPACE(v1) | |
| /// @endcond | |
| } // namespace msgpack | |
| #include "msgpack/type.hpp" | |
| #endif /* msgpack/object.hpp */ |