Async  1.5.0
AsyncMsg.h
Go to the documentation of this file.
1 
117 #ifndef ASYNC_MSG_INCLUDED
118 #define ASYNC_MSG_INCLUDED
119 
120 
121 /****************************************************************************
122  *
123  * System Includes
124  *
125  ****************************************************************************/
126 
127 #include <istream>
128 #include <ostream>
129 #include <vector>
130 #include <map>
131 #include <limits>
132 #include <endian.h>
133 #include <stdint.h>
134 
135 
136 /****************************************************************************
137  *
138  * Project Includes
139  *
140  ****************************************************************************/
141 
142 
143 
144 /****************************************************************************
145  *
146  * Local Includes
147  *
148  ****************************************************************************/
149 
150 
151 
152 /****************************************************************************
153  *
154  * Forward declarations
155  *
156  ****************************************************************************/
157 
158 
159 
160 /****************************************************************************
161  *
162  * Namespace
163  *
164  ****************************************************************************/
165 
166 namespace Async
167 {
168 
169 
170 /****************************************************************************
171  *
172  * Forward declarations of classes inside of the declared namespace
173  *
174  ****************************************************************************/
175 
176 
177 
178 /****************************************************************************
179  *
180  * Defines & typedefs
181  *
182  ****************************************************************************/
183 
191 #define ASYNC_MSG_DERIVED_FROM(BASE_CLASS) \
192  bool packParent(std::ostream& os) const \
193  { \
194  return BASE_CLASS::pack(os); \
195  } \
196  size_t packedSizeParent(void) const \
197  { \
198  return BASE_CLASS::packedSize(); \
199  } \
200  bool unpackParent(std::istream& is) \
201  { \
202  return BASE_CLASS::unpack(is); \
203  }
204 
212 #define ASYNC_MSG_MEMBERS(...) \
213  bool pack(std::ostream& os) const \
214  { \
215  return packParent(os) && Msg::pack(os, __VA_ARGS__); \
216  } \
217  size_t packedSize(void) const \
218  { \
219  return packedSizeParent() + Msg::packedSize(__VA_ARGS__); \
220  } \
221  bool unpack(std::istream& is) \
222  { \
223  return unpackParent(is) && Msg::unpack(is, __VA_ARGS__); \
224  }
225 
231 #define ASYNC_MSG_NO_MEMBERS \
232  bool pack(std::ostream& os) const \
233  { \
234  return packParent(os); \
235  } \
236  size_t packedSize(void) const { return packedSizeParent(); } \
237  bool unpack(std::istream& is) \
238  { \
239  return unpackParent(is); \
240  }
241 
242 
243 /****************************************************************************
244  *
245  * Exported Global Variables
246  *
247  ****************************************************************************/
248 
249 
250 
251 /****************************************************************************
252  *
253  * Class definitions
254  *
255  ****************************************************************************/
256 
257 template <typename T>
259 {
260  public:
261  static bool pack(std::ostream& os, const T& val) { return val.pack(os); }
262  static size_t packedSize(const T& val) { return val.packedSize(); }
263  static bool unpack(std::istream& is, T& val) { return val.unpack(is); }
264 };
265 
266 template <>
267 class MsgPacker<char>
268 {
269  public:
270  static bool pack(std::ostream& os, char val)
271  {
272  //std::cout << "pack<char>("<< int(val) << ")" << std::endl;
273  return os.write(&val, 1).good();
274  }
275  static size_t packedSize(const char& val) { return sizeof(char); }
276  static bool unpack(std::istream& is, char& val)
277  {
278  is.read(&val, 1);
279  //std::cout << "unpack<char>(" << int(val) << ")" << std::endl;
280  return is.good();
281  }
282 };
283 
284 template <typename T>
285 class Packer64
286 {
287  public:
288  static bool pack(std::ostream& os, const T& val)
289  {
290  //std::cout << "pack<64>(" << val << ")" << std::endl;
291  Overlay o;
292  o.val = val;
293  o.uval = htobe64(o.uval);
294  return os.write(o.buf, sizeof(T)).good();
295  }
296  static size_t packedSize(const T& val) { return sizeof(T); }
297  static bool unpack(std::istream& is, T& val)
298  {
299  Overlay o;
300  is.read(o.buf, sizeof(T));
301  o.uval = be64toh(o.uval);
302  val = o.val;
303  //std::cout << "unpack<64>(" << val << ")" << std::endl;
304  return is.good();
305  }
306  private:
307  union Overlay
308  {
309  char buf[sizeof(T)];
310  uint64_t uval;
311  T val;
312  };
313 };
314 template <> class MsgPacker<uint64_t> : public Packer64<uint64_t> {};
315 template <> class MsgPacker<int64_t> : public Packer64<int64_t> {};
316 template <> class MsgPacker<double> : public Packer64<double> {};
317 
318 template <typename T>
319 class Packer32
320 {
321  public:
322  static bool pack(std::ostream& os, const T& val)
323  {
324  //std::cout << "pack<32>(" << val << ")" << std::endl;
325  Overlay o;
326  o.val = val;
327  o.uval = htobe32(o.uval);
328  return os.write(o.buf, sizeof(T)).good();
329  }
330  static size_t packedSize(const T& val) { return sizeof(T); }
331  static bool unpack(std::istream& is, T& val)
332  {
333  Overlay o;
334  is.read(o.buf, sizeof(T));
335  o.uval = be32toh(o.uval);
336  val = o.val;
337  //std::cout << "unpack<32>(" << val << ")" << std::endl;
338  return is.good();
339  }
340  private:
341  union Overlay
342  {
343  char buf[sizeof(T)];
344  uint32_t uval;
345  T val;
346  };
347 };
348 template <> class MsgPacker<uint32_t> : public Packer32<uint32_t> {};
349 template <> class MsgPacker<int32_t> : public Packer32<int32_t> {};
350 template <> class MsgPacker<float> : public Packer32<float> {};
351 
352 template <typename T>
353 class Packer16
354 {
355  public:
356  static bool pack(std::ostream& os, const T& val)
357  {
358  //std::cout << "pack<16>(" << val << ")" << std::endl;
359  Overlay o;
360  o.val = val;
361  o.uval = htobe16(o.uval);
362  return os.write(o.buf, sizeof(T)).good();
363  }
364  static size_t packedSize(const T& val) { return sizeof(T); }
365  static bool unpack(std::istream& is, T& val)
366  {
367  Overlay o;
368  is.read(o.buf, sizeof(T));
369  o.uval = be16toh(o.uval);
370  val = o.val;
371  //std::cout << "unpack<16>(" << val << ")" << std::endl;
372  return is.good();
373  }
374  private:
375  union Overlay
376  {
377  char buf[sizeof(T)];
378  uint16_t uval;
379  T val;
380  };
381 };
382 template <> class MsgPacker<uint16_t> : public Packer16<uint16_t> {};
383 template <> class MsgPacker<int16_t> : public Packer16<int16_t> {};
384 
385 template <typename T>
386 class Packer8
387 {
388  public:
389  static bool pack(std::ostream& os, const T& val)
390  {
391  //std::cout << "pack<8>(" << int(val) << ")" << std::endl;
392  return os.write(reinterpret_cast<const char*>(&val), sizeof(T)).good();
393  }
394  static size_t packedSize(const T& val) { return sizeof(T); }
395  static bool unpack(std::istream& is, T& val)
396  {
397  is.read(reinterpret_cast<char*>(&val), sizeof(T));
398  //std::cout << "unpack<8>(" << int(val) << ")" << std::endl;
399  return is.good();
400  }
401 };
402 template <> class MsgPacker<uint8_t> : public Packer8<uint8_t> {};
403 template <> class MsgPacker<int8_t> : public Packer8<int8_t> {};
404 
405 template <>
406 class MsgPacker<std::string>
407 {
408  public:
409  static bool pack(std::ostream& os, const std::string& val)
410  {
411  //std::cout << "pack<string>(" << val << ")" << std::endl;
412  if (val.size() > std::numeric_limits<uint16_t>::max())
413  {
414  return false;
415  }
416  uint16_t str_len(val.size());
417  return MsgPacker<uint16_t>::pack(os, str_len) &&
418  os.write(val.c_str(), val.size());
419  }
420  static size_t packedSize(const std::string& val)
421  {
422  return sizeof(uint16_t) + val.size();
423  }
424  static bool unpack(std::istream& is, std::string& val)
425  {
426  uint16_t str_len;
427  if (MsgPacker<uint16_t>::unpack(is, str_len))
428  {
429  if (str_len > std::numeric_limits<uint16_t>::max())
430  {
431  return false;
432  }
433  char buf[str_len];
434  if (is.read(buf, str_len))
435  {
436  val.assign(buf, str_len);
437  //std::cout << "unpack<string>(" << val << ")" << std::endl;
438  return true;
439  }
440  }
441  return false;
442  }
443 };
444 
445 template <typename I>
446 class MsgPacker<std::vector<I> >
447 {
448  public:
449  static bool pack(std::ostream& os, const std::vector<I>& vec)
450  {
451  //std::cout << "pack<vector>(" << vec.size() << ")" << std::endl;
452  if (vec.size() > std::numeric_limits<uint16_t>::max())
453  {
454  return false;
455  }
456  MsgPacker<uint16_t>::pack(os, vec.size());
457  for (typename std::vector<I>::const_iterator it = vec.begin();
458  it != vec.end();
459  ++it)
460  {
461  MsgPacker<I>::pack(os, *it);
462  }
463  return true;
464  }
465  static size_t packedSize(const std::vector<I>& vec)
466  {
467  size_t size = sizeof(uint16_t);
468  for (typename std::vector<I>::const_iterator it = vec.begin();
469  it != vec.end(); ++it)
470  {
471  size += MsgPacker<I>::packedSize(*it);
472  }
473  return size;
474  }
475  static bool unpack(std::istream& is, std::vector<I>& vec)
476  {
477  uint16_t vec_size;
478  MsgPacker<uint16_t>::unpack(is, vec_size);
479  if (vec_size > std::numeric_limits<uint16_t>::max())
480  {
481  return false;
482  }
483  //std::cout << "unpack<vector>(" << vec_size << ")" << std::endl;
484  vec.clear();
485  vec.reserve(vec_size);
486  for (int i=0; i<vec_size; ++i)
487  {
488  I val;
489  MsgPacker<I>::unpack(is, val);
490  vec.push_back(val);
491  }
492  return true;
493  }
494 };
495 
496 template <typename Tag, typename Value>
497 class MsgPacker<std::map<Tag,Value> >
498 {
499  public:
500  static bool pack(std::ostream& os, const std::map<Tag, Value>& m)
501  {
502  //std::cout << "pack<map>(" << m.size() << ")" << std::endl;
503  if (m.size() > std::numeric_limits<uint16_t>::max())
504  {
505  return false;
506  }
507  MsgPacker<uint16_t>::pack(os, m.size());
508  for (typename std::map<Tag,Value>::const_iterator it = m.begin();
509  it != m.end();
510  ++it)
511  {
512  MsgPacker<Tag>::pack(os, (*it).first);
513  MsgPacker<Value>::pack(os, (*it).second);
514  }
515  return true;
516  }
517  static size_t packedSize(const std::map<Tag, Value>& m)
518  {
519  size_t size = sizeof(uint16_t);
520  for (typename std::map<Tag, Value>::const_iterator it = m.begin();
521  it != m.end(); ++it)
522  {
523  size += (MsgPacker<Tag>::packedSize((*it).first) +
524  MsgPacker<Value>::packedSize((*it).second));
525  }
526  return size;
527  }
528  static bool unpack(std::istream& is, std::map<Tag,Value>& m)
529  {
530  uint16_t map_size;
531  MsgPacker<uint16_t>::unpack(is, map_size);
532  if (map_size > std::numeric_limits<uint16_t>::max())
533  {
534  return false;
535  }
536  //std::cout << "unpack<map>(" << map_size << ")" << std::endl;
537  m.clear();
538  for (int i=0; i<map_size; ++i)
539  {
540  Tag tag;
541  Value val;
542  MsgPacker<Tag>::unpack(is, tag);
543  MsgPacker<Value>::unpack(is, val);
544  m[tag] = val;
545  }
546  return true;
547  }
548 };
549 
550 
556 class Msg
557 {
558  public:
559  virtual ~Msg(void) {}
560 
561  bool packParent(std::ostream&) const { return true; }
562  size_t packedSizeParent(void) const { return 0; }
563  bool unpackParent(std::istream&) const { return true; }
564 
565  virtual bool pack(std::ostream&) const { return true; }
566  virtual size_t packedSize(void) const { return 0; }
567  virtual bool unpack(std::istream&) const { return true; }
568 
569  template <typename T>
570  bool pack(std::ostream& os, const T& val) const
571  {
572  return MsgPacker<T>::pack(os, val);
573  }
574  template <typename T>
575  size_t packedSize(const T& val) const
576  {
577  return MsgPacker<T>::packedSize(val);
578  }
579  template <typename T>
580  bool unpack(std::istream& is, T& val) const
581  {
582  return MsgPacker<T>::unpack(is, val);
583  }
584 
585  template <typename T1, typename T2>
586  bool pack(std::ostream& os, const T1& v1, const T2& v2) const
587  {
588  return pack(os, v1) && pack(os, v2);
589  }
590  template <typename T1, typename T2>
591  size_t packedSize(const T1& v1, const T2& v2) const
592  {
593  return packedSize(v1) + packedSize(v2);
594  }
595  template <typename T1, typename T2>
596  bool unpack(std::istream& is, T1& v1, T2& v2)
597  {
598  return unpack(is, v1) && unpack(is, v2);
599  }
600 
601  template <typename T1, typename T2, typename T3>
602  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3) const
603  {
604  return pack(os, v1) && pack(os, v2) && pack(os, v3);
605  }
606  template <typename T1, typename T2, typename T3>
607  size_t packedSize(const T1& v1, const T2& v2, const T3& v3) const
608  {
609  return packedSize(v1) + packedSize(v2) + packedSize(v3);
610  }
611  template <typename T1, typename T2, typename T3>
612  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3)
613  {
614  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3);
615  }
616 
617  template <typename T1, typename T2, typename T3, typename T4>
618  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
619  const T4& v4) const
620  {
621  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4);
622  }
623  template <typename T1, typename T2, typename T3, typename T4>
624  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
625  const T4& v4) const
626  {
627  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4);
628  }
629  template <typename T1, typename T2, typename T3, typename T4>
630  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4)
631  {
632  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
633  unpack(is, v4);
634  }
635 
636  template <typename T1, typename T2, typename T3, typename T4, typename T5>
637  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
638  const T4& v4, const T5& v5) const
639  {
640  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
641  pack(os, v5);
642  }
643  template <typename T1, typename T2, typename T3, typename T4, typename T5>
644  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
645  const T4& v4, const T5& v5) const
646  {
647  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
648  packedSize(v5);
649  }
650  template <typename T1, typename T2, typename T3, typename T4, typename T5>
651  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5)
652  {
653  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
654  unpack(is, v4) && unpack(is, v5);
655  }
656 
657  template <typename T1, typename T2, typename T3, typename T4, typename T5,
658  typename T6>
659  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
660  const T4& v4, const T5& v5, const T6& v6) const
661  {
662  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
663  pack(os, v5) && pack(os, v6);
664  }
665  template <typename T1, typename T2, typename T3, typename T4, typename T5,
666  typename T6>
667  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
668  const T4& v4, const T5& v5, const T6& v6) const
669  {
670  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
671  packedSize(v5) + packedSize(v6);
672  }
673  template <typename T1, typename T2, typename T3, typename T4, typename T5,
674  typename T6>
675  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5,
676  T6& v6)
677  {
678  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
679  unpack(is, v4) && unpack(is, v5) && unpack(is, v6);
680  }
681 
682  template <typename T1, typename T2, typename T3, typename T4, typename T5,
683  typename T6, typename T7>
684  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
685  const T4& v4, const T5& v5, const T6& v6, const T7& v7) const
686  {
687  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
688  pack(os, v5) && pack(os, v6) && pack(os, v7);
689  }
690  template <typename T1, typename T2, typename T3, typename T4, typename T5,
691  typename T6, typename T7>
692  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
693  const T4& v4, const T5& v5, const T6& v6,
694  const T7& v7) const
695  {
696  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
697  packedSize(v5) + packedSize(v6) + packedSize(v7);
698  }
699  template <typename T1, typename T2, typename T3, typename T4, typename T5,
700  typename T6, typename T7>
701  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5,
702  T6& v6, T7& v7)
703  {
704  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
705  unpack(is, v4) && unpack(is, v5) && unpack(is, v6) &&
706  unpack(is, v7);
707  }
708 
709  template <typename T1, typename T2, typename T3, typename T4, typename T5,
710  typename T6, typename T7, typename T8>
711  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
712  const T4& v4, const T5& v5, const T6& v6, const T7& v7,
713  const T8& v8) const
714  {
715  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
716  pack(os, v5) && pack(os, v6) && pack(os, v7) && pack(os, v8);
717  }
718  template <typename T1, typename T2, typename T3, typename T4, typename T5,
719  typename T6, typename T7, typename T8>
720  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
721  const T4& v4, const T5& v5, const T6& v6,
722  const T7& v7, const T8& v8) const
723  {
724  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
725  packedSize(v5) + packedSize(v6) + packedSize(v7) + packedSize(v8);
726  }
727  template <typename T1, typename T2, typename T3, typename T4, typename T5,
728  typename T6, typename T7, typename T8>
729  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5,
730  T6& v6, T7& v7, T8& v8)
731  {
732  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
733  unpack(is, v4) && unpack(is, v5) && unpack(is, v6) &&
734  unpack(is, v7) && unpack(is, v8);
735  }
736 
737  template <typename T1, typename T2, typename T3, typename T4, typename T5,
738  typename T6, typename T7, typename T8, typename T9>
739  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
740  const T4& v4, const T5& v5, const T6& v6, const T7& v7,
741  const T8& v8, const T9& v9) const
742  {
743  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
744  pack(os, v5) && pack(os, v6) && pack(os, v7) && pack(os, v8) &&
745  pack(os, v9);
746  }
747  template <typename T1, typename T2, typename T3, typename T4, typename T5,
748  typename T6, typename T7, typename T8, typename T9>
749  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
750  const T4& v4, const T5& v5, const T6& v6,
751  const T7& v7, const T8& v8, const T9& v9) const
752  {
753  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
754  packedSize(v5) + packedSize(v6) + packedSize(v7) + packedSize(v8) +
755  packedSize(v9);
756  }
757  template <typename T1, typename T2, typename T3, typename T4, typename T5,
758  typename T6, typename T7, typename T8, typename T9>
759  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5,
760  T6& v6, T7& v7, T8& v8, T9& v9)
761  {
762  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
763  unpack(is, v4) && unpack(is, v5) && unpack(is, v6) &&
764  unpack(is, v7) && unpack(is, v8) && unpack(is, v9);
765  }
766 
767  template <typename T1, typename T2, typename T3, typename T4, typename T5,
768  typename T6, typename T7, typename T8, typename T9, typename T10>
769  bool pack(std::ostream& os, const T1& v1, const T2& v2, const T3& v3,
770  const T4& v4, const T5& v5, const T6& v6, const T7& v7,
771  const T8& v8, const T9& v9, const T10& v10) const
772  {
773  return pack(os, v1) && pack(os, v2) && pack(os, v3) && pack(os, v4) &&
774  pack(os, v5) && pack(os, v6) && pack(os, v7) && pack(os, v8) &&
775  pack(os, v9) && pack(os, v10);
776  }
777  template <typename T1, typename T2, typename T3, typename T4, typename T5,
778  typename T6, typename T7, typename T8, typename T9, typename T10>
779  size_t packedSize(const T1& v1, const T2& v2, const T3& v3,
780  const T4& v4, const T5& v5, const T6& v6,
781  const T7& v7, const T8& v8, const T9& v9,
782  const T10& v10) const
783  {
784  return packedSize(v1) + packedSize(v2) + packedSize(v3) + packedSize(v4) +
785  packedSize(v5) + packedSize(v6) + packedSize(v7) + packedSize(v8) +
786  packedSize(v9) + packedSize(v10);
787  }
788  template <typename T1, typename T2, typename T3, typename T4, typename T5,
789  typename T6, typename T7, typename T8, typename T9, typename T10>
790  bool unpack(std::istream& is, T1& v1, T2& v2, T3& v3, T4& v4, T5& v5,
791  T6& v6, T7& v7, T8& v8, T9& v9, T10& v10)
792  {
793  return unpack(is, v1) && unpack(is, v2) && unpack(is, v3) &&
794  unpack(is, v4) && unpack(is, v5) && unpack(is, v6) &&
795  unpack(is, v7) && unpack(is, v8) && unpack(is, v9) &&
796  unpack(is, v10);
797  }
798 }; /* class Msg */
799 
800 
801 } /* namespace */
802 
803 #endif /* ASYNC_MSG_INCLUDED */
804 
805 
806 /*
807  * This file has not been truncated
808  */
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) const
Definition: AsyncMsg.h:618
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8) const
Definition: AsyncMsg.h:720
static size_t packedSize(const char &val)
Definition: AsyncMsg.h:275
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) const
Definition: AsyncMsg.h:624
bool unpack(std::istream &is, T &val) const
Definition: AsyncMsg.h:580
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:389
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8) const
Definition: AsyncMsg.h:711
virtual bool unpack(std::istream &) const
Definition: AsyncMsg.h:567
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10) const
Definition: AsyncMsg.h:779
static size_t packedSize(const std::string &val)
Definition: AsyncMsg.h:420
size_t packedSize(const T &val) const
Definition: AsyncMsg.h:575
bool unpackParent(std::istream &) const
Definition: AsyncMsg.h:563
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6) const
Definition: AsyncMsg.h:667
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7) const
Definition: AsyncMsg.h:692
static bool unpack(std::istream &is, std::vector< I > &vec)
Definition: AsyncMsg.h:475
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3) const
Definition: AsyncMsg.h:602
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:263
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)
Definition: AsyncMsg.h:651
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9) const
Definition: AsyncMsg.h:749
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:331
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)
Definition: AsyncMsg.h:701
virtual ~Msg(void)
Definition: AsyncMsg.h:559
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)
Definition: AsyncMsg.h:675
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:395
static bool unpack(std::istream &is, char &val)
Definition: AsyncMsg.h:276
bool pack(std::ostream &os, const T1 &v1, const T2 &v2) const
Definition: AsyncMsg.h:586
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:262
static size_t packedSize(const std::vector< I > &vec)
Definition: AsyncMsg.h:465
static bool unpack(std::istream &is, std::map< Tag, Value > &m)
Definition: AsyncMsg.h:528
static bool pack(std::ostream &os, const std::map< Tag, Value > &m)
Definition: AsyncMsg.h:500
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3) const
Definition: AsyncMsg.h:607
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8, T9 &v9, T10 &v10)
Definition: AsyncMsg.h:790
Base class for all messages.
Definition: AsyncMsg.h:556
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:364
static bool pack(std::ostream &os, const std::string &val)
Definition: AsyncMsg.h:409
static bool pack(std::ostream &os, char val)
Definition: AsyncMsg.h:270
virtual bool pack(std::ostream &) const
Definition: AsyncMsg.h:565
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8)
Definition: AsyncMsg.h:729
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9, const T10 &v10) const
Definition: AsyncMsg.h:769
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8, T9 &v9)
Definition: AsyncMsg.h:759
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:296
bool packParent(std::ostream &) const
Definition: AsyncMsg.h:561
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:330
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:365
virtual size_t packedSize(void) const
Definition: AsyncMsg.h:566
Namespace for the asynchronous programming classes.
size_t packedSize(const T1 &v1, const T2 &v2) const
Definition: AsyncMsg.h:591
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3)
Definition: AsyncMsg.h:612
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:261
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:394
size_t packedSizeParent(void) const
Definition: AsyncMsg.h:562
static bool pack(std::ostream &os, const std::vector< I > &vec)
Definition: AsyncMsg.h:449
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:297
static size_t packedSize(const std::map< Tag, Value > &m)
Definition: AsyncMsg.h:517
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:322
bool unpack(std::istream &is, T1 &v1, T2 &v2)
Definition: AsyncMsg.h:596
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5) const
Definition: AsyncMsg.h:637
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6) const
Definition: AsyncMsg.h:659
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7) const
Definition: AsyncMsg.h:684
bool pack(std::ostream &os, const T &val) const
Definition: AsyncMsg.h:570
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4)
Definition: AsyncMsg.h:630
size_t packedSize(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5) const
Definition: AsyncMsg.h:644
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:288
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8, const T9 &v9) const
Definition: AsyncMsg.h:739
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:356
static bool unpack(std::istream &is, std::string &val)
Definition: AsyncMsg.h:424