| // | |
| // MessagePack for C++ serializing routine | |
| // | |
| // Copyright (C) 2008-2013 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_PACK_HPP | |
| #define MSGPACK_PACK_HPP | |
| #include "msgpack/versioning.hpp" | |
| #include "msgpack/cpp_config.hpp" | |
| #include <stdexcept> | |
| #include <limits> | |
| #include <cstring> | |
| #include <climits> | |
| #include "sysdep.h" | |
| 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/pack.hpp */ |