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
166namespace 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
257template <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
266template <>
267class 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
284template <typename T>
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};
314template <> class MsgPacker<uint64_t> : public Packer64<uint64_t> {};
315template <> class MsgPacker<int64_t> : public Packer64<int64_t> {};
316template <> class MsgPacker<double> : public Packer64<double> {};
317
318template <typename T>
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};
348template <> class MsgPacker<uint32_t> : public Packer32<uint32_t> {};
349template <> class MsgPacker<int32_t> : public Packer32<int32_t> {};
350template <> class MsgPacker<float> : public Packer32<float> {};
351
352template <typename T>
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};
382template <> class MsgPacker<uint16_t> : public Packer16<uint16_t> {};
383template <> class MsgPacker<int16_t> : public Packer16<int16_t> {};
384
385template <typename T>
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};
402template <> class MsgPacker<uint8_t> : public Packer8<uint8_t> {};
403template <> class MsgPacker<int8_t> : public Packer8<int8_t> {};
404
405template <>
406class 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
445template <typename I>
446class 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
496template <typename Tag, typename Value>
497class 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);
544 m[tag] = val;
545 }
546 return true;
547 }
548};
549
550
556class 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 */
static bool pack(std::ostream &os, char val)
Definition: AsyncMsg.h:270
static bool unpack(std::istream &is, char &val)
Definition: AsyncMsg.h:276
static size_t packedSize(const char &val)
Definition: AsyncMsg.h:275
static bool pack(std::ostream &os, const std::map< Tag, Value > &m)
Definition: AsyncMsg.h:500
static bool unpack(std::istream &is, std::map< Tag, Value > &m)
Definition: AsyncMsg.h:528
static size_t packedSize(const std::map< Tag, Value > &m)
Definition: AsyncMsg.h:517
static bool unpack(std::istream &is, std::string &val)
Definition: AsyncMsg.h:424
static size_t packedSize(const std::string &val)
Definition: AsyncMsg.h:420
static bool pack(std::ostream &os, const std::string &val)
Definition: AsyncMsg.h:409
static bool unpack(std::istream &is, std::vector< I > &vec)
Definition: AsyncMsg.h:475
static size_t packedSize(const std::vector< I > &vec)
Definition: AsyncMsg.h:465
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:263
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:261
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:262
Base class for all messages.
Definition: AsyncMsg.h:557
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)
Definition: AsyncMsg.h:675
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
Definition: AsyncMsg.h:624
virtual ~Msg(void)
Definition: AsyncMsg.h:559
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
size_t packedSize(const T &val) const
Definition: AsyncMsg.h:575
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4)
Definition: AsyncMsg.h:630
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4) const
Definition: AsyncMsg.h:618
bool pack(std::ostream &os, const T1 &v1, const T2 &v2) const
Definition: AsyncMsg.h:586
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
Definition: AsyncMsg.h:644
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
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
bool unpack(std::istream &is, T &val) const
Definition: AsyncMsg.h:580
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)
Definition: AsyncMsg.h:701
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, 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
Definition: AsyncMsg.h:739
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 T &val) const
Definition: AsyncMsg.h:570
bool packParent(std::ostream &) const
Definition: AsyncMsg.h:561
bool unpack(std::istream &is, T1 &v1, T2 &v2)
Definition: AsyncMsg.h:596
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
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3)
Definition: AsyncMsg.h:612
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
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
virtual bool unpack(std::istream &) const
Definition: AsyncMsg.h:567
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
size_t packedSizeParent(void) const
Definition: AsyncMsg.h:562
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
virtual size_t packedSize(void) const
Definition: AsyncMsg.h:566
bool pack(std::ostream &os, const T1 &v1, const T2 &v2, const T3 &v3) const
Definition: AsyncMsg.h:602
bool unpack(std::istream &is, T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)
Definition: AsyncMsg.h:651
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
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)
Definition: AsyncMsg.h:759
virtual bool pack(std::ostream &) const
Definition: AsyncMsg.h:565
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:365
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:364
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:356
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:331
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:322
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:330
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:288
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:296
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:297
static bool unpack(std::istream &is, T &val)
Definition: AsyncMsg.h:395
static bool pack(std::ostream &os, const T &val)
Definition: AsyncMsg.h:389
static size_t packedSize(const T &val)
Definition: AsyncMsg.h:394
Namespace for the asynchronous programming classes.