FastCDR  Version 2.3.0
FastCDR
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 <array>
19 #include <bitset>
20 #include <cassert>
21 #include <cstdint>
22 #include <cstring>
23 #include <functional>
24 #include <map>
25 #include <string>
26 #include <type_traits>
27 #include <utility>
28 #include <vector>
29 
30 #include "fastcdr_dll.h"
31 
32 #include "CdrEncoding.hpp"
33 #include "cdr/fixed_size_string.hpp"
34 #include "detail/container_recursive_inspector.hpp"
35 #include "exceptions/BadParamException.h"
36 #include "exceptions/Exception.h"
37 #include "exceptions/NotEnoughMemoryException.h"
38 #include "FastBuffer.h"
39 #include "xcdr/external.hpp"
40 #include "xcdr/MemberId.hpp"
41 #include "xcdr/optional.hpp"
42 
43 #if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
44 #include <malloc.h>
45 #else
46 #include <stdlib.h>
47 #endif // if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
48 
49 namespace eprosima {
50 namespace fastcdr {
51 
52 class Cdr;
53 
54 template<class _T>
55 extern void serialize(
56  Cdr&,
57  const _T&);
58 
59 template<class _T>
60 extern void deserialize(
61  Cdr&,
62  _T&);
63 
68 class Cdr
69 {
70 public:
71 
75  typedef enum : uint8_t
76  {
81  } Endianness;
82 
84  Cdr_DllAPI static const Endianness DEFAULT_ENDIAN;
85 
90  typedef enum
91  {
101 
105  class state
106  {
107  friend class Cdr;
108 
109  public:
110 
112  Cdr_DllAPI state(
113  const Cdr& cdr);
114 
116  Cdr_DllAPI state(
117  const state& state);
118 
119 
121  Cdr_DllAPI bool operator ==(
122  const state& other_state) const;
123 
124  private:
125 
126  state& operator =(
127  const state& state) = delete;
128 
130  const FastBuffer::iterator offset_;
131 
133  const FastBuffer::iterator origin_;
134 
136  bool swap_bytes_ {false};
137 
139  size_t last_data_size_ {0};
140 
142  MemberId next_member_id_;
143 
145  uint32_t member_size_ {0};
146 
148  XCdrHeaderSelection header_selection_ {XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT};
149 
151  XCdrHeaderSelection header_serialized_ {XCdrHeaderSelection::SHORT_HEADER};
152 
154  EncodingAlgorithmFlag previous_encoding_ {EncodingAlgorithmFlag::PLAIN_CDR2};
155  };
156 
165  Cdr_DllAPI Cdr(
166  FastBuffer& cdr_buffer,
168  const CdrVersion cdr_version = XCDRv2);
169 
179  Cdr_DllAPI Cdr& read_encapsulation();
180 
187  Cdr_DllAPI Cdr& serialize_encapsulation();
188 
193  Cdr_DllAPI CdrVersion get_cdr_version() const;
194 
200  Cdr_DllAPI EncodingAlgorithmFlag get_encoding_flag() const;
201 
209  Cdr_DllAPI bool set_encoding_flag(
210  EncodingAlgorithmFlag encoding_flag);
211 
216  Cdr_DllAPI std::array<uint8_t, 2> get_dds_cdr_options() const;
217 
222  Cdr_DllAPI void set_dds_cdr_options(
223  const std::array<uint8_t, 2>& options);
224 
229  Cdr_DllAPI void change_endianness(
231 
236  Cdr_DllAPI Endianness endianness() const;
237 
243  Cdr_DllAPI bool jump(
244  size_t num_bytes);
245 
249  Cdr_DllAPI void reset();
250 
255  Cdr_DllAPI char* get_buffer_pointer();
256 
261  Cdr_DllAPI char* get_current_position();
262 
267  Cdr_DllAPI size_t get_serialized_data_length() const;
268 
275  inline static size_t alignment(
276  size_t current_alignment,
277  size_t data_size)
278  {
279  return (data_size - (current_alignment % data_size)) & (data_size - 1);
280  }
281 
286  Cdr_DllAPI state get_state() const;
287 
292  Cdr_DllAPI void set_state(
293  const state& state);
294 
300  Cdr_DllAPI bool move_alignment_forward(
301  size_t num_bytes);
302 
306  inline void reset_alignment()
307  {
308  origin_ = offset_;
309  last_data_size_ = 0;
310  }
311 
325  template<class _T>
326  inline Cdr& operator <<(
327  const _T& value)
328  {
329  if (MEMBER_ID_INVALID == next_member_id_)
330  {
331  serialize(value);
332  }
333  else
334  {
335  serialize_member(next_member_id_, value);
336 
337  }
338 
339  return *this;
340  }
341 
355  template<class _T>
356  inline Cdr& operator >>(
357  _T& value)
358  {
359  if (MEMBER_ID_INVALID == next_member_id_)
360  {
361  deserialize(value);
362  }
363  else
364  {
365  deserialize_member(value);
366  }
367  return *this;
368  }
369 
380  template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void>
382  const _T& value)
383  {
384  eprosima::fastcdr::serialize(*this, value);
385  return *this;
386  }
387 
396  template<class _T>
398  const _T& value,
400  {
401  bool aux_swap = swap_bytes_;
402  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
403  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
404 
405  try
406  {
407  serialize(value);
408  swap_bytes_ = aux_swap;
409  }
410  catch (exception::Exception& ex)
411  {
412  swap_bytes_ = aux_swap;
413  ex.raise();
414  }
415 
416  return *this;
417  }
418 
427  template<class _T,
428  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
429  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
430  int32_t>::value>::type* = nullptr>
432  const _T& value)
433  {
434  return serialize(static_cast<int32_t>(value));
435  }
436 
445  template<class _T,
446  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
447  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
448  uint32_t>::value>::type* = nullptr>
450  const _T& value)
451  {
452  return serialize(static_cast<uint32_t>(value));
453  }
454 
463  template<class _T,
464  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
465  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
466  int16_t>::value>::type* = nullptr>
468  const _T& value)
469  {
470  return serialize(static_cast<int16_t>(value));
471  }
472 
481  template<class _T,
482  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
483  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
484  uint16_t>::value>::type* = nullptr>
486  const _T& value)
487  {
488  return serialize(static_cast<uint16_t>(value));
489  }
490 
499  template<class _T,
500  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
501  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
502  int8_t>::value>::type* = nullptr>
504  const _T& value)
505  {
506  return serialize(static_cast<int8_t>(value));
507  }
508 
517  template<class _T,
518  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
519  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
520  uint8_t>::value>::type* = nullptr>
522  const _T& value)
523  {
524  return serialize(static_cast<uint8_t>(value));
525  }
526 
533  Cdr_DllAPI Cdr& serialize(
534  const uint8_t& octet_t);
535 
542  Cdr_DllAPI Cdr& serialize(
543  const char char_t);
544 
551  Cdr_DllAPI Cdr& serialize(
552  const int8_t int8);
553 
560  Cdr_DllAPI Cdr& serialize(
561  const uint16_t ushort_t);
562 
569  Cdr_DllAPI Cdr& serialize(
570  const int16_t short_t);
571 
578  Cdr_DllAPI Cdr& serialize(
579  const uint32_t ulong_t);
580 
587  Cdr_DllAPI Cdr& serialize(
588  const int32_t long_t);
589 
596  Cdr_DllAPI Cdr& serialize(
597  const wchar_t wchar);
598 
605  Cdr_DllAPI Cdr& serialize(
606  const uint64_t ulonglong_t);
607 
614  Cdr_DllAPI Cdr& serialize(
615  const int64_t longlong_t);
616 
623  Cdr_DllAPI Cdr& serialize(
624  const float float_t);
625 
632  Cdr_DllAPI Cdr& serialize(
633  const double double_t);
634 
642  Cdr_DllAPI Cdr& serialize(
643  const long double ldouble_t);
644 
651  Cdr_DllAPI Cdr& serialize(
652  const bool bool_t);
653 
660  Cdr_DllAPI Cdr& serialize(
661  char* string_t);
662 
669  Cdr_DllAPI Cdr& serialize(
670  const char* string_t);
671 
678  Cdr_DllAPI Cdr& serialize(
679  const wchar_t* string_t);
680 
688  TEMPLATE_SPEC
690  const std::string& string_t)
691  {
692  // Check there are no null characters in the string.
693  const char* c_str = string_t.c_str();
694  const auto str_len = strlen(c_str);
695  if (string_t.size() > str_len)
696  {
697  throw exception::BadParamException("The string contains null characters");
698  }
699 
700  return serialize_sequence(c_str, str_len + 1);
701  }
702 
709  TEMPLATE_SPEC
711  const std::wstring& string_t)
712  {
713  return serialize(string_t.c_str());
714  }
715 
723  template <size_t MAX_CHARS>
725  const fixed_string<MAX_CHARS>& value)
726  {
727  return serialize(value.c_str());
728  }
729 
736  template<class _T, size_t _Size>
738  const std::array<_T, _Size>& array_t)
739  {
740  if (!is_multi_array_primitive(&array_t))
741  {
742  Cdr::state dheader_state {allocate_xcdrv2_dheader()};
743 
744  serialize_array(array_t.data(), array_t.size());
745 
746  set_xcdrv2_dheader(dheader_state);
747  }
748  else
749  {
750  serialize_array(array_t.data(), array_t.size());
751  }
752 
753  return *this;
754  }
755 
762  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
763  !std::is_arithmetic<_T>::value>::type* = nullptr>
765  const std::vector<_T>& vector_t)
766  {
767  Cdr::state dheader_state {allocate_xcdrv2_dheader()};
768 
769  serialize(static_cast<int32_t>(vector_t.size()));
770 
771  try
772  {
773  serialize_array(vector_t.data(), vector_t.size());
774  }
775  catch (exception::Exception& ex)
776  {
777  set_state(dheader_state);
778  ex.raise();
779  }
780 
781  set_xcdrv2_dheader(dheader_state);
782 
783  return *this;
784  }
785 
792  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
793  std::is_arithmetic<_T>::value>::type* = nullptr>
795  const std::vector<_T>& vector_t)
796  {
797  state state_before_error(*this);
798 
799  serialize(static_cast<int32_t>(vector_t.size()));
800 
801  try
802  {
803  serialize_array(vector_t.data(), vector_t.size());
804  }
805  catch (exception::Exception& ex)
806  {
807  set_state(state_before_error);
808  ex.raise();
809  }
810 
811  if (CdrVersion::XCDRv2 == cdr_version_)
812  {
813  serialized_member_size_ = get_serialized_member_size<_T>();
814  }
815 
816  return *this;
817  }
818 
825  TEMPLATE_SPEC
827  const std::vector<bool>& vector_t)
828  {
829  return serialize_bool_sequence(vector_t);
830  }
831 
838  template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value &&
839  !std::is_arithmetic<_T>::value>::type* = nullptr>
841  const std::map<_K, _T>& map_t)
842  {
843  Cdr::state dheader_state {allocate_xcdrv2_dheader()};
844 
845  serialize(static_cast<int32_t>(map_t.size()));
846 
847  try
848  {
849  for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
850  {
851  serialize(it_pair->first);
852  serialize(it_pair->second);
853  }
854  }
855  catch (exception::Exception& ex)
856  {
857  set_state(dheader_state);
858  ex.raise();
859  }
860 
861  set_xcdrv2_dheader(dheader_state);
862 
863  return *this;
864  }
865 
872  template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value ||
873  std::is_arithmetic<_T>::value>::type* = nullptr>
875  const std::map<_K, _T>& map_t)
876  {
877  state state_(*this);
878 
879  serialize(static_cast<int32_t>(map_t.size()));
880 
881  try
882  {
883  for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
884  {
885  serialize(it_pair->first);
886  serialize(it_pair->second);
887  }
888  }
889  catch (exception::Exception& ex)
890  {
891  set_state(state_);
892  ex.raise();
893  }
894 
895  return *this;
896  }
897 
906  template<size_t N, typename std::enable_if < (N < 9) > ::type* = nullptr>
907  Cdr& serialize(
908  const std::bitset<N>& value)
909  {
910  return serialize(static_cast<uint8_t>(value.to_ulong()));
911  }
912 
913  template<size_t N, typename std::enable_if < (8 < N && N < 17) > ::type* = nullptr>
914  Cdr& serialize(
915  const std::bitset<N>& value)
916  {
917  return serialize(static_cast<uint16_t>(value.to_ulong()));
918  }
919 
920  template<size_t N, typename std::enable_if < (16 < N && N < 33) > ::type* = nullptr>
921  Cdr& serialize(
922  const std::bitset<N>& value)
923  {
924  return serialize(static_cast<uint32_t>(value.to_ulong()));
925  }
926 
927  template<size_t N, typename std::enable_if < (32 < N && N < 65) > ::type* = nullptr>
928  Cdr& serialize(
929  const std::bitset<N>& value)
930  {
931  return serialize(static_cast<uint64_t>(value.to_ullong()));
932  }
933 
945  template<class _T>
947  const _T* value,
948  size_t num_elements)
949  {
950  for (size_t count = 0; count < num_elements; ++count)
951  {
952  serialize(value[count]);
953  }
954  return *this;
955  }
956 
965  template<class _T>
967  const _T* type_t,
968  size_t num_elements,
970  {
971  bool aux_swap = swap_bytes_;
972  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
973  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
974 
975  try
976  {
977  serialize_array(type_t, num_elements);
978  swap_bytes_ = aux_swap;
979  }
980  catch (exception::Exception& ex)
981  {
982  swap_bytes_ = aux_swap;
983  ex.raise();
984  }
985 
986  return *this;
987  }
988 
996  TEMPLATE_SPEC
998  const uint8_t* octet_t,
999  size_t num_elements)
1000  {
1001  return serialize_array(reinterpret_cast<const char*>(octet_t), num_elements);
1002  }
1003 
1011  Cdr_DllAPI Cdr& serialize_array(
1012  const char* char_t,
1013  size_t num_elements);
1014 
1022  TEMPLATE_SPEC
1024  const int8_t* int8,
1025  size_t num_elements)
1026  {
1027  return serialize_array(reinterpret_cast<const char*>(int8), num_elements);
1028  }
1029 
1037  TEMPLATE_SPEC
1039  const uint16_t* ushort_t,
1040  size_t num_elements)
1041  {
1042  return serialize_array(reinterpret_cast<const int16_t*>(ushort_t), num_elements);
1043  }
1044 
1052  Cdr_DllAPI Cdr& serialize_array(
1053  const int16_t* short_t,
1054  size_t num_elements);
1055 
1063  TEMPLATE_SPEC
1065  const uint32_t* ulong_t,
1066  size_t num_elements)
1067  {
1068  return serialize_array(reinterpret_cast<const int32_t*>(ulong_t), num_elements);
1069  }
1070 
1078  Cdr_DllAPI Cdr& serialize_array(
1079  const int32_t* long_t,
1080  size_t num_elements);
1081 
1089  Cdr_DllAPI Cdr& serialize_array(
1090  const wchar_t* wchar,
1091  size_t num_elements);
1092 
1100  TEMPLATE_SPEC
1102  const uint64_t* ulonglong_t,
1103  size_t num_elements)
1104  {
1105  return serialize_array(reinterpret_cast<const int64_t*>(ulonglong_t), num_elements);
1106  }
1107 
1115  Cdr_DllAPI Cdr& serialize_array(
1116  const int64_t* longlong_t,
1117  size_t num_elements);
1118 
1126  Cdr_DllAPI Cdr& serialize_array(
1127  const float* float_t,
1128  size_t num_elements);
1129 
1137  Cdr_DllAPI Cdr& serialize_array(
1138  const double* double_t,
1139  size_t num_elements);
1140 
1149  Cdr_DllAPI Cdr& serialize_array(
1150  const long double* ldouble_t,
1151  size_t num_elements);
1152 
1160  Cdr_DllAPI Cdr& serialize_array(
1161  const bool* bool_t,
1162  size_t num_elements);
1163 
1171  TEMPLATE_SPEC
1173  const std::string* string_t,
1174  size_t num_elements)
1175  {
1176  for (size_t count = 0; count < num_elements; ++count)
1177  {
1178  serialize(string_t[count].c_str());
1179  }
1180  return *this;
1181  }
1182 
1190  TEMPLATE_SPEC
1192  const std::wstring* string_t,
1193  size_t num_elements)
1194  {
1195  for (size_t count = 0; count < num_elements; ++count)
1196  {
1197  serialize(string_t[count].c_str());
1198  }
1199  return *this;
1200  }
1201 
1210  template<size_t MAX_CHARS>
1212  const fixed_string<MAX_CHARS>* value,
1213  size_t num_elements)
1214  {
1215  for (size_t count = 0; count < num_elements; ++count)
1216  {
1217  serialize(value[count].c_str());
1218  }
1219  return *this;
1220  }
1221 
1229  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1230  std::is_arithmetic<_T>::value>::type* = nullptr>
1232  const std::vector<_T>& value)
1233  {
1234  serialize_array(value.data(), value.size());
1235 
1236  return *this;
1237  }
1238 
1246  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1247  !std::is_arithmetic<_T>::value>::type* = nullptr>
1249  const std::vector<_T>& value)
1250  {
1251  Cdr::state dheader_state {allocate_xcdrv2_dheader()};
1252 
1253  serialize_array(value.data(), value.size());
1254 
1255  set_xcdrv2_dheader(dheader_state);
1256 
1257  return *this;
1258  }
1259 
1268  template<class _T>
1270  const std::vector<_T>& value,
1272  {
1273  bool aux_swap = swap_bytes_;
1274  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1275  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1276 
1277  try
1278  {
1279  serialize_array(value);
1280  swap_bytes_ = aux_swap;
1281  }
1282  catch (exception::Exception& ex)
1283  {
1284  swap_bytes_ = aux_swap;
1285  ex.raise();
1286  }
1287 
1288  return *this;
1289  }
1290 
1298  TEMPLATE_SPEC
1300  const std::vector<bool>& value)
1301  {
1302  serialize_bool_array(value);
1303 
1304  return *this;
1305  }
1306 
1314  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1315  !std::is_arithmetic<_T>::value>::type* = nullptr>
1317  const _T* sequence_t,
1318  size_t num_elements)
1319  {
1320  Cdr::state dheader_state {allocate_xcdrv2_dheader()};
1321 
1322  serialize(static_cast<int32_t>(num_elements));
1323 
1324  try
1325  {
1326  serialize_array(sequence_t, num_elements);
1327  }
1328  catch (exception::Exception& ex)
1329  {
1330  set_state(dheader_state);
1331  ex.raise();
1332  }
1333 
1334  set_xcdrv2_dheader(dheader_state);
1335 
1336  return *this;
1337  }
1338 
1346  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1347  std::is_arithmetic<_T>::value>::type* = nullptr>
1349  const _T* sequence_t,
1350  size_t num_elements)
1351  {
1352  state state_before_error(*this);
1353 
1354  serialize(static_cast<int32_t>(num_elements));
1355 
1356  try
1357  {
1358  serialize_array(sequence_t, num_elements);
1359  }
1360  catch (exception::Exception& ex)
1361  {
1362  set_state(state_before_error);
1363  ex.raise();
1364  }
1365 
1366  if (CdrVersion::XCDRv2 == cdr_version_)
1367  {
1368  serialized_member_size_ = get_serialized_member_size<_T>();
1369  }
1370 
1371  return *this;
1372  }
1373 
1382  template<class _T>
1384  const _T* sequence_t,
1385  size_t num_elements,
1387  {
1388  bool aux_swap = swap_bytes_;
1389  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1390  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1391 
1392  try
1393  {
1394  serialize_sequence(sequence_t, num_elements);
1395  swap_bytes_ = aux_swap;
1396  }
1397  catch (exception::Exception& ex)
1398  {
1399  swap_bytes_ = aux_swap;
1400  ex.raise();
1401  }
1402 
1403  return *this;
1404  }
1405 
1416  template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void>
1418  _T& value)
1419  {
1420  eprosima::fastcdr::deserialize(*this, value);
1421  return *this;
1422  }
1423 
1432  template<class _T>
1434  _T& value,
1436  {
1437  bool aux_swap = swap_bytes_;
1438  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1439  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1440 
1441  try
1442  {
1443  deserialize(value);
1444  swap_bytes_ = aux_swap;
1445  }
1446  catch (exception::Exception& ex)
1447  {
1448  swap_bytes_ = aux_swap;
1449  ex.raise();
1450  }
1451 
1452  return *this;
1453  }
1454 
1462  template<class _T,
1463  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1464  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1465  int32_t>::value>::type* = nullptr>
1467  _T& value)
1468  {
1469  int32_t decode_value {0};
1470  deserialize(decode_value);
1471  value = static_cast<_T>(decode_value);
1472  return *this;
1473  }
1474 
1482  template<class _T,
1483  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1484  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1485  uint32_t>::value>::type* = nullptr>
1487  _T& value)
1488  {
1489  uint32_t decode_value {0};
1490  deserialize(decode_value);
1491  value = static_cast<_T>(decode_value);
1492  return *this;
1493  }
1494 
1502  template<class _T,
1503  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1504  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1505  int16_t>::value>::type* = nullptr>
1507  _T& value)
1508  {
1509  int16_t decode_value {0};
1510  deserialize(decode_value);
1511  value = static_cast<_T>(decode_value);
1512  return *this;
1513  }
1514 
1522  template<class _T,
1523  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1524  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1525  uint16_t>::value>::type* = nullptr>
1527  _T& value)
1528  {
1529  uint16_t decode_value {0};
1530  deserialize(decode_value);
1531  value = static_cast<_T>(decode_value);
1532  return *this;
1533  }
1534 
1542  template<class _T,
1543  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1544  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1545  int8_t>::value>::type* = nullptr>
1547  _T& value)
1548  {
1549  int8_t decode_value {0};
1550  deserialize(decode_value);
1551  value = static_cast<_T>(decode_value);
1552  return *this;
1553  }
1554 
1562  template<class _T,
1563  typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr,
1564  typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1565  uint8_t>::value>::type* = nullptr>
1567  _T& value)
1568  {
1569  uint8_t decode_value {0};
1570  deserialize(decode_value);
1571  value = static_cast<_T>(decode_value);
1572  return *this;
1573  }
1574 
1581  TEMPLATE_SPEC
1583  uint8_t& octet_t)
1584  {
1585  return deserialize(reinterpret_cast<char&>(octet_t));
1586  }
1587 
1594  Cdr_DllAPI Cdr& deserialize(
1595  char& char_t);
1596 
1603  TEMPLATE_SPEC
1605  int8_t& int8)
1606  {
1607  return deserialize(reinterpret_cast<char&>(int8));
1608  }
1609 
1616  TEMPLATE_SPEC
1618  uint16_t& ushort_t)
1619  {
1620  return deserialize(reinterpret_cast<int16_t&>(ushort_t));
1621  }
1622 
1629  Cdr_DllAPI Cdr& deserialize(
1630  int16_t& short_t);
1631 
1638  TEMPLATE_SPEC
1640  uint32_t& ulong_t)
1641  {
1642  return deserialize(reinterpret_cast<int32_t&>(ulong_t));
1643  }
1644 
1651  Cdr_DllAPI Cdr& deserialize(
1652  int32_t& long_t);
1653 
1660  TEMPLATE_SPEC
1662  wchar_t& wchar)
1663  {
1664  uint16_t ret;
1665  deserialize(ret);
1666  wchar = static_cast<wchar_t>(ret);
1667  return *this;
1668  }
1669 
1676  TEMPLATE_SPEC
1678  uint64_t& ulonglong_t)
1679  {
1680  return deserialize(reinterpret_cast<int64_t&>(ulonglong_t));
1681  }
1682 
1689  Cdr_DllAPI Cdr& deserialize(
1690  int64_t& longlong_t);
1691 
1698  Cdr_DllAPI Cdr& deserialize(
1699  float& float_t);
1700 
1707  Cdr_DllAPI Cdr& deserialize(
1708  double& double_t);
1709 
1717  Cdr_DllAPI Cdr& deserialize(
1718  long double& ldouble_t);
1719 
1727  Cdr_DllAPI Cdr& deserialize(
1728  bool& bool_t);
1729 
1738  Cdr_DllAPI Cdr& deserialize(
1739  char*& string_t);
1740 
1749  Cdr_DllAPI Cdr& deserialize(
1750  wchar_t*& string_t);
1751 
1758  TEMPLATE_SPEC
1760  std::string& string_t)
1761  {
1762  uint32_t length = 0;
1763  const char* str = read_string(length);
1764  string_t.assign(str, length);
1765  return *this;
1766  }
1767 
1774  TEMPLATE_SPEC
1776  std::wstring& string_t)
1777  {
1778  uint32_t length = 0;
1779  string_t = read_wstring(length);
1780  return *this;
1781  }
1782 
1790  template <size_t MAX_CHARS>
1792  fixed_string<MAX_CHARS>& value)
1793  {
1794  uint32_t length = 0;
1795  const char* str = read_string(length);
1796  value.assign(str, length);
1797  return *this;
1798  }
1799 
1806  template<class _T, size_t _Size>
1808  std::array<_T, _Size>& array_t)
1809  {
1810  if (CdrVersion::XCDRv2 == cdr_version_ && !is_multi_array_primitive(&array_t))
1811  {
1812  uint32_t dheader {0};
1813  deserialize(dheader);
1814 
1815  uint32_t count {0};
1816  auto offset = offset_;
1817  while (offset_ - offset < dheader && count < _Size)
1818  {
1819  deserialize_array(&array_t.data()[count], 1);
1820  ++count;
1821  }
1822 
1823  if (offset_ - offset != dheader)
1824  {
1825  throw exception::BadParamException("Member size greater than size specified by DHEADER");
1826  }
1827  }
1828  else
1829  {
1830  return deserialize_array(array_t.data(), array_t.size());
1831  }
1832 
1833  return *this;
1834  }
1835 
1842  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1843  !std::is_arithmetic<_T>::value>::type* = nullptr>
1845  std::vector<_T>& vector_t)
1846  {
1847  uint32_t sequence_length {0};
1848 
1849  if (CdrVersion::XCDRv2 == cdr_version_)
1850  {
1851  uint32_t dheader {0};
1852  deserialize(dheader);
1853 
1854  auto offset = offset_;
1855 
1856  deserialize(sequence_length);
1857 
1858  if (0 == sequence_length)
1859  {
1860  vector_t.clear();
1861  return *this;
1862  }
1863  else
1864  {
1865  vector_t.resize(sequence_length);
1866  }
1867 
1868  uint32_t count {0};
1869  while (offset_ - offset < dheader && count < sequence_length)
1870  {
1871  deserialize(vector_t.data()[count]);
1872  ++count;
1873  }
1874 
1875  if (offset_ - offset != dheader)
1876  {
1877  throw exception::BadParamException("Member size differs from the size specified by DHEADER");
1878  }
1879  }
1880  else
1881  {
1882  state state_before_error(*this);
1883 
1884  deserialize(sequence_length);
1885 
1886  if (sequence_length == 0)
1887  {
1888  vector_t.clear();
1889  return *this;
1890  }
1891 
1892  if ((end_ - offset_) < sequence_length)
1893  {
1894  set_state(state_before_error);
1897  }
1898 
1899  try
1900  {
1901  vector_t.resize(sequence_length);
1902  return deserialize_array(vector_t.data(), vector_t.size());
1903  }
1904  catch (exception::Exception& ex)
1905  {
1906  set_state(state_before_error);
1907  ex.raise();
1908  }
1909  }
1910 
1911  return *this;
1912  }
1913 
1920  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1921  std::is_arithmetic<_T>::value>::type* = nullptr>
1923  std::vector<_T>& vector_t)
1924  {
1925  uint32_t sequence_length = 0;
1926  state state_before_error(*this);
1927 
1928  deserialize(sequence_length);
1929 
1930  if (sequence_length == 0)
1931  {
1932  vector_t.clear();
1933  return *this;
1934  }
1935 
1936  if ((end_ - offset_) < sequence_length)
1937  {
1938  set_state(state_before_error);
1941  }
1942 
1943  try
1944  {
1945  vector_t.resize(sequence_length);
1946  return deserialize_array(vector_t.data(), vector_t.size());
1947  }
1948  catch (exception::Exception& ex)
1949  {
1950  set_state(state_before_error);
1951  ex.raise();
1952  }
1953 
1954  return *this;
1955  }
1956 
1963  TEMPLATE_SPEC
1965  std::vector<bool>& vector_t)
1966  {
1967  return deserialize_bool_sequence(vector_t);
1968  }
1969 
1976  template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1977  !std::is_arithmetic<_T>::value>::type* = nullptr>
1979  std::map<_K, _T>& map_t)
1980  {
1981  if (CdrVersion::XCDRv2 == cdr_version_)
1982  {
1983  uint32_t dheader {0};
1984  deserialize(dheader);
1985 
1986  auto offset = offset_;
1987 
1988  uint32_t map_length {0};
1989  deserialize(map_length);
1990 
1991  map_t.clear();
1992 
1993  uint32_t count {0};
1994  while (offset_ - offset < dheader && count < map_length)
1995  {
1996  _K key;
1997  _T val;
1998  deserialize(key);
1999  deserialize(val);
2000  map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(val)));
2001  ++count;
2002  }
2003 
2004  if (offset_ - offset != dheader)
2005  {
2006  throw exception::BadParamException("Member size greater than size specified by DHEADER");
2007  }
2008  }
2009  else
2010  {
2011  uint32_t sequence_length = 0;
2012  state state_(*this);
2013 
2014  deserialize(sequence_length);
2015 
2016  map_t.clear();
2017 
2018  try
2019  {
2020  for (uint32_t i = 0; i < sequence_length; ++i)
2021  {
2022  _K key;
2023  _T value;
2024  deserialize(key);
2025  deserialize(value);
2026  map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2027  }
2028  }
2029  catch (exception::Exception& ex)
2030  {
2031  set_state(state_);
2032  ex.raise();
2033  }
2034  }
2035 
2036  return *this;
2037  }
2038 
2045  template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value ||
2046  std::is_arithmetic<_T>::value>::type* = nullptr>
2048  std::map<_K, _T>& map_t)
2049  {
2050  uint32_t sequence_length = 0;
2051  state state_(*this);
2052 
2053  deserialize(sequence_length);
2054 
2055  try
2056  {
2057  for (uint32_t i = 0; i < sequence_length; ++i)
2058  {
2059  _K key;
2060  _T value;
2061  deserialize(key);
2062  deserialize(value);
2063  map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2064  }
2065  }
2066  catch (exception::Exception& ex)
2067  {
2068  set_state(state_);
2069  ex.raise();
2070  }
2071 
2072  return *this;
2073  }
2074 
2082  template<size_t N, typename std::enable_if < (N < 9) > ::type* = nullptr>
2083  Cdr& deserialize(
2084  std::bitset<N>& value)
2085  {
2086  uint8_t decode_value {0};
2087  deserialize(decode_value);
2088  value = decode_value;
2089  return *this;
2090  }
2091 
2092  template<size_t N, typename std::enable_if < (8 < N && N < 17) > ::type* = nullptr>
2093  Cdr& deserialize(
2094  std::bitset<N>& value)
2095  {
2096  uint16_t decode_value {0};
2097  deserialize(decode_value);
2098  value = decode_value;
2099  return *this;
2100  }
2101 
2102  template<size_t N, typename std::enable_if < (16 < N && N < 33) > ::type* = nullptr>
2103  Cdr& deserialize(
2104  std::bitset<N>& value)
2105  {
2106  uint32_t decode_value {0};
2107  deserialize(decode_value);
2108  value = decode_value;
2109  return *this;
2110  }
2111 
2112  template<size_t N, typename std::enable_if < (32 < N && N < 65) > ::type* = nullptr>
2113  Cdr& deserialize(
2114  std::bitset<N>& value)
2115  {
2116  uint64_t decode_value {0};
2117  deserialize(decode_value);
2118  value = decode_value;
2119  return *this;
2120  }
2121 
2133  template<class _T>
2135  _T* value,
2136  size_t num_elements)
2137  {
2138  for (size_t count = 0; count < num_elements; ++count)
2139  {
2140  deserialize(value[count]);
2141  }
2142  return *this;
2143  }
2144 
2153  template<class _T>
2155  _T* type_t,
2156  size_t num_elements,
2158  {
2159  bool aux_swap = swap_bytes_;
2160  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2161  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2162 
2163  try
2164  {
2165  deserialize_array(type_t, num_elements);
2166  swap_bytes_ = aux_swap;
2167  }
2168  catch (exception::Exception& ex)
2169  {
2170  swap_bytes_ = aux_swap;
2171  ex.raise();
2172  }
2173 
2174  return *this;
2175  }
2176 
2184  TEMPLATE_SPEC
2186  uint8_t* octet_t,
2187  size_t num_elements)
2188  {
2189  return deserialize_array(reinterpret_cast<char*>(octet_t), num_elements);
2190  }
2191 
2199  Cdr_DllAPI Cdr& deserialize_array(
2200  char* char_t,
2201  size_t num_elements);
2202 
2210  TEMPLATE_SPEC
2212  int8_t* int8,
2213  size_t num_elements)
2214  {
2215  return deserialize_array(reinterpret_cast<char*>(int8), num_elements);
2216  }
2217 
2225  TEMPLATE_SPEC
2227  uint16_t* ushort_t,
2228  size_t num_elements)
2229  {
2230  return deserialize_array(reinterpret_cast<int16_t*>(ushort_t), num_elements);
2231  }
2232 
2240  Cdr_DllAPI Cdr& deserialize_array(
2241  int16_t* short_t,
2242  size_t num_elements);
2243 
2251  TEMPLATE_SPEC
2253  uint32_t* ulong_t,
2254  size_t num_elements)
2255  {
2256  return deserialize_array(reinterpret_cast<int32_t*>(ulong_t), num_elements);
2257  }
2258 
2266  Cdr_DllAPI Cdr& deserialize_array(
2267  int32_t* long_t,
2268  size_t num_elements);
2269 
2277  Cdr_DllAPI Cdr& deserialize_array(
2278  wchar_t* wchar,
2279  size_t num_elements);
2280 
2288  TEMPLATE_SPEC
2290  uint64_t* ulonglong_t,
2291  size_t num_elements)
2292  {
2293  return deserialize_array(reinterpret_cast<int64_t*>(ulonglong_t), num_elements);
2294  }
2295 
2303  Cdr_DllAPI Cdr& deserialize_array(
2304  int64_t* longlong_t,
2305  size_t num_elements);
2306 
2314  Cdr_DllAPI Cdr& deserialize_array(
2315  float* float_t,
2316  size_t num_elements);
2317 
2325  Cdr_DllAPI Cdr& deserialize_array(
2326  double* double_t,
2327  size_t num_elements);
2328 
2337  Cdr_DllAPI Cdr& deserialize_array(
2338  long double* ldouble_t,
2339  size_t num_elements);
2340 
2348  Cdr_DllAPI Cdr& deserialize_array(
2349  bool* bool_t,
2350  size_t num_elements);
2351 
2362  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2363  std::is_arithmetic<_T>::value>::type* = nullptr>
2365  std::vector<_T>& value)
2366  {
2367  deserialize_array(value.data(), value.size());
2368 
2369  return *this;
2370  }
2371 
2382  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2383  !std::is_arithmetic<_T>::value>::type* = nullptr>
2385  std::vector<_T>& value)
2386  {
2387  if (CdrVersion::XCDRv2 == cdr_version_)
2388  {
2389  uint32_t dheader {0};
2390  deserialize(dheader);
2391 
2392  uint32_t count {0};
2393  auto offset = offset_;
2394  while (offset_ - offset < dheader && count < value.size())
2395  {
2396  deserialize_array(&value.data()[count], 1);
2397  ++count;
2398  }
2399 
2400  if (offset_ - offset != dheader)
2401  {
2402  throw exception::BadParamException("Member size greater than size specified by DHEADER");
2403  }
2404  }
2405  else
2406  {
2407  return deserialize_array(value.data(), value.size());
2408  }
2409 
2410  return *this;
2411  }
2412 
2424  template<class _T>
2426  std::vector<_T>& value,
2428  {
2429  bool aux_swap = swap_bytes_;
2430  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2431  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2432 
2433  try
2434  {
2435  deserialize_array(value);
2436  swap_bytes_ = aux_swap;
2437  }
2438  catch (exception::Exception& ex)
2439  {
2440  swap_bytes_ = aux_swap;
2441  ex.raise();
2442  }
2443 
2444  return *this;
2445  }
2446 
2457  TEMPLATE_SPEC
2459  std::vector<bool>& value)
2460  {
2461  deserialize_bool_array(value);
2462 
2463  return *this;
2464  }
2465 
2475  template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2476  !std::is_arithmetic<_T>::value>::type* = nullptr>
2478  _T*& sequence_t,
2479  size_t& num_elements)
2480  {
2481  uint32_t sequence_length {0};
2482 
2483  if (CdrVersion::XCDRv2 == cdr_version_)
2484  {
2485  uint32_t dheader {0};
2486  deserialize(dheader);
2487 
2488  auto offset = offset_;
2489 
2490  deserialize(sequence_length);
2491 
2492  try
2493  {
2494  sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2495 
2496  uint32_t count {0};
2497  while (offset_ - offset < dheader && count < sequence_length)
2498  {
2499  deserialize(sequence_t[count]);
2500  ++count;
2501  }
2502 
2503  if (offset_ - offset != dheader)
2504  {
2505  throw exception::BadParamException("Member size greater than size specified by DHEADER");
2506  }
2507  }
2508  catch (exception::Exception& ex)
2509  {
2510  free(sequence_t);
2511  sequence_t = NULL;
2512  ex.raise();
2513  }
2514  }
2515  else
2516  {
2517  state state_before_error(*this);
2518 
2519  deserialize(sequence_length);
2520 
2521  if ((end_ - offset_) < sequence_length)
2522  {
2523  set_state(state_before_error);
2526  }
2527 
2528  try
2529  {
2530  sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2531  deserialize_array(sequence_t, sequence_length);
2532  }
2533  catch (exception::Exception& ex)
2534  {
2535  free(sequence_t);
2536  sequence_t = NULL;
2537  set_state(state_before_error);
2538  ex.raise();
2539  }
2540  }
2541 
2542  num_elements = sequence_length;
2543  return *this;
2544  }
2545 
2555  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2556  std::is_arithmetic<_T>::value>::type* = nullptr>
2558  _T*& sequence_t,
2559  size_t& num_elements)
2560  {
2561  uint32_t sequence_length = 0;
2562  state state_before_error(*this);
2563 
2564  deserialize(sequence_length);
2565 
2566  try
2567  {
2568  sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2569  deserialize_array(sequence_t, sequence_length);
2570  }
2571  catch (exception::Exception& ex)
2572  {
2573  free(sequence_t);
2574  sequence_t = NULL;
2575  set_state(state_before_error);
2576  ex.raise();
2577  }
2578 
2579  num_elements = sequence_length;
2580  return *this;
2581  }
2582 
2593  template<class _T>
2595  _T*& sequence_t,
2596  size_t& num_elements,
2598  {
2599  bool aux_swap = swap_bytes_;
2600  swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2601  (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2602 
2603  try
2604  {
2605  deserialize_sequence(sequence_t, num_elements);
2606  swap_bytes_ = aux_swap;
2607  }
2608  catch (exception::Exception& ex)
2609  {
2610  swap_bytes_ = aux_swap;
2611  ex.raise();
2612  }
2613 
2614  return *this;
2615  }
2616 
2626  TEMPLATE_SPEC
2628  std::string*& sequence_t,
2629  size_t& num_elements)
2630  {
2631  return deserialize_string_sequence(sequence_t, num_elements);
2632  }
2633 
2643  TEMPLATE_SPEC
2645  std::wstring*& sequence_t,
2646  size_t& num_elements)
2647  {
2648  return deserialize_wstring_sequence(sequence_t, num_elements);
2649  }
2650 
2654 
2665  template<class _T>
2667  const MemberId& member_id,
2668  const _T& member_value,
2669  XCdrHeaderSelection header_selection = XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT)
2670  {
2671  Cdr::state current_state(*this);
2672  (this->*begin_serialize_member_)(member_id, true, current_state, header_selection);
2673  serialize(member_value);
2674  return (this->*end_serialize_member_)(current_state);
2675  }
2676 
2687  template<class _T>
2689  const MemberId& member_id,
2690  const optional<_T>& member_value,
2691  XCdrHeaderSelection header_selection = XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT)
2692  {
2693  Cdr::state current_state(*this);
2694  (this->*begin_serialize_opt_member_)(member_id, member_value.has_value(), current_state, header_selection);
2695  serialize(member_value);
2696  return (this->*end_serialize_opt_member_)(current_state);
2697  }
2698 
2706  template<class _T>
2708  _T& member_value)
2709  {
2710  return deserialize(member_value);
2711  }
2712 
2720  template<class _T>
2722  optional<_T>& member_value)
2723  {
2724  if (EncodingAlgorithmFlag::PLAIN_CDR == current_encoding_)
2725  {
2726  Cdr::state current_state(*this);
2727  MemberId member_id;
2728  xcdr1_deserialize_member_header(member_id, current_state);
2729  auto prev_offset = offset_;
2730  if (0 < current_state.member_size_)
2731  {
2732  deserialize(member_value);
2733  }
2734  if (current_state.member_size_ != offset_ - prev_offset)
2735  {
2737  "Member size provided by member header is not equal to the real decoded member size");
2738  }
2739  }
2740  else
2741  {
2742  deserialize(member_value);
2743  }
2744  return *this;
2745  }
2746 
2755  Cdr_DllAPI Cdr& begin_serialize_type(
2756  Cdr::state& current_state,
2757  EncodingAlgorithmFlag type_encoding);
2758 
2766  Cdr_DllAPI Cdr& end_serialize_type(
2767  Cdr::state& current_state);
2768 
2777  Cdr_DllAPI Cdr& deserialize_type(
2778  EncodingAlgorithmFlag type_encoding,
2779  std::function<bool (Cdr&, const MemberId&)> functor);
2780 
2788  template<class _T>
2790  const optional<_T>& value)
2791  {
2792  if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2793  {
2794  serialize(value.has_value());
2795  }
2796 
2797  if (value.has_value())
2798  {
2799  serialize(*value);
2800  }
2801  return *this;
2802  }
2803 
2812  template<class _T>
2814  const external<_T>& value)
2815  {
2816  if (!value)
2817  {
2818  throw exception::BadParamException("External member is null");
2819  }
2820 
2821  serialize(*value);
2822  return *this;
2823  }
2824 
2832  Cdr_DllAPI Cdr& operator <<(
2833  const MemberId& member_id);
2834 
2842  template<class _T>
2844  optional<_T>& value)
2845  {
2846  bool is_present = true;
2847  if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2848  {
2849  deserialize(is_present);
2850  }
2851  value.reset(is_present);
2852  if (is_present)
2853  {
2854  deserialize(*value);
2855  }
2856  return *this;
2857  }
2858 
2867  template<class _T>
2869  external<_T>& value)
2870  {
2871  if (value.is_locked())
2872  {
2873  throw exception::BadParamException("External member is locked");
2874  }
2875 
2876  if (!value)
2877  {
2878  value = external<_T>{new typename external<_T>::type()};
2879  }
2880 
2881  deserialize(*value);
2882  return *this;
2883  }
2884 
2893  template<class _T>
2895  optional<external<_T>>& value)
2896  {
2897  if (value.has_value() && value.value().is_locked())
2898  {
2899  throw exception::BadParamException("External member is locked");
2900  }
2901 
2902  bool is_present = true;
2903  if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2904  {
2905  deserialize(is_present);
2906  }
2907  value.reset(is_present);
2908  if (is_present)
2909  {
2910  deserialize(*value);
2911  }
2912  return *this;
2913  }
2914 
2920  Cdr_DllAPI state allocate_xcdrv2_dheader();
2921 
2928  Cdr_DllAPI void set_xcdrv2_dheader(
2929  const state& state);
2930 
2931 private:
2932 
2933  Cdr(
2934  const Cdr&) = delete;
2935 
2936  Cdr& operator =(
2937  const Cdr&) = delete;
2938 
2939  Cdr_DllAPI Cdr& serialize_bool_array(
2940  const std::vector<bool>& vector_t);
2941 
2942  Cdr_DllAPI Cdr& serialize_bool_sequence(
2943  const std::vector<bool>& vector_t);
2944 
2945  Cdr_DllAPI Cdr& deserialize_bool_array(
2946  std::vector<bool>& vector_t);
2947 
2948  Cdr_DllAPI Cdr& deserialize_bool_sequence(
2949  std::vector<bool>& vector_t);
2950 
2951  Cdr_DllAPI Cdr& deserialize_string_sequence(
2952  std::string*& sequence_t,
2953  size_t& num_elements);
2954 
2955  Cdr_DllAPI Cdr& deserialize_wstring_sequence(
2956  std::wstring*& sequence_t,
2957  size_t& num_elements);
2958 
2966  template<class _T, size_t _Size>
2968  const std::array<_T, _Size>* array_t,
2969  size_t num_elements)
2970  {
2971  return serialize_array(array_t->data(), num_elements * array_t->size());
2972  }
2973 
2981  template<class _T, size_t _Size>
2983  std::array<_T, _Size>* array_t,
2984  size_t num_elements)
2985  {
2986  return deserialize_array(array_t->data(), num_elements * array_t->size());
2987  }
2988 
2997  template<class _T, size_t _Size>
2999  std::array<_T, _Size>* array_t,
3000  size_t num_elements,
3002  {
3003  return deserialize_array(array_t->data(), num_elements * array_t->size(), endianness);
3004  }
3005 
3012  inline size_t alignment(
3013  size_t data_size) const
3014  {
3015  return data_size > last_data_size_ ? (data_size - ((offset_ - origin_) % data_size)) & (data_size - 1) : 0;
3016  }
3017 
3022  inline void make_alignment(
3023  size_t align)
3024  {
3025  offset_ += align;
3026  last_data_size_ = 0;
3027  }
3028 
3034  bool resize(
3035  size_t min_size_inc);
3036 
3037  Cdr_DllAPI const char* read_string(
3038  uint32_t& length);
3039  Cdr_DllAPI const std::wstring read_wstring(
3040  uint32_t& length);
3041 
3045 
3052  void xcdr1_serialize_short_member_header(
3053  const MemberId& member_id);
3054 
3064  void xcdr1_end_short_member_header(
3065  const MemberId& member_id,
3066  size_t member_serialized_size);
3067 
3074  void xcdr1_serialize_long_member_header(
3075  const MemberId& member_id);
3076 
3084  void xcdr1_end_long_member_header(
3085  const MemberId& member_id,
3086  size_t member_serialized_size);
3087 
3097  void xcdr1_change_to_short_member_header(
3098  const MemberId& member_id,
3099  size_t member_serialized_size);
3100 
3108  void xcdr1_change_to_long_member_header(
3109  const MemberId& member_id,
3110  size_t member_serialized_size);
3111 
3120  Cdr_DllAPI bool xcdr1_deserialize_member_header(
3121  MemberId& member_id,
3122  Cdr::state& current_state);
3123 
3131  void xcdr2_serialize_short_member_header(
3132  const MemberId& member_id);
3133 
3143  void xcdr2_end_short_member_header(
3144  const MemberId& member_id,
3145  size_t member_serialized_size);
3146 
3154  void xcdr2_serialize_long_member_header(
3155  const MemberId& member_id);
3156 
3165  void xcdr2_end_long_member_header(
3166  const MemberId& member_id,
3167  size_t member_serialized_size);
3168 
3178  void xcdr2_change_to_short_member_header(
3179  const MemberId& member_id,
3180  size_t member_serialized_size);
3181 
3190  void xcdr2_change_to_long_member_header(
3191  const MemberId& member_id,
3192  size_t member_serialized_size);
3193 
3202  void xcdr2_shrink_to_long_member_header(
3203  const MemberId& member_id,
3204  const FastBuffer::iterator& offset);
3205 
3214  void xcdr2_deserialize_member_header(
3215  MemberId& member_id,
3216  Cdr::state& current_state);
3217 
3234  Cdr& xcdr1_begin_serialize_member(
3235  const MemberId& member_id,
3236  bool is_present,
3237  Cdr::state& current_state,
3238  XCdrHeaderSelection header_selection);
3239 
3250  Cdr& xcdr1_end_serialize_member(
3251  const Cdr::state& current_state);
3252 
3268  Cdr& xcdr1_begin_serialize_opt_member(
3269  const MemberId& member_id,
3270  bool is_present,
3271  Cdr::state& current_state,
3272  XCdrHeaderSelection header_selection);
3273 
3284  Cdr& xcdr1_end_serialize_opt_member(
3285  const Cdr::state& current_state);
3286 
3303  Cdr& xcdr2_begin_serialize_member(
3304  const MemberId& member_id,
3305  bool is_present,
3306  Cdr::state& current_state,
3307  XCdrHeaderSelection header_selection);
3308 
3319  Cdr& xcdr2_end_serialize_member(
3320  const Cdr::state& current_state);
3321 
3331  Cdr& xcdr1_begin_serialize_type(
3332  Cdr::state& current_state,
3333  EncodingAlgorithmFlag type_encoding) noexcept;
3334 
3343  Cdr& xcdr1_end_serialize_type(
3344  const Cdr::state& current_state);
3345 
3359  Cdr& xcdr2_begin_serialize_type(
3360  Cdr::state& current_state,
3361  EncodingAlgorithmFlag type_encoding);
3362 
3372  Cdr& xcdr2_end_serialize_type(
3373  const Cdr::state& current_state);
3374 
3387  Cdr& xcdr1_deserialize_type(
3388  EncodingAlgorithmFlag type_encoding,
3389  std::function<bool (Cdr&, const MemberId&)> functor);
3390 
3404  Cdr& xcdr2_deserialize_type(
3405  EncodingAlgorithmFlag type_encoding,
3406  std::function<bool (Cdr&, const MemberId&)> functor);
3407 
3408  Cdr& cdr_begin_serialize_member(
3409  const MemberId& member_id,
3410  bool is_present,
3411  Cdr::state& current_state,
3412  XCdrHeaderSelection header_selection);
3413 
3414  Cdr& cdr_end_serialize_member(
3415  const Cdr::state& current_state);
3416 
3417  Cdr& cdr_begin_serialize_type(
3418  Cdr::state& current_state,
3419  EncodingAlgorithmFlag type_encoding);
3420 
3421  Cdr& cdr_end_serialize_type(
3422  const Cdr::state& current_state);
3423 
3424  Cdr& cdr_deserialize_type(
3425  EncodingAlgorithmFlag type_encoding,
3426  std::function<bool (Cdr&, const MemberId&)> functor);
3427 
3431  void reset_callbacks();
3432 
3433  using begin_serialize_member_functor = Cdr& (Cdr::*)(
3434  const MemberId&,
3435  bool,
3436  Cdr::state&,
3438  begin_serialize_member_functor begin_serialize_member_ { nullptr };
3439 
3440  using end_serialize_member_functor = Cdr& (Cdr::*)(
3441  const Cdr::state&);
3442  end_serialize_member_functor end_serialize_member_ { nullptr };
3443 
3444  using begin_serialize_opt_member_functor = Cdr& (Cdr::*)(
3445  const MemberId&,
3446  bool,
3447  Cdr::state&,
3449  begin_serialize_opt_member_functor begin_serialize_opt_member_ { nullptr };
3450 
3451  using end_serialize_memberopt__functor = Cdr& (Cdr::*)(
3452  const Cdr::state&);
3453  end_serialize_member_functor end_serialize_opt_member_ { nullptr };
3454 
3455  using begin_serialize_type_functor = Cdr& (Cdr::*)(
3456  Cdr::state&,
3458  begin_serialize_type_functor begin_serialize_type_ { nullptr };
3459 
3460  using end_serialize_type_functor = Cdr& (Cdr::*)(
3461  const Cdr::state&);
3462  end_serialize_type_functor end_serialize_type_ { nullptr };
3463 
3464  using deserialize_type_functor = Cdr& (Cdr::*)(
3466  std::function<bool (Cdr&, const MemberId&)>);
3467  deserialize_type_functor deserialize_type_ { nullptr };
3468 
3470  FastBuffer& cdr_buffer_;
3471 
3473  CdrVersion cdr_version_ {CdrVersion::XCDRv2};
3474 
3476  EncodingAlgorithmFlag encoding_flag_ {EncodingAlgorithmFlag::PLAIN_CDR2};
3477 
3479  EncodingAlgorithmFlag current_encoding_ {EncodingAlgorithmFlag::PLAIN_CDR2};
3480 
3482  std::array<uint8_t, 2> options_{{0}};
3483 
3485  uint8_t endianness_ {Endianness::LITTLE_ENDIANNESS};
3486 
3488  bool swap_bytes_ {false};
3489 
3491  size_t last_data_size_ {0};
3492 
3494  FastBuffer::iterator offset_;
3495 
3497  FastBuffer::iterator origin_;
3498 
3500  FastBuffer::iterator end_;
3501 
3503  MemberId next_member_id_;
3504 
3506  size_t align64_ {4};
3507 
3512  enum SerializedMemberSizeForNextInt
3513  {
3514  NO_SERIALIZED_MEMBER_SIZE,
3515  SERIALIZED_MEMBER_SIZE,
3516  SERIALIZED_MEMBER_SIZE_4,
3517  SERIALIZED_MEMBER_SIZE_8
3518  }
3520  serialized_member_size_ {NO_SERIALIZED_MEMBER_SIZE};
3521 
3523  state initial_state_;
3524 
3526  bool encapsulation_serialized_ {false};
3527 
3528 
3529  uint32_t get_long_lc(
3530  SerializedMemberSizeForNextInt serialized_member_size);
3531 
3532  uint32_t get_short_lc(
3533  size_t member_serialized_size);
3534 
3535  template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
3536  std::is_arithmetic<_T>::value>::type* = nullptr>
3537  constexpr SerializedMemberSizeForNextInt get_serialized_member_size() const
3538  {
3539  return (1 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE :
3540  (4 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE_4 :
3541  (8 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE_8 : NO_SERIALIZED_MEMBER_SIZE)));
3542  }
3543 
3544 };
3545 
3546 } //namespace fastcdr
3547 } //namespace eprosima
3548 
3549 #endif // _CDR_CDR_H_
Cdr_DllAPI void change_endianness(Endianness endianness)
This function sets the current endianness used by the CDR type.
Big endianness.
Definition: Cdr.h:78
TEMPLATE_SPEC Cdr & deserialize_array(uint8_t *octet_t, size_t num_elements)
This function deserializes an array of octets.
Definition: Cdr.h:2185
TEMPLATE_SPEC Cdr & serialize_array(const uint32_t *ulong_t, size_t num_elements)
This function serializes an array of unsigned longs.
Definition: Cdr.h:1064
This class offers an interface to serialize/deserialize some basic types using CDR protocol inside an...
Definition: Cdr.h:68
Cdr_DllAPI bool set_encoding_flag(EncodingAlgorithmFlag encoding_flag)
Sets the EncodingAlgorithmFlag for the encapsulation when the CDR type is CdrVersion::DDS_CDR, CdrVersion::XCDRv1 or CdrVersion::XCDRv2.
Cdr & serialize(const fixed_string< MAX_CHARS > &value)
Encodes a eprosima::fastcdr::fixed_string in the buffer.
Definition: Cdr.h:724
Cdr & serialize(const _T &value)
Encodes the value of a type into the buffer.
Definition: Cdr.h:381
Cdr & serialize(const optional< _T > &value)
Encodes an optional in the buffer.
Definition: Cdr.h:2789
TEMPLATE_SPEC Cdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: Cdr.h:1661
Cdr & deserialize(optional< _T > &value)
Decodes an optional from the buffer.
Definition: Cdr.h:2843
TEMPLATE_SPEC Cdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence.
Definition: Cdr.h:1964
Initially a long member header is allocated but can be changed to the shorter version.
Definition: Cdr.h:99
Cdr_DllAPI char * get_current_position()
This function returns the current position in the CDR stream.
Cdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence of non-primitive.
Definition: Cdr.h:1844
TEMPLATE_SPEC Cdr & deserialize_array(uint16_t *ushort_t, size_t num_elements)
This function deserializes an array of unsigned shorts.
Definition: Cdr.h:2226
TEMPLATE_SPEC Cdr & serialize_array(const uint16_t *ushort_t, size_t num_elements)
This function serializes an array of unsigned shorts.
Definition: Cdr.h:1038
TEMPLATE_SPEC Cdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition: Cdr.h:1775
XCDRv2 encoding defined by standard DDS X-Types 1.3.
Definition: CdrEncoding.hpp:33
void deserialize(Cdr &, _T &)
Cdr_DllAPI Cdr & serialize_encapsulation()
This function writes the encapsulation of the CDR stream.
Cdr_DllAPI bool operator==(const state &other_state) const
Compares two states.
_FastBuffer_iterator iterator
Definition: FastBuffer.h:247
TEMPLATE_SPEC Cdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition: Cdr.h:1677
void reset(bool initial_engaged=false)
Reset the state of the optional.
Definition: optional.hpp:115
Cdr & deserialize_array(_T *value, size_t num_elements)
Decodes an array of a type not managed by this encoder from the buffer.
Definition: Cdr.h:2134
Initially a long member header is allocated and cannot be changed.
Definition: Cdr.h:95
This class is thrown as an exception when an invalid parameter is being serialized.
Definition: BadParamException.h:27
Cdr & deserialize_sequence(_T *&sequence_t, size_t &num_elements)
This function template deserializes a raw sequence of non-primitives.
Definition: Cdr.h:2477
TEMPLATE_SPEC Cdr & serialize_array(const uint8_t *octet_t, size_t num_elements)
This function serializes an array of octets.
Definition: Cdr.h:997
Cdr & deserialize_member(optional< _T > &member_value)
Decodes an optional member of a type according to the encoding algorithm used.
Definition: Cdr.h:2721
Cdr_DllAPI Cdr & read_encapsulation()
This function reads the encapsulation of the CDR stream.
Cdr & serialize_member(const MemberId &member_id, const _T &member_value, XCdrHeaderSelection header_selection=XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT)
XCDR extensions.
Definition: Cdr.h:2666
bool has_value() const
Checks whether the optional contains a value.
Definition: optional.hpp:202
TEMPLATE_SPEC Cdr & deserialize_array(uint32_t *ulong_t, size_t num_elements)
This function deserializes an array of unsigned longs.
Definition: Cdr.h:2252
Cdr & serialize_array(const std::vector< _T > &value)
Encodes an std::vector of primitives as an array.
Definition: Cdr.h:1231
Cdr_DllAPI bool move_alignment_forward(size_t num_bytes)
This function moves the alignment forward.
static size_t alignment(size_t current_alignment, size_t data_size)
Returns the number of bytes needed to align a position to certain data size.
Definition: Cdr.h:275
Cdr & serialize(const external< _T > &value)
Encodes an external in the buffer.
Definition: Cdr.h:2813
T type
Definition: external.hpp:33
Cdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence of non-primitive.
Definition: Cdr.h:764
TEMPLATE_SPEC Cdr & serialize_array(const std::vector< bool > &value)
Encodes an std::vector of booleans as an array.
Definition: Cdr.h:1299
Definition: MemberId.hpp:27
static Cdr_DllAPI const Endianness DEFAULT_ENDIAN
Default endianess in the system.
Definition: Cdr.h:84
Cdr_DllAPI void set_dds_cdr_options(const std::array< uint8_t, 2 > &options)
This function sets the option flags when the CDR type is eprosima::fastcdr::DDS_CDR.
TEMPLATE_SPEC Cdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: Cdr.h:1617
TEMPLATE_SPEC Cdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition: Cdr.h:1582
Cdr_DllAPI Cdr & deserialize_type(EncodingAlgorithmFlag type_encoding, std::function< bool(Cdr &, const MemberId &)> functor)
Tells to the encoder a new type and its members starts to be decoded.
Cdr & operator<<(const _T &value)
Encodes the value into the buffer.
Definition: Cdr.h:326
Cdr & serialize_array(const _T *value, size_t num_elements)
Encodes an array of a type not managed by this encoder into the buffer.
Definition: Cdr.h:946
Cdr & serialize_array(const fixed_string< MAX_CHARS > *value, size_t num_elements)
Encodes an array of fixed strings.
Definition: Cdr.h:1211
Cdr_DllAPI state allocate_xcdrv2_dheader()
Encodes an empty DHEADER if the encoding version is XCDRv2.
Initially a short member header is allocated and cannot be changed. This option may cause an exceptio...
Definition: Cdr.h:93
Cdr & serialize_sequence(const _T *sequence_t, size_t num_elements, Endianness endianness)
This function template serializes a raw sequence with a different endianness.
Definition: Cdr.h:1383
This class is thrown as an exception when the buffer&#39;s internal memory reachs its size limit...
Definition: NotEnoughMemoryException.h:27
Cdr & deserialize_array(std::vector< _T > &value)
Decodes an array of primitives on a std::vector.
Definition: Cdr.h:2364
Cdr & deserialize(_T &value)
Decodes the value of a type from the buffer.
Definition: Cdr.h:1417
TEMPLATE_SPEC Cdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition: Cdr.h:1759
Cdr_DllAPI char * get_buffer_pointer()
This function returns the pointer to the current used buffer.
TEMPLATE_SPEC Cdr & deserialize_array(uint64_t *ulonglong_t, size_t num_elements)
This function deserializes an array of unsigned long longs.
Definition: Cdr.h:2289
Cdr_DllAPI Cdr(FastBuffer &cdr_buffer, const Endianness endianness=DEFAULT_ENDIAN, const CdrVersion cdr_version=XCDRv2)
This constructor creates an eprosima::fastcdr::Cdr object that can serialize/deserialize the assigned...
Definition: fixed_size_string.hpp:32
Cdr_DllAPI Cdr & begin_serialize_type(Cdr::state &current_state, EncodingAlgorithmFlag type_encoding)
Tells to the encoder a new type and its members starts to be encoded.
Cdr_DllAPI void reset()
This function resets the current position in the buffer to the beginning.
Cdr & deserialize_array(_T *type_t, size_t num_elements, Endianness endianness)
This function template deserializes an array of non-basic objects with a different endianness...
Definition: Cdr.h:2154
Cdr & serialize(const std::map< _K, _T > &map_t)
This function template serializes a map of non-primitive.
Definition: Cdr.h:840
constexpr bool is_multi_array_primitive(...)
Basis.
Definition: container_recursive_inspector.hpp:27
Cdr & operator>>(_T &value)
Decodes the value from the buffer.
Definition: Cdr.h:356
bool is_locked() const noexcept
Checks if locked.
Definition: external.hpp:168
Cdr & deserialize(optional< external< _T >> &value)
Decodes an optional of an external from the buffer.
Definition: Cdr.h:2894
TEMPLATE_SPEC Cdr & deserialize_array(int8_t *int8, size_t num_elements)
This function deserializes an array of int8_t.
Definition: Cdr.h:2211
Cdr & deserialize(fixed_string< MAX_CHARS > &value)
Decodes a fixed string.
Definition: Cdr.h:1791
void serialize(Cdr &, const _T &)
This class template manages an external member, a member declared to be external to the storage of a ...
Definition: external.hpp:29
TEMPLATE_SPEC Cdr & serialize_array(const int8_t *int8, size_t num_elements)
This function serializes an array of int8_t.
Definition: Cdr.h:1023
TEMPLATE_SPEC Cdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition: Cdr.h:1604
Cdr & serialize_member(const MemberId &member_id, const optional< _T > &member_value, XCdrHeaderSelection header_selection=XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT)
Encodes an optional member of a type according to the encoding algorithm used.
Definition: Cdr.h:2688
Cdr_DllAPI state(const Cdr &cdr)
Default constructor.
Cdr & serialize_array(const _T *type_t, size_t num_elements, Endianness endianness)
This function template serializes an array of non-basic objects with a different endianness.
Definition: Cdr.h:966
EncodingAlgorithmFlag
This enumeration represents the supported XCDR encoding algorithms.
Definition: CdrEncoding.hpp:37
TEMPLATE_SPEC Cdr & serialize_array(const std::wstring *string_t, size_t num_elements)
This function serializes an array of wide-strings.
Definition: Cdr.h:1191
Cdr & deserialize_member(_T &member_value)
Decodes a member of a type according to the encoding algorithm used.
Definition: Cdr.h:2707
This class implements the iterator used to go through a FastBuffer.
Definition: FastBuffer.h:42
Cdr_DllAPI Endianness endianness() const
This function returns the current endianness used by the CDR type.
Cdr & serialize_array(const std::vector< _T > &value, Endianness endianness)
Encodes an std::vector as an array with a different endianness.
Definition: Cdr.h:1269
TEMPLATE_SPEC Cdr & deserialize_sequence(std::string *&sequence_t, size_t &num_elements)
This function template deserializes a string sequence.
Definition: Cdr.h:2627
fixed_string & assign(const char *c_array, size_t n_chars) noexcept
Assigns from a char array.
Definition: fixed_size_string.hpp:78
Cdr_DllAPI EncodingAlgorithmFlag get_encoding_flag() const
Returns the EncodingAlgorithmFlag set in the encapsulation when the CDR type is CdrVersion::DDS_CDR, CdrVersion::XCDRv1 or CdrVersion::XCDRv2.
Cdr_DllAPI size_t get_serialized_data_length() const
This function returns the length of the serialized data inside the stream.
TEMPLATE_SPEC Cdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition: Cdr.h:689
This class stores the current state of a CDR serialization.
Definition: Cdr.h:105
TEMPLATE_SPEC Cdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: Cdr.h:1639
Cdr & deserialize_sequence(_T *&sequence_t, size_t &num_elements, Endianness endianness)
This function template deserializes a raw sequence with a different endianness.
Definition: Cdr.h:2594
Initially a short member header is allocated but can be changed to the longer version.
Definition: Cdr.h:97
Cdr & serialize_sequence(const _T *sequence_t, size_t num_elements)
This function template serializes a raw sequence of non-primitives.
Definition: Cdr.h:1316
TEMPLATE_SPEC Cdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition: Cdr.h:826
static const char *const NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT
Default message used in the library.
Definition: NotEnoughMemoryException.h:78
Cdr_DllAPI std::array< uint8_t, 2 > get_dds_cdr_options() const
This function returns the option flags when the CDR type is eprosima::fastcdr::DDS_CDR.
TEMPLATE_SPEC Cdr & deserialize_array(std::vector< bool > &value)
Decodes an array of booleans on a std::vector.
Definition: Cdr.h:2458
Cdr_DllAPI CdrVersion get_cdr_version() const
Retrieves the CdrVersion used by the instance.
This abstract class is used to create exceptions.
Definition: Exception.h:28
Template class for non-alloc strings.
Definition: fixed_size_string.hpp:44
Cdr_DllAPI Cdr & end_serialize_type(Cdr::state &current_state)
Tells to the encoder the encoding of the type finishes.
XCdrHeaderSelection
Used to decide, in encoding algorithms where member headers support a short header version and a long...
Definition: Cdr.h:90
Cdr & deserialize(external< _T > &value)
Decodes an external from the buffer.
Definition: Cdr.h:2868
Cdr & deserialize(_T &value, Endianness endianness)
Decodes the value of a type with a different endianness.
Definition: Cdr.h:1433
CdrVersion
This enumeration represents the kinds of CDR serialization supported by eprosima::fastcdr::CDR.
Definition: CdrEncoding.hpp:24
This class template manages an optional contained value, i.e.
Definition: optional.hpp:46
TEMPLATE_SPEC Cdr & serialize_array(const uint64_t *ulonglong_t, size_t num_elements)
This function serializes an array of unsigned long longs.
Definition: Cdr.h:1101
Cdr & deserialize(std::map< _K, _T > &map_t)
This function template deserializes a map of non-primitive.
Definition: Cdr.h:1978
Cdr_DllAPI bool jump(size_t num_bytes)
This function skips a number of bytes in the CDR stream buffer.
TEMPLATE_SPEC Cdr & deserialize_sequence(std::wstring *&sequence_t, size_t &num_elements)
This function template deserializes a wide-string sequence.
Definition: Cdr.h:2644
Cdr & serialize(const _T &value, Endianness endianness)
Encodes the value of a type with a different endianness.
Definition: Cdr.h:397
void reset_alignment()
This function resets the alignment to the current position in the buffer.
Definition: Cdr.h:306
Cdr_DllAPI void set_xcdrv2_dheader(const state &state)
Uses the state to calculate the member&#39;s type size and serialize the value in the previous allocated ...
Cdr_DllAPI void set_state(const state &state)
Sets a previous state of the CDR serialization process;.
TEMPLATE_SPEC Cdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition: Cdr.h:710
virtual void raise() const =0
This function throws the object as exception.
Endianness
This enumeration represents endianness types.
Definition: Cdr.h:75
Cdr_DllAPI state get_state() const
Returns the current state of the CDR serialization process.
Cdr & deserialize_array(std::vector< _T > &value, Endianness endianness)
Decodes an array of non-primitives on a std::vector with a different endianness.
Definition: Cdr.h:2425
TEMPLATE_SPEC Cdr & serialize_array(const std::string *string_t, size_t num_elements)
This function serializes an array of strings.
Definition: Cdr.h:1172
Cdr & deserialize(std::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition: Cdr.h:1807
const char * c_str() const noexcept
Converts to C string.
Definition: fixed_size_string.hpp:153
Little endianness.
Definition: Cdr.h:80
Cdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition: Cdr.h:737
static const MemberId MEMBER_ID_INVALID
Definition: MemberId.hpp:67