Fast CDR  Version 1.0.25
Fast CDR
Cdr.h
1// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#ifndef _FASTCDR_CDR_H_
16#define _FASTCDR_CDR_H_
17
18#include "fastcdr_dll.h"
19#include "FastBuffer.h"
20#include "exceptions/NotEnoughMemoryException.h"
21#include <stdint.h>
22#include <string>
23#include <vector>
24#include <map>
25#include <iostream>
26
27#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
28#include <malloc.h>
29#else
30#include <stdlib.h>
31#endif // if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
32
33#if HAVE_CXX0X
34#include <array>
35#endif // if HAVE_CXX0X
36
37namespace eprosima {
38namespace fastcdr {
43class Cdr_DllAPI Cdr
44{
45public:
46
48 typedef enum
49 {
53 DDS_CDR
54 } CdrType;
55
57
58#ifdef HAVE_CXX0X
59 typedef enum : uint8_t
60#else
61 typedef enum
62#endif // ifdef HAVE_CXX0X
63 {
65 DDS_CDR_WITHOUT_PL = 0x0,
67 DDS_CDR_WITH_PL = 0x2
68 } DDSCdrPlFlag;
69
73#ifdef HAVE_CXX0X
74 typedef enum : uint8_t
75#else
76 typedef enum
77#endif // ifdef HAVE_CXX0X
78 {
80 BIG_ENDIANNESS = 0x0,
82 LITTLE_ENDIANNESS = 0x1
83 } Endianness;
84
87
91 class Cdr_DllAPI state
92 {
93 friend class Cdr;
94
95 public:
96
101 const Cdr& cdr);
102
107 const state&);
108
109 private:
110
111 state& operator =(
112 const state&) = delete;
113
115 const FastBuffer::iterator m_currentPosition;
116
118 const FastBuffer::iterator m_alignPosition;
119
121 bool m_swapBytes;
122
124 size_t m_lastDataSize;
125 };
126
136 FastBuffer& cdrBuffer,
137 const Endianness endianness = DEFAULT_ENDIAN,
138 const CdrType cdrType = CORBA_CDR);
139
148
156
162
168 DDSCdrPlFlag plFlag);
169
174 uint16_t getDDSCdrOptions() const;
175
181 uint16_t options);
182
188 Endianness endianness);
189
195 {
196 return static_cast<Endianness>(m_endianness);
197 }
198
204 bool jump(
205 size_t numBytes);
206
210 void reset();
211
217
223
228 inline size_t getSerializedDataLength() const
229 {
230 return m_currentPosition - m_cdrBuffer.begin();
231 }
232
239 inline static size_t alignment(
240 size_t current_alignment,
241 size_t dataSize)
242 {
243 return (dataSize - (current_alignment % dataSize)) & (dataSize - 1);
244 }
245
251
257 state& state);
258
265 size_t numBytes);
266
270 inline void resetAlignment()
271 {
272 m_alignPosition = m_currentPosition;
273 }
274
281 inline Cdr& operator <<(
282 const uint8_t octet_t)
283 {
284 return serialize(octet_t);
285 }
286
293 inline Cdr& operator <<(
294 const char char_t)
295 {
296 return serialize(char_t);
297 }
298
305 inline Cdr& operator <<(
306 const int8_t int8)
307 {
308 return serialize(int8);
309 }
310
317 inline Cdr& operator <<(
318 const uint16_t ushort_t)
319 {
320 return serialize(ushort_t);
321 }
322
329 inline Cdr& operator <<(
330 const int16_t short_t)
331 {
332 return serialize(short_t);
333 }
334
341 inline Cdr& operator <<(
342 const uint32_t ulong_t)
343 {
344 return serialize(ulong_t);
345 }
346
353 inline Cdr& operator <<(
354 const int32_t long_t)
355 {
356 return serialize(long_t);
357 }
358
365 inline Cdr& operator <<(
366 const wchar_t wchar)
367 {
368 return serialize(wchar);
369 }
370
377 inline Cdr& operator <<(
378 const uint64_t ulonglong_t)
379 {
380 return serialize(ulonglong_t);
381 }
382
389 inline Cdr& operator <<(
390 const int64_t longlong_t)
391 {
392 return serialize(longlong_t);
393 }
394
401 inline Cdr& operator <<(
402 const float float_t)
403 {
404 return serialize(float_t);
405 }
406
413 inline Cdr& operator <<(
414 const double double_t)
415 {
416 return serialize(double_t);
417 }
418
425 inline Cdr& operator <<(
426 const long double ldouble_t)
427 {
428 return serialize(ldouble_t);
429 }
430
437 inline Cdr& operator <<(
438 const bool bool_t)
439 {
440 return serialize(bool_t);
441 }
442
449 inline Cdr& operator <<(
450 const char* string_t)
451 {
452 return serialize(string_t);
453 }
454
461 inline Cdr& operator <<(
462 char* string_t)
463 {
464 return serialize(string_t);
465 }
466
473 inline Cdr& operator <<(
474 const std::string& string_t)
475 {
476 return serialize(string_t);
477 }
478
485 inline Cdr& operator <<(
486 const std::wstring& string_t)
487 {
488 return serialize(string_t);
489 }
490
491#if HAVE_CXX0X
498 template<class _T, size_t _Size>
499 inline Cdr& operator <<(
500 const std::array<_T, _Size>& array_t)
501 {
502 return serialize<_T, _Size>(array_t);
503 }
504
505#endif // if HAVE_CXX0X
506
513 template<class _T>
514 inline Cdr& operator <<(
515 const std::vector<_T>& vector_t)
516 {
517 return serialize<_T>(vector_t);
518 }
519
526 template<class _K, class _T>
527 inline Cdr& operator <<(
528 const std::map<_K, _T>& map_t)
529 {
530 return serialize<_K, _T>(map_t);
531 }
532
539 template<class _T>
540 inline Cdr& operator <<(
541 const _T& type_t)
542 {
543 type_t.serialize(*this);
544 return *this;
545 }
546
553 inline Cdr& operator >>(
554 uint8_t& octet_t)
555 {
556 return deserialize(octet_t);
557 }
558
565 inline Cdr& operator >>(
566 char& char_t)
567 {
568 return deserialize(char_t);
569 }
570
577 inline Cdr& operator >>(
578 int8_t& int8)
579 {
580 return deserialize(int8);
581 }
582
589 inline Cdr& operator >>(
590 uint16_t& ushort_t)
591 {
592 return deserialize(ushort_t);
593 }
594
601 inline Cdr& operator >>(
602 int16_t& short_t)
603 {
604 return deserialize(short_t);
605 }
606
613 inline Cdr& operator >>(
614 uint32_t& ulong_t)
615 {
616 return deserialize(ulong_t);
617 }
618
625 inline Cdr& operator >>(
626 int32_t& long_t)
627 {
628 return deserialize(long_t);
629 }
630
631 // TODO in FastCdr
638 inline Cdr& operator >>(
639 wchar_t& wchar)
640 {
641 return deserialize(wchar);
642 }
643
650 inline Cdr& operator >>(
651 uint64_t& ulonglong_t)
652 {
653 return deserialize(ulonglong_t);
654 }
655
662 inline Cdr& operator >>(
663 int64_t& longlong_t)
664 {
665 return deserialize(longlong_t);
666 }
667
674 inline Cdr& operator >>(
675 float& float_t)
676 {
677 return deserialize(float_t);
678 }
679
686 inline Cdr& operator >>(
687 double& double_t)
688 {
689 return deserialize(double_t);
690 }
691
698 inline Cdr& operator >>(
699 long double& ldouble_t)
700 {
701 return deserialize(ldouble_t);
702 }
703
711 inline Cdr& operator >>(
712 bool& bool_t)
713 {
714 return deserialize(bool_t);
715 }
716
726 inline Cdr& operator >>(
727 char*& string_t)
728 {
729 return deserialize(string_t);
730 }
731
738 inline Cdr& operator >>(
739 std::string& string_t)
740 {
741 return deserialize(string_t);
742 }
743
750 inline Cdr& operator >>(
751 std::wstring& string_t)
752 {
753 return deserialize(string_t);
754 }
755
756#if HAVE_CXX0X
763 template<class _T, size_t _Size>
764 inline Cdr& operator >>(
765 std::array<_T, _Size>& array_t)
766 {
767 return deserialize<_T, _Size>(array_t);
768 }
769
770#endif // if HAVE_CXX0X
771
778 template<class _T>
779 inline Cdr& operator >>(
780 std::vector<_T>& vector_t)
781 {
782 return deserialize<_T>(vector_t);
783 }
784
791 template<class _K, class _T>
792 inline Cdr& operator >>(
793 std::map<_K, _T>& map_t)
794 {
795 return deserialize<_K, _T>(map_t);
796 }
797
804 template<class _T>
805 inline Cdr& operator >>(
806 _T& type_t)
807 {
808 type_t.deserialize(*this);
809 return *this;
810 }
811
818 inline
820 const uint8_t octet_t)
821 {
822 return serialize(static_cast<char>(octet_t));
823 }
824
832 inline
834 const uint8_t octet_t,
835 Endianness endianness)
836 {
837 return serialize(static_cast<char>(octet_t), endianness);
838 }
839
847 const char char_t);
848
856 inline
858 const char char_t,
859 Endianness endianness)
860 {
861 (void) endianness;
862 return serialize(char_t);
863 }
864
871 inline
873 const int8_t int8)
874 {
875 return serialize(static_cast<char>(int8));
876 }
877
885 inline
887 const int8_t int8,
888 Endianness endianness)
889 {
890 return serialize(static_cast<char>(int8), endianness);
891 }
892
899 inline
901 const uint16_t ushort_t)
902 {
903 return serialize(static_cast<int16_t>(ushort_t));
904 }
905
913 inline
915 const uint16_t ushort_t,
916 Endianness endianness)
917 {
918 return serialize(static_cast<int16_t>(ushort_t), endianness);
919 }
920
928 const int16_t short_t);
929
938 const int16_t short_t,
939 Endianness endianness);
940
947 inline
949 const uint32_t ulong_t)
950 {
951 return serialize(static_cast<int32_t>(ulong_t));
952 }
953
961 inline
963 const uint32_t ulong_t,
964 Endianness endianness)
965 {
966 return serialize(static_cast<int32_t>(ulong_t), endianness);
967 }
968
976 const int32_t long_t);
977
986 const int32_t long_t,
987 Endianness endianness);
988
995 inline
997 const wchar_t wchar)
998 {
999 return serialize(static_cast<uint32_t>(wchar));
1000 }
1001
1009 inline
1011 const wchar_t wchar,
1012 Endianness endianness)
1013 {
1014 return serialize(static_cast<uint32_t>(wchar), endianness);
1015 }
1016
1023 inline
1025 const uint64_t ulonglong_t)
1026 {
1027 return serialize(static_cast<int64_t>(ulonglong_t));
1028 }
1029
1037 inline
1039 const uint64_t ulonglong_t,
1040 Endianness endianness)
1041 {
1042 return serialize(static_cast<int64_t>(ulonglong_t), endianness);
1043 }
1044
1052 const int64_t longlong_t);
1053
1062 const int64_t longlong_t,
1063 Endianness endianness);
1064
1072 const float float_t);
1073
1082 const float float_t,
1083 Endianness endianness);
1084
1092 const double double_t);
1093
1102 const double double_t,
1103 Endianness endianness);
1104
1105
1114 const long double ldouble_t);
1115
1125 const long double ldouble_t,
1126 Endianness endianness);
1127
1135 const bool bool_t);
1136
1144 inline
1146 const bool bool_t,
1147 Endianness endianness)
1148 {
1149 (void) endianness;
1150 return serialize(bool_t);
1151 }
1152
1160 char* string_t)
1161 {
1162 return serialize(static_cast<const char*>(string_t));
1163 }
1164
1172 const char* string_t);
1173
1181 const wchar_t* string_t);
1182
1191 const char* string_t,
1192 Endianness endianness);
1193
1202 const wchar_t* string_t,
1203 Endianness endianness);
1204
1211 inline
1213 const std::string& string_t)
1214 {
1215 return serialize(string_t.c_str());
1216 }
1217
1224 inline
1226 const std::wstring& string_t)
1227 {
1228 return serialize(string_t.c_str());
1229 }
1230
1238 inline
1240 const std::string& string_t,
1241 Endianness endianness)
1242 {
1243 return serialize(string_t.c_str(), endianness);
1244 }
1245
1246#if HAVE_CXX0X
1253 template<class _T, size_t _Size>
1254 inline Cdr& serialize(
1255 const std::array<_T, _Size>& array_t)
1256 {
1257 return serializeArray(array_t.data(), array_t.size());
1258 }
1259
1267 template<class _T, size_t _Size>
1268 inline Cdr& serialize(
1269 const std::array<_T, _Size>& array_t,
1270 Endianness endianness)
1271 {
1272 return serializeArray(array_t.data(), array_t.size(), endianness);
1273 }
1274
1275#endif // if HAVE_CXX0X
1276
1277#if !defined(_MSC_VER) && HAVE_CXX0X
1284 template<class _T = bool>
1285 Cdr& serialize(
1286 const std::vector<bool>& vector_t)
1287 {
1288 return serializeBoolSequence(vector_t);
1289 }
1290
1291#endif // if !defined(_MSC_VER) && HAVE_CXX0X
1292
1299 template<class _T>
1301 const std::vector<_T>& vector_t)
1302 {
1303 state state_before_error(*this);
1304
1305 *this << static_cast<int32_t>(vector_t.size());
1306
1307 try
1308 {
1309 return serializeArray(vector_t.data(), vector_t.size());
1310 }
1312 {
1313 setState(state_before_error);
1314 ex.raise();
1315 }
1316
1317 return *this;
1318 }
1319
1326 template<class _K, class _T>
1328 const std::map<_K, _T>& map_t)
1329 {
1330 state state_(*this);
1331
1332 *this << static_cast<int32_t>(map_t.size());
1333
1334 try
1335 {
1336 for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
1337 {
1338 *this << it_pair->first;
1339 *this << it_pair->second;
1340 }
1341 //return serializeArray(map_t.data(), map_t.size());
1342 }
1344 {
1345 setState(state_);
1346 ex.raise();
1347 }
1348
1349 return *this;
1350 }
1351
1352#ifdef _MSC_VER
1359 template<>
1360 Cdr& serialize<bool>(
1361 const std::vector<bool>& vector_t)
1362 {
1363 return serializeBoolSequence(vector_t);
1364 }
1365
1366#endif // ifdef _MSC_VER
1367
1375 template<class _T>
1377 const std::vector<_T>& vector_t,
1378 Endianness endianness)
1379 {
1380 bool auxSwap = m_swapBytes;
1381 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
1382
1383 try
1384 {
1385 serialize(vector_t);
1386 m_swapBytes = auxSwap;
1387 }
1389 {
1390 m_swapBytes = auxSwap;
1391 ex.raise();
1392 }
1393
1394 return *this;
1395 }
1396
1403 template<class _T>
1405 const _T& type_t)
1406 {
1407 type_t.serialize(*this);
1408 return *this;
1409 }
1410
1418 inline
1420 const uint8_t* octet_t,
1421 size_t numElements)
1422 {
1423 return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
1424 }
1425
1434 inline
1436 const uint8_t* octet_t,
1437 size_t numElements,
1438 Endianness endianness)
1439 {
1440 (void) endianness;
1441 return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
1442 }
1443
1452 const char* char_t,
1453 size_t numElements);
1454
1463 inline
1465 const char* char_t,
1466 size_t numElements,
1467 Endianness endianness)
1468 {
1469 (void) endianness;
1470 return serializeArray(char_t, numElements);
1471 }
1472
1480 inline
1482 const int8_t* int8,
1483 size_t numElements)
1484 {
1485 return serializeArray(reinterpret_cast<const char*>(int8), numElements);
1486 }
1487
1496 inline
1498 const int8_t* int8,
1499 size_t numElements,
1500 Endianness endianness)
1501 {
1502 (void) endianness;
1503 return serializeArray(reinterpret_cast<const char*>(int8), numElements);
1504 }
1505
1513 inline
1515 const uint16_t* ushort_t,
1516 size_t numElements)
1517 {
1518 return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements);
1519 }
1520
1529 inline
1531 const uint16_t* ushort_t,
1532 size_t numElements,
1533 Endianness endianness)
1534 {
1535 return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements, endianness);
1536 }
1537
1546 const int16_t* short_t,
1547 size_t numElements);
1548
1558 const int16_t* short_t,
1559 size_t numElements,
1560 Endianness endianness);
1561
1569 inline
1571 const uint32_t* ulong_t,
1572 size_t numElements)
1573 {
1574 return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements);
1575 }
1576
1585 inline
1587 const uint32_t* ulong_t,
1588 size_t numElements,
1589 Endianness endianness)
1590 {
1591 return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements, endianness);
1592 }
1593
1602 const int32_t* long_t,
1603 size_t numElements);
1604
1614 const int32_t* long_t,
1615 size_t numElements,
1616 Endianness endianness);
1617
1626 const wchar_t* wchar,
1627 size_t numElements);
1628
1638 const wchar_t* wchar,
1639 size_t numElements,
1640 Endianness endianness);
1641
1649 inline
1651 const uint64_t* ulonglong_t,
1652 size_t numElements)
1653 {
1654 return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements);
1655 }
1656
1665 inline
1667 const uint64_t* ulonglong_t,
1668 size_t numElements,
1669 Endianness endianness)
1670 {
1671 return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements, endianness);
1672 }
1673
1682 const int64_t* longlong_t,
1683 size_t numElements);
1684
1694 const int64_t* longlong_t,
1695 size_t numElements,
1696 Endianness endianness);
1697
1706 const float* float_t,
1707 size_t numElements);
1708
1718 const float* float_t,
1719 size_t numElements,
1720 Endianness endianness);
1721
1730 const double* double_t,
1731 size_t numElements);
1732
1742 const double* double_t,
1743 size_t numElements,
1744 Endianness endianness);
1745
1754 const long double* ldouble_t,
1755 size_t numElements);
1756
1766 const long double* ldouble_t,
1767 size_t numElements,
1768 Endianness endianness);
1769
1778 const bool* bool_t,
1779 size_t numElements);
1780
1789 inline
1791 const bool* bool_t,
1792 size_t numElements,
1793 Endianness endianness)
1794 {
1795 (void) endianness;
1796 return serializeArray(bool_t, numElements);
1797 }
1798
1806 inline
1808 const std::string* string_t,
1809 size_t numElements)
1810 {
1811 for (size_t count = 0; count < numElements; ++count)
1812 {
1813 serialize(string_t[count].c_str());
1814 }
1815 return *this;
1816 }
1817
1825 inline
1827 const std::wstring* string_t,
1828 size_t numElements)
1829 {
1830 for (size_t count = 0; count < numElements; ++count)
1831 {
1832 serialize(string_t[count].c_str());
1833 }
1834 return *this;
1835 }
1836
1845 inline
1847 const std::string* string_t,
1848 size_t numElements,
1849 Endianness endianness)
1850 {
1851 bool auxSwap = m_swapBytes;
1852 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
1853
1854 try
1855 {
1856 serializeArray(string_t, numElements);
1857 m_swapBytes = auxSwap;
1858 }
1860 {
1861 m_swapBytes = auxSwap;
1862 ex.raise();
1863 }
1864
1865 return *this;
1866 }
1867
1876 inline
1878 const std::wstring* string_t,
1879 size_t numElements,
1880 Endianness endianness)
1881 {
1882 bool auxSwap = m_swapBytes;
1883 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
1884
1885 try
1886 {
1887 serializeArray(string_t, numElements);
1888 m_swapBytes = auxSwap;
1889 }
1891 {
1892 m_swapBytes = auxSwap;
1893 ex.raise();
1894 }
1895
1896 return *this;
1897 }
1898
1906 template<class _T>
1908 const std::vector<_T>* vector_t,
1909 size_t numElements)
1910 {
1911 for (size_t count = 0; count < numElements; ++count)
1912 {
1913 serialize(vector_t[count]);
1914 }
1915 return *this;
1916 }
1917
1925 template<class _T>
1927 const _T* type_t,
1928 size_t numElements)
1929 {
1930 for (size_t count = 0; count < numElements; ++count)
1931 {
1932 type_t[count].serialize(*this);
1933 }
1934 return *this;
1935 }
1936
1945 template<class _T>
1947 const _T* type_t,
1948 size_t numElements,
1949 Endianness endianness)
1950 {
1951 bool auxSwap = m_swapBytes;
1952 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
1953
1954 try
1955 {
1956 serializeArray(type_t, numElements);
1957 m_swapBytes = auxSwap;
1958 }
1960 {
1961 m_swapBytes = auxSwap;
1962 ex.raise();
1963 }
1964
1965 return *this;
1966 }
1967
1975 template<class _T>
1977 const _T* sequence_t,
1978 size_t numElements)
1979 {
1980 state state_before_error(*this);
1981
1982 serialize(static_cast<int32_t>(numElements));
1983
1984 try
1985 {
1986 return serializeArray(sequence_t, numElements);
1987 }
1989 {
1990 setState(state_before_error);
1991 ex.raise();
1992 }
1993
1994 return *this;
1995 }
1996
2005 template<class _T>
2007 const _T* sequence_t,
2008 size_t numElements,
2009 Endianness endianness)
2010 {
2011 bool auxSwap = m_swapBytes;
2012 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
2013
2014 try
2015 {
2016 serializeSequence(sequence_t, numElements);
2017 m_swapBytes = auxSwap;
2018 }
2020 {
2021 m_swapBytes = auxSwap;
2022 ex.raise();
2023 }
2024
2025 return *this;
2026 }
2027
2034 inline
2036 uint8_t& octet_t)
2037 {
2038 return deserialize(reinterpret_cast<char&>(octet_t));
2039 }
2040
2048 inline
2050 uint8_t& octet_t,
2051 Endianness endianness)
2052 {
2053 return deserialize(reinterpret_cast<char&>(octet_t), endianness);
2054 }
2055
2063 char& char_t);
2064
2072 inline
2074 char& char_t,
2075 Endianness endianness)
2076 {
2077 (void) endianness;
2078 return deserialize(char_t);
2079 }
2080
2087 inline
2089 int8_t& int8)
2090 {
2091 return deserialize(reinterpret_cast<char&>(int8));
2092 }
2093
2101 inline
2103 int8_t& int8,
2104 Endianness endianness)
2105 {
2106 return deserialize(reinterpret_cast<char&>(int8), endianness);
2107 }
2108
2115 inline
2117 uint16_t& ushort_t)
2118 {
2119 return deserialize(reinterpret_cast<int16_t&>(ushort_t));
2120 }
2121
2129 inline
2131 uint16_t& ushort_t,
2132 Endianness endianness)
2133 {
2134 return deserialize(reinterpret_cast<int16_t&>(ushort_t), endianness);
2135 }
2136
2144 int16_t& short_t);
2145
2154 int16_t& short_t,
2155 Endianness endianness);
2156
2163 inline
2165 uint32_t& ulong_t)
2166 {
2167 return deserialize(reinterpret_cast<int32_t&>(ulong_t));
2168 }
2169
2177 inline
2179 uint32_t& ulong_t,
2180 Endianness endianness)
2181 {
2182 return deserialize(reinterpret_cast<int32_t&>(ulong_t), endianness);
2183 }
2184
2192 int32_t& long_t);
2193
2202 int32_t& long_t,
2203 Endianness endianness);
2204
2211 inline
2213 wchar_t& wchar)
2214 {
2215 uint32_t ret;
2216 deserialize(ret);
2217 wchar = static_cast<wchar_t>(ret);
2218 return *this;
2219 }
2220
2228 inline
2230 wchar_t& wchar,
2231 Endianness endianness)
2232 {
2233 uint32_t ret;
2234 deserialize(ret, endianness);
2235 wchar = static_cast<wchar_t>(ret);
2236 return *this;
2237 }
2238
2245 inline
2247 uint64_t& ulonglong_t)
2248 {
2249 return deserialize(reinterpret_cast<int64_t&>(ulonglong_t));
2250 }
2251
2259 inline
2261 uint64_t& ulonglong_t,
2262 Endianness endianness)
2263 {
2264 return deserialize(reinterpret_cast<int64_t&>(ulonglong_t), endianness);
2265 }
2266
2274 int64_t& longlong_t);
2275
2284 int64_t& longlong_t,
2285 Endianness endianness);
2286
2294 float& float_t);
2295
2304 float& float_t,
2305 Endianness endianness);
2306
2314 double& double_t);
2315
2324 double& double_t,
2325 Endianness endianness);
2326
2335 long double& ldouble_t);
2336
2346 long double& ldouble_t,
2347 Endianness endianness);
2348
2357 bool& bool_t);
2358
2367 inline
2369 bool& bool_t,
2370 Endianness endianness)
2371 {
2372 (void) endianness;
2373 return deserialize(bool_t);
2374 }
2375
2386 char*& string_t);
2387
2398 wchar_t*& string_t);
2399
2411 char*& string_t,
2412 Endianness endianness);
2413
2425 wchar_t*& string_t,
2426 Endianness endianness);
2427
2434 inline
2436 std::string& string_t)
2437 {
2438 uint32_t length = 0;
2439 const char* str = readString(length);
2440 string_t = std::string(str, length);
2441 return *this;
2442 }
2443
2450 inline
2452 std::wstring& string_t)
2453 {
2454 uint32_t length = 0;
2455 string_t = readWString(length);
2456 return *this;
2457 }
2458
2466 inline
2468 std::string& string_t,
2469 Endianness endianness)
2470 {
2471 bool auxSwap = m_swapBytes;
2472 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
2473
2474 try
2475 {
2476 deserialize(string_t);
2477 m_swapBytes = auxSwap;
2478 }
2480 {
2481 m_swapBytes = auxSwap;
2482 ex.raise();
2483 }
2484
2485 return *this;
2486 }
2487
2495 inline
2497 std::wstring& string_t,
2498 Endianness endianness)
2499 {
2500 bool auxSwap = m_swapBytes;
2501 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
2502
2503 try
2504 {
2505 deserialize(string_t);
2506 m_swapBytes = auxSwap;
2507 }
2509 {
2510 m_swapBytes = auxSwap;
2511 ex.raise();
2512 }
2513
2514 return *this;
2515 }
2516
2517#if HAVE_CXX0X
2524 template<class _T, size_t _Size>
2525 inline Cdr& deserialize(
2526 std::array<_T, _Size>& array_t)
2527 {
2528 return deserializeArray(array_t.data(), array_t.size());
2529 }
2530
2538 template<class _T, size_t _Size>
2539 inline Cdr& deserialize(
2540 std::array<_T, _Size>& array_t,
2541 Endianness endianness)
2542 {
2543 return deserializeArray(array_t.data(), array_t.size(), endianness);
2544 }
2545
2546#endif // if HAVE_CXX0X
2547
2548#if !defined(_MSC_VER) && HAVE_CXX0X
2555 template<class _T = bool>
2556 Cdr& deserialize(
2557 std::vector<bool>& vector_t)
2558 {
2559 return deserializeBoolSequence(vector_t);
2560 }
2561
2562#endif // if !defined(_MSC_VER) && HAVE_CXX0X
2563
2570 template<class _T>
2572 std::vector<_T>& vector_t)
2573 {
2574 uint32_t seqLength = 0;
2575 state state_before_error(*this);
2576
2577 *this >> seqLength;
2578
2579 if (seqLength == 0)
2580 {
2581 vector_t.clear();
2582 return *this;
2583 }
2584
2585 if ((m_lastPosition - m_currentPosition) < seqLength)
2586 {
2587 setState(state_before_error);
2590 }
2591
2592 try
2593 {
2594 vector_t.resize(seqLength);
2595 return deserializeArray(vector_t.data(), vector_t.size());
2596 }
2598 {
2599 setState(state_before_error);
2600 ex.raise();
2601 }
2602
2603 return *this;
2604 }
2605
2612 template<class _K, class _T>
2614 std::map<_K, _T>& map_t)
2615 {
2616 uint32_t seqLength = 0;
2617 state state_(*this);
2618
2619 *this >> seqLength;
2620
2621 try
2622 {
2623 for (uint32_t i = 0; i < seqLength; ++i)
2624 {
2625 _K key;
2626 _T value;
2627 *this >> key;
2628 *this >> value;
2629 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2630 }
2631 }
2633 {
2634 setState(state_);
2635 ex.raise();
2636 }
2637
2638 return *this;
2639 }
2640
2641#ifdef _MSC_VER
2648 template<>
2649 Cdr& deserialize<bool>(
2650 std::vector<bool>& vector_t)
2651 {
2652 return deserializeBoolSequence(vector_t);
2653 }
2654
2655#endif // ifdef _MSC_VER
2656
2664 template<class _T>
2666 std::vector<_T>& vector_t,
2667 Endianness endianness)
2668 {
2669 bool auxSwap = m_swapBytes;
2670 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
2671
2672 try
2673 {
2674 deserialize(vector_t);
2675 m_swapBytes = auxSwap;
2676 }
2677 catch (exception::Exception& ex)
2678 {
2679 m_swapBytes = auxSwap;
2680 ex.raise();
2681 }
2682
2683 return *this;
2684 }
2685
2692 template<class _T>
2694 _T& type_t)
2695 {
2696 type_t.deserialize(*this);
2697 return *this;
2698 }
2699
2707 inline
2709 uint8_t* octet_t,
2710 size_t numElements)
2711 {
2712 return deserializeArray(reinterpret_cast<char*>(octet_t), numElements);
2713 }
2714
2723 inline
2725 uint8_t* octet_t,
2726 size_t numElements,
2727 Endianness endianness)
2728 {
2729 return deserializeArray(reinterpret_cast<char*>(octet_t), numElements, endianness);
2730 }
2731
2740 char* char_t,
2741 size_t numElements);
2742
2751 inline
2753 char* char_t,
2754 size_t numElements,
2755 Endianness endianness)
2756 {
2757 (void) endianness;
2758 return deserializeArray(char_t, numElements);
2759 }
2760
2768 inline
2770 int8_t* int8,
2771 size_t numElements)
2772 {
2773 return deserializeArray(reinterpret_cast<char*>(int8), numElements);
2774 }
2775
2784 inline
2786 int8_t* int8,
2787 size_t numElements,
2788 Endianness endianness)
2789 {
2790 return deserializeArray(reinterpret_cast<char*>(int8), numElements, endianness);
2791 }
2792
2800 inline
2802 uint16_t* ushort_t,
2803 size_t numElements)
2804 {
2805 return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements);
2806 }
2807
2816 inline
2818 uint16_t* ushort_t,
2819 size_t numElements,
2820 Endianness endianness)
2821 {
2822 return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements, endianness);
2823 }
2824
2833 int16_t* short_t,
2834 size_t numElements);
2835
2845 int16_t* short_t,
2846 size_t numElements,
2847 Endianness endianness);
2848
2856 inline
2858 uint32_t* ulong_t,
2859 size_t numElements)
2860 {
2861 return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements);
2862 }
2863
2872 inline
2874 uint32_t* ulong_t,
2875 size_t numElements,
2876 Endianness endianness)
2877 {
2878 return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements, endianness);
2879 }
2880
2889 int32_t* long_t,
2890 size_t numElements);
2891
2901 int32_t* long_t,
2902 size_t numElements,
2903 Endianness endianness);
2904
2913 wchar_t* wchar,
2914 size_t numElements);
2915
2925 wchar_t* wchar,
2926 size_t numElements,
2927 Endianness endianness);
2928
2936 inline
2938 uint64_t* ulonglong_t,
2939 size_t numElements)
2940 {
2941 return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements);
2942 }
2943
2952 inline
2954 uint64_t* ulonglong_t,
2955 size_t numElements,
2956 Endianness endianness)
2957 {
2958 return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements, endianness);
2959 }
2960
2969 int64_t* longlong_t,
2970 size_t numElements);
2971
2981 int64_t* longlong_t,
2982 size_t numElements,
2983 Endianness endianness);
2984
2993 float* float_t,
2994 size_t numElements);
2995
3005 float* float_t,
3006 size_t numElements,
3007 Endianness endianness);
3008
3017 double* double_t,
3018 size_t numElements);
3019
3029 double* double_t,
3030 size_t numElements,
3031 Endianness endianness);
3032
3041 long double* ldouble_t,
3042 size_t numElements);
3043
3053 long double* ldouble_t,
3054 size_t numElements,
3055 Endianness endianness);
3056
3065 bool* bool_t,
3066 size_t numElements);
3067
3076 inline
3078 bool* bool_t,
3079 size_t numElements,
3080 Endianness endianness)
3081 {
3082 (void) endianness;
3083 return deserializeArray(bool_t, numElements);
3084 }
3085
3093 inline
3095 std::string* string_t,
3096 size_t numElements)
3097 {
3098 for (size_t count = 0; count < numElements; ++count)
3099 {
3100 deserialize(string_t[count]);
3101 }
3102 return *this;
3103 }
3104
3112 inline
3114 std::wstring* string_t,
3115 size_t numElements)
3116 {
3117 for (size_t count = 0; count < numElements; ++count)
3118 {
3119 deserialize(string_t[count]);
3120 }
3121 return *this;
3122 }
3123
3132 inline
3134 std::string* string_t,
3135 size_t numElements,
3136 Endianness endianness)
3137 {
3138 bool auxSwap = m_swapBytes;
3139 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
3140
3141 try
3142 {
3143 deserializeArray(string_t, numElements);
3144 m_swapBytes = auxSwap;
3145 }
3147 {
3148 m_swapBytes = auxSwap;
3149 ex.raise();
3150 }
3151
3152 return *this;
3153 }
3154
3163 inline
3165 std::wstring* string_t,
3166 size_t numElements,
3167 Endianness endianness)
3168 {
3169 bool auxSwap = m_swapBytes;
3170 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
3171
3172 try
3173 {
3174 deserializeArray(string_t, numElements);
3175 m_swapBytes = auxSwap;
3176 }
3178 {
3179 m_swapBytes = auxSwap;
3180 ex.raise();
3181 }
3182
3183 return *this;
3184 }
3185
3193 template<class _T>
3195 std::vector<_T>* vector_t,
3196 size_t numElements)
3197 {
3198 for (size_t count = 0; count < numElements; ++count)
3199 {
3200 deserialize(vector_t[count]);
3201 }
3202 return *this;
3203 }
3204
3212 template<class _T>
3214 _T* type_t,
3215 size_t numElements)
3216 {
3217 for (size_t count = 0; count < numElements; ++count)
3218 {
3219 type_t[count].deserialize(*this);
3220 }
3221 return *this;
3222 }
3223
3232 template<class _T>
3234 _T* type_t,
3235 size_t numElements,
3236 Endianness endianness)
3237 {
3238 bool auxSwap = m_swapBytes;
3239 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
3240
3241 try
3242 {
3243 deserializeArray(type_t, numElements);
3244 m_swapBytes = auxSwap;
3245 }
3247 {
3248 m_swapBytes = auxSwap;
3249 ex.raise();
3250 }
3251
3252 return *this;
3253 }
3254
3255#if !defined(_MSC_VER) && HAVE_CXX0X
3265 template<class _T = std::string>
3266 Cdr& deserializeSequence(
3267 std::string*& sequence_t,
3268 size_t& numElements)
3269 {
3270 return deserializeStringSequence(sequence_t, numElements);
3271 }
3272
3282 template<class _T = std::wstring>
3283 Cdr& deserializeSequence(
3284 std::wstring*& sequence_t,
3285 size_t& numElements)
3286 {
3287 return deserializeWStringSequence(sequence_t, numElements);
3288 }
3289
3290#endif // if !defined(_MSC_VER) && HAVE_CXX0X
3291
3301 template<class _T>
3303 _T*& sequence_t,
3304 size_t& numElements)
3305 {
3306 uint32_t seqLength = 0;
3307 state state_before_error(*this);
3308
3309 deserialize(seqLength);
3310
3311 try
3312 {
3313 sequence_t = reinterpret_cast<_T*>(calloc(seqLength, sizeof(_T)));
3314 deserializeArray(sequence_t, seqLength);
3315 }
3317 {
3318 free(sequence_t);
3319 sequence_t = NULL;
3320 setState(state_before_error);
3321 ex.raise();
3322 }
3323
3324 numElements = seqLength;
3325 return *this;
3326 }
3327
3328#ifdef _MSC_VER
3338 template<>
3339 Cdr& deserializeSequence<std::string>(
3340 std::string*& sequence_t,
3341 size_t& numElements)
3342 {
3343 return deserializeStringSequence(sequence_t, numElements);
3344 }
3345
3355 template<>
3356 Cdr& deserializeSequence<std::wstring>(
3357 std::wstring*& sequence_t,
3358 size_t& numElements)
3359 {
3360 return deserializeWStringSequence(sequence_t, numElements);
3361 }
3362
3363#endif // ifdef _MSC_VER
3364
3375 template<class _T>
3377 _T*& sequence_t,
3378 size_t& numElements,
3379 Endianness endianness)
3380 {
3381 bool auxSwap = m_swapBytes;
3382 m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));
3383
3384 try
3385 {
3386 deserializeSequence(sequence_t, numElements);
3387 m_swapBytes = auxSwap;
3388 }
3390 {
3391 m_swapBytes = auxSwap;
3392 ex.raise();
3393 }
3394
3395 return *this;
3396 }
3397
3398private:
3399
3400 Cdr(
3401 const Cdr&) = delete;
3402
3403 Cdr& operator =(
3404 const Cdr&) = delete;
3405
3406 Cdr& serializeBoolSequence(
3407 const std::vector<bool>& vector_t);
3408
3409 Cdr& deserializeBoolSequence(
3410 std::vector<bool>& vector_t);
3411
3412 Cdr& deserializeStringSequence(
3413 std::string*& sequence_t,
3414 size_t& numElements);
3415
3416 Cdr& deserializeWStringSequence(
3417 std::wstring*& sequence_t,
3418 size_t& numElements);
3419
3420#if HAVE_CXX0X
3428 template<class _T, size_t _Size>
3429 Cdr& serializeArray(
3430 const std::array<_T, _Size>* array_t,
3431 size_t numElements)
3432 {
3433 return serializeArray(array_t->data(), numElements * array_t->size());
3434 }
3435
3444 template<class _T, size_t _Size>
3445 Cdr& serializeArray(
3446 const std::array<_T, _Size>* array_t,
3447 size_t numElements,
3448 Endianness endianness)
3449 {
3450 return serializeArray(array_t->data(), numElements * array_t->size(), endianness);
3451 }
3452
3460 template<class _T, size_t _Size>
3461 Cdr& deserializeArray(
3462 std::array<_T, _Size>* array_t,
3463 size_t numElements)
3464 {
3465 return deserializeArray(array_t->data(), numElements * array_t->size());
3466 }
3467
3476 template<class _T, size_t _Size>
3477 Cdr& deserializeArray(
3478 std::array<_T, _Size>* array_t,
3479 size_t numElements,
3480 Endianness endianness)
3481 {
3482 return deserializeArray(array_t->data(), numElements * array_t->size(), endianness);
3483 }
3484
3485#endif // if HAVE_CXX0X
3486
3492 inline size_t alignment(
3493 size_t dataSize) const
3494 {
3495 return dataSize >
3496 m_lastDataSize ? (dataSize - ((m_currentPosition - m_alignPosition) % dataSize)) &
3497 (dataSize - 1) : 0;
3498 }
3499
3504 inline void makeAlign(
3505 size_t align)
3506 {
3507 m_currentPosition += align;
3508 }
3509
3515 bool resize(
3516 size_t minSizeInc);
3517
3518 //TODO
3519 const char* readString(
3520 uint32_t& length);
3521 const std::wstring readWString(
3522 uint32_t& length);
3523
3525 FastBuffer& m_cdrBuffer;
3526
3528 CdrType m_cdrType;
3529
3531 DDSCdrPlFlag m_plFlag;
3532
3534 uint16_t m_options;
3535
3537 uint8_t m_endianness;
3538
3540 bool m_swapBytes;
3541
3543 size_t m_lastDataSize;
3544
3546 FastBuffer::iterator m_currentPosition;
3547
3549 FastBuffer::iterator m_alignPosition;
3550
3552 FastBuffer::iterator m_lastPosition;
3553};
3554} //namespace fastcdr
3555} //namespace eprosima
3556
3557#endif // _CDR_CDR_H_
This class implements the iterator used to go through a FastBuffer.
Definition: FastBuffer.h:43
This class stores the current state of a CDR serialization.
Definition: Cdr.h:92
state(const Cdr &cdr)
Default constructor.
state(const state &)
Copy constructor.
This class offers an interface to serialize/deserialize some basic types using CDR protocol inside an...
Definition: Cdr.h:44
Cdr & deserializeArray(int32_t *long_t, size_t numElements, Endianness endianness)
This function deserializes an array of longs with a different endianness.
Cdr & serialize(const _T &type_t)
This function template serializes a non-basic object.
Definition: Cdr.h:1404
Cdr & deserialize(double &double_t)
This function deserializes a double.
Cdr & serializeArray(const int16_t *short_t, size_t numElements, Endianness endianness)
This function serializes an array of shorts with a different endianness.
Cdr & deserializeArray(uint32_t *ulong_t, size_t numElements, Endianness endianness)
This function deserializes an array of unsigned longs with a different endianness.
Definition: Cdr.h:2873
Cdr & deserializeArray(char *char_t, size_t numElements, Endianness endianness)
This function deserializes an array of characters with a different endianness.
Definition: Cdr.h:2752
Cdr & deserialize(float &float_t)
This function deserializes a float.
Cdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition: Cdr.h:996
Cdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: Cdr.h:2212
Cdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition: Cdr.h:1024
Cdr & deserializeArray(int64_t *longlong_t, size_t numElements, Endianness endianness)
This function deserializes an array of long longs with a different endianness.
DDSCdrPlFlag
This enumeration represents the two posible values of the flag that points if the content is a parame...
Definition: Cdr.h:63
Cdr & deserializeArray(wchar_t *wchar, size_t numElements)
This function deserializes an array of wide-chars.
Cdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
Cdr & serialize(const int64_t longlong_t)
This function serializes a long long.
Cdr & deserializeArray(wchar_t *wchar, size_t numElements, Endianness endianness)
This function deserializes an array of wide-chars with a different endianness.
Cdr & deserialize(std::vector< _T > &vector_t, Endianness endianness)
This function template deserializes a sequence with a different endianness.
Definition: Cdr.h:2665
Cdr & serializeArray(const std::string *string_t, size_t numElements)
This function serializes an array of strings.
Definition: Cdr.h:1807
void changeEndianness(Endianness endianness)
This function sets the current endianness used by the CDR type.
Cdr & serialize(const std::map< _K, _T > &map_t)
This function template serializes a map.
Definition: Cdr.h:1327
Cdr & serializeArray(const uint8_t *octet_t, size_t numElements, Endianness endianness)
This function serializes an array of octets with a different endianness.
Definition: Cdr.h:1435
Cdr & serialize(const double double_t)
This function serializes a double.
void setDDSCdrOptions(uint16_t options)
This function sets the option flags when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & serializeArray(const uint16_t *ushort_t, size_t numElements, Endianness endianness)
This function serializes an array of unsigned shorts with a different endianness.
Definition: Cdr.h:1530
Cdr & deserialize(bool &bool_t)
This function deserializes a boolean.
Cdr & deserialize(bool &bool_t, Endianness endianness)
This function deserializes a boolean with a different endianness.
Definition: Cdr.h:2368
Cdr & serializeSequence(const _T *sequence_t, size_t numElements, Endianness endianness)
This function template serializes a raw sequence with a different endianness.
Definition: Cdr.h:2006
Cdr & serialize(const int32_t long_t)
This function serializes a long.
Cdr & serializeArray(const _T *type_t, size_t numElements, Endianness endianness)
This function template serializes an array of non-basic objects with a different endianness.
Definition: Cdr.h:1946
Cdr & deserialize(int32_t &long_t)
This function deserializes a long.
Cdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition: Cdr.h:2435
Cdr & deserialize(wchar_t *&string_t)
This function deserializes a wide string.
Cdr & deserializeArray(float *float_t, size_t numElements, Endianness endianness)
This function deserializes an array of floats with a different endianness.
Cdr & deserializeArray(long double *ldouble_t, size_t numElements)
This function deserializes an array of long doubles.
Cdr & serializeArray(const std::string *string_t, size_t numElements, Endianness endianness)
This function serializes an array of strings with a different endianness.
Definition: Cdr.h:1846
Cdr & serialize(const uint16_t ushort_t, Endianness endianness)
This function serializes an unsigned short with a different endianness.
Definition: Cdr.h:914
Cdr & deserializeArray(int8_t *int8, size_t numElements)
This function deserializes an array of int8_t.
Definition: Cdr.h:2769
Cdr & serializeArray(const char *char_t, size_t numElements, Endianness endianness)
This function serializes an array of characters with a different endianness.
Definition: Cdr.h:1464
Cdr & serialize(const long double ldouble_t)
This function serializes a long double.
Cdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence.
Definition: Cdr.h:2571
Cdr & deserializeSequence(_T *&sequence_t, size_t &numElements, Endianness endianness)
This function template deserializes a raw sequence with a different endianness.
Definition: Cdr.h:3376
Cdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements)
This function deserializes an array of unsigned long longs.
Definition: Cdr.h:2937
Cdr(FastBuffer &cdrBuffer, const Endianness endianness=DEFAULT_ENDIAN, const CdrType cdrType=CORBA_CDR)
This constructor creates an eprosima::fastcdr::Cdr object that can serialize/deserialize the assigned...
Cdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition: Cdr.h:1225
Cdr & deserialize(long double &ldouble_t, Endianness endianness)
This function deserializes a long double with a different endianness.
Cdr & deserializeArray(int16_t *short_t, size_t numElements)
This function deserializes an array of shorts.
Cdr & serialize(const int64_t longlong_t, Endianness endianness)
This function serializes a long long with a different endianness.
Cdr & serializeArray(const uint32_t *ulong_t, size_t numElements)
This function serializes an array of unsigned longs.
Definition: Cdr.h:1570
Cdr & serialize(const bool bool_t, Endianness endianness)
This function serializes a boolean with a different endianness.
Definition: Cdr.h:1145
Cdr & deserialize(wchar_t *&string_t, Endianness endianness)
This function deserializes a wide string with a different endianness.
Endianness
This enumeration represents endianness types.
Definition: Cdr.h:78
Cdr & serializeArray(const float *float_t, size_t numElements)
This function serializes an array of floats.
size_t getSerializedDataLength() const
This function returns the length of the serialized data inside the stream.
Definition: Cdr.h:228
Cdr & deserialize(uint32_t &ulong_t, Endianness endianness)
This function deserializes an unsigned long with a different endianness.
Definition: Cdr.h:2178
Cdr & deserialize(int16_t &short_t, Endianness endianness)
This function deserializes a short with a different endianness.
Cdr & serialize(const uint8_t octet_t, Endianness endianness)
This function serializes an octet with a different endianness.
Definition: Cdr.h:833
Cdr & serializeArray(const int16_t *short_t, size_t numElements)
This function serializes an array of shorts.
Cdr & deserialize(_T &type_t)
This function template deserializes a non-basic object.
Definition: Cdr.h:2693
Cdr & deserializeArray(bool *bool_t, size_t numElements)
This function deserializes an array of booleans.
Cdr & read_encapsulation()
This function reads the encapsulation of the CDR stream.
void setState(state &state)
This function sets a previous state of the CDR serialization process;.
Cdr & serializeArray(const _T *type_t, size_t numElements)
This function template serializes an array of non-basic objects.
Definition: Cdr.h:1926
Cdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition: Cdr.h:2246
Cdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements, Endianness endianness)
This function deserializes an array of unsigned long longs with a different endianness.
Definition: Cdr.h:2953
Cdr & serialize(const std::vector< _T > &vector_t, Endianness endianness)
This function template serializes a sequence with a different endianness.
Definition: Cdr.h:1376
Cdr & serializeArray(const long double *ldouble_t, size_t numElements)
This function serializes an array of long doubles.
Cdr & deserialize(std::wstring &string_t)
This function deserializes a std::string.
Definition: Cdr.h:2451
Cdr & deserializeArray(std::wstring *string_t, size_t numElements, Endianness endianness)
This function deserializes an array of wide-strings with a different endianness.
Definition: Cdr.h:3164
Cdr & deserializeArray(double *double_t, size_t numElements, Endianness endianness)
This function deserializes an array of doubles with a different endianness.
Cdr & deserializeArray(std::string *string_t, size_t numElements)
This function deserializes an array of strings.
Definition: Cdr.h:3094
Cdr & serialize(const double double_t, Endianness endianness)
This function serializes a double with a different endianness.
Cdr & deserialize(wchar_t &wchar, Endianness endianness)
This function deserializes a wide-char with a different endianness.
Definition: Cdr.h:2229
Cdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: Cdr.h:2164
Cdr & deserializeArray(int64_t *longlong_t, size_t numElements)
This function deserializes an array of long longs.
Cdr & serialize(char *string_t)
This function serializes a string.
Definition: Cdr.h:1159
Cdr & serializeSequence(const _T *sequence_t, size_t numElements)
This function template serializes a raw sequence.
Definition: Cdr.h:1976
Cdr & serializeArray(const wchar_t *wchar, size_t numElements)
This function serializes an array of wide-chars.
static const Endianness DEFAULT_ENDIAN
Default endiness in the system.
Definition: Cdr.h:86
Cdr & serialize(const uint32_t ulong_t, Endianness endianness)
This function serializes an unsigned long with a different endianness.
Definition: Cdr.h:962
Cdr & serialize(const uint8_t octet_t)
This function serializes an octet.
Definition: Cdr.h:819
Cdr & deserializeArray(float *float_t, size_t numElements)
This function deserializes an array of floats.
Cdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition: Cdr.h:2088
Cdr & serialize(const wchar_t wchar, Endianness endianness)
This function serializes a wide-char with a different endianness.
Definition: Cdr.h:1010
Cdr & serialize(const int8_t int8, Endianness endianness)
This function serializes an int8_t with a different endianness.
Definition: Cdr.h:886
Cdr & deserializeArray(long double *ldouble_t, size_t numElements, Endianness endianness)
This function deserializes an array of long doubles with a different endianness.
Cdr & serialize(const uint64_t ulonglong_t, Endianness endianness)
This function serializes an unsigned long long with a different endianness.
Definition: Cdr.h:1038
Cdr & deserialize(int32_t &long_t, Endianness endianness)
This function deserializes a long with a different endianness.
Cdr & deserialize(int16_t &short_t)
This function deserializes a short.
Cdr & deserializeArray(uint16_t *ushort_t, size_t numElements, Endianness endianness)
This function deserializes an array of unsigned shorts with a different endianness.
Definition: Cdr.h:2817
Cdr & serializeArray(const int64_t *longlong_t, size_t numElements)
This function serializes an array of long longs.
Cdr & deserialize(char &char_t)
This function deserializes a character.
Cdr & serializeArray(const char *char_t, size_t numElements)
This function serializes an array of characters.
Cdr & deserialize(char *&string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Cdr & serialize(const std::string &string_t, Endianness endianness)
This function serializes a std::string with a different endianness.
Definition: Cdr.h:1239
Cdr & serializeArray(const double *double_t, size_t numElements)
This function serializes an array of doubles.
Cdr & serializeArray(const bool *bool_t, size_t numElements)
This function serializes an array of booleans.
Cdr & serialize(const char char_t)
This function serializes a character.
Cdr & serializeArray(const std::wstring *string_t, size_t numElements)
This function serializes an array of wide-strings.
Definition: Cdr.h:1826
Cdr & deserializeArray(int8_t *int8, size_t numElements, Endianness endianness)
This function deserializes an array of int8_t with a different endianness.
Definition: Cdr.h:2785
Cdr & serialize(const char *string_t)
This function serializes a string.
Cdr & deserializeArray(int32_t *long_t, size_t numElements)
This function deserializes an array of longs.
Cdr & deserializeArray(std::string *string_t, size_t numElements, Endianness endianness)
This function deserializes an array of strings with a different endianness.
Definition: Cdr.h:3133
Cdr & serialize(const int16_t short_t, Endianness endianness)
This function serializes a short with a different endianness.
Cdr & deserialize(std::wstring &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2496
Cdr & deserializeArray(uint16_t *ushort_t, size_t numElements)
This function deserializes an array of unsigned shorts.
Definition: Cdr.h:2801
Cdr & serialize(const bool bool_t)
This function serializes a boolean.
Cdr & serializeArray(const bool *bool_t, size_t numElements, Endianness endianness)
This function serializes an array of booleans with a different endianness.
Definition: Cdr.h:1790
Cdr & serializeArray(const int32_t *long_t, size_t numElements)
This function serializes an array of longs.
Cdr & deserializeSequence(_T *&sequence_t, size_t &numElements)
This function template deserializes a raw sequence.
Definition: Cdr.h:3302
Cdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: Cdr.h:2116
Cdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements)
This function serializes an array of unsigned long longs.
Definition: Cdr.h:1650
Cdr & deserialize(uint8_t &octet_t, Endianness endianness)
This function deserializes an octet with a different endianness.
Definition: Cdr.h:2049
uint16_t getDDSCdrOptions() const
This function returns the option flags when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & serializeArray(const int8_t *int8, size_t numElements, Endianness endianness)
This function serializes an array of int8_t with a different endianness.
Definition: Cdr.h:1497
Cdr & deserialize(std::string &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2467
static size_t alignment(size_t current_alignment, size_t dataSize)
Get the number of bytes needed to align a position to certain data size.
Definition: Cdr.h:239
Cdr & deserializeArray(uint8_t *octet_t, size_t numElements)
This function deserializes an array of octets.
Definition: Cdr.h:2708
Cdr & serializeArray(const double *double_t, size_t numElements, Endianness endianness)
This function serializes an array of doubles with a different endianness.
Cdr & deserializeArray(_T *type_t, size_t numElements)
This function template deserializes an array of non-basic objects.
Definition: Cdr.h:3213
Cdr & serializeArray(const int32_t *long_t, size_t numElements, Endianness endianness)
This function serializes an array of longs with a different endianness.
Cdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition: Cdr.h:872
Cdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
Cdr & deserializeArray(double *double_t, size_t numElements)
This function deserializes an array of doubles.
Cdr & serialize(const char *string_t, Endianness endianness)
This function serializes a string with a different endianness.
Cdr & deserialize(uint64_t &ulonglong_t, Endianness endianness)
This function deserializes an unsigned long long with a different endianness.
Definition: Cdr.h:2260
Cdr & serialize(const long double ldouble_t, Endianness endianness)
This function serializes a long double with a different endianness.
Cdr & serialize_encapsulation()
This function writes the encapsulation of the CDR stream.
DDSCdrPlFlag getDDSCdrPlFlag() const
This function returns the parameter list flag when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & serializeArray(const std::vector< _T > *vector_t, size_t numElements)
This function template serializes an array of sequences of objects.
Definition: Cdr.h:1907
Cdr & serialize(const int16_t short_t)
This function serializes a short.
void setDDSCdrPlFlag(DDSCdrPlFlag plFlag)
This function sets the parameter list flag when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition: Cdr.h:2035
Cdr & deserialize(int8_t &int8, Endianness endianness)
This function deserializes an int8_t with a different endianness.
Definition: Cdr.h:2102
Cdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition: Cdr.h:948
Cdr & serializeArray(const wchar_t *wchar, size_t numElements, Endianness endianness)
This function serializes an array of wide-chars with a different endianness.
void reset()
This function resets the current position in the buffer to the beginning.
Cdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence.
Definition: Cdr.h:1300
Cdr & deserialize(char *&string_t)
This function deserializes a string.
Cdr & deserialize(int64_t &longlong_t, Endianness endianness)
This function deserializes a long long with a different endianness.
Cdr & deserializeArray(uint8_t *octet_t, size_t numElements, Endianness endianness)
This function deserializes an array of octets with a different endianness.
Definition: Cdr.h:2724
Cdr & deserialize(float &float_t, Endianness endianness)
This function deserializes a float with a different endianness.
Cdr & serialize(const char char_t, Endianness endianness)
This function serializes a character with a different endianness.
Definition: Cdr.h:857
Cdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition: Cdr.h:900
Cdr & serializeArray(const uint16_t *ushort_t, size_t numElements)
This function serializes an array of unsigned shorts.
Definition: Cdr.h:1514
bool jump(size_t numBytes)
This function skips a number of bytes in the CDR stream buffer.
Cdr & deserializeArray(_T *type_t, size_t numElements, Endianness endianness)
This function template deserializes an array of non-basic objects with a different endianness.
Definition: Cdr.h:3233
CdrType
This enumeration represents the two kinds of CDR serialization supported by eprosima::fastcdr::CDR.
Definition: Cdr.h:49
@ CORBA_CDR
Common CORBA CDR serialization.
Definition: Cdr.h:51
Cdr & serializeArray(const uint32_t *ulong_t, size_t numElements, Endianness endianness)
This function serializes an array of unsigned longs with a different endianness.
Definition: Cdr.h:1586
Cdr & serialize(const float float_t)
This function serializes a float.
Cdr & deserialize(double &double_t, Endianness endianness)
This function deserializes a double with a different endianness.
Cdr & serialize(const int32_t long_t, Endianness endianness)
This function serializes a long with a different endianness.
Endianness endianness() const
This function returns the current endianness used by the CDR type.
Definition: Cdr.h:194
Cdr & deserialize(std::map< _K, _T > &map_t)
This function template deserializes a map.
Definition: Cdr.h:2613
Cdr & serializeArray(const long double *ldouble_t, size_t numElements, Endianness endianness)
This function serializes an array of long doubles with a different endianness.
Cdr & serializeArray(const uint8_t *octet_t, size_t numElements)
This function serializes an array of octets.
Definition: Cdr.h:1419
Cdr & deserializeArray(uint32_t *ulong_t, size_t numElements)
This function deserializes an array of unsigned longs.
Definition: Cdr.h:2857
bool moveAlignmentForward(size_t numBytes)
This function moves the alignment forward.
Cdr & serialize(const wchar_t *string_t, Endianness endianness)
This function serializes a wstring with a different endianness.
Cdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition: Cdr.h:1212
Cdr & deserializeArray(int16_t *short_t, size_t numElements, Endianness endianness)
This function deserializes an array of shorts with a different endianness.
Cdr & serializeArray(const int8_t *int8, size_t numElements)
This function serializes an array of int8_t.
Definition: Cdr.h:1481
Cdr & deserializeArray(char *char_t, size_t numElements)
This function deserializes an array of characters.
Cdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements, Endianness endianness)
This function serializes an array of unsigned long longs with a different endianness.
Definition: Cdr.h:1666
Cdr & deserializeArray(std::vector< _T > *vector_t, size_t numElements)
This function deserializes an array of sequences of objects.
Definition: Cdr.h:3194
char * getCurrentPosition()
This function returns the current position in the CDR stream.
Cdr & serialize(const float float_t, Endianness endianness)
This function serializes a float with a different endianness.
Cdr & deserializeArray(bool *bool_t, size_t numElements, Endianness endianness)
This function deserializes an array of booleans with a different endianness.
Definition: Cdr.h:3077
char * getBufferPointer()
This function returns the pointer to the current used buffer.
Cdr & deserialize(char &char_t, Endianness endianness)
This function deserializes a character with a different endianness.
Definition: Cdr.h:2073
Cdr & deserialize(uint16_t &ushort_t, Endianness endianness)
This function deserializes an unsigned short with a different endianness.
Definition: Cdr.h:2130
state getState()
This function returns the current state of the CDR serialization process.
Cdr & serializeArray(const std::wstring *string_t, size_t numElements, Endianness endianness)
This function serializes an array of wide-strings with a different endianness.
Definition: Cdr.h:1877
Cdr & serializeArray(const int64_t *longlong_t, size_t numElements, Endianness endianness)
This function serializes an array of long longs with a different endianness.
void resetAlignment()
This function resets the alignment to the current position in the buffer.
Definition: Cdr.h:270
Cdr & deserializeArray(std::wstring *string_t, size_t numElements)
This function deserializes an array of wide-strings.
Definition: Cdr.h:3113
Cdr & serializeArray(const float *float_t, size_t numElements, Endianness endianness)
This function serializes an array of floats with a different endianness.
Cdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
This class represents a stream of bytes that contains (or will contain) serialized data.
Definition: FastBuffer.h:229
_FastBuffer_iterator iterator
Definition: FastBuffer.h:232
This abstract class is used to create exceptions.
Definition: Exception.h:30
virtual void raise() const =0
This function throws the object as exception.
This class is thrown as an exception when the buffer's internal memory reachs its size limit.
Definition: NotEnoughMemoryException.h:28
static const char *const NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT
Default message used in the library.
Definition: NotEnoughMemoryException.h:82
Definition: Cdr.h:37