Fast CDR  Version 1.1.1
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 #include <array>
34 
35 namespace eprosima {
36 namespace fastcdr {
41 class Cdr_DllAPI Cdr
42 {
43 public:
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 
76  static const Endianness DEFAULT_ENDIAN;
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 
246  void setState(
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 
1143  inline Cdr& serialize(
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>
1237  inline Cdr& serialize(
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>
1251  inline Cdr& serialize(
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>
1383  inline Cdr& serialize(
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>
2528  inline Cdr& deserialize(
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>
2542  inline Cdr& deserialize(
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>
2692  inline Cdr& deserialize(
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 
3417 private:
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(double *double_t, size_t numElements, Endianness endianness)
This function deserializes an array of doubles with a different endianness.
Cdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements)
This function serializes an array of unsigned long longs.
Definition: Cdr.h:1629
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 & deserializeArray(int32_t *long_t, size_t numElements)
This function deserializes an array of longs.
Cdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements)
This function deserializes an array of unsigned long longs.
Definition: Cdr.h:2936
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.
Cdr & deserializeArray(char *char_t, size_t numElements)
This function deserializes an array of characters.
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 uint8_t octet_t)
This function serializes an octet.
Definition: Cdr.h:803
Cdr & deserializeArray(uint16_t *ushort_t, size_t numElements)
This function deserializes an array of unsigned shorts.
Definition: Cdr.h:2800
Cdr & deserializeArray(uint32_t *ulong_t, size_t numElements)
This function deserializes an array of unsigned longs.
Definition: Cdr.h:2856
Cdr & serialize(const wchar_t wchar, Endianness endianness)
This function serializes a wide-char with a different endianness.
Definition: Cdr.h:994
Cdr & deserializeArray(float *float_t, size_t numElements)
This function deserializes an array of floats.
void changeEndianness(Endianness endianness)
This function sets the current endianness used by the CDR type.
Cdr & serializeArray(const int64_t *longlong_t, size_t numElements, Endianness endianness)
This function serializes an array of long longs with a different endianness.
Cdr & deserialize(int8_t &int8, Endianness endianness)
This function deserializes an int8_t with a different endianness.
Definition: Cdr.h:2104
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::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition: Cdr.h:1265
Cdr & serialize(const float float_t, Endianness endianness)
This function serializes a float with a different endianness.
Cdr & serializeArray(const uint16_t *ushort_t, size_t numElements)
This function serializes an array of unsigned shorts.
Definition: Cdr.h:1493
void setDDSCdrOptions(uint16_t options)
This function sets the option flags 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 std::string &string_t)
This function serializes a std::string.
Definition: Cdr.h:1196
Cdr & deserializeArray(_T *type_t, size_t numElements)
This function template deserializes an array of non-basic objects.
Definition: Cdr.h:3233
Cdr & serialize(const uint8_t octet_t, Endianness endianness)
This function serializes an octet with a different endianness.
Definition: Cdr.h:817
Cdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
Cdr & deserializeArray(int32_t *long_t, size_t numElements, Endianness endianness)
This function deserializes an array of longs with a different endianness.
Cdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition: Cdr.h:2037
Cdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition: Cdr.h:1209
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 & deserializeArray(int64_t *longlong_t, size_t numElements)
This function deserializes an array of long longs.
Cdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition: Cdr.h:932
Cdr & serializeArray(const float *float_t, size_t numElements, Endianness endianness)
This function serializes an array of floats with a different endianness.
Cdr & deserialize(uint16_t &ushort_t, Endianness endianness)
This function deserializes an unsigned short with a different endianness.
Definition: Cdr.h:2132
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 int8_t int8, Endianness endianness)
This function serializes an int8_t with a different endianness.
Definition: Cdr.h:870
Cdr & serialize(const _T &type_t)
This function template serializes a non-basic object.
Definition: Cdr.h:1383
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 & serialize(const int64_t longlong_t, Endianness endianness)
This function serializes a long long with a different endianness.
Cdr & serialize(const uint16_t ushort_t, Endianness endianness)
This function serializes an unsigned short with a different endianness.
Definition: Cdr.h:898
Cdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition: Cdr.h:856
Cdr & serializeArray(const double *double_t, size_t numElements)
This function serializes an array of doubles.
Cdr & serialize(const std::map< _K, _T > &map_t)
This function template serializes a map.
Definition: Cdr.h:1305
Cdr & deserializeArray(int16_t *short_t, size_t numElements)
This function deserializes an array of shorts.
Cdr & deserialize(int32_t &long_t)
This function deserializes a long.
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 & deserializeArray(uint8_t *octet_t, size_t numElements)
This function deserializes an array of octets.
Definition: Cdr.h:2707
Cdr & serialize(const int16_t short_t)
This function serializes a short.
Cdr & deserialize(int32_t &long_t, Endianness endianness)
This function deserializes a long with a different endianness.
Cdr & deserialize(char *&string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Cdr & deserialize(uint8_t &octet_t, Endianness endianness)
This function deserializes an octet with a different endianness.
Definition: Cdr.h:2051
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 & serialize(const uint32_t ulong_t, Endianness endianness)
This function serializes an unsigned long with a different endianness.
Definition: Cdr.h:946
size_t getSerializedDataLength() const
This function returns the length of the serialized data inside the stream.
Definition: Cdr.h:218
Cdr & deserializeArray(std::string *string_t, size_t numElements)
This function deserializes an array of strings.
Definition: Cdr.h:3093
Cdr & serializeArray(const wchar_t *wchar, size_t numElements)
This function serializes an array of wide-chars.
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 & deserializeArray(long double *ldouble_t, size_t numElements, Endianness endianness)
This function deserializes an array of long doubles with a different endianness.
Cdr & deserialize(char &char_t, Endianness endianness)
This function deserializes a character with a different endianness.
Definition: Cdr.h:2075
Cdr & serializeArray(const float *float_t, size_t numElements)
This function serializes an array of floats.
Cdr & serialize(const bool bool_t, Endianness endianness)
This function serializes a boolean with a different endianness.
Definition: Cdr.h:1129
Cdr & deserialize(int16_t &short_t, Endianness endianness)
This function deserializes a short 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(std::map< _K, _T > *map_t, size_t numElements)
This function deserializes an array of maps of objects.
Definition: Cdr.h:3214
void setState(state &state)
This function sets a previous state of the CDR serialization process;.
Cdr & serialize(const int16_t short_t, Endianness endianness)
This function serializes a short with a different endianness.
Cdr & serializeArray(const std::string *string_t, size_t numElements)
This function serializes an array of strings.
Definition: Cdr.h:1786
Cdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition: Cdr.h:1008
Endianness
This enumeration represents endianness types.
Definition: Cdr.h:68
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 & 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 & deserialize(std::map< _K, _T > &map_t)
This function template deserializes a map.
Definition: Cdr.h:2611
Cdr & deserialize(long double &ldouble_t, Endianness endianness)
This function deserializes a long double with a different endianness.
static const Endianness DEFAULT_ENDIAN
Default endiness in the system.
Definition: Cdr.h:76
Cdr & deserialize(wchar_t *&string_t, Endianness endianness)
This function deserializes a wide string with a different endianness.
Cdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition: Cdr.h:1237
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 & serializeArray(const int32_t *long_t, size_t numElements)
This function serializes an array of longs.
Cdr & serializeArray(const int16_t *short_t, size_t numElements, Endianness endianness)
This function serializes an array of shorts with a different endianness.
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::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition: Cdr.h:2528
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 & deserializeArray(float *float_t, size_t numElements, Endianness endianness)
This function deserializes an array of floats with a different endianness.
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 & deserialize(std::string &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2469
Cdr & serialize(const int32_t long_t)
This function serializes a long.
Cdr & deserialize(char *&string_t)
This function deserializes a string.
Cdr & serializeArray(const double *double_t, size_t numElements, Endianness endianness)
This function serializes an array of doubles with a different endianness.
Cdr & deserialize(double &double_t)
This function deserializes a double.
Cdr & deserialize(int64_t &longlong_t, Endianness endianness)
This function deserializes a long long with a different endianness.
Cdr & deserialize(std::wstring &string_t)
This function deserializes a std::string.
Definition: Cdr.h:2453
Cdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: Cdr.h:2214
Cdr & serializeSequence(const _T *sequence_t, size_t numElements)
This function template serializes a raw sequence.
Definition: Cdr.h:1977
Cdr & deserialize(bool &bool_t, Endianness endianness)
This function deserializes a boolean with a different endianness.
Definition: Cdr.h:2370
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 int64_t *longlong_t, size_t numElements)
This function serializes an array of long longs.
Cdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition: Cdr.h:2437
Cdr & serialize(const long double ldouble_t)
This function serializes a long double.
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
Cdr & serialize_encapsulation()
This function writes the encapsulation of the CDR stream.
Cdr & deserializeSequence(std::wstring *&sequence_t, size_t &numElements)
This function template deserializes a wide-string sequence.
Definition: Cdr.h:3303
Cdr & deserializeArray(std::vector< _T > *vector_t, size_t numElements)
This function deserializes an array of sequences of objects.
Definition: Cdr.h:3195
Cdr & deserializeArray(wchar_t *wchar, size_t numElements, Endianness endianness)
This function deserializes an array of wide-chars with a different endianness.
Cdr & serialize(const int32_t long_t, Endianness endianness)
This function serializes a long 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 & deserialize(int16_t &short_t)
This function deserializes a short.
Cdr & serialize(const double double_t)
This function serializes a double.
Cdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence.
Definition: Cdr.h:1278
Cdr & serialize(const wchar_t *string_t, Endianness endianness)
This function serializes a wstring with a different endianness.
Cdr & deserializeArray(int16_t *short_t, size_t numElements, Endianness endianness)
This function deserializes an array of shorts with a different endianness.
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
Cdr & deserialize(double &double_t, Endianness endianness)
This function deserializes a double with a different endianness.
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 & deserialize(float &float_t)
This function deserializes a float.
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(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: Cdr.h:2118
Cdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition: Cdr.h:980
Cdr & serializeArray(const std::wstring *string_t, size_t numElements)
This function serializes an array of wide-strings.
Definition: Cdr.h:1805
uint16_t getDDSCdrOptions() const
This function returns the option flags when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & deserialize(std::wstring &string_t, Endianness endianness)
This function deserializes a string with a different endianness.
Definition: Cdr.h:2499
Cdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition: Cdr.h:884
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 & serialize(const int64_t longlong_t)
This function serializes a long long.
Cdr & serialize(const char char_t)
This function serializes a character.
Cdr & deserialize(_T &type_t)
This function template deserializes a non-basic object.
Definition: Cdr.h:2692
Cdr & deserialize(char &char_t)
This function deserializes a character.
Cdr & deserialize(wchar_t &wchar, Endianness endianness)
This function deserializes a wide-char with a different endianness.
Definition: Cdr.h:2231
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 double double_t, Endianness endianness)
This function serializes a 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 & 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 & 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 & deserialize(uint64_t &ulonglong_t, Endianness endianness)
This function deserializes an unsigned long long with a different endianness.
Definition: Cdr.h:2262
Cdr & deserializeArray(double *double_t, size_t numElements)
This function deserializes an array of doubles.
Cdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence.
Definition: Cdr.h:2556
Cdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: Cdr.h:2166
Cdr & serializeArray(const int16_t *short_t, size_t numElements)
This function serializes an array of shorts.
DDSCdrPlFlag getDDSCdrPlFlag() const
This function returns the parameter list flag when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & deserializeArray(wchar_t *wchar, size_t numElements)
This function deserializes an array of wide-chars.
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 wchar_t *string_t)
This function serializes a wstring.
void setDDSCdrPlFlag(DDSCdrPlFlag plFlag)
This function sets the parameter list flag when the CDR type is eprosima::fastcdr::DDS_CDR.
Cdr & deserializeArray(int8_t *int8, size_t numElements)
This function deserializes an array of int8_t.
Definition: Cdr.h:2768
Cdr & serialize(const std::string &string_t, Endianness endianness)
This function serializes a std::string with a different endianness.
Definition: Cdr.h:1223
Cdr & deserializeArray(long double *ldouble_t, size_t numElements)
This function deserializes an array of long doubles.
Cdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence.
Definition: Cdr.h:2569
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 & serialize(const bool bool_t)
This function serializes a boolean.
void reset()
This function resets the current position in the buffer to the beginning.
Cdr & serialize(const float float_t)
This function serializes a float.
Cdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition: Cdr.h:2090
Cdr & serialize(char *string_t)
This function serializes a string.
Definition: Cdr.h:1143
Cdr & deserialize(float &float_t, Endianness endianness)
This function deserializes a float with a different endianness.
Cdr & deserialize(wchar_t *&string_t)
This function deserializes a wide string.
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 & serializeArray(const bool *bool_t, size_t numElements)
This function serializes an array of booleans.
bool jump(size_t numBytes)
This function skips a number of bytes in the CDR stream buffer.
Cdr & serialize(const char *string_t)
This function serializes a string.
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 wchar_t *wchar, size_t numElements, Endianness endianness)
This function serializes an array of wide-chars with a different endianness.
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
char * getCurrentPosition()
This function returns the current position in the CDR stream.
Cdr & serialize(const char *string_t, Endianness endianness)
This function serializes a string with a different endianness.
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
Endianness endianness() const
This function returns the current endianness used by the CDR type.
Definition: Cdr.h:184
Cdr & serializeArray(const long double *ldouble_t, size_t numElements)
This function serializes an array of long doubles.
Cdr & serializeArray(const _T *type_t, size_t numElements)
This function template serializes an array of non-basic objects.
Definition: Cdr.h:1926
Cdr & serializeArray(const char *char_t, size_t numElements)
This function serializes an array of characters.
Cdr & serializeArray(const uint8_t *octet_t, size_t numElements)
This function serializes an array of octets.
Definition: Cdr.h:1398
bool moveAlignmentForward(size_t numBytes)
This function moves the alignment forward.
Cdr & deserializeArray(int64_t *longlong_t, size_t numElements, Endianness endianness)
This function deserializes an array of long longs with a different endianness.
Cdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
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 long double ldouble_t, Endianness endianness)
This function serializes a long double 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
char * getBufferPointer()
This function returns the pointer to the current used buffer.
Cdr & deserializeArray(std::wstring *string_t, size_t numElements)
This function deserializes an array of wide-strings.
Definition: Cdr.h:3112
Cdr & deserializeSequence(_T *&sequence_t, size_t &numElements)
This function template deserializes a raw sequence.
Definition: Cdr.h:3320
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(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition: Cdr.h:2248
state getState()
This function returns the current state of the CDR serialization process.
Cdr & deserializeSequence(std::string *&sequence_t, size_t &numElements)
This function template deserializes a string sequence.
Definition: Cdr.h:3286
Cdr & deserialize(uint32_t &ulong_t, Endianness endianness)
This function deserializes an unsigned long with a different endianness.
Definition: Cdr.h:2180
void resetAlignment()
This function resets the alignment to the current position in the buffer.
Definition: Cdr.h:260
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(bool &bool_t)
This function deserializes a boolean.
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 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