rroonga 6.0.5-x64-mingw32 → 6.0.7-x64-mingw32

data/vendor/local/include/msgpack/v1/object_decl.hpp

@@ -0,0 +1,112 @@
+//
+// 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_V1_OBJECT_DECL_HPP
+#define MSGPACK_V1_OBJECT_DECL_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;
+
+namespace detail {
+
+template <std::size_t N>
+std::size_t add_ext_type_size(std::size_t size);
+
+template <>
+std::size_t add_ext_type_size<4>(std::size_t size);
+
+} // namespace detail
+
+std::size_t aligned_zone_size(msgpack::object const& obj);
+
+/// 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.
+ */
+object_handle clone(msgpack::object const& obj);
+
+namespace detail {
+
+template <typename Stream, typename T>
+struct packer_serializer;
+
+} // namespace detail
+
+// obsolete
+template <typename Type>
+class define;
+
+bool operator==(const msgpack::object& x, const msgpack::object& y);
+
+template <typename T>
+bool operator==(const msgpack::object& x, const T& y);
+
+bool operator!=(const msgpack::object& x, const msgpack::object& y);
+
+template <typename T>
+bool operator==(const T& y, const msgpack::object& x);
+
+template <typename T>
+bool operator!=(const msgpack::object& x, const T& y);
+
+template <typename T>
+bool operator!=(const T& y, const msgpack::object& x);
+
+void operator<< (msgpack::object& o, const msgpack_object& v);
+
+// obsolete
+template <typename T>
+void convert(T& v, msgpack::object const& o);
+
+// obsolete
+template <typename Stream, typename T>
+void pack(msgpack::packer<Stream>& o, const T& v);
+
+// obsolete
+template <typename Stream, typename T>
+void pack_copy(msgpack::packer<Stream>& o, T v);
+
+template <typename Stream>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v);
+
+template <typename Stream>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v);
+
+std::ostream& operator<< (std::ostream& s, const msgpack::object& o);
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_OBJECT_DECL_HPP

data/vendor/local/include/msgpack/v1/object_fwd.hpp

@@ -0,0 +1,252 @@
+//
+// 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_V1_OBJECT_FWD_HPP
+#define MSGPACK_V1_OBJECT_FWD_HPP
+
+#include "msgpack/object_fwd_decl.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+struct object_array {
+    uint32_t size;
+    msgpack::object* ptr;
+};
+
+struct object_map {
+    uint32_t size;
+    msgpack::object_kv* ptr;
+};
+
+struct object_str {
+    uint32_t size;
+    const char* ptr;
+};
+
+struct object_bin {
+    uint32_t size;
+    const char* ptr;
+};
+
+struct object_ext {
+    int8_t type() const { return ptr[0]; }
+    const char* data() const { return &ptr[1]; }
+    uint32_t size;
+    const char* ptr;
+};
+
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T>
+struct has_as {
+private:
+    template <typename U>
+    static auto check(U*) ->
+        // Check v1 specialization
+        typename std::is_same<
+            decltype(adaptor::as<U>()(std::declval<msgpack::object>())),
+            T
+        >::type;
+    template <typename>
+    static std::false_type check(...);
+public:
+    using type = decltype(check<T>(MSGPACK_NULLPTR));
+    static constexpr bool value = type::value;
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+/// Object class that corresponding to MessagePack format object
+/**
+ * See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_object
+ */
+struct object {
+    union union_type {
+        bool boolean;
+        uint64_t u64;
+        int64_t  i64;
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        double   dec; // obsolete
+#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
+        double   f64;
+        msgpack::object_array array;
+        msgpack::object_map map;
+        msgpack::object_str str;
+        msgpack::object_bin bin;
+        msgpack::object_ext ext;
+    };
+
+    msgpack::type::object_type type;
+    union_type via;
+
+    /// Cheking nil
+    /**
+     * @return If the object is nil, then return true, else return false.
+     */
+    bool is_nil() const { return type == msgpack::type::NIL; }
+
+#if defined(MSGPACK_USE_CPP03)
+
+    /// Get value as T
+    /**
+     * If the object can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type you want to get.
+     * @return The converted object.
+     */
+    template <typename T>
+    T as() const;
+
+#else  // defined(MSGPACK_USE_CPP03)
+
+    /// Get value as T
+    /**
+     * If the object can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type you want to get.
+     * @return The converted object.
+     */
+    template <typename T>
+    typename std::enable_if<msgpack::has_as<T>::value, T>::type as() const;
+
+    /// Get value as T
+    /**
+     * If the object can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type you want to get.
+     * @return The converted object.
+     */
+    template <typename T>
+    typename std::enable_if<!msgpack::has_as<T>::value, T>::type as() const;
+
+#endif // defined(MSGPACK_USE_CPP03)
+
+    /// Convert the object
+    /**
+     * If the object can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type of v.
+     * @param v The value you want to get. `v` is output parameter. `v` is overwritten by converted value from the object.
+     * @return The reference of `v`.
+     */
+    template <typename T>
+    typename msgpack::enable_if<
+        !msgpack::is_array<T>::value && !msgpack::is_pointer<T>::value,
+        T&
+    >::type
+    convert(T& v) const;
+
+    template <typename T, std::size_t N>
+    T (&convert(T(&v)[N]) const)[N];
+
+
+#if !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
+    /// Convert the object (obsolete)
+    /**
+     * If the object can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type of v.
+     * @param v The pointer of the value you want to get. `v` is output parameter. `*v` is overwritten by converted value from the object.
+     * @return The pointer of `v`.
+     */
+    template <typename T>
+    typename msgpack::enable_if<
+        msgpack::is_pointer<T>::value,
+        T
+    >::type
+    convert(T v) const;
+#endif // !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
+
+    /// Convert the object if not nil
+    /**
+     * If the object is not nil and can't be converted to T, msgpack::type_error would be thrown.
+     * @tparam T The type of v.
+     * @param v The value you want to get. `v` is output parameter. `v` is overwritten by converted value from the object if the object is not nil.
+     * @return If the object is nil, then return false, else return true.
+     */
+    template <typename T>
+    bool convert_if_not_nil(T& v) const;
+
+    /// Default constructor. The object is set to nil.
+    object();
+
+    /// Copy constructor. Object is shallow copied.
+    object(const msgpack_object& o);
+
+    /// Construct object from T
+    /**
+     * If `v` is the type that is corresponding to MessegePack format str, bin, ext, array, or map,
+     * you need to call `object(const T& v, msgpack::zone& z)` instead of this constructor.
+     *
+     * @tparam T The type of `v`.
+     * @param v The value you want to convert.
+     */
+    template <typename T>
+    explicit object(const T& v);
+
+    /// Construct object from T
+    /**
+     * The object is constructed on the zone `z`.
+     * See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_object
+     *
+     * @tparam T The type of `v`.
+     * @param v The value you want to convert.
+     * @param z The zone that is used by the object.
+     */
+    template <typename T>
+    object(const T& v, msgpack::zone& z);
+
+    /// Construct object from T (obsolete)
+    /**
+     * The object is constructed on the zone `z`.
+     * Use `object(const T& v, msgpack::zone& z)` instead of this constructor.
+     * See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_object
+     *
+     * @tparam T The type of `v`.
+     * @param v The value you want to convert.
+     * @param z The pointer to the zone that is used by the object.
+     */
+    template <typename T>
+    object(const T& v, msgpack::zone* z);
+
+    template <typename T>
+    object& operator=(const T& v);
+
+    operator msgpack_object() const;
+
+    struct with_zone;
+
+protected:
+    struct implicit_type;
+
+public:
+    implicit_type convert() const;
+};
+
+class type_error : public std::bad_cast { };
+
+struct object::implicit_type {
+    implicit_type(object const& o) : obj(o) { }
+    ~implicit_type() { }
+
+    template <typename T>
+    operator T();
+
+private:
+    object const& obj;
+};
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_V1_OBJECT_FWD_HPP

data/vendor/local/include/msgpack/v1/object_fwd_decl.hpp

@@ -0,0 +1,76 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 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_V1_OBJECT_FWD_DECL_HPP
+#define MSGPACK_V1_OBJECT_FWD_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/zone.hpp"
+#include "msgpack/object.h"
+
+#include <typeinfo>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+
+namespace type {
+    enum object_type {
+        NIL                 = MSGPACK_OBJECT_NIL,
+        BOOLEAN             = MSGPACK_OBJECT_BOOLEAN,
+        POSITIVE_INTEGER    = MSGPACK_OBJECT_POSITIVE_INTEGER,
+        NEGATIVE_INTEGER    = MSGPACK_OBJECT_NEGATIVE_INTEGER,
+        FLOAT               = MSGPACK_OBJECT_FLOAT,
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        DOUBLE              = MSGPACK_OBJECT_DOUBLE, // obsolete
+#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
+        STR                 = MSGPACK_OBJECT_STR,
+        BIN                 = MSGPACK_OBJECT_BIN,
+        ARRAY               = MSGPACK_OBJECT_ARRAY,
+        MAP                 = MSGPACK_OBJECT_MAP,
+        EXT                 = MSGPACK_OBJECT_EXT
+    };
+}
+
+
+struct object;
+struct object_kv;
+
+struct object_array;
+struct object_map;
+struct object_str;
+struct object_bin;
+struct object_ext;
+
+
+#if !defined(MSGPACK_USE_CPP03)
+
+namespace adaptor {
+template <typename T, typename Enabler = void>
+struct as;
+} // namespace adaptor
+
+template <typename T>
+struct has_as;
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+class type_error;
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_V1_OBJECT_FWD_DECL_HPP

data/vendor/local/include/msgpack/v1/pack.hpp

@@ -0,0 +1,1602 @@
+//
+// MessagePack for C++ serializing routine
+//
+// Copyright (C) 2008-2016 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_V1_PACK_HPP
+#define MSGPACK_V1_PACK_HPP
+
+#include "msgpack/v1/pack_decl.hpp"
+
+#include <stdexcept>
+#include <limits>
+#include <cstring>
+#include <climits>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+/// The class template that supports continuous packing.
+/**
+ * @tparam Stream  Any type that have a member function `Stream write(const char*, size_t s)`
+ *
+ */
+template <typename Stream>
+class packer {
+public:
+    /// Constructor
+    /**
+     * This constructor is left for compatibility.
+     * Use `packer(Stream& s)` instead of the constructor.
+     *
+     * @param s A pointer to packing destination stream object.
+     */
+    packer(Stream* s);
+    /// Constructor
+    /**
+     * @param s Packing destination stream object.
+     */
+    packer(Stream& s);
+
+public:
+    /// Packing function template
+    /**
+     * @tparam T The type of packing object.
+     *
+     * @param v a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    template <typename T>
+    packer<Stream>& pack(const T& v);
+
+    /// Packing uint8
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum or uint8.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_uint8(uint8_t d);
+
+    /// Packing uint16
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, uint8 or uint16.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_uint16(uint16_t d);
+
+    /// Packing uint32
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, uint8, uint16 or uint32.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_uint32(uint32_t d);
+
+    /// Packing uint16
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, uint8, uint16, uint32 or uint64.
+     * The minimum byte size expression is used.
+     * positive fixnum, uint8, uint16, or uint32 is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_uint64(uint64_t d);
+
+    /// Packing int8
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint8,
+     * else the packed type is negative fixnum, or int8
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_int8(int8_t d);
+
+    /// Packing int16
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, uint8, or uint16,
+     * else the packed type is negative fixnum, int8, or int16.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_int16(int16_t d);
+
+    /// Packing int32
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, uint8, uint16, or uint32,
+     * else the packed type is negative fixnum, int8, int16, or int32.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_int32(int32_t d);
+
+    /// Packing int32
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, uint8, uint16, uint32, or uint64,
+     * else the packed type is negative fixnum, int8, int16, int32, or int64.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_int64(int64_t d);
+
+
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always uint8.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_uint8(uint8_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always uint16.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_uint16(uint16_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always uint32.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_uint32(uint32_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always uint64.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_uint64(uint64_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always int8.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_int8(int8_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always int16.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_int16(int16_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always int32.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_int32(int32_t d);
+
+    /// Packing uint8 (fixed packed type).
+    /**
+     * The packed type is always int64.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_fix_int64(int64_t d);
+
+
+    /// Packing char
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_char(char d);
+
+    /// Packing signed char
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_signed_char(signed char d);
+
+    /// Packing short
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_short(short d);
+
+    /// Packing int
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_int(int d);
+
+    /// Packing long
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_long(long d);
+
+    /// Packing long long
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_long_long(long long d);
+
+
+    /// Packing unsigned char
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, or uint*.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_unsigned_char(unsigned char d);
+
+    /// Packing unsigned short
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, or uint*.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_unsigned_short(unsigned short d);
+
+    /// Packing unsigned int
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, or uint*.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_unsigned_int(unsigned int d);
+
+    /// Packing unsigned long
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, or uint*.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_unsigned_long(unsigned long d);
+
+    /// Packing unsigned long long
+    /**
+     * The byte size of the packed data depends on `d`.
+     * The packed type is positive fixnum, or uint*.
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_unsigned_long_long(unsigned long long d);
+
+    /// Packing float
+    /**
+     * The packed type is float32.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-float
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_float(float d);
+
+    /// Packing double
+    /**
+     * The packed type is float64.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-float
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_double(double d);
+
+
+    /// Packing nil
+    /**
+     * The packed type is nil.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-nil
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_nil();
+
+    /// Packing true
+    /**
+     * The packed type is bool, value is true.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#bool-format-family
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_true();
+
+    /// Packing false
+    /**
+     * The packed type is bool, value is false.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#bool-format-family
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_false();
+
+    /// Packing array header and size
+    /**
+     * The packed type is array header and array size.
+     * You need to pack `n` msgpack objects following this header and size.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#array-format-family
+     *
+     * @param n The number of array elements (array size).
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_array(uint32_t n);
+
+    /// Packing map header and size
+    /**
+     * The packed type is map header and map size.
+     * You need to pack `n` pairs of msgpack objects following this header and size.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#map-format-family
+     *
+     * @param n The number of array elements (array size).
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_map(uint32_t n);
+
+
+    /// Packing str header and length
+    /**
+     * The packed type is str header and length.
+     * The minimum byte size length expression is used.
+     * You need to call `pack_str_body(const char* b, uint32_t l)` after this function calling with the same `l` value.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-str
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_str(uint32_t l);
+
+    /// Packing str body
+    /**
+     * You need to call this function just after `pack_str(uint32_t l)` calling.
+     * The value `l` should be the same as `pack_str(uint32_t l)` argument `l`.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-str
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_str_body(const char* b, uint32_t l);
+
+    /// Packing raw (v4) header and length
+    /**
+     * The packed type is raw header and length.
+     * The minimum byte size length expression is used.
+     * The format raw (v4) is old MessagePack version4 format.
+     * You need to call `pack_v4raw_body(const char* b, uint32_t l)` after this function calling with the same `l` value.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-str
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_v4raw(uint32_t l);
+
+    /// Packing raw (v4) body
+    /**
+     * The format raw (v4) is old MessagePack version4 format.
+     * You need to call this function just after `pack_v4raw(uint32_t l)` calling.
+     * The value `l` should be the same as `pack_v4raw(uint32_t l)` argument `l`.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-str
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_v4raw_body(const char* b, uint32_t l);
+
+    /// Packing bin header and length
+    /**
+     * The packed type is bin header and length.
+     * The minimum byte size length expression is used.
+     * You need to call `pack_bin_body(const char* b, uint32_t l)` after this function calling with the same `l` value.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_bin(uint32_t l);
+
+    /// Packing bin body
+    /**
+     * You need to call this function just after `pack_bin(uint32_t l)` calling.
+     * The value `l` should be the same as `pack_bin(uint32_t l)` argument `l`.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_bin_body(const char* b, uint32_t l);
+
+    /// Packing ext header, type, and length
+    /**
+     * The packed type is ext.
+     * The minimum byte size length expression is used.
+     * The length 1, 2, 4, 8, and 16 can be encoded in the header.
+     * You need to call `pack_ext_body(const char* b, uint32_t l)` after this function calling with the same `l` value.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-ext
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_ext(size_t l, int8_t type);
+
+    /// Packing ext body
+    /**
+     * You need to call this function just after `pack_ext(size_t l, int8_t type)` calling.
+     * The value `l` should be the same as `pack_ext(size_t l, int8_t type)` argument `l`.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family
+     *
+     * @param l The length of string.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_ext_body(const char* b, uint32_t l);
+
+private:
+    template <typename T>
+    void pack_imp_uint8(T d);
+    template <typename T>
+    void pack_imp_uint16(T d);
+    template <typename T>
+    void pack_imp_uint32(T d);
+    template <typename T>
+    void pack_imp_uint64(T d);
+    template <typename T>
+    void pack_imp_int8(T d);
+    template <typename T>
+    void pack_imp_int16(T d);
+    template <typename T>
+    void pack_imp_int32(T d);
+    template <typename T>
+    void pack_imp_int64(T d);
+
+    void append_buffer(const char* buf, size_t len)
+        { m_stream.write(buf, len); }
+
+private:
+    Stream& m_stream;
+
+#if defined(MSGPACK_USE_CPP03)
+private:
+    packer(const packer&);
+    packer& operator=(const packer&);
+    packer();
+#else  // defined(MSGPACK_USE_CPP03)
+public:
+    packer(const packer&) = delete;
+    packer& operator=(const packer&) = delete;
+    packer() = delete;
+#endif // defined(MSGPACK_USE_CPP03)
+};
+
+
+/// Pack the value as MessagePack format into the stream
+/**
+ * This function template is left for compatibility.
+ * Use `void pack(Stream& s, const T& v)` instead of the function template.
+ *
+ * @tparam Stream Any type that have a member function `Stream write(const char*, size_t s)`
+ * @tparam T Any type that is adapted to MessagePack
+ * @param s The pointer to packing destination stream
+ * @param v Packing value
+ */
+template <typename Stream, typename T>
+inline void pack(Stream* s, const T& v)
+{
+    packer<Stream>(*s).pack(v);
+}
+
+/// Pack the value as MessagePack format into the stream
+/**
+ * @tparam Stream Any type that have a member function `Stream write(const char*, size_t s)`
+ * @tparam T Any type that is adapted to MessagePack
+ * @param s Packing destination stream
+ * @param v Packing value
+ */
+template <typename Stream, typename T>
+inline void pack(Stream& s, const T& v)
+{
+    packer<Stream>(s).pack(v);
+}
+
+
+#if MSGPACK_ENDIAN_LITTLE_BYTE
+template <typename T>
+inline char take8_8(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_16(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_32(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_64(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+
+#elif MSGPACK_ENDIAN_BIG_BYTE
+
+template <typename T>
+inline char take8_8(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_16(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[1]);
+}
+template <typename T>
+inline char take8_32(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[3]);
+}
+template <typename T>
+inline char take8_64(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[7]);
+}
+
+#else
+#error msgpack-c supports only big endian and little endian
+#endif
+
+template <typename Stream>
+inline packer<Stream>::packer(Stream* s) : m_stream(*s) { }
+
+template <typename Stream>
+inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint8(uint8_t d)
+{ pack_imp_uint8(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint16(uint16_t d)
+{ pack_imp_uint16(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint32(uint32_t d)
+{ pack_imp_uint32(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint64(uint64_t d)
+{ pack_imp_uint64(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int8(int8_t d)
+{ pack_imp_int8(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int16(int16_t d)
+{ pack_imp_int16(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int32(int32_t d)
+{ pack_imp_int32(d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int64(int64_t d)
+{ pack_imp_int64(d); return *this;}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_uint8(uint8_t d)
+{
+    char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
+    append_buffer(buf, 2);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_uint16(uint16_t d)
+{
+    char buf[3];
+    buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], d);
+    append_buffer(buf, 3);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_uint32(uint32_t d)
+{
+    char buf[5];
+    buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], d);
+    append_buffer(buf, 5);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_uint64(uint64_t d)
+{
+    char buf[9];
+    buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+    append_buffer(buf, 9);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_int8(int8_t d)
+{
+    char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
+    append_buffer(buf, 2);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
+{
+    char buf[3];
+    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
+    append_buffer(buf, 3);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
+{
+    char buf[5];
+    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
+    append_buffer(buf, 5);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
+{
+    char buf[9];
+    buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
+    append_buffer(buf, 9);
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_char(char d)
+{
+#if defined(CHAR_MIN)
+#if CHAR_MIN < 0
+    pack_imp_int8(d);
+#else
+    pack_imp_uint8(d);
+#endif
+#else
+#error CHAR_MIN is not defined
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
+{
+    pack_imp_int8(d);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_short(short d)
+{
+#if defined(SIZEOF_SHORT)
+#if SIZEOF_SHORT == 2
+    pack_imp_int16(d);
+#elif SIZEOF_SHORT == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(SHRT_MAX)
+#if SHRT_MAX == 0x7fff
+    pack_imp_int16(d);
+#elif SHRT_MAX == 0x7fffffff
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(short) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(short) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int(int d)
+{
+#if defined(SIZEOF_INT)
+#if SIZEOF_INT == 2
+    pack_imp_int16(d);
+#elif SIZEOF_INT == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(INT_MAX)
+#if INT_MAX == 0x7fff
+    pack_imp_int16(d);
+#elif INT_MAX == 0x7fffffff
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(int) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(int) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_long(long d)
+{
+#if defined(SIZEOF_LONG)
+#if SIZEOF_LONG == 2
+    pack_imp_int16(d);
+#elif SIZEOF_LONG == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(LONG_MAX)
+#if LONG_MAX == 0x7fffL
+    pack_imp_int16(d);
+#elif LONG_MAX == 0x7fffffffL
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(long) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(long) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
+{
+#if defined(SIZEOF_LONG_LONG)
+#if SIZEOF_LONG_LONG == 2
+    pack_imp_int16(d);
+#elif SIZEOF_LONG_LONG == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(LLONG_MAX)
+#if LLONG_MAX == 0x7fffL
+    pack_imp_int16(d);
+#elif LLONG_MAX == 0x7fffffffL
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(long long) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(long long) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_char(unsigned char d)
+{
+    pack_imp_uint8(d);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
+{
+#if defined(SIZEOF_SHORT)
+#if SIZEOF_SHORT == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_SHORT == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(USHRT_MAX)
+#if USHRT_MAX == 0xffffU
+    pack_imp_uint16(d);
+#elif USHRT_MAX == 0xffffffffU
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned short) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned short) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_int(unsigned int d)
+{
+#if defined(SIZEOF_INT)
+#if SIZEOF_INT == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_INT == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(UINT_MAX)
+#if UINT_MAX == 0xffffU
+    pack_imp_uint16(d);
+#elif UINT_MAX == 0xffffffffU
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned int) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned int) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_long(unsigned long d)
+{
+#if defined(SIZEOF_LONG)
+#if SIZEOF_LONG == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_LONG == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(ULONG_MAX)
+#if ULONG_MAX == 0xffffUL
+    pack_imp_uint16(d);
+#elif ULONG_MAX == 0xffffffffUL
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned long) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned long) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_long_long(unsigned long long d)
+{
+#if defined(SIZEOF_LONG_LONG)
+#if SIZEOF_LONG_LONG == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_LONG_LONG == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(ULLONG_MAX)
+#if ULLONG_MAX == 0xffffUL
+    pack_imp_uint16(d);
+#elif ULLONG_MAX == 0xffffffffUL
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned long long) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned long long) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_float(float d)
+{
+    union { float f; uint32_t i; } mem;
+    mem.f = d;
+    char buf[5];
+    buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
+    append_buffer(buf, 5);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_double(double d)
+{
+    union { double f; uint64_t i; } mem;
+    mem.f = d;
+    char buf[9];
+    buf[0] = static_cast<char>(0xcbu);
+
+#if defined(TARGET_OS_IPHONE)
+    // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+    // https://github.com/msgpack/msgpack-perl/pull/1
+    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+    _msgpack_store64(&buf[1], mem.i);
+    append_buffer(buf, 9);
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_nil()
+{
+    const char d = static_cast<char>(0xc0u);
+    append_buffer(&d, 1);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_true()
+{
+    const char d = static_cast<char>(0xc3u);
+    append_buffer(&d, 1);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_false()
+{
+    const char d = static_cast<char>(0xc2u);
+    append_buffer(&d, 1);
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_array(uint32_t n)
+{
+    if(n < 16) {
+        char d = static_cast<char>(0x90u | n);
+        append_buffer(&d, 1);
+    } else if(n < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_map(uint32_t n)
+{
+    if(n < 16) {
+        unsigned char d = static_cast<unsigned char>(0x80u | n);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(n < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
+{
+    if(l < 32) {
+        unsigned char d = static_cast<uint8_t>(0xa0u | l);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(l < 256) {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<uint8_t>(l);
+        append_buffer(buf, 2);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_str_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+// Raw (V4)
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_v4raw(uint32_t l)
+{
+    if(l < 32) {
+        unsigned char d = static_cast<uint8_t>(0xa0u | l);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_v4raw_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
+{
+    if(l < 256) {
+        char buf[2];
+        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<uint8_t>(l);
+        append_buffer(buf, 2);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_bin_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_ext(size_t l, int8_t type)
+{
+    switch(l) {
+    case 1: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd4u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 2: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd5u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 4: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd6u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 8: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd7u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 16: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd8u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    default:
+        if(l < 256) {
+            char buf[3];
+            buf[0] = static_cast<char>(0xc7u);
+            buf[1] = static_cast<char>(l);
+            buf[2] = static_cast<char>(type);
+            append_buffer(buf, 3);
+        } else if(l < 65536) {
+            char buf[4];
+            buf[0] = static_cast<char>(0xc8u);
+            _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+            buf[3] = static_cast<char>(type);
+            append_buffer(buf, 4);
+        } else {
+            char buf[6];
+            buf[0] = static_cast<char>(0xc9u);
+            _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+            buf[5] = static_cast<char>(type);
+            append_buffer(buf, 6);
+        }
+        break;
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_ext_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint8(T d)
+{
+    if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else {
+        /* unsigned 8 */
+        char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
+        append_buffer(buf, 2);
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint16(T d)
+{
+    if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_16(d);
+        append_buffer(&buf, 1);
+    } else if(d < (1<<8)) {
+        /* unsigned 8 */
+        char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
+        append_buffer(buf, 2);
+    } else {
+        /* unsigned 16 */
+        char buf[3];
+        buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+        append_buffer(buf, 3);
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint32(T d)
+{
+    if(d < (1<<8)) {
+        if(d < (1<<7)) {
+            /* fixnum */
+            char buf = take8_32(d);
+            append_buffer(&buf, 1);
+        } else {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_32(d)};
+            append_buffer(buf, 2);
+        }
+    } else {
+        if(d < (1<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        }
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint64(T d)
+{
+    if(d < (1ULL<<8)) {
+        if(d < (1ULL<<7)) {
+            /* fixnum */
+            char buf = take8_64(d);
+            append_buffer(&buf, 1);
+        } else {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
+            append_buffer(buf, 2);
+        }
+    } else {
+        if(d < (1ULL<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else if(d < (1ULL<<32)) {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        } else {
+            /* unsigned 64 */
+            char buf[9];
+            buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+            append_buffer(buf, 9);
+        }
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_int8(T d)
+{
+    if(d < -(1<<5)) {
+        /* signed 8 */
+        char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
+        append_buffer(buf, 2);
+    } else {
+        /* fixnum */
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_int16(T d)
+{
+    if(d < -(1<<5)) {
+        if(d < -(1<<7)) {
+            /* signed 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* signed 8 */
+            char buf[2] = {static_cast<char>(0xd0u), take8_16(d)};
+            append_buffer(buf, 2);
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_16(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1<<8)) {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
+            append_buffer(buf, 2);
+        } else {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        }
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_int32(T d)
+{
+    if(d < -(1<<5)) {
+        if(d < -(1<<15)) {
+            /* signed 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
+            append_buffer(buf, 5);
+        } else if(d < -(1<<7)) {
+            /* signed 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* signed 8 */
+            char buf[2] = { static_cast<char>(0xd0u), take8_32(d)};
+            append_buffer(buf, 2);
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_32(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1<<8)) {
+            /* unsigned 8 */
+            char buf[2] = { static_cast<char>(0xccu), take8_32(d)};
+            append_buffer(buf, 2);
+        } else if(d < (1<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        }
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_int64(T d)
+{
+    if(d < -(1LL<<5)) {
+        if(d < -(1LL<<15)) {
+            if(d < -(1LL<<31)) {
+                /* signed 64 */
+                char buf[9];
+                buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
+                append_buffer(buf, 9);
+            } else {
+                /* signed 32 */
+                char buf[5];
+                buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
+                append_buffer(buf, 5);
+            }
+        } else {
+            if(d < -(1<<7)) {
+                /* signed 16 */
+                char buf[3];
+                buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+                append_buffer(buf, 3);
+            } else {
+                /* signed 8 */
+                char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
+                append_buffer(buf, 2);
+            }
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_64(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1LL<<16)) {
+            if(d < (1<<8)) {
+                /* unsigned 8 */
+                char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
+                append_buffer(buf, 2);
+            } else {
+                /* unsigned 16 */
+                char buf[3];
+                buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+                append_buffer(buf, 3);
+            }
+        } else {
+            if(d < (1LL<<32)) {
+                /* unsigned 32 */
+                char buf[5];
+                buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+                append_buffer(buf, 5);
+            } else {
+                /* unsigned 64 */
+                char buf[9];
+                buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+                append_buffer(buf, 9);
+            }
+        }
+    }
+}
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_PACK_HPP