Fast CDR  Version 1.1.1
Fast CDR
Loading...
Searching...
No Matches
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#include <array>
34
35namespace eprosima {
36namespace fastcdr {
41class Cdr_DllAPI Cdr
42{
43public:
44
46 typedef enum
47 {
51 DDS_CDR
52 } CdrType;
53
55
56 typedef enum : uint8_t
57 {
59 DDS_CDR_WITHOUT_PL = 0x0,
61 DDS_CDR_WITH_PL = 0x2
62 } DDSCdrPlFlag;
63
67 typedef enum : uint8_t
68 {
70 BIG_ENDIANNESS = 0x0,
72 LITTLE_ENDIANNESS = 0x1
73 } Endianness;
74
77
81 class Cdr_DllAPI state
82 {
83 friend class Cdr;
84
85 public:
86
91 const Cdr& cdr);
92
97 const state&);
98
99 private:
100
101 state& operator =(
102 const state&) = delete;
103
105 const FastBuffer::iterator m_currentPosition;
106
108 const FastBuffer::iterator m_alignPosition;
109
111 bool m_swapBytes;
112
114 size_t m_lastDataSize;
115 };
116
126 FastBuffer& cdrBuffer,
127 const Endianness endianness = DEFAULT_ENDIAN,
128 const CdrType cdrType = CORBA_CDR);
129
138
146
152
158 DDSCdrPlFlag plFlag);
159
164 uint16_t getDDSCdrOptions() const;
165
171 uint16_t options);
172
178 Endianness endianness);
179
185 {
186 return static_cast<Endianness>(m_endianness);
187 }
188
194 bool jump(
195 size_t numBytes);
196
200 void reset();
201
207
213
218 inline size_t getSerializedDataLength() const
219 {
220 return m_currentPosition - m_cdrBuffer.begin();
221 }
222
229 inline static size_t alignment(
230 size_t current_alignment,
231 size_t dataSize)
232 {
233 return (dataSize - (current_alignment % dataSize)) & (dataSize - 1);
234 }
235
241
247 state& state);
248
255 size_t numBytes);
256
260 inline void resetAlignment()
261 {
262 m_alignPosition = m_currentPosition;
263 }
264
271 inline Cdr& operator <<(
272 const uint8_t octet_t)
273 {
274 return serialize(octet_t);
275 }
276
283 inline Cdr& operator <<(
284 const char char_t)
285 {
286 return serialize(char_t);
287 }
288
295 inline Cdr& operator <<(
296 const int8_t int8)
297 {
298 return serialize(int8);
299 }
300
307 inline Cdr& operator <<(
308 const uint16_t ushort_t)
309 {
310 return serialize(ushort_t);
311 }
312
319 inline Cdr& operator <<(
320 const int16_t short_t)
321 {
322 return serialize(short_t);
323 }
324
331 inline Cdr& operator <<(
332 const uint32_t ulong_t)
333 {
334 return serialize(ulong_t);
335 }
336
343 inline Cdr& operator <<(
344 const int32_t long_t)
345 {
346 return serialize(long_t);
347 }
348
355 inline Cdr& operator <<(
356 const wchar_t wchar)
357 {
358 return serialize(wchar);
359 }
360
367 inline Cdr& operator <<(
368 const uint64_t ulonglong_t)
369 {
370 return serialize(ulonglong_t);
371 }
372
379 inline Cdr& operator <<(
380 const int64_t longlong_t)
381 {
382 return serialize(longlong_t);
383 }
384
391 inline Cdr& operator <<(
392 const float float_t)
393 {
394 return serialize(float_t);
395 }
396
403 inline Cdr& operator <<(
404 const double double_t)
405 {
406 return serialize(double_t);
407 }
408
415 inline Cdr& operator <<(
416 const long double ldouble_t)
417 {
418 return serialize(ldouble_t);
419 }
420
427 inline Cdr& operator <<(
428 const bool bool_t)
429 {
430 return serialize(bool_t);
431 }
432
439 inline Cdr& operator <<(
440 const char* string_t)
441 {
442 return serialize(string_t);
443 }
444
451 inline Cdr& operator <<(
452 char* string_t)
453 {
454 return serialize(string_t);
455 }
456
463 inline Cdr& operator <<(
464 const std::string& string_t)
465 {
466 return serialize(string_t);
467 }
468
475 inline Cdr& operator <<(
476 const std::wstring& string_t)
477 {
478 return serialize(string_t);
479 }
480
487 template<class _T, size_t _Size>
488 inline Cdr& operator <<(
489 const std::array<_T, _Size>& array_t)
490 {
491 return serialize<_T, _Size>(array_t);
492 }
493
500 template<class _T>
501 inline Cdr& operator <<(
502 const std::vector<_T>& vector_t)
503 {
504 return serialize<_T>(vector_t);
505 }
506
513 template<class _K, class _T>
514 inline Cdr& operator <<(
515 const std::map<_K, _T>& map_t)
516 {
517 return serialize<_K, _T>(map_t);
518 }
519
526 template<class _T>
527 inline Cdr& operator <<(
528 const _T& type_t)
529 {
530 type_t.serialize(*this);
531 return *this;
532 }
533
540 inline Cdr& operator >>(
541 uint8_t& octet_t)
542 {
543 return deserialize(octet_t);
544 }
545
552 inline Cdr& operator >>(
553 char& char_t)
554 {
555 return deserialize(char_t);
556 }
557
564 inline Cdr& operator >>(
565 int8_t& int8)
566 {
567 return deserialize(int8);
568 }
569
576 inline Cdr& operator >>(
577 uint16_t& ushort_t)
578 {
579 return deserialize(ushort_t);
580 }
581
588 inline Cdr& operator >>(
589 int16_t& short_t)
590 {
591 return deserialize(short_t);
592 }
593
600 inline Cdr& operator >>(
601 uint32_t& ulong_t)
602 {
603 return deserialize(ulong_t);
604 }
605
612 inline Cdr& operator >>(
613 int32_t& long_t)
614 {
615 return deserialize(long_t);
616 }
617
618 // TODO in FastCdr
625 inline Cdr& operator >>(
626 wchar_t& wchar)
627 {
628 return deserialize(wchar);
629 }
630
637 inline Cdr& operator >>(
638 uint64_t& ulonglong_t)
639 {
640 return deserialize(ulonglong_t);
641 }
642
649 inline Cdr& operator >>(
650 int64_t& longlong_t)
651 {
652 return deserialize(longlong_t);
653 }
654
661 inline Cdr& operator >>(
662 float& float_t)
663 {
664 return deserialize(float_t);
665 }
666
673 inline Cdr& operator >>(
674 double& double_t)
675 {
676 return deserialize(double_t);
677 }
678
685 inline Cdr& operator >>(
686 long double& ldouble_t)
687 {
688 return deserialize(ldouble_t);
689 }
690
698 inline Cdr& operator >>(
699 bool& bool_t)
700 {
701 return deserialize(bool_t);
702 }
703
713 inline Cdr& operator >>(
714 char*& string_t)
715 {
716 return deserialize(string_t);
717 }
718
725 inline Cdr& operator >>(
726 std::string& string_t)
727 {
728 return deserialize(string_t);
729 }
730
737 inline Cdr& operator >>(
738 std::wstring& string_t)
739 {
740 return deserialize(string_t);
741 }
742
749 template<class _T, size_t _Size>
750 inline Cdr& operator >>(
751 std::array<_T, _Size>& array_t)
752 {
753 return deserialize<_T, _Size>(array_t);
754 }
755
762 template<class _T>
763 inline Cdr& operator >>(
764 std::vector<_T>& vector_t)
765 {
766 return deserialize<_T>(vector_t);
767 }
768
775 template<class _K, class _T>
776 inline Cdr& operator >>(
777 std::map<_K, _T>& map_t)
778 {
779 return deserialize<_K, _T>(map_t);
780 }
781
788 template<class _T>
789 inline Cdr& operator >>(
790 _T& type_t)
791 {
792 type_t.deserialize(*this);
793 return *this;
794 }
795
802 inline
804 const uint8_t octet_t)
805 {
806 return serialize(static_cast<char>(octet_t));
807 }
808
816 inline
818 const uint8_t octet_t,
819 Endianness endianness)
820 {
821 return serialize(static_cast<char>(octet_t), endianness);
822 }
823
831 const char char_t);
832
840 inline
842 const char char_t,
843 Endianness endianness)
844 {
845 (void) endianness;
846 return serialize(char_t);
847 }
848
855 inline
857 const int8_t int8)
858 {
859 return serialize(static_cast<char>(int8));
860 }
861
869 inline
871 const int8_t int8,
872 Endianness endianness)
873 {
874 return serialize(static_cast<char>(int8), endianness);
875 }
876
883 inline
885 const uint16_t ushort_t)
886 {
887 return serialize(static_cast<int16_t>(ushort_t));
888 }
889
897 inline
899 const uint16_t ushort_t,
900 Endianness endianness)
901 {
902 return serialize(static_cast<int16_t>(ushort_t), endianness);
903 }
904
912 const int16_t short_t);
913
922 const int16_t short_t,
923 Endianness endianness);
924
931 inline
933 const uint32_t ulong_t)
934 {
935 return serialize(static_cast<int32_t>(ulong_t));
936 }
937
945 inline
947 const uint32_t ulong_t,
948 Endianness endianness)
949 {
950 return serialize(static_cast<int32_t>(ulong_t), endianness);
951 }
952
960 const int32_t long_t);
961
970 const int32_t long_t,
971 Endianness endianness);
972
979 inline
981 const wchar_t wchar)
982 {
983 return serialize(static_cast<uint32_t>(wchar));
984 }
985
993 inline
995 const wchar_t wchar,
996 Endianness endianness)
997 {
998 return serialize(static_cast<uint32_t>(wchar), endianness);
999 }
1000
1007 inline
1009 const uint64_t ulonglong_t)
1010 {
1011 return serialize(static_cast<int64_t>(ulonglong_t));
1012 }
1013
1021 inline
1023 const uint64_t ulonglong_t,
1024 Endianness endianness)
1025 {
1026 return serialize(static_cast<int64_t>(ulonglong_t), endianness);
1027 }
1028
1036 const int64_t longlong_t);
1037
1046 const int64_t longlong_t,
1047 Endianness endianness);
1048
1056 const float float_t);
1057
1066 const float float_t,
1067 Endianness endianness);
1068
1076 const double double_t);
1077
1086 const double double_t,
1087 Endianness endianness);
1088
1089
1098 const long double ldouble_t);
1099
1109 const long double ldouble_t,
1110 Endianness endianness);
1111
1119 const bool bool_t);
1120
1128 inline
1130 const bool bool_t,
1131 Endianness endianness)
1132 {
1133 (void) endianness;
1134 return serialize(bool_t);
1135 }
1136
1144 char* string_t)
1145 {
1146 return serialize(static_cast<const char*>(string_t));
1147 }
1148
1156 const char* string_t);
1157
1165 const wchar_t* string_t);
1166
1175 const char* string_t,
1176 Endianness endianness);
1177
1186 const wchar_t* string_t,
1187 Endianness endianness);
1188
1195 inline
1197 const std::string& string_t)
1198 {
1199 return serialize(string_t.c_str());
1200 }
1201
1208 inline
1210 const std::wstring& string_t)
1211 {
1212 return serialize(string_t.c_str());
1213 }
1214
1222 inline
1224 const std::string& string_t,
1225 Endianness endianness)
1226 {
1227 return serialize(string_t.c_str(), endianness);
1228 }
1229
1236 template<class _T, size_t _Size>
1238 const std::array<_T, _Size>& array_t)
1239 {
1240 return serializeArray(array_t.data(), array_t.size());
1241 }
1242
1250 template<class _T, size_t _Size>
1252 const std::array<_T, _Size>& array_t,
1253 Endianness endianness)
1254 {
1255 return serializeArray(array_t.data(), array_t.size(), endianness);
1256 }
1257
1264 template<class _T = bool>
1266 const std::vector<bool>& vector_t)
1267 {
1268 return serializeBoolSequence(vector_t);
1269 }
1270
1277 template<class _T>
1279 const std::vector<_T>& vector_t)
1280 {
1281 state state_before_error(*this);
1282
1283 *this << static_cast<int32_t>(vector_t.size());
1284
1285 try
1286 {
1287 return serializeArray(vector_t.data(), vector_t.size());
1288 }
1290 {
1291 setState(state_before_error);
1292 ex.raise();
1293 }
1294
1295 return *this;
1296 }
1297
1304 template<class _K, class _T>
1306 const std::map<_K, _T>& map_t)
1307 {
1308 state state_(*this);
1309
1310 *this << static_cast<int32_t>(map_t.size());
1311
1312 try
1313 {
1314 for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
1315 {
1316 *this << it_pair->first;
1317 *this << it_pair->second;
1318 }
1319 //return serializeArray(map_t.data(), map_t.size());
1320 }
1322 {
1323 setState(state_);
1324 ex.raise();
1325 }
1326
1327 return *this;
1328 }
1329
1330#ifdef _MSC_VER
1337 template<>
1338 Cdr& serialize<bool>(
1339 const std::vector<bool>& vector_t)
1340 {
1341 return serializeBoolSequence(vector_t);
1342 }
1343
1344#endif // ifdef _MSC_VER
1345
1353 template<class _T>
1355 const std::vector<_T>& vector_t,
1356 Endianness endianness)
1357 {
1358 bool auxSwap = m_swapBytes;
1359 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
1360 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
1361
1362 try
1363 {
1364 serialize(vector_t);
1365 m_swapBytes = auxSwap;
1366 }
1368 {
1369 m_swapBytes = auxSwap;
1370 ex.raise();
1371 }
1372
1373 return *this;
1374 }
1375
1382 template<class _T>
1384 const _T& type_t)
1385 {
1386 type_t.serialize(*this);
1387 return *this;
1388 }
1389
1397 inline
1399 const uint8_t* octet_t,
1400 size_t numElements)
1401 {
1402 return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
1403 }
1404
1413 inline
1415 const uint8_t* octet_t,
1416 size_t numElements,
1417 Endianness endianness)
1418 {
1419 (void) endianness;
1420 return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
1421 }
1422
1431 const char* char_t,
1432 size_t numElements);
1433
1442 inline
1444 const char* char_t,
1445 size_t numElements,
1446 Endianness endianness)
1447 {
1448 (void) endianness;
1449 return serializeArray(char_t, numElements);
1450 }
1451
1459 inline
1461 const int8_t* int8,
1462 size_t numElements)
1463 {
1464 return serializeArray(reinterpret_cast<const char*>(int8), numElements);
1465 }
1466
1475 inline
1477 const int8_t* int8,
1478 size_t numElements,
1479 Endianness endianness)
1480 {
1481 (void) endianness;
1482 return serializeArray(reinterpret_cast<const char*>(int8), numElements);
1483 }
1484
1492 inline
1494 const uint16_t* ushort_t,
1495 size_t numElements)
1496 {
1497 return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements);
1498 }
1499
1508 inline
1510 const uint16_t* ushort_t,
1511 size_t numElements,
1512 Endianness endianness)
1513 {
1514 return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements, endianness);
1515 }
1516
1525 const int16_t* short_t,
1526 size_t numElements);
1527
1537 const int16_t* short_t,
1538 size_t numElements,
1539 Endianness endianness);
1540
1548 inline
1550 const uint32_t* ulong_t,
1551 size_t numElements)
1552 {
1553 return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements);
1554 }
1555
1564 inline
1566 const uint32_t* ulong_t,
1567 size_t numElements,
1568 Endianness endianness)
1569 {
1570 return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements, endianness);
1571 }
1572
1581 const int32_t* long_t,
1582 size_t numElements);
1583
1593 const int32_t* long_t,
1594 size_t numElements,
1595 Endianness endianness);
1596
1605 const wchar_t* wchar,
1606 size_t numElements);
1607
1617 const wchar_t* wchar,
1618 size_t numElements,
1619 Endianness endianness);
1620
1628 inline
1630 const uint64_t* ulonglong_t,
1631 size_t numElements)
1632 {
1633 return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements);
1634 }
1635
1644 inline
1646 const uint64_t* ulonglong_t,
1647 size_t numElements,
1648 Endianness endianness)
1649 {
1650 return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements, endianness);
1651 }
1652
1661 const int64_t* longlong_t,
1662 size_t numElements);
1663
1673 const int64_t* longlong_t,
1674 size_t numElements,
1675 Endianness endianness);
1676
1685 const float* float_t,
1686 size_t numElements);
1687
1697 const float* float_t,
1698 size_t numElements,
1699 Endianness endianness);
1700
1709 const double* double_t,
1710 size_t numElements);
1711
1721 const double* double_t,
1722 size_t numElements,
1723 Endianness endianness);
1724
1733 const long double* ldouble_t,
1734 size_t numElements);
1735
1745 const long double* ldouble_t,
1746 size_t numElements,
1747 Endianness endianness);
1748
1757 const bool* bool_t,
1758 size_t numElements);
1759
1768 inline
1770 const bool* bool_t,
1771 size_t numElements,
1772 Endianness endianness)
1773 {
1774 (void) endianness;
1775 return serializeArray(bool_t, numElements);
1776 }
1777
1785 inline
1787 const std::string* string_t,
1788 size_t numElements)
1789 {
1790 for (size_t count = 0; count < numElements; ++count)
1791 {
1792 serialize(string_t[count].c_str());
1793 }
1794 return *this;
1795 }
1796
1804 inline
1806 const std::wstring* string_t,
1807 size_t numElements)
1808 {
1809 for (size_t count = 0; count < numElements; ++count)
1810 {
1811 serialize(string_t[count].c_str());
1812 }
1813 return *this;
1814 }
1815
1824 inline
1826 const std::string* string_t,
1827 size_t numElements,
1828 Endianness endianness)
1829 {
1830 bool auxSwap = m_swapBytes;
1831 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
1832 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
1833
1834 try
1835 {
1836 serializeArray(string_t, numElements);
1837 m_swapBytes = auxSwap;
1838 }
1840 {
1841 m_swapBytes = auxSwap;
1842 ex.raise();
1843 }
1844
1845 return *this;
1846 }
1847
1856 inline
1858 const std::wstring* string_t,
1859 size_t numElements,
1860 Endianness endianness)
1861 {
1862 bool auxSwap = m_swapBytes;
1863 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
1864 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
1865
1866 try
1867 {
1868 serializeArray(string_t, numElements);
1869 m_swapBytes = auxSwap;
1870 }
1872 {
1873 m_swapBytes = auxSwap;
1874 ex.raise();
1875 }
1876
1877 return *this;
1878 }
1879
1887 template<class _T>
1889 const std::vector<_T>* vector_t,
1890 size_t numElements)
1891 {
1892 for (size_t count = 0; count < numElements; ++count)
1893 {
1894 serialize(vector_t[count]);
1895 }
1896 return *this;
1897 }
1898
1906 template<class _K, class _T>
1908 const std::map<_K, _T>* map_t,
1909 size_t numElements)
1910 {
1911 for (size_t count = 0; count < numElements; ++count)
1912 {
1913 serialize(map_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 *this << type_t[count];
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 && (static_cast<Endianness>(m_endianness) == endianness)) ||
1953 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
1954
1955 try
1956 {
1957 serializeArray(type_t, numElements);
1958 m_swapBytes = auxSwap;
1959 }
1961 {
1962 m_swapBytes = auxSwap;
1963 ex.raise();
1964 }
1965
1966 return *this;
1967 }
1968
1976 template<class _T>
1978 const _T* sequence_t,
1979 size_t numElements)
1980 {
1981 state state_before_error(*this);
1982
1983 serialize(static_cast<int32_t>(numElements));
1984
1985 try
1986 {
1987 return serializeArray(sequence_t, numElements);
1988 }
1990 {
1991 setState(state_before_error);
1992 ex.raise();
1993 }
1994
1995 return *this;
1996 }
1997
2006 template<class _T>
2008 const _T* sequence_t,
2009 size_t numElements,
2010 Endianness endianness)
2011 {
2012 bool auxSwap = m_swapBytes;
2013 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
2014 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
2015
2016 try
2017 {
2018 serializeSequence(sequence_t, numElements);
2019 m_swapBytes = auxSwap;
2020 }
2022 {
2023 m_swapBytes = auxSwap;
2024 ex.raise();
2025 }
2026
2027 return *this;
2028 }
2029
2036 inline
2038 uint8_t& octet_t)
2039 {
2040 return deserialize(reinterpret_cast<char&>(octet_t));
2041 }
2042
2050 inline
2052 uint8_t& octet_t,
2053 Endianness endianness)
2054 {
2055 return deserialize(reinterpret_cast<char&>(octet_t), endianness);
2056 }
2057
2065 char& char_t);
2066
2074 inline
2076 char& char_t,
2077 Endianness endianness)
2078 {
2079 (void) endianness;
2080 return deserialize(char_t);
2081 }
2082
2089 inline
2091 int8_t& int8)
2092 {
2093 return deserialize(reinterpret_cast<char&>(int8));
2094 }
2095
2103 inline
2105 int8_t& int8,
2106 Endianness endianness)
2107 {
2108 return deserialize(reinterpret_cast<char&>(int8), endianness);
2109 }
2110
2117 inline
2119 uint16_t& ushort_t)
2120 {
2121 return deserialize(reinterpret_cast<int16_t&>(ushort_t));
2122 }
2123
2131 inline
2133 uint16_t& ushort_t,
2134 Endianness endianness)
2135 {
2136 return deserialize(reinterpret_cast<int16_t&>(ushort_t), endianness);
2137 }
2138
2146 int16_t& short_t);
2147
2156 int16_t& short_t,
2157 Endianness endianness);
2158
2165 inline
2167 uint32_t& ulong_t)
2168 {
2169 return deserialize(reinterpret_cast<int32_t&>(ulong_t));
2170 }
2171
2179 inline
2181 uint32_t& ulong_t,
2182 Endianness endianness)
2183 {
2184 return deserialize(reinterpret_cast<int32_t&>(ulong_t), endianness);
2185 }
2186
2194 int32_t& long_t);
2195
2204 int32_t& long_t,
2205 Endianness endianness);
2206
2213 inline
2215 wchar_t& wchar)
2216 {
2217 uint32_t ret;
2218 deserialize(ret);
2219 wchar = static_cast<wchar_t>(ret);
2220 return *this;
2221 }
2222
2230 inline
2232 wchar_t& wchar,
2233 Endianness endianness)
2234 {
2235 uint32_t ret;
2236 deserialize(ret, endianness);
2237 wchar = static_cast<wchar_t>(ret);
2238 return *this;
2239 }
2240
2247 inline
2249 uint64_t& ulonglong_t)
2250 {
2251 return deserialize(reinterpret_cast<int64_t&>(ulonglong_t));
2252 }
2253
2261 inline
2263 uint64_t& ulonglong_t,
2264 Endianness endianness)
2265 {
2266 return deserialize(reinterpret_cast<int64_t&>(ulonglong_t), endianness);
2267 }
2268
2276 int64_t& longlong_t);
2277
2286 int64_t& longlong_t,
2287 Endianness endianness);
2288
2296 float& float_t);
2297
2306 float& float_t,
2307 Endianness endianness);
2308
2316 double& double_t);
2317
2326 double& double_t,
2327 Endianness endianness);
2328
2337 long double& ldouble_t);
2338
2348 long double& ldouble_t,
2349 Endianness endianness);
2350
2359 bool& bool_t);
2360
2369 inline
2371 bool& bool_t,
2372 Endianness endianness)
2373 {
2374 (void) endianness;
2375 return deserialize(bool_t);
2376 }
2377
2388 char*& string_t);
2389
2400 wchar_t*& string_t);
2401
2413 char*& string_t,
2414 Endianness endianness);
2415
2427 wchar_t*& string_t,
2428 Endianness endianness);
2429
2436 inline
2438 std::string& string_t)
2439 {
2440 uint32_t length = 0;
2441 const char* str = readString(length);
2442 string_t.assign(str, length);
2443 return *this;
2444 }
2445
2452 inline
2454 std::wstring& string_t)
2455 {
2456 uint32_t length = 0;
2457 string_t = readWString(length);
2458 return *this;
2459 }
2460
2468 inline
2470 std::string& string_t,
2471 Endianness endianness)
2472 {
2473 bool auxSwap = m_swapBytes;
2474 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
2475 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
2476
2477 try
2478 {
2479 deserialize(string_t);
2480 m_swapBytes = auxSwap;
2481 }
2483 {
2484 m_swapBytes = auxSwap;
2485 ex.raise();
2486 }
2487
2488 return *this;
2489 }
2490
2498 inline
2500 std::wstring& string_t,
2501 Endianness endianness)
2502 {
2503 bool auxSwap = m_swapBytes;
2504 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
2505 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
2506
2507 try
2508 {
2509 deserialize(string_t);
2510 m_swapBytes = auxSwap;
2511 }
2513 {
2514 m_swapBytes = auxSwap;
2515 ex.raise();
2516 }
2517
2518 return *this;
2519 }
2520
2527 template<class _T, size_t _Size>
2529 std::array<_T, _Size>& array_t)
2530 {
2531 return deserializeArray(array_t.data(), array_t.size());
2532 }
2533
2541 template<class _T, size_t _Size>
2543 std::array<_T, _Size>& array_t,
2544 Endianness endianness)
2545 {
2546 return deserializeArray(array_t.data(), array_t.size(), endianness);
2547 }
2548
2555 template<class _T = bool>
2557 std::vector<bool>& vector_t)
2558 {
2559 return deserializeBoolSequence(vector_t);
2560 }
2561
2568 template<class _T>
2570 std::vector<_T>& vector_t)
2571 {
2572 uint32_t seqLength = 0;
2573 state state_before_error(*this);
2574
2575 *this >> seqLength;
2576
2577 if (seqLength == 0)
2578 {
2579 vector_t.clear();
2580 return *this;
2581 }
2582
2583 if ((m_lastPosition - m_currentPosition) < seqLength)
2584 {
2585 setState(state_before_error);
2588 }
2589
2590 try
2591 {
2592 vector_t.resize(seqLength);
2593 return deserializeArray(vector_t.data(), vector_t.size());
2594 }
2596 {
2597 setState(state_before_error);
2598 ex.raise();
2599 }
2600
2601 return *this;
2602 }
2603
2610 template<class _K, class _T>
2612 std::map<_K, _T>& map_t)
2613 {
2614 uint32_t seqLength = 0;
2615 state state_(*this);
2616
2617 *this >> seqLength;
2618
2619 try
2620 {
2621 for (uint32_t i = 0; i < seqLength; ++i)
2622 {
2623 _K key;
2624 _T value;
2625 *this >> key;
2626 *this >> value;
2627 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2628 }
2629 }
2631 {
2632 setState(state_);
2633 ex.raise();
2634 }
2635
2636 return *this;
2637 }
2638
2639#ifdef _MSC_VER
2646 template<>
2647 Cdr& deserialize<bool>(
2648 std::vector<bool>& vector_t)
2649 {
2650 return deserializeBoolSequence(vector_t);
2651 }
2652
2653#endif // ifdef _MSC_VER
2654
2662 template<class _T>
2664 std::vector<_T>& vector_t,
2665 Endianness endianness)
2666 {
2667 bool auxSwap = m_swapBytes;
2668 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
2669 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
2670
2671 try
2672 {
2673 deserialize(vector_t);
2674 m_swapBytes = auxSwap;
2675 }
2676 catch (exception::Exception& ex)
2677 {
2678 m_swapBytes = auxSwap;
2679 ex.raise();
2680 }
2681
2682 return *this;
2683 }
2684
2691 template<class _T>
2693 _T& type_t)
2694 {
2695 type_t.deserialize(*this);
2696 return *this;
2697 }
2698
2706 inline
2708 uint8_t* octet_t,
2709 size_t numElements)
2710 {
2711 return deserializeArray(reinterpret_cast<char*>(octet_t), numElements);
2712 }
2713
2722 inline
2724 uint8_t* octet_t,
2725 size_t numElements,
2726 Endianness endianness)
2727 {
2728 return deserializeArray(reinterpret_cast<char*>(octet_t), numElements, endianness);
2729 }
2730
2739 char* char_t,
2740 size_t numElements);
2741
2750 inline
2752 char* char_t,
2753 size_t numElements,
2754 Endianness endianness)
2755 {
2756 (void) endianness;
2757 return deserializeArray(char_t, numElements);
2758 }
2759
2767 inline
2769 int8_t* int8,
2770 size_t numElements)
2771 {
2772 return deserializeArray(reinterpret_cast<char*>(int8), numElements);
2773 }
2774
2783 inline
2785 int8_t* int8,
2786 size_t numElements,
2787 Endianness endianness)
2788 {
2789 return deserializeArray(reinterpret_cast<char*>(int8), numElements, endianness);
2790 }
2791
2799 inline
2801 uint16_t* ushort_t,
2802 size_t numElements)
2803 {
2804 return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements);
2805 }
2806
2815 inline
2817 uint16_t* ushort_t,
2818 size_t numElements,
2819 Endianness endianness)
2820 {
2821 return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements, endianness);
2822 }
2823
2832 int16_t* short_t,
2833 size_t numElements);
2834
2844 int16_t* short_t,
2845 size_t numElements,
2846 Endianness endianness);
2847
2855 inline
2857 uint32_t* ulong_t,
2858 size_t numElements)
2859 {
2860 return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements);
2861 }
2862
2871 inline
2873 uint32_t* ulong_t,
2874 size_t numElements,
2875 Endianness endianness)
2876 {
2877 return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements, endianness);
2878 }
2879
2888 int32_t* long_t,
2889 size_t numElements);
2890
2900 int32_t* long_t,
2901 size_t numElements,
2902 Endianness endianness);
2903
2912 wchar_t* wchar,
2913 size_t numElements);
2914
2924 wchar_t* wchar,
2925 size_t numElements,
2926 Endianness endianness);
2927
2935 inline
2937 uint64_t* ulonglong_t,
2938 size_t numElements)
2939 {
2940 return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements);
2941 }
2942
2951 inline
2953 uint64_t* ulonglong_t,
2954 size_t numElements,
2955 Endianness endianness)
2956 {
2957 return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements, endianness);
2958 }
2959
2968 int64_t* longlong_t,
2969 size_t numElements);
2970
2980 int64_t* longlong_t,
2981 size_t numElements,
2982 Endianness endianness);
2983
2992 float* float_t,
2993 size_t numElements);
2994
3004 float* float_t,
3005 size_t numElements,
3006 Endianness endianness);
3007
3016 double* double_t,
3017 size_t numElements);
3018
3028 double* double_t,
3029 size_t numElements,
3030 Endianness endianness);
3031
3040 long double* ldouble_t,
3041 size_t numElements);
3042
3052 long double* ldouble_t,
3053 size_t numElements,
3054 Endianness endianness);
3055
3064 bool* bool_t,
3065 size_t numElements);
3066
3075 inline
3077 bool* bool_t,
3078 size_t numElements,
3079 Endianness endianness)
3080 {
3081 (void) endianness;
3082 return deserializeArray(bool_t, numElements);
3083 }
3084
3092 inline
3094 std::string* string_t,
3095 size_t numElements)
3096 {
3097 for (size_t count = 0; count < numElements; ++count)
3098 {
3099 deserialize(string_t[count]);
3100 }
3101 return *this;
3102 }
3103
3111 inline
3113 std::wstring* string_t,
3114 size_t numElements)
3115 {
3116 for (size_t count = 0; count < numElements; ++count)
3117 {
3118 deserialize(string_t[count]);
3119 }
3120 return *this;
3121 }
3122
3131 inline
3133 std::string* string_t,
3134 size_t numElements,
3135 Endianness endianness)
3136 {
3137 bool auxSwap = m_swapBytes;
3138 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
3139 (!m_swapBytes && (static_cast<Endianness>(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 && (static_cast<Endianness>(m_endianness) == endianness)) ||
3171 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
3172
3173 try
3174 {
3175 deserializeArray(string_t, numElements);
3176 m_swapBytes = auxSwap;
3177 }
3179 {
3180 m_swapBytes = auxSwap;
3181 ex.raise();
3182 }
3183
3184 return *this;
3185 }
3186
3194 template<class _T>
3196 std::vector<_T>* vector_t,
3197 size_t numElements)
3198 {
3199 for (size_t count = 0; count < numElements; ++count)
3200 {
3201 deserialize(vector_t[count]);
3202 }
3203 return *this;
3204 }
3205
3213 template<class _K, class _T>
3215 std::map<_K, _T>* map_t,
3216 size_t numElements)
3217 {
3218 for (size_t count = 0; count < numElements; ++count)
3219 {
3220 deserialize(map_t[count]);
3221 }
3222 return *this;
3223 }
3224
3232 template<class _T>
3234 _T* type_t,
3235 size_t numElements)
3236 {
3237 for (size_t count = 0; count < numElements; ++count)
3238 {
3239 *this >> type_t[count];
3240 }
3241 return *this;
3242 }
3243
3252 template<class _T>
3254 _T* type_t,
3255 size_t numElements,
3256 Endianness endianness)
3257 {
3258 bool auxSwap = m_swapBytes;
3259 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
3260 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
3261
3262 try
3263 {
3264 deserializeArray(type_t, numElements);
3265 m_swapBytes = auxSwap;
3266 }
3268 {
3269 m_swapBytes = auxSwap;
3270 ex.raise();
3271 }
3272
3273 return *this;
3274 }
3275
3285 template<class _T = std::string>
3287 std::string*& sequence_t,
3288 size_t& numElements)
3289 {
3290 return deserializeStringSequence(sequence_t, numElements);
3291 }
3292
3302 template<class _T = std::wstring>
3304 std::wstring*& sequence_t,
3305 size_t& numElements)
3306 {
3307 return deserializeWStringSequence(sequence_t, numElements);
3308 }
3309
3319 template<class _T>
3321 _T*& sequence_t,
3322 size_t& numElements)
3323 {
3324 uint32_t seqLength = 0;
3325 state state_before_error(*this);
3326
3327 deserialize(seqLength);
3328
3329 try
3330 {
3331 sequence_t = reinterpret_cast<_T*>(calloc(seqLength, sizeof(_T)));
3332 deserializeArray(sequence_t, seqLength);
3333 }
3335 {
3336 free(sequence_t);
3337 sequence_t = NULL;
3338 setState(state_before_error);
3339 ex.raise();
3340 }
3341
3342 numElements = seqLength;
3343 return *this;
3344 }
3345
3346#ifdef _MSC_VER
3356 template<>
3357 Cdr& deserializeSequence<std::string>(
3358 std::string*& sequence_t,
3359 size_t& numElements)
3360 {
3361 return deserializeStringSequence(sequence_t, numElements);
3362 }
3363
3373 template<>
3374 Cdr& deserializeSequence<std::wstring>(
3375 std::wstring*& sequence_t,
3376 size_t& numElements)
3377 {
3378 return deserializeWStringSequence(sequence_t, numElements);
3379 }
3380
3381#endif // ifdef _MSC_VER
3382
3393 template<class _T>
3395 _T*& sequence_t,
3396 size_t& numElements,
3397 Endianness endianness)
3398 {
3399 bool auxSwap = m_swapBytes;
3400 m_swapBytes = (m_swapBytes && (static_cast<Endianness>(m_endianness) == endianness)) ||
3401 (!m_swapBytes && (static_cast<Endianness>(m_endianness) != endianness));
3402
3403 try
3404 {
3405 deserializeSequence(sequence_t, numElements);
3406 m_swapBytes = auxSwap;
3407 }
3409 {
3410 m_swapBytes = auxSwap;
3411 ex.raise();
3412 }
3413
3414 return *this;
3415 }
3416
3417private:
3418
3419 Cdr(
3420 const Cdr&) = delete;
3421
3422 Cdr& operator =(
3423 const Cdr&) = delete;
3424
3425 Cdr& serializeBoolSequence(
3426 const std::vector<bool>& vector_t);
3427
3428 Cdr& deserializeBoolSequence(
3429 std::vector<bool>& vector_t);
3430
3431 Cdr& deserializeStringSequence(
3432 std::string*& sequence_t,
3433 size_t& numElements);
3434
3435 Cdr& deserializeWStringSequence(
3436 std::wstring*& sequence_t,
3437 size_t& numElements);
3438
3446 template<class _T, size_t _Size>
3447 Cdr& serializeArray(
3448 const std::array<_T, _Size>* array_t,
3449 size_t numElements)
3450 {
3451 return serializeArray(array_t->data(), numElements * array_t->size());
3452 }
3453
3462 template<class _T, size_t _Size>
3463 Cdr& serializeArray(
3464 const std::array<_T, _Size>* array_t,
3465 size_t numElements,
3466 Endianness endianness)
3467 {
3468 return serializeArray(array_t->data(), numElements * array_t->size(), endianness);
3469 }
3470
3478 template<class _T, size_t _Size>
3479 Cdr& deserializeArray(
3480 std::array<_T, _Size>* array_t,
3481 size_t numElements)
3482 {
3483 return deserializeArray(array_t->data(), numElements * array_t->size());
3484 }
3485
3494 template<class _T, size_t _Size>
3495 Cdr& deserializeArray(
3496 std::array<_T, _Size>* array_t,
3497 size_t numElements,
3498 Endianness endianness)
3499 {
3500 return deserializeArray(array_t->data(), numElements * array_t->size(), endianness);
3501 }
3502
3508 inline size_t alignment(
3509 size_t dataSize) const
3510 {
3511 return dataSize >
3512 m_lastDataSize ? (dataSize - ((m_currentPosition - m_alignPosition) % dataSize)) &
3513 (dataSize - 1) : 0;
3514 }
3515
3520 inline void makeAlign(
3521 size_t align)
3522 {
3523 m_currentPosition += align;
3524 }
3525
3531 bool resize(
3532 size_t minSizeInc);
3533
3534 //TODO
3535 const char* readString(
3536 uint32_t& length);
3537 const std::wstring readWString(
3538 uint32_t& length);
3539
3541 FastBuffer& m_cdrBuffer;
3542
3544 CdrType m_cdrType;
3545
3547 DDSCdrPlFlag m_plFlag;
3548
3550 uint16_t m_options;
3551
3553 uint8_t m_endianness;
3554
3556 bool m_swapBytes;
3557
3559 size_t m_lastDataSize;
3560
3562 FastBuffer::iterator m_currentPosition;
3563
3565 FastBuffer::iterator m_alignPosition;
3566
3568 FastBuffer::iterator m_lastPosition;
3569};
3570} //namespace fastcdr
3571} //namespace eprosima
3572
3573#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:82
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:42
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:1383
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:2872
Cdr & deserializeArray(char *char_t, size_t numElements, Endianness endianness)
This function deserializes an array of characters with a different endianness.
Definition: Cdr.h:2751
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:980
Cdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: Cdr.h:2214
Cdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition: Cdr.h:1008
Cdr & deserializeArray(int64_t *longlong_t, size_t numElements, Endianness endianness)
This function deserializes an array of long longs with a different endianness.
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:2663
Cdr & serializeArray(const std::string *string_t, size_t numElements)
This function serializes an array of strings.
Definition: Cdr.h:1786
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:1305
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:1414
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:1509
Cdr & deserialize(std::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition: Cdr.h:2528
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:2370
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:2007
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 & serialize(const std::array< _T, _Size > &array_t, Endianness endianness)
This function template serializes an array with a different endianness.
Definition: Cdr.h:1251
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:2437
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:1825
Cdr & serialize(const uint16_t ushort_t, Endianness endianness)
This function serializes an unsigned short with a different endianness.
Definition: Cdr.h:898
Cdr & deserializeArray(int8_t *int8, size_t numElements)
This function deserializes an array of int8_t.
Definition: Cdr.h:2768
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:1443
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:2569
Cdr & deserializeSequence(_T *&sequence_t, size_t &numElements, Endianness endianness)
This function template deserializes a raw sequence with a different endianness.
Definition: Cdr.h:3394
Cdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements)
This function deserializes an array of unsigned long longs.
Definition: Cdr.h:2936
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:1209
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:1549
Cdr & serialize(const bool bool_t, Endianness endianness)
This function serializes a boolean with a different endianness.
Definition: Cdr.h:1129
Cdr & deserialize(wchar_t *&string_t, Endianness endianness)
This function deserializes a wide string with a different endianness.
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:218
Cdr & deserialize(uint32_t &ulong_t, Endianness endianness)
This function deserializes an unsigned long with a different endianness.
Definition: Cdr.h:2180
Cdr & deserializeSequence(std::string *&sequence_t, size_t &numElements)
This function template deserializes a string sequence.
Definition: Cdr.h:3286
Cdr & deserializeArray(std::map< _K, _T > *map_t, size_t numElements)
This function deserializes an array of maps of objects.
Definition: Cdr.h:3214
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:817
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:2692
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:2248
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:2952
Cdr & serialize(const std::vector< _T > &vector_t, Endianness endianness)
This function template serializes a sequence with a different endianness.
Definition: Cdr.h:1354
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:2453
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:3093
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:2231
Cdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: Cdr.h:2166
Endianness
This enumeration represents endianness types.
Definition: Cdr.h:68
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:1143
Cdr & serializeSequence(const _T *sequence_t, size_t numElements)
This function template serializes a raw sequence.
Definition: Cdr.h:1977
Cdr & serializeArray(const std::map< _K, _T > *map_t, size_t numElements)
This function template serializes an array of maps of objects.
Definition: Cdr.h:1907
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:76
Cdr & serialize(const uint32_t ulong_t, Endianness endianness)
This function serializes an unsigned long with a different endianness.
Definition: Cdr.h:946
Cdr & serialize(const uint8_t octet_t)
This function serializes an octet.
Definition: Cdr.h:803
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:2090
Cdr & serialize(const wchar_t wchar, Endianness endianness)
This function serializes a wide-char with a different endianness.
Definition: Cdr.h:994
Cdr & serialize(const int8_t int8, Endianness endianness)
This function serializes an int8_t with a different endianness.
Definition: Cdr.h:870
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:1022
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:2816
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:1223
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:1805
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:2784
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:3132
Cdr & serialize(const int16_t short_t, Endianness endianness)
This function serializes a short with a different endianness.
Cdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition: Cdr.h:1265
Cdr & deserialize(std::wstring &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2499
Cdr & deserializeArray(uint16_t *ushort_t, size_t numElements)
This function deserializes an array of unsigned shorts.
Definition: Cdr.h:2800
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:1769
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:3320
Cdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: Cdr.h:2118
Cdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements)
This function serializes an array of unsigned long longs.
Definition: Cdr.h:1629
Cdr & deserialize(uint8_t &octet_t, Endianness endianness)
This function deserializes an octet with a different endianness.
Definition: Cdr.h:2051
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:1476
Cdr & deserialize(std::string &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2469
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:229
Cdr & deserializeArray(uint8_t *octet_t, size_t numElements)
This function deserializes an array of octets.
Definition: Cdr.h:2707
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:3233
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:856
Cdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
Cdr & deserializeSequence(std::wstring *&sequence_t, size_t &numElements)
This function template deserializes a wide-string sequence.
Definition: Cdr.h:3303
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:2262
Cdr & serialize(const long double ldouble_t, Endianness endianness)
This function serializes a long double 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:57
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:1888
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:2037
Cdr & deserialize(int8_t &int8, Endianness endianness)
This function deserializes an int8_t with a different endianness.
Definition: Cdr.h:2104
Cdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition: Cdr.h:932
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:1278
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:2723
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:841
Cdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence.
Definition: Cdr.h:2556
Cdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition: Cdr.h:884
Cdr & serializeArray(const uint16_t *ushort_t, size_t numElements)
This function serializes an array of unsigned shorts.
Definition: Cdr.h:1493
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:3253
CdrType
This enumeration represents the two kinds of CDR serialization supported by eprosima::fastcdr::CDR.
Definition: Cdr.h:47
@ CORBA_CDR
Common CORBA CDR serialization.
Definition: Cdr.h:49
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:1565
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:184
Cdr & deserialize(std::map< _K, _T > &map_t)
This function template deserializes a map.
Definition: Cdr.h:2611
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:1398
Cdr & deserializeArray(uint32_t *ulong_t, size_t numElements)
This function deserializes an array of unsigned longs.
Definition: Cdr.h:2856
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:1196
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:1460
Cdr & deserializeArray(char *char_t, size_t numElements)
This function deserializes an array of characters.
Cdr & deserialize(std::array< _T, _Size > &array_t, Endianness endianness)
This function template deserializes an array with a different endianness.
Definition: Cdr.h:2542
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:1645
Cdr & deserializeArray(std::vector< _T > *vector_t, size_t numElements)
This function deserializes an array of sequences of objects.
Definition: Cdr.h:3195
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:3076
char * getBufferPointer()
This function returns the pointer to the current used buffer.
Cdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition: Cdr.h:1237
Cdr & deserialize(char &char_t, Endianness endianness)
This function deserializes a character with a different endianness.
Definition: Cdr.h:2075
Cdr & deserialize(uint16_t &ushort_t, Endianness endianness)
This function deserializes an unsigned short with a different endianness.
Definition: Cdr.h:2132
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:1857
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:260
Cdr & deserializeArray(std::wstring *string_t, size_t numElements)
This function deserializes an array of wide-strings.
Definition: Cdr.h:3112
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
This abstract class is used to create exceptions.
Definition: Exception.h:30
virtual Cdr_DllAPI 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 Cdr_DllAPI const char *const NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT
Default message used in the library.
Definition: NotEnoughMemoryException.h:78
Definition: Cdr.h:35