MessagePack for C++
object.hpp
Go to the documentation of this file.
1 //
2 // MessagePack for C++ static resolution routine
3 //
4 // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
5 //
6 // Distributed under the Boost Software License, Version 1.0.
7 // (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9 //
10 #ifndef MSGPACK_V1_OBJECT_HPP
11 #define MSGPACK_V1_OBJECT_HPP
12 
13 #include "msgpack/object_decl.hpp"
14 
15 #include <cstring>
16 #include <stdexcept>
17 #include <typeinfo>
18 #include <limits>
19 #include <ostream>
20 #include <typeinfo>
21 #include <iomanip>
22 
23 namespace msgpack {
24 
28 
29 struct object_kv {
32 };
33 
37 private:
38  with_zone();
39 };
40 
41 
44 public:
47 
49 
54  msgpack::object const& obj,
55 #if defined(MSGPACK_USE_CPP03)
57 #else // defined(MSGPACK_USE_CPP03)
59 #endif // defined(MSGPACK_USE_CPP03)
60  ) :
61  m_obj(obj), m_zone(msgpack::move(z)) { }
62 
63  void set(msgpack::object const& obj)
64  { m_obj = obj; }
65 
67 
70  const msgpack::object& get() const
71  { return m_obj; }
72 
74 
78  { return m_zone; }
79 
81 
85  { return m_zone; }
86 
87 #if defined(MSGPACK_USE_CPP03)
88  struct object_handle_ref {
89  object_handle_ref(object_handle* oh):m_oh(oh) {}
90  object_handle* m_oh;
91  };
92 
94  m_obj(other.m_obj),
95  m_zone(msgpack::move(other.m_zone)) {
96  }
97 
98  object_handle(object_handle_ref ref):
99  m_obj(ref.m_oh->m_obj),
100  m_zone(msgpack::move(ref.m_oh->m_zone)) {
101  }
102 
103  object_handle& operator=(object_handle& other) {
104  m_obj = other.m_obj;
105  m_zone = msgpack::move(other.m_zone);
106  return *this;
107  }
108 
109  object_handle& operator=(object_handle_ref ref) {
110  m_obj = ref.m_oh->m_obj;
111  m_zone = msgpack::move(ref.m_oh->m_zone);
112  return *this;
113  }
114 
115  operator object_handle_ref() {
116  return object_handle_ref(this);
117  }
118 #endif // defined(MSGPACK_USE_CPP03)
119 
120 private:
121  msgpack::object m_obj;
123 };
124 
125 namespace detail {
126 
127 template <std::size_t N>
128 inline std::size_t add_ext_type_size(std::size_t size) {
129  return size + 1;
130 }
131 
132 template <>
133 inline std::size_t add_ext_type_size<4>(std::size_t size) {
134  return size == 0xffffffff ? size : size + 1;
135 }
136 
137 } // namespace detail
138 
139 inline std::size_t aligned_zone_size(msgpack::object const& obj) {
140  std::size_t s = 0;
141  switch (obj.type) {
144  sizeof(msgpack::object) * obj.via.array.size,
146  for (uint32_t i = 0; i < obj.via.array.size; ++i) {
148  }
149  break;
150  case msgpack::type::MAP:
152  sizeof(msgpack::object_kv) * obj.via.map.size,
154  for (uint32_t i = 0; i < obj.via.map.size; ++i) {
157  }
158  break;
159  case msgpack::type::EXT:
161  detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size),
162  MSGPACK_ZONE_ALIGNOF(char));
163  break;
164  case msgpack::type::STR:
166  break;
167  case msgpack::type::BIN:
169  break;
170  default:
171  break;
172  }
173  return s;
174 }
175 
177 
184 inline object_handle clone(msgpack::object const& obj) {
185  std::size_t size = msgpack::aligned_zone_size(obj);
187  msgpack::object newobj = z.get() ? msgpack::object(obj, *z) : obj;
188  return object_handle(newobj, msgpack::move(z));
189 }
190 
191 template <typename T>
192 inline object::implicit_type::operator T() { return obj.as<T>(); }
193 
194 namespace detail {
195 template <typename Stream, typename T>
198  v.msgpack_pack(o);
199  return o;
200  }
201 };
202 } // namespace detail
203 
204 // Adaptor functors' member functions definitions.
205 template <typename T, typename Enabler>
206 inline
207 msgpack::object const&
209  v.msgpack_unpack(o.convert());
210  return o;
211 }
212 
213 template <typename T, typename Enabler>
214 template <typename Stream>
215 inline
219 }
220 
221 template <typename T, typename Enabler>
222 inline
223 void
225  v.msgpack_object(static_cast<msgpack::object*>(&o), o.zone);
226 }
227 
228 // Adaptor functor specialization to object
229 namespace adaptor {
230 
231 template <>
234  v = o;
235  return o;
236  }
237 };
238 
239 template <>
240 struct pack<msgpack::object> {
241  template <typename Stream>
243  switch(v.type) {
244  case msgpack::type::NIL:
245  o.pack_nil();
246  return o;
247 
249  if(v.via.boolean) {
250  o.pack_true();
251  } else {
252  o.pack_false();
253  }
254  return o;
255 
257  o.pack_uint64(v.via.u64);
258  return o;
259 
261  o.pack_int64(v.via.i64);
262  return o;
263 
265  o.pack_float(static_cast<float>(v.via.f64));
266  return o;
267 
269  o.pack_double(v.via.f64);
270  return o;
271 
272  case msgpack::type::STR:
273  o.pack_str(v.via.str.size);
274  o.pack_str_body(v.via.str.ptr, v.via.str.size);
275  return o;
276 
277  case msgpack::type::BIN:
278  o.pack_bin(v.via.bin.size);
279  o.pack_bin_body(v.via.bin.ptr, v.via.bin.size);
280  return o;
281 
282  case msgpack::type::EXT:
283  o.pack_ext(v.via.ext.size, v.via.ext.type());
284  o.pack_ext_body(v.via.ext.data(), v.via.ext.size);
285  return o;
286 
288  o.pack_array(v.via.array.size);
289  for(msgpack::object* p(v.via.array.ptr),
290  * const pend(v.via.array.ptr + v.via.array.size);
291  p < pend; ++p) {
292  msgpack::operator<<(o, *p);
293  }
294  return o;
295 
296  case msgpack::type::MAP:
297  o.pack_map(v.via.map.size);
298  for(msgpack::object_kv* p(v.via.map.ptr),
299  * const pend(v.via.map.ptr + v.via.map.size);
300  p < pend; ++p) {
301  msgpack::operator<<(o, p->key);
302  msgpack::operator<<(o, p->val);
303  }
304  return o;
305 
306  default:
307  throw msgpack::type_error();
308  }
309  }
310 };
311 
312 template <>
315  o.type = v.type;
316 
317  switch(v.type) {
318  case msgpack::type::NIL:
324  std::memcpy(&o.via, &v.via, sizeof(v.via));
325  return;
326 
327  case msgpack::type::STR: {
328  char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size, MSGPACK_ZONE_ALIGNOF(char)));
329  o.via.str.ptr = ptr;
330  o.via.str.size = v.via.str.size;
331  std::memcpy(ptr, v.via.str.ptr, v.via.str.size);
332  return;
333  }
334 
335  case msgpack::type::BIN: {
336  char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size, MSGPACK_ZONE_ALIGNOF(char)));
337  o.via.bin.ptr = ptr;
338  o.via.bin.size = v.via.bin.size;
339  std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size);
340  return;
341  }
342 
343  case msgpack::type::EXT: {
344  char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1, MSGPACK_ZONE_ALIGNOF(char)));
345  o.via.ext.ptr = ptr;
346  o.via.ext.size = v.via.ext.size;
347  std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1);
348  return;
349  }
350 
353  o.via.array.size = v.via.array.size;
354  for (msgpack::object
355  * po(o.via.array.ptr),
356  * pv(v.via.array.ptr),
357  * const pvend(v.via.array.ptr + v.via.array.size);
358  pv < pvend;
359  ++po, ++pv) {
360  new (po) msgpack::object(*pv, o.zone);
361  }
362  return;
363 
364  case msgpack::type::MAP:
366  o.via.map.size = v.via.map.size;
368  * po(o.via.map.ptr),
369  * pv(v.via.map.ptr),
370  * const pvend(v.via.map.ptr + v.via.map.size);
371  pv < pvend;
372  ++po, ++pv) {
373  msgpack::object_kv* kv = new (po) msgpack::object_kv;
374  new (&kv->key) msgpack::object(pv->key, o.zone);
375  new (&kv->val) msgpack::object(pv->val, o.zone);
376  }
377  return;
378 
379  default:
380  throw msgpack::type_error();
381  }
382 
383  }
384 };
385 
386 // Adaptor functor specialization to object::with_zone
387 
388 template <>
392  msgpack::object::with_zone const& v) const {
393  o << static_cast<msgpack::object const&>(v);
394  }
395 };
396 
397 
398 } // namespace adaptor
399 
400 
401 // obsolete
402 template <typename Type>
403 class define : public Type {
404 public:
405  typedef Type msgpack_type;
407  define() {}
408  define(const msgpack_type& v) : msgpack_type(v) {}
409 
410  template <typename Packer>
411  void msgpack_pack(Packer& o) const
412  {
413  msgpack::operator<<(o, static_cast<const msgpack_type&>(*this));
414  }
415 
416  void msgpack_unpack(object const& o)
417  {
418  msgpack::operator>>(o, static_cast<msgpack_type&>(*this));
419  }
420 };
421 
422 // deconvert operator
423 
424 template <typename Stream>
425 template <typename T>
427 {
428  msgpack::operator<<(*this, v);
429  return *this;
430 }
431 
432 inline bool operator==(const msgpack::object& x, const msgpack::object& y)
433 {
434  if(x.type != y.type) { return false; }
435 
436  switch(x.type) {
437  case msgpack::type::NIL:
438  return true;
439 
441  return x.via.boolean == y.via.boolean;
442 
444  return x.via.u64 == y.via.u64;
445 
447  return x.via.i64 == y.via.i64;
448 
451  return x.via.f64 == y.via.f64;
452 
453  case msgpack::type::STR:
454  return x.via.str.size == y.via.str.size &&
455  std::memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
456 
457  case msgpack::type::BIN:
458  return x.via.bin.size == y.via.bin.size &&
459  std::memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
460 
461  case msgpack::type::EXT:
462  return x.via.ext.size == y.via.ext.size &&
463  std::memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0;
464 
466  if(x.via.array.size != y.via.array.size) {
467  return false;
468  } else if(x.via.array.size == 0) {
469  return true;
470  } else {
471  msgpack::object* px = x.via.array.ptr;
472  msgpack::object* const pxend = x.via.array.ptr + x.via.array.size;
473  msgpack::object* py = y.via.array.ptr;
474  do {
475  if(!(*px == *py)) {
476  return false;
477  }
478  ++px;
479  ++py;
480  } while(px < pxend);
481  return true;
482  }
483 
484  case msgpack::type::MAP:
485  if(x.via.map.size != y.via.map.size) {
486  return false;
487  } else if(x.via.map.size == 0) {
488  return true;
489  } else {
490  msgpack::object_kv* px = x.via.map.ptr;
491  msgpack::object_kv* const pxend = x.via.map.ptr + x.via.map.size;
492  msgpack::object_kv* py = y.via.map.ptr;
493  do {
494  if(!(px->key == py->key) || !(px->val == py->val)) {
495  return false;
496  }
497  ++px;
498  ++py;
499  } while(px < pxend);
500  return true;
501  }
502 
503  default:
504  return false;
505  }
506 }
507 
508 template <typename T>
509 inline bool operator==(const msgpack::object& x, const T& y)
510 try {
511  return x == msgpack::object(y);
512 } catch (msgpack::type_error&) {
513  return false;
514 }
515 
516 inline bool operator!=(const msgpack::object& x, const msgpack::object& y)
517 { return !(x == y); }
518 
519 template <typename T>
520 inline bool operator==(const T& y, const msgpack::object& x)
521 { return x == y; }
522 
523 template <typename T>
524 inline bool operator!=(const msgpack::object& x, const T& y)
525 { return !(x == y); }
526 
527 template <typename T>
528 inline bool operator!=(const T& y, const msgpack::object& x)
529 { return x != y; }
530 
531 
533 {
534  return object::implicit_type(*this);
535 }
536 
537 template <typename T>
538 inline
539 typename msgpack::enable_if<
541  T&
542 >::type
543 object::convert(T& v) const
544 {
545  msgpack::operator>>(*this, v);
546  return v;
547 }
548 
549 template <typename T, std::size_t N>
550 inline T(&object::convert(T(&v)[N]) const)[N]
551 {
552  msgpack::operator>>(*this, v);
553  return v;
554 }
555 
556 #if !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
557 template <typename T>
558 inline
559 typename msgpack::enable_if<
561  T
562 >::type
563 object::convert(T v) const
564 {
565  convert(*v);
566  return v;
567 }
568 #endif // !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
569 
570 template <typename T>
571 inline bool object::convert_if_not_nil(T& v) const
572 {
573  if (is_nil()) {
574  return false;
575  }
576  convert(v);
577  return true;
578 }
579 
580 #if defined(MSGPACK_USE_CPP03)
581 
582 template <typename T>
583 inline T object::as() const
584 {
585  T v;
586  convert(v);
587  return v;
588 }
589 
590 #else // defined(MSGPACK_USE_CPP03)
591 
592 template <typename T>
593 inline typename std::enable_if<msgpack::has_as<T>::value, T>::type object::as() const {
594  return msgpack::adaptor::as<T>()(*this);
595 }
596 
597 template <typename T>
598 inline typename std::enable_if<!msgpack::has_as<T>::value, T>::type object::as() const {
599  T v;
600  convert(v);
601  return v;
602 }
603 
604 #endif // defined(MSGPACK_USE_CPP03)
605 
607 {
608  type = msgpack::type::NIL;
609 }
610 
611 template <typename T>
612 inline object::object(const T& v)
613 {
614  *this << v;
615 }
616 
617 template <typename T>
618 inline object& object::operator=(const T& v)
619 {
620  *this = object(v);
621  return *this;
622 }
623 
624 template <typename T>
625 inline object::object(const T& v, msgpack::zone& z)
626 {
627  with_zone oz(z);
628  msgpack::operator<<(oz, v);
629  type = oz.type;
630  via = oz.via;
631 }
632 
633 template <typename T>
634 inline object::object(const T& v, msgpack::zone* z)
635 {
636  with_zone oz(*z);
637  msgpack::operator<<(oz, v);
638  type = oz.type;
639  via = oz.via;
640 }
641 
642 
643 inline object::object(const msgpack_object& o)
644 {
645  // FIXME beter way?
646  std::memcpy(this, &o, sizeof(o));
647 }
648 
649 inline void operator<< (msgpack::object& o, const msgpack_object& v)
650 {
651  // FIXME beter way?
652  std::memcpy(&o, &v, sizeof(v));
653 }
654 
655 inline object::operator msgpack_object() const
656 {
657  // FIXME beter way?
658  msgpack_object obj;
659  std::memcpy(&obj, this, sizeof(obj));
660  return obj;
661 }
662 
663 
664 // obsolete
665 template <typename T>
666 inline void convert(T& v, msgpack::object const& o)
667 {
668  o.convert(v);
669 }
670 
671 // obsolete
672 template <typename Stream, typename T>
673 inline void pack(msgpack::packer<Stream>& o, const T& v)
674 {
675  o.pack(v);
676 }
677 
678 // obsolete
679 template <typename Stream, typename T>
680 inline void pack_copy(msgpack::packer<Stream>& o, T v)
681 {
682  pack(o, v);
683 }
684 
685 
686 template <typename Stream>
687 inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v)
688 {
689  switch(v.type) {
690  case msgpack::type::NIL:
691  o.pack_nil();
692  return o;
693 
695  if(v.via.boolean) {
696  o.pack_true();
697  } else {
698  o.pack_false();
699  }
700  return o;
701 
703  o.pack_uint64(v.via.u64);
704  return o;
705 
707  o.pack_int64(v.via.i64);
708  return o;
709 
711  o.pack_float(v.via.f64);
712  return o;
713 
715  o.pack_double(v.via.f64);
716  return o;
717 
718  case msgpack::type::STR:
719  o.pack_str(v.via.str.size);
720  o.pack_str_body(v.via.str.ptr, v.via.str.size);
721  return o;
722 
723  case msgpack::type::BIN:
724  o.pack_bin(v.via.bin.size);
725  o.pack_bin_body(v.via.bin.ptr, v.via.bin.size);
726  return o;
727 
728  case msgpack::type::EXT:
729  o.pack_ext(v.via.ext.size, v.via.ext.type());
730  o.pack_ext_body(v.via.ext.data(), v.via.ext.size);
731  return o;
732 
734  o.pack_array(v.via.array.size);
735  for(msgpack::object* p(v.via.array.ptr),
736  * const pend(v.via.array.ptr + v.via.array.size);
737  p < pend; ++p) {
738  msgpack::operator<<(o, *p);
739  }
740  return o;
741 
742  case msgpack::type::MAP:
743  o.pack_map(v.via.map.size);
744  for(msgpack::object_kv* p(v.via.map.ptr),
745  * const pend(v.via.map.ptr + v.via.map.size);
746  p < pend; ++p) {
747  msgpack::operator<<(o, p->key);
748  msgpack::operator<<(o, p->val);
749  }
750  return o;
751 
752  default:
753  throw msgpack::type_error();
754  }
755 }
756 
757 template <typename Stream>
758 inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v)
759 {
760  return o << static_cast<msgpack::object>(v);
761 }
762 
763 inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
764 {
765  switch(o.type) {
766  case msgpack::type::NIL:
767  s << "null";
768  break;
769 
771  s << (o.via.boolean ? "true" : "false");
772  break;
773 
775  s << o.via.u64;
776  break;
777 
779  s << o.via.i64;
780  break;
781 
784  s << o.via.f64;
785  break;
786 
787  case msgpack::type::STR:
788  s << '"';
789  for (uint32_t i = 0; i < o.via.str.size; ++i) {
790  char c = o.via.str.ptr[i];
791  switch (c) {
792  case '\\':
793  s << "\\\\";
794  break;
795  case '"':
796  s << "\\\"";
797  break;
798  case '/':
799  s << "\\/";
800  break;
801  case '\b':
802  s << "\\b";
803  break;
804  case '\f':
805  s << "\\f";
806  break;
807  case '\n':
808  s << "\\n";
809  break;
810  case '\r':
811  s << "\\r";
812  break;
813  case '\t':
814  s << "\\t";
815  break;
816  default: {
817  unsigned int code = static_cast<unsigned int>(c);
818  if (code < 0x20 || code == 0x7f) {
819  std::ios::fmtflags flags(s.flags());
820  s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff);
821  s.flags(flags);
822  }
823  else {
824  s << c;
825  }
826  } break;
827  }
828  }
829  s << '"';
830  break;
831 
832  case msgpack::type::BIN:
833  (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"';
834  break;
835 
836  case msgpack::type::EXT:
837  s << "EXT";
838  break;
839 
841  s << "[";
842  if(o.via.array.size != 0) {
844  s << *p;
845  ++p;
846  for(msgpack::object* const pend(o.via.array.ptr + o.via.array.size);
847  p < pend; ++p) {
848  s << ", " << *p;
849  }
850  }
851  s << "]";
852  break;
853 
854  case msgpack::type::MAP:
855  s << "{";
856  if(o.via.map.size != 0) {
858  s << p->key << ':' << p->val;
859  ++p;
860  for(msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
861  p < pend; ++p) {
862  s << ", " << p->key << ':' << p->val;
863  }
864  }
865  s << "}";
866  break;
867 
868  default:
869  // FIXME
870  s << "#<UNKNOWN " << static_cast<uint16_t>(o.type) << ">";
871  }
872  return s;
873 }
874 
876 } // MSGPACK_API_VERSION_NAMESPACE(v1)
878 
879 } // namespace msgpack
880 
881 #endif // MSGPACK_V1_OBJECT_HPP
define()
Definition: object.hpp:407
Definition: cpp_config_decl.hpp:71
packer< Stream > & pack_bin(uint32_t l)
Packing bin header and length.
Definition: pack.hpp:1255
Definition: object_fwd_decl.hpp:39
msgpack::object_kv * ptr
Definition: object_fwd.hpp:29
uint32_t size
Definition: object_fwd.hpp:23
object_handle()
Constructor that creates nil object and null zone.
Definition: object.hpp:46
packer< Stream > & pack_ext(size_t l, int8_t type)
Packing ext header, type, and length.
Definition: pack.hpp:1281
bool operator==(const msgpack::object &x, const msgpack::object &y)
Definition: object.hpp:432
void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:246
define(const msgpack_type &v)
Definition: object.hpp:408
Definition: object_fwd_decl.hpp:33
Definition: object_fwd_decl.hpp:30
const char * ptr
Definition: object_fwd.hpp:39
void operator()(msgpack::object::with_zone &o, T const &v) const
Definition: object.hpp:224
Type msgpack_type
Definition: object.hpp:405
void operator()(msgpack::object::with_zone &o, msgpack::object const &v) const
Definition: object.hpp:314
Definition: object_fwd_decl.hpp:62
union_type via
Definition: object_fwd.hpp:93
msgpack::packer< Stream > & operator()(msgpack::packer< Stream > &o, msgpack::object const &v) const
Definition: object.hpp:242
object()
Default constructor. The object is set to nil.
Definition: object.hpp:606
Definition: object_fwd_decl.hpp:40
msgpack::zone & zone
Definition: object.hpp:36
Definition: object.hpp:403
const char * ptr
Definition: object_fwd.hpp:46
msgpack::object * ptr
Definition: object_fwd.hpp:24
packer< Stream > & pack_array(uint32_t n)
Packing array header and size.
Definition: pack.hpp:1160
msgpack::object val
Definition: object.hpp:31
uint32_t size
Definition: object_fwd.hpp:38
packer< Stream > & pack_uint64(uint64_t d)
Packing uint16.
Definition: pack.hpp:717
Definition: adaptor_base.hpp:15
std::size_t aligned_size(std::size_t size, std::size_t align)
Definition: cpp03_zone.hpp:344
packer< Stream > & pack_int64(int64_t d)
Packing int32.
Definition: pack.hpp:733
Definition: object_fwd.hpp:238
const char * data() const
Definition: object_fwd.hpp:44
const char * ptr
Definition: object_fwd.hpp:34
object_handle(msgpack::object const &obj, msgpack::unique_ptr< msgpack::zone > &&z)
Constructor that creates an object_handle holding object obj and zone z.
Definition: object.hpp:53
Definition: cpp03_zone.hpp:22
void msgpack_pack(Packer &o) const
Definition: object.hpp:411
packer< Stream > & pack_bin_body(const char *b, uint32_t l)
Packing bin body.
Definition: pack.hpp:1274
packer< Stream > & pack_false()
Packing false.
Definition: pack.hpp:1151
bool boolean
Definition: object_fwd.hpp:77
msgpack::enable_if< !is_array< T >::value, msgpack::object const & >::type operator>>(msgpack::object const &o, T &v)
Definition: adaptor_base.hpp:57
void convert(T &v, msgpack::object const &o)
Definition: object.hpp:666
Definition: object.hpp:34
packer< Stream > & pack(const T &v)
Packing function template.
packer< Stream > & pack_str_body(const char *b, uint32_t l)
Packing str body.
Definition: pack.hpp:1220
Definition: object.hpp:29
Definition: cpp_config_decl.hpp:47
Definition: object_fwd_decl.hpp:29
int64_t i64
Definition: object_fwd.hpp:79
Definition: object_fwd_decl.hpp:32
#define MSGPACK_USE_CPP03
Definition: cpp_config_decl.hpp:21
packer< Stream > & pack_true()
Packing true.
Definition: pack.hpp:1143
std::enable_if< msgpack::has_as< T >::value, T >::type as() const
Get value as T.
Definition: object.hpp:593
Definition: adaptor_base.hpp:43
Definition: cpp_config_decl.hpp:81
uint32_t size
Definition: object_fwd.hpp:45
void pack_copy(msgpack::packer< Stream > &o, T v)
Definition: object.hpp:680
void operator()(msgpack::object::with_zone &o, msgpack::object::with_zone const &v) const
Definition: object.hpp:390
msgpack::enable_if< !msgpack::is_array< T >::value &&!msgpack::is_pointer< T >::value, T & >::type convert(T &v) const
Convert the object.
Definition: object.hpp:543
Definition: object_fwd.hpp:236
bool convert_if_not_nil(T &v) const
Convert the object if not nil.
Definition: object.hpp:571
define< Type > define_type
Definition: object.hpp:406
Definition: adaptor_base.hpp:32
std::size_t size(T const &t)
Definition: size_equal_only.hpp:24
object & operator=(const T &v)
Definition: object.hpp:618
int8_t type() const
Definition: object_fwd.hpp:43
std::size_t add_ext_type_size< 4 >(std::size_t size)
Definition: object.hpp:133
msgpack::enable_if< !is_array< T >::value, msgpack::packer< Stream > & >::type operator<<(msgpack::packer< Stream > &o, T const &v)
Definition: adaptor_base.hpp:72
double f64
Definition: object_fwd.hpp:84
Definition: object_fwd_decl.hpp:43
msgpack::object_array array
Definition: object_fwd.hpp:85
void pack(msgpack::packer< Stream > &o, const T &v)
Definition: object.hpp:673
with_zone(msgpack::zone &z)
Definition: object.hpp:35
msgpack::object const & operator()(msgpack::object const &o, msgpack::object &v) const
Definition: object.hpp:233
packer< Stream > & pack_map(uint32_t n)
Packing map header and size.
Definition: pack.hpp:1178
Definition: cpp_config_decl.hpp:56
msgpack::object_map map
Definition: object_fwd.hpp:86
msgpack::object_str str
Definition: object_fwd.hpp:87
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:75
packer< Stream > & pack_float(float d)
Packing float.
Definition: pack.hpp:1104
Definition: object.hpp:196
packer< Stream > & pack_double(double d)
Packing double.
Definition: pack.hpp:1115
packer< Stream > & pack_ext_body(const char *b, uint32_t l)
Packing ext body.
Definition: pack.hpp:1340
msgpack::type::object_type type
Definition: object_fwd.hpp:92
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
Definition: object_fwd_decl.hpp:41
msgpack::object key
Definition: object.hpp:30
uint32_t size
Definition: object_fwd.hpp:28
Definition: object_fwd_decl.hpp:42
msgpack::unique_ptr< msgpack::zone > & zone()
Get unique_ptr reference of zone.
Definition: object.hpp:77
Definition: object_fwd_decl.hpp:34
implicit_type convert() const
Definition: object.hpp:532
uint32_t size
Definition: object_fwd.hpp:33
#define MSGPACK_ZONE_ALIGNOF(type)
Definition: cpp03_zone_decl.hpp:30
std::size_t add_ext_type_size(std::size_t size)
Definition: object.hpp:128
Definition: adaptor_base.hpp:38
The class template that supports continuous packing.
Definition: adaptor_base_decl.hpp:24
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35
T & move(T &t)
object_handle clone(msgpack::object const &obj)
clone object
Definition: object.hpp:184
msgpack::object_ext ext
Definition: object_fwd.hpp:89
void msgpack_unpack(object const &o)
Definition: object.hpp:416
packer< Stream > & pack_nil()
Packing nil.
Definition: pack.hpp:1135
Definition: adaptor_base.hpp:27
packer< Stream > & pack_str(uint32_t l)
Packing str header and length.
Definition: pack.hpp:1197
msgpack::object const & operator()(msgpack::object const &o, T &v) const
Definition: object.hpp:208
static msgpack::packer< Stream > & pack(msgpack::packer< Stream > &o, const T &v)
Definition: object.hpp:197
msgpack::packer< Stream > & operator()(msgpack::packer< Stream > &o, T const &v) const
Definition: object.hpp:217
The class holds object and zone.
Definition: object.hpp:43
std::size_t aligned_zone_size(msgpack::object const &obj)
Definition: object.hpp:139
bool operator!=(const msgpack::object &x, const msgpack::object &y)
Definition: object.hpp:516
Definition: object_fwd_decl.hpp:31
uint64_t u64
Definition: object_fwd.hpp:78
msgpack::object_bin bin
Definition: object_fwd.hpp:88
const msgpack::unique_ptr< msgpack::zone > & zone() const
Get unique_ptr const reference of zone.
Definition: object.hpp:84