15#ifndef _FASTCDR_CDR_H_
16#define _FASTCDR_CDR_H_
29#include "fastcdr_dll.h"
31#include "CdrEncoding.hpp"
32#include "cdr/fixed_size_string.hpp"
33#include "detail/container_recursive_inspector.hpp"
34#include "exceptions/BadParamException.h"
35#include "exceptions/Exception.h"
36#include "exceptions/NotEnoughMemoryException.h"
37#include "FastBuffer.h"
38#include "xcdr/external.hpp"
39#include "xcdr/MemberId.hpp"
40#include "xcdr/optional.hpp"
42#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
74 typedef enum : uint8_t
121 const state& other_state)
const;
135 bool swap_bytes_ {
false};
138 size_t last_data_size_ {0};
144 uint32_t member_size_ {0};
222 const std::array<uint8_t, 2>& options);
275 size_t current_alignment,
278 return (data_size - (current_alignment % data_size)) & (data_size - 1);
379 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* =
nullptr,
typename =
void>
400 bool aux_swap = swap_bytes_;
407 swap_bytes_ = aux_swap;
411 swap_bytes_ = aux_swap;
427 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
428 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
429 int32_t>::value>::type* =
nullptr>
433 return serialize(
static_cast<int32_t
>(value));
445 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
446 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
447 uint32_t>::value>::type* =
nullptr>
451 return serialize(
static_cast<uint32_t
>(value));
463 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
464 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
465 int16_t>::value>::type* =
nullptr>
469 return serialize(
static_cast<int16_t
>(value));
481 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
482 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
483 uint16_t>::value>::type* =
nullptr>
487 return serialize(
static_cast<uint16_t
>(value));
499 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
500 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
501 int8_t>::value>::type* =
nullptr>
505 return serialize(
static_cast<int8_t
>(value));
517 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
518 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
519 uint8_t>::value>::type* =
nullptr>
523 return serialize(
static_cast<uint8_t
>(value));
533 const uint8_t& octet_t)
535 return serialize(
static_cast<char>(octet_t));
556 return serialize(
static_cast<char>(int8));
566 const uint16_t ushort_t)
568 return serialize(
static_cast<int16_t
>(ushort_t));
578 const int16_t short_t);
587 const uint32_t ulong_t)
589 return serialize(
static_cast<int32_t
>(ulong_t));
599 const int32_t long_t);
610 return serialize(
static_cast<uint16_t
>(wchar));
620 const uint64_t ulonglong_t)
622 return serialize(
static_cast<int64_t
>(ulonglong_t));
632 const int64_t longlong_t);
641 const float float_t);
650 const double double_t);
660 const long double ldouble_t);
680 return serialize(
static_cast<const char*
>(string_t));
690 const char* string_t);
699 const wchar_t* string_t);
709 const std::string& string_t)
722 const std::wstring& string_t)
734 template <
size_t MAX_CHARS>
747 template<
class _T,
size_t _Size>
749 const std::array<_T, _Size>& array_t)
773 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
774 !std::is_arithmetic<_T>::value>::type* =
nullptr>
776 const std::vector<_T>& vector_t)
780 serialize(
static_cast<int32_t
>(vector_t.size()));
803 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
804 std::is_arithmetic<_T>::value>::type* =
nullptr>
806 const std::vector<_T>& vector_t)
808 state state_before_error(*
this);
810 serialize(
static_cast<int32_t
>(vector_t.size()));
824 serialized_member_size_ = get_serialized_member_size<_T>();
838 const std::vector<bool>& vector_t)
840 return serialize_bool_sequence(vector_t);
849 template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value &&
850 !std::is_arithmetic<_T>::value>::type* =
nullptr>
852 const std::map<_K, _T>& map_t)
856 serialize(
static_cast<int32_t
>(map_t.size()));
860 for (
auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
883 template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value ||
884 std::is_arithmetic<_T>::value>::type* =
nullptr>
886 const std::map<_K, _T>& map_t)
890 serialize(
static_cast<int32_t
>(map_t.size()));
894 for (
auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
917 template<
size_t N,
typename std::enable_if < (N < 9) > ::type* =
nullptr>
919 const std::bitset<N>& value)
921 return serialize(static_cast<u
int8_t>(value.to_u
long()));
924 template<
size_t N,
typename std::enable_if < (8 < N && N < 17) > ::type* =
nullptr>
926 const std::bitset<N>& value)
928 return serialize(static_cast<u
int16_t>(value.to_u
long()));
931 template<
size_t N,
typename std::enable_if < (16 < N && N < 33) > ::type* =
nullptr>
933 const std::bitset<N>& value)
935 return serialize(static_cast<u
int32_t>(value.to_u
long()));
938 template<
size_t N,
typename std::enable_if < (32 < N && N < 65) > ::type* =
nullptr>
940 const std::bitset<N>& value)
942 return serialize(static_cast<u
int64_t>(value.to_ul
long()));
961 for (
size_t count = 0; count < num_elements; ++count)
982 bool aux_swap = swap_bytes_;
989 swap_bytes_ = aux_swap;
993 swap_bytes_ = aux_swap;
1009 const uint8_t* octet_t,
1010 size_t num_elements)
1012 return serialize_array(
reinterpret_cast<const char*
>(octet_t), num_elements);
1024 size_t num_elements);
1036 size_t num_elements)
1038 return serialize_array(
reinterpret_cast<const char*
>(int8), num_elements);
1050 const uint16_t* ushort_t,
1051 size_t num_elements)
1053 return serialize_array(
reinterpret_cast<const int16_t*
>(ushort_t), num_elements);
1064 const int16_t* short_t,
1065 size_t num_elements);
1076 const uint32_t* ulong_t,
1077 size_t num_elements)
1079 return serialize_array(
reinterpret_cast<const int32_t*
>(ulong_t), num_elements);
1090 const int32_t* long_t,
1091 size_t num_elements);
1101 const wchar_t* wchar,
1102 size_t num_elements);
1113 const uint64_t* ulonglong_t,
1114 size_t num_elements)
1116 return serialize_array(
reinterpret_cast<const int64_t*
>(ulonglong_t), num_elements);
1127 const int64_t* longlong_t,
1128 size_t num_elements);
1138 const float* float_t,
1139 size_t num_elements);
1149 const double* double_t,
1150 size_t num_elements);
1161 const long double* ldouble_t,
1162 size_t num_elements);
1173 size_t num_elements);
1184 const std::string* string_t,
1185 size_t num_elements)
1187 for (
size_t count = 0; count < num_elements; ++count)
1203 const std::wstring* string_t,
1204 size_t num_elements)
1206 for (
size_t count = 0; count < num_elements; ++count)
1221 template<
size_t MAX_CHARS>
1224 size_t num_elements)
1226 for (
size_t count = 0; count < num_elements; ++count)
1240 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1241 std::is_arithmetic<_T>::value>::type* =
nullptr>
1243 const std::vector<_T>& value)
1257 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1258 !std::is_arithmetic<_T>::value>::type* =
nullptr>
1260 const std::vector<_T>& value)
1281 const std::vector<_T>& value,
1284 bool aux_swap = swap_bytes_;
1291 swap_bytes_ = aux_swap;
1295 swap_bytes_ = aux_swap;
1311 const std::vector<bool>& value)
1313 serialize_bool_array(value);
1325 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1326 !std::is_arithmetic<_T>::value>::type* =
nullptr>
1328 const _T* sequence_t,
1329 size_t num_elements)
1333 serialize(
static_cast<int32_t
>(num_elements));
1357 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1358 std::is_arithmetic<_T>::value>::type* =
nullptr>
1360 const _T* sequence_t,
1361 size_t num_elements)
1363 state state_before_error(*
this);
1365 serialize(
static_cast<int32_t
>(num_elements));
1379 serialized_member_size_ = get_serialized_member_size<_T>();
1395 const _T* sequence_t,
1396 size_t num_elements,
1399 bool aux_swap = swap_bytes_;
1406 swap_bytes_ = aux_swap;
1410 swap_bytes_ = aux_swap;
1427 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* =
nullptr,
typename =
void>
1448 bool aux_swap = swap_bytes_;
1455 swap_bytes_ = aux_swap;
1459 swap_bytes_ = aux_swap;
1474 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1475 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1476 int32_t>::value>::type* =
nullptr>
1480 int32_t decode_value {0};
1482 value =
static_cast<_T
>(decode_value);
1494 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1495 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1496 uint32_t>::value>::type* =
nullptr>
1500 uint32_t decode_value {0};
1502 value =
static_cast<_T
>(decode_value);
1514 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1515 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1516 int16_t>::value>::type* =
nullptr>
1520 int16_t decode_value {0};
1522 value =
static_cast<_T
>(decode_value);
1534 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1535 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1536 uint16_t>::value>::type* =
nullptr>
1540 uint16_t decode_value {0};
1542 value =
static_cast<_T
>(decode_value);
1554 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1555 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1556 int8_t>::value>::type* =
nullptr>
1560 int8_t decode_value {0};
1562 value =
static_cast<_T
>(decode_value);
1574 typename std::enable_if<std::is_enum<_T>::value>::type* =
nullptr,
1575 typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type,
1576 uint8_t>::value>::type* =
nullptr>
1580 uint8_t decode_value {0};
1582 value =
static_cast<_T
>(decode_value);
1596 return deserialize(
reinterpret_cast<char&
>(octet_t));
1618 return deserialize(
reinterpret_cast<char&
>(int8));
1631 return deserialize(
reinterpret_cast<int16_t&
>(ushort_t));
1653 return deserialize(
reinterpret_cast<int32_t&
>(ulong_t));
1677 wchar =
static_cast<wchar_t>(ret);
1689 uint64_t& ulonglong_t)
1691 return deserialize(
reinterpret_cast<int64_t&
>(ulonglong_t));
1701 int64_t& longlong_t);
1729 long double& ldouble_t);
1761 wchar_t*& string_t);
1771 std::string& string_t)
1773 uint32_t length = 0;
1774 const char* str = read_string(length);
1775 string_t.assign(str, length);
1787 std::wstring& string_t)
1789 uint32_t length = 0;
1790 string_t = read_wstring(length);
1801 template <
size_t MAX_CHARS>
1805 uint32_t length = 0;
1806 const char* str = read_string(length);
1807 value = std::string(str, length);
1817 template<
class _T,
size_t _Size>
1819 std::array<_T, _Size>& array_t)
1823 uint32_t dheader {0};
1827 auto offset = offset_;
1828 while (offset_ - offset < dheader && count < _Size)
1834 if (offset_ - offset != dheader)
1853 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1854 !std::is_arithmetic<_T>::value>::type* =
nullptr>
1856 std::vector<_T>& vector_t)
1858 uint32_t sequence_length {0};
1862 uint32_t dheader {0};
1865 auto offset = offset_;
1869 if (0 == sequence_length)
1876 vector_t.resize(sequence_length);
1880 while (offset_ - offset < dheader && count < sequence_length)
1886 if (offset_ - offset != dheader)
1893 state state_before_error(*
this);
1897 if (sequence_length == 0)
1903 if ((end_ - offset_) < sequence_length)
1912 vector_t.resize(sequence_length);
1931 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
1932 std::is_arithmetic<_T>::value>::type* =
nullptr>
1934 std::vector<_T>& vector_t)
1936 uint32_t sequence_length = 0;
1937 state state_before_error(*
this);
1941 if (sequence_length == 0)
1947 if ((end_ - offset_) < sequence_length)
1956 vector_t.resize(sequence_length);
1976 std::vector<bool>& vector_t)
1978 return deserialize_bool_sequence(vector_t);
1987 template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value &&
1988 !std::is_arithmetic<_T>::value>::type* =
nullptr>
1990 std::map<_K, _T>& map_t)
1994 uint32_t dheader {0};
1997 auto offset = offset_;
1999 uint32_t map_length {0};
2005 while (offset_ - offset < dheader && count < map_length)
2011 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(val)));
2015 if (offset_ - offset != dheader)
2022 uint32_t sequence_length = 0;
2023 state state_(*
this);
2031 for (uint32_t i = 0; i < sequence_length; ++i)
2037 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2056 template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value ||
2057 std::is_arithmetic<_T>::value>::type* =
nullptr>
2059 std::map<_K, _T>& map_t)
2061 uint32_t sequence_length = 0;
2062 state state_(*
this);
2068 for (uint32_t i = 0; i < sequence_length; ++i)
2074 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2093 template<
size_t N,
typename std::enable_if < (N < 9) > ::type* =
nullptr>
2095 std::bitset<N>& value)
2097 u
int8_t decode_value {0};
2098 deserialize(decode_value);
2099 value = decode_value;
2103 template<
size_t N,
typename std::enable_if < (8 < N && N < 17) > ::type* =
nullptr>
2105 std::bitset<N>& value)
2107 u
int16_t decode_value {0};
2108 deserialize(decode_value);
2109 value = decode_value;
2113 template<
size_t N,
typename std::enable_if < (16 < N && N < 33) > ::type* =
nullptr>
2115 std::bitset<N>& value)
2117 u
int32_t decode_value {0};
2118 deserialize(decode_value);
2119 value = decode_value;
2123 template<
size_t N,
typename std::enable_if < (32 < N && N < 65) > ::type* =
nullptr>
2125 std::bitset<N>& value)
2127 u
int64_t decode_value {0};
2128 deserialize(decode_value);
2129 value = decode_value;
2147 size_t num_elements)
2149 for (
size_t count = 0; count < num_elements; ++count)
2167 size_t num_elements,
2170 bool aux_swap = swap_bytes_;
2177 swap_bytes_ = aux_swap;
2181 swap_bytes_ = aux_swap;
2198 size_t num_elements)
2212 size_t num_elements);
2224 size_t num_elements)
2239 size_t num_elements)
2253 size_t num_elements);
2265 size_t num_elements)
2279 size_t num_elements);
2290 size_t num_elements);
2301 uint64_t* ulonglong_t,
2302 size_t num_elements)
2304 return deserialize_array(
reinterpret_cast<int64_t*
>(ulonglong_t), num_elements);
2315 int64_t* longlong_t,
2316 size_t num_elements);
2327 size_t num_elements);
2338 size_t num_elements);
2349 long double* ldouble_t,
2350 size_t num_elements);
2361 size_t num_elements);
2373 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2374 std::is_arithmetic<_T>::value>::type* =
nullptr>
2376 std::vector<_T>& value)
2393 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2394 !std::is_arithmetic<_T>::value>::type* =
nullptr>
2396 std::vector<_T>& value)
2400 uint32_t dheader {0};
2404 auto offset = offset_;
2405 while (offset_ - offset < dheader && count < value.size())
2411 if (offset_ - offset != dheader)
2437 std::vector<_T>& value,
2440 bool aux_swap = swap_bytes_;
2447 swap_bytes_ = aux_swap;
2451 swap_bytes_ = aux_swap;
2470 std::vector<bool>& value)
2472 deserialize_bool_array(value);
2486 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2487 !std::is_arithmetic<_T>::value>::type* =
nullptr>
2490 size_t& num_elements)
2492 uint32_t sequence_length {0};
2496 uint32_t dheader {0};
2499 auto offset = offset_;
2505 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2508 while (offset_ - offset < dheader && count < sequence_length)
2514 if (offset_ - offset != dheader)
2528 state state_before_error(*
this);
2532 if ((end_ - offset_) < sequence_length)
2541 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2553 num_elements = sequence_length;
2566 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2567 std::is_arithmetic<_T>::value>::type* =
nullptr>
2570 size_t& num_elements)
2572 uint32_t sequence_length = 0;
2573 state state_before_error(*
this);
2579 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2590 num_elements = sequence_length;
2607 size_t& num_elements,
2610 bool aux_swap = swap_bytes_;
2617 swap_bytes_ = aux_swap;
2621 swap_bytes_ = aux_swap;
2639 std::string*& sequence_t,
2640 size_t& num_elements)
2642 return deserialize_string_sequence(sequence_t, num_elements);
2656 std::wstring*& sequence_t,
2657 size_t& num_elements)
2659 return deserialize_wstring_sequence(sequence_t, num_elements);
2679 const _T& member_value,
2683 (this->*begin_serialize_member_)(member_id,
true, current_state, header_selection);
2685 return (this->*end_serialize_member_)(current_state);
2705 (this->*begin_serialize_opt_member_)(member_id, member_value.
has_value(), current_state, header_selection);
2707 return (this->*end_serialize_opt_member_)(current_state);
2739 xcdr1_deserialize_member_header(member_id, current_state);
2740 auto prev_offset = offset_;
2741 if (0 < current_state.member_size_)
2745 if (current_state.member_size_ != offset_ - prev_offset)
2748 "Member size provided by member header is not equal to the real decoded member size");
2770 return (this->*begin_serialize_type_)(current_state, type_encoding);
2783 return (this->*end_serialize_type_)(current_state);
2796 std::function<
bool (
Cdr&,
const MemberId&)> functor)
2798 return (this->*deserialize_type_)(type_encoding, functor);
2860 next_member_id_ = member_id;
2875 bool is_present =
true;
2880 value.
reset(is_present);
2926 if (value.has_value() && value.value().is_locked())
2931 bool is_present =
true;
2936 value.reset(is_present);
2963 const Cdr&) =
delete;
2966 const Cdr&) =
delete;
2968 Cdr_DllAPI
Cdr& serialize_bool_array(
2969 const std::vector<bool>& vector_t);
2971 Cdr_DllAPI
Cdr& serialize_bool_sequence(
2972 const std::vector<bool>& vector_t);
2974 Cdr_DllAPI
Cdr& deserialize_bool_array(
2975 std::vector<bool>& vector_t);
2977 Cdr_DllAPI
Cdr& deserialize_bool_sequence(
2978 std::vector<bool>& vector_t);
2980 Cdr_DllAPI
Cdr& deserialize_string_sequence(
2981 std::string*& sequence_t,
2982 size_t& num_elements);
2984 Cdr_DllAPI
Cdr& deserialize_wstring_sequence(
2985 std::wstring*& sequence_t,
2986 size_t& num_elements);
2995 template<
class _T,
size_t _Size>
2997 const std::array<_T, _Size>* array_t,
2998 size_t num_elements)
3000 return serialize_array(array_t->data(), num_elements * array_t->size());
3010 template<
class _T,
size_t _Size>
3012 std::array<_T, _Size>* array_t,
3013 size_t num_elements)
3026 template<
class _T,
size_t _Size>
3028 std::array<_T, _Size>* array_t,
3029 size_t num_elements,
3042 size_t data_size)
const
3044 return data_size > last_data_size_ ? (data_size - ((offset_ - origin_) % data_size)) & (data_size - 1) : 0;
3051 inline void make_alignment(
3055 last_data_size_ = 0;
3064 size_t min_size_inc);
3066 Cdr_DllAPI
const char* read_string(
3068 Cdr_DllAPI
const std::wstring read_wstring(
3081 void xcdr1_serialize_short_member_header(
3082 const MemberId& member_id);
3093 void xcdr1_end_short_member_header(
3094 const MemberId& member_id,
3095 size_t member_serialized_size);
3103 void xcdr1_serialize_long_member_header(
3104 const MemberId& member_id);
3113 void xcdr1_end_long_member_header(
3114 const MemberId& member_id,
3115 size_t member_serialized_size);
3126 void xcdr1_change_to_short_member_header(
3127 const MemberId& member_id,
3128 size_t member_serialized_size);
3137 void xcdr1_change_to_long_member_header(
3138 const MemberId& member_id,
3139 size_t member_serialized_size);
3149 Cdr_DllAPI
bool xcdr1_deserialize_member_header(
3150 MemberId& member_id,
3151 Cdr::state& current_state);
3160 void xcdr2_serialize_short_member_header(
3161 const MemberId& member_id);
3172 void xcdr2_end_short_member_header(
3173 const MemberId& member_id,
3174 size_t member_serialized_size);
3183 void xcdr2_serialize_long_member_header(
3184 const MemberId& member_id);
3194 void xcdr2_end_long_member_header(
3195 const MemberId& member_id,
3196 size_t member_serialized_size);
3207 void xcdr2_change_to_short_member_header(
3208 const MemberId& member_id,
3209 size_t member_serialized_size);
3219 void xcdr2_change_to_long_member_header(
3220 const MemberId& member_id,
3221 size_t member_serialized_size);
3231 void xcdr2_shrink_to_long_member_header(
3232 const MemberId& member_id,
3243 void xcdr2_deserialize_member_header(
3244 MemberId& member_id,
3245 Cdr::state& current_state);
3263 Cdr& xcdr1_begin_serialize_member(
3264 const MemberId& member_id,
3266 Cdr::state& current_state,
3279 Cdr& xcdr1_end_serialize_member(
3280 const Cdr::state& current_state);
3297 Cdr& xcdr1_begin_serialize_opt_member(
3298 const MemberId& member_id,
3300 Cdr::state& current_state,
3313 Cdr& xcdr1_end_serialize_opt_member(
3314 const Cdr::state& current_state);
3332 Cdr& xcdr2_begin_serialize_member(
3333 const MemberId& member_id,
3335 Cdr::state& current_state,
3348 Cdr& xcdr2_end_serialize_member(
3349 const Cdr::state& current_state);
3360 Cdr& xcdr1_begin_serialize_type(
3361 Cdr::state& current_state,
3372 Cdr& xcdr1_end_serialize_type(
3373 const Cdr::state& current_state);
3388 Cdr& xcdr2_begin_serialize_type(
3389 Cdr::state& current_state,
3401 Cdr& xcdr2_end_serialize_type(
3402 const Cdr::state& current_state);
3416 Cdr& xcdr1_deserialize_type(
3418 std::function<
bool (Cdr&,
const MemberId&)> functor);
3433 Cdr& xcdr2_deserialize_type(
3435 std::function<
bool (Cdr&,
const MemberId&)> functor);
3437 Cdr& cdr_begin_serialize_member(
3438 const MemberId& member_id,
3440 Cdr::state& current_state,
3443 Cdr& cdr_end_serialize_member(
3444 const Cdr::state& current_state);
3446 Cdr& cdr_begin_serialize_type(
3447 Cdr::state& current_state,
3450 Cdr& cdr_end_serialize_type(
3451 const Cdr::state& current_state);
3453 Cdr& cdr_deserialize_type(
3455 std::function<
bool (Cdr&,
const MemberId&)> functor);
3460 void reset_callbacks();
3462 using begin_serialize_member_functor =
Cdr& (
Cdr::*)(
3467 begin_serialize_member_functor begin_serialize_member_ {
nullptr };
3469 using end_serialize_member_functor =
Cdr& (
Cdr::*)(
3471 end_serialize_member_functor end_serialize_member_ {
nullptr };
3473 using begin_serialize_opt_member_functor =
Cdr& (
Cdr::*)(
3478 begin_serialize_opt_member_functor begin_serialize_opt_member_ {
nullptr };
3480 using end_serialize_memberopt__functor =
Cdr& (
Cdr::*)(
3482 end_serialize_member_functor end_serialize_opt_member_ {
nullptr };
3484 using begin_serialize_type_functor =
Cdr& (
Cdr::*)(
3487 begin_serialize_type_functor begin_serialize_type_ {
nullptr };
3489 using end_serialize_type_functor =
Cdr& (
Cdr::*)(
3491 end_serialize_type_functor end_serialize_type_ {
nullptr };
3493 using deserialize_type_functor =
Cdr& (
Cdr::*)(
3495 std::function<
bool (Cdr&,
const MemberId&)>);
3496 deserialize_type_functor deserialize_type_ {
nullptr };
3499 FastBuffer& cdr_buffer_;
3511 std::array<uint8_t, 2> options_{{0}};
3517 bool swap_bytes_ {
false};
3520 size_t last_data_size_ {0};
3532 MemberId next_member_id_;
3535 size_t align64_ {4};
3541 enum SerializedMemberSizeForNextInt
3543 NO_SERIALIZED_MEMBER_SIZE,
3544 SERIALIZED_MEMBER_SIZE,
3545 SERIALIZED_MEMBER_SIZE_4,
3546 SERIALIZED_MEMBER_SIZE_8
3549 serialized_member_size_ {NO_SERIALIZED_MEMBER_SIZE};
3552 uint32_t get_long_lc(
3553 SerializedMemberSizeForNextInt serialized_member_size);
3555 uint32_t get_short_lc(
3556 size_t member_serialized_size);
3558 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
3559 std::is_arithmetic<_T>::value>::type* =
nullptr>
3560 constexpr SerializedMemberSizeForNextInt get_serialized_member_size()
const
3562 return (1 ==
sizeof(_T) ? SERIALIZED_MEMBER_SIZE :
3563 (4 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE_4 :
3564 (8 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE_8 : NO_SERIALIZED_MEMBER_SIZE)));
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:105
Cdr_DllAPI state(const Cdr &cdr)
Default constructor.
Cdr_DllAPI state(const state &state)
Copy constructor.
Cdr_DllAPI bool operator==(const state &other_state) const
Compares two states.
This class offers an interface to serialize/deserialize some basic types using CDR protocol inside an...
Definition Cdr.h:68
Cdr_DllAPI Cdr & serialize(const int16_t short_t)
This function serializes a short.
void reset_alignment()
This function resets the alignment to the current position in the buffer.
Definition Cdr.h:305
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:1202
Cdr_DllAPI Cdr & deserialize_array(char *char_t, size_t num_elements)
This function deserializes an array of characters.
TEMPLATE_SPEC Cdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition Cdr.h:721
Cdr_DllAPI Cdr & serialize(const int32_t long_t)
This function serializes a long.
Cdr_DllAPI Cdr & serialize(const long double ldouble_t)
This function serializes a long double.
Cdr & serialize(const optional< _T > &value)
Encodes an optional in the buffer.
Definition Cdr.h:2809
TEMPLATE_SPEC Cdr & deserialize_array(uint16_t *ushort_t, size_t num_elements)
This function deserializes an array of unsigned shorts.
Definition Cdr.h:2237
TEMPLATE_SPEC Cdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition Cdr.h:1628
Cdr_DllAPI Cdr & deserialize_array(long double *ldouble_t, size_t num_elements)
This function deserializes an array of long doubles.
Cdr_DllAPI void change_endianness(Endianness endianness)
This function sets the current endianness used by the CDR type.
Cdr_DllAPI Cdr & begin_serialize_type(Cdr::state ¤t_state, EncodingAlgorithmFlag type_encoding)
Tells to the encoder a new type and its members starts to be encoded.
Definition Cdr.h:2766
Cdr & deserialize_array(std::vector< _T > &value)
Decodes an array of primitives on a std::vector.
Definition Cdr.h:2375
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:1112
static Cdr_DllAPI const Endianness DEFAULT_ENDIAN
Default endianess in the system.
Definition Cdr.h:83
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:1075
Cdr & deserialize_member(optional< _T > &member_value)
Decodes an optional member of a type according to the encoding algorithm used.
Definition Cdr.h:2732
Cdr_DllAPI Cdr & serialize(const float float_t)
This function serializes a float.
Cdr & deserialize(std::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition Cdr.h:1818
TEMPLATE_SPEC Cdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition Cdr.h:1615
Cdr_DllAPI Cdr & serialize_array(const float *float_t, size_t num_elements)
This function serializes an array of floats.
TEMPLATE_SPEC Cdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition Cdr.h:1770
Cdr_DllAPI Cdr & deserialize(bool &bool_t)
This function deserializes a boolean.
Cdr_DllAPI size_t get_serialized_data_length() const
This function returns the length of the serialized data inside the stream.
Cdr_DllAPI Cdr & serialize_array(const int32_t *long_t, size_t num_elements)
This function serializes an array of longs.
Cdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence of non-primitive.
Definition Cdr.h:775
Cdr_DllAPI Cdr & deserialize_array(int32_t *long_t, size_t num_elements)
This function deserializes an array of longs.
Cdr_DllAPI Cdr & deserialize_array(wchar_t *wchar, size_t num_elements)
This function deserializes an array of wide-chars.
Cdr_DllAPI Cdr & serialize(const uint8_t &octet_t)
This function serializes an octet.
Definition Cdr.h:532
XCdrHeaderSelection
Used to decide, in encoding algorithms where member headers support a short header version and a long...
Definition Cdr.h:90
@ AUTO_WITH_SHORT_HEADER_BY_DEFAULT
Initially a short member header is allocated but can be changed to the longer version.
Definition Cdr.h:96
@ SHORT_HEADER
Initially a short member header is allocated and cannot be changed. This option may cause an exceptio...
Definition Cdr.h:92
@ AUTO_WITH_LONG_HEADER_BY_DEFAULT
Initially a long member header is allocated but can be changed to the shorter version.
Definition Cdr.h:98
@ LONG_HEADER
Initially a long member header is allocated and cannot be changed.
Definition Cdr.h:94
Cdr_DllAPI Cdr & serialize_array(const bool *bool_t, size_t num_elements)
This function serializes an array of booleans.
TEMPLATE_SPEC Cdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition Cdr.h:1650
Cdr_DllAPI Cdr & serialize_array(const int16_t *short_t, size_t num_elements)
This function serializes an array of shorts.
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:2605
TEMPLATE_SPEC Cdr & serialize_array(const uint8_t *octet_t, size_t num_elements)
This function serializes an array of octets.
Definition Cdr.h:1008
Cdr & deserialize(std::map< _K, _T > &map_t)
This function template deserializes a map of non-primitive.
Definition Cdr.h:1989
Cdr_DllAPI Cdr & deserialize(char *&string_t)
This function deserializes a string.
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.
Cdr_DllAPI Cdr & end_serialize_type(Cdr::state ¤t_state)
Tells to the encoder the encoding of the type finishes.
Definition Cdr.h:2780
Cdr_DllAPI Cdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
Cdr_DllAPI Cdr & deserialize(double &double_t)
This function deserializes a double.
TEMPLATE_SPEC Cdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition Cdr.h:1672
Cdr & deserialize(optional< external< _T > > &value)
Decodes an optional of an external from the buffer.
Definition Cdr.h:2923
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:957
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.
Cdr & deserialize_member(_T &member_value)
Decodes a member of a type according to the encoding algorithm used.
Definition Cdr.h:2718
Cdr_DllAPI Cdr & serialize_array(const char *char_t, size_t num_elements)
This function serializes an array of characters.
Cdr & deserialize(_T &value, Endianness endianness)
Decodes the value of a type with a different endianness.
Definition Cdr.h:1444
TEMPLATE_SPEC Cdr & deserialize_array(int8_t *int8, size_t num_elements)
This function deserializes an array of int8_t.
Definition Cdr.h:2222
Cdr_DllAPI Cdr & serialize(const int64_t longlong_t)
This function serializes a long long.
Cdr_DllAPI char * get_current_position()
This function returns the current position in the CDR stream.
Cdr_DllAPI Cdr & serialize(const char *string_t)
This function serializes a string.
Cdr & deserialize(_T &value)
Decodes the value of a type from the buffer.
Definition Cdr.h:1428
Cdr_DllAPI Cdr & deserialize(wchar_t *&string_t)
This function deserializes a wide-string.
Endianness
This enumeration represents endianness types.
Definition Cdr.h:75
@ LITTLE_ENDIANNESS
Little endianness.
Definition Cdr.h:79
@ BIG_ENDIANNESS
Big endianness.
Definition Cdr.h:77
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:1280
TEMPLATE_SPEC Cdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition Cdr.h:1688
Cdr_DllAPI Cdr & serialize(const double double_t)
This function serializes a double.
Cdr & serialize(const std::map< _K, _T > &map_t)
This function template serializes a map of non-primitive.
Definition Cdr.h:851
Cdr_DllAPI Cdr & deserialize_array(float *float_t, size_t num_elements)
This function deserializes an array of floats.
TEMPLATE_SPEC Cdr & serialize_array(const int8_t *int8, size_t num_elements)
This function serializes an array of int8_t.
Definition Cdr.h:1034
TEMPLATE_SPEC Cdr & serialize_array(const std::vector< bool > &value)
Encodes an std::vector of booleans as an array.
Definition Cdr.h:1310
Cdr_DllAPI Cdr & serialize_array(const int64_t *longlong_t, size_t num_elements)
This function serializes an array of long longs.
Cdr_DllAPI Cdr & deserialize_array(int16_t *short_t, size_t num_elements)
This function deserializes an array of shorts.
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:2165
Cdr & serialize_array(const fixed_string< MAX_CHARS > *value, size_t num_elements)
Encodes an array of fixed strings.
Definition Cdr.h:1222
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:1394
Cdr_DllAPI Cdr & deserialize(char &char_t)
This function deserializes a character.
Cdr & deserialize_sequence(_T *&sequence_t, size_t &num_elements)
This function template deserializes a raw sequence of non-primitives.
Definition Cdr.h:2488
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:2145
Cdr_DllAPI Cdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
TEMPLATE_SPEC Cdr & deserialize_array(uint8_t *octet_t, size_t num_elements)
This function deserializes an array of octets.
Definition Cdr.h:2196
Cdr_DllAPI Cdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition Cdr.h:619
Cdr & serialize_array(const std::vector< _T > &value)
Encodes an std::vector of primitives as an array.
Definition Cdr.h:1242
Cdr_DllAPI bool jump(size_t num_bytes)
This function skips a number of bytes in the CDR stream 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:2300
Cdr & serialize(const fixed_string< MAX_CHARS > &value)
Encodes a eprosima::fastcdr::fixed_string in the buffer.
Definition Cdr.h:735
TEMPLATE_SPEC Cdr & deserialize_sequence(std::string *&sequence_t, size_t &num_elements)
This function template deserializes a string sequence.
Definition Cdr.h:2638
TEMPLATE_SPEC Cdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence.
Definition Cdr.h:1975
Cdr_DllAPI Cdr & serialize(const char char_t)
This function serializes a character.
TEMPLATE_SPEC Cdr & deserialize_array(std::vector< bool > &value)
Decodes an array of booleans on a std::vector.
Definition Cdr.h:2469
Cdr_DllAPI Cdr & serialize_encapsulation()
This function writes the encapsulation of the CDR stream.
TEMPLATE_SPEC Cdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition Cdr.h:1593
Cdr_DllAPI void reset()
This function resets the current position in the buffer to the beginning.
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.
Definition Cdr.h:2794
TEMPLATE_SPEC Cdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition Cdr.h:708
Cdr_DllAPI Cdr & serialize_array(const wchar_t *wchar, size_t num_elements)
This function serializes an array of wide-chars.
Cdr_DllAPI char * get_buffer_pointer()
This function returns the pointer to the current used buffer.
Cdr & deserialize(optional< _T > &value)
Decodes an optional from the buffer.
Definition Cdr.h:2872
Cdr_DllAPI state get_state() const
Returns the current state of the CDR serialization process.
Cdr_DllAPI EncodingAlgorithmFlag get_encoding_flag() const
Returns the EncodingAlgorithmFlag set in the encapsulation when the CDR type is CdrVersion::DDS_CDR,...
Cdr_DllAPI Cdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition Cdr.h:607
Cdr & operator>>(_T &value)
Decodes the value from the buffer.
Definition Cdr.h:355
Cdr_DllAPI Cdr & deserialize_array(double *double_t, size_t num_elements)
This function deserializes an array of doubles.
Cdr_DllAPI bool set_encoding_flag(EncodingAlgorithmFlag encoding_flag)
Sets the EncodingAlgorithmFlag for the encapsulation when the CDR type is CdrVersion::DDS_CDR,...
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:2677
Cdr_DllAPI Cdr & serialize(char *string_t)
This function serializes a string.
Definition Cdr.h:677
Cdr & deserialize(fixed_string< MAX_CHARS > &value)
Decodes a fixed string.
Definition Cdr.h:1802
Cdr_DllAPI Cdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition Cdr.h:586
Cdr & serialize(const _T &value)
Encodes the value of a type into the buffer.
Definition Cdr.h:380
Cdr_DllAPI Cdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition Cdr.h:565
Cdr_DllAPI state allocate_xcdrv2_dheader()
Encodes an empty DHEADER if the encoding version is XCDRv2.
Cdr_DllAPI Cdr & read_encapsulation()
This function reads the encapsulation of the CDR stream.
TEMPLATE_SPEC Cdr & deserialize_array(uint32_t *ulong_t, size_t num_elements)
This function deserializes an array of unsigned longs.
Definition Cdr.h:2263
Cdr_DllAPI CdrVersion get_cdr_version() const
Retrieves the CdrVersion used by the instance.
Cdr_DllAPI Cdr & serialize_array(const long double *ldouble_t, size_t num_elements)
This function serializes an array of long doubles.
Cdr_DllAPI Cdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
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...
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:2436
Cdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence of non-primitive.
Definition Cdr.h:1855
Cdr_DllAPI Cdr & deserialize_array(int64_t *longlong_t, size_t num_elements)
This function deserializes an array of long longs.
Cdr_DllAPI void set_xcdrv2_dheader(const state &state)
Uses the state to calculate the member's type size and serialize the value in the previous allocated ...
Cdr & deserialize(external< _T > &value)
Decodes an external from the buffer.
Definition Cdr.h:2897
Cdr_DllAPI Cdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition Cdr.h:553
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:2699
TEMPLATE_SPEC Cdr & serialize_array(const std::string *string_t, size_t num_elements)
This function serializes an array of strings.
Definition Cdr.h:1183
TEMPLATE_SPEC Cdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition Cdr.h:1786
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:274
Cdr_DllAPI Cdr & serialize_array(const double *double_t, size_t num_elements)
This function serializes an array of doubles.
Cdr & operator<<(const _T &value)
Encodes the value into the buffer.
Definition Cdr.h:325
Cdr_DllAPI bool move_alignment_forward(size_t num_bytes)
This function moves the alignment forward.
Cdr_DllAPI Cdr & deserialize(int32_t &long_t)
This function deserializes a long.
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:977
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:1049
Cdr & serialize_sequence(const _T *sequence_t, size_t num_elements)
This function template serializes a raw sequence of non-primitives.
Definition Cdr.h:1327
Cdr_DllAPI Cdr & deserialize(int16_t &short_t)
This function deserializes a short.
Cdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition Cdr.h:748
Cdr & serialize(const external< _T > &value)
Encodes an external in the buffer.
Definition Cdr.h:2833
Cdr_DllAPI void set_state(const state &state)
Sets a previous state of the CDR serialization process;.
Cdr & serialize(const _T &value, Endianness endianness)
Encodes the value of a type with a different endianness.
Definition Cdr.h:396
Cdr_DllAPI Cdr & deserialize_array(bool *bool_t, size_t num_elements)
This function deserializes an array of booleans.
TEMPLATE_SPEC Cdr & deserialize_sequence(std::wstring *&sequence_t, size_t &num_elements)
This function template deserializes a wide-string sequence.
Definition Cdr.h:2655
TEMPLATE_SPEC Cdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition Cdr.h:837
Cdr_DllAPI Cdr & deserialize(float &float_t)
This function deserializes a float.
Cdr_DllAPI Cdr & serialize(const bool bool_t)
This function serializes a boolean.
This class represents a stream of bytes that contains (or will contain) serialized data.
Definition FastBuffer.h:244
_FastBuffer_iterator iterator
Definition FastBuffer.h:247
Definition MemberId.hpp:28
This class is thrown as an exception when an invalid parameter is being serialized.
Definition BadParamException.h:28
This abstract class is used to create exceptions.
Definition Exception.h:30
virtual void raise() const =0
This function throws the object as exception.
This class is thrown as an exception when the buffer's internal memory reachs its size limit.
Definition NotEnoughMemoryException.h:28
static const char *const NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT
Default message used in the library.
Definition NotEnoughMemoryException.h:78
This class template manages an external member, a member declared to be external to the storage of a ...
Definition external.hpp:30
bool is_locked() const noexcept
Checks if locked.
Definition external.hpp:168
T type
Definition external.hpp:33
This class template manages an optional contained value, i.e.
Definition optional.hpp:47
void reset(bool initial_engaged=false)
Reset the state of the optional.
Definition optional.hpp:109
bool has_value() const
Checks whether the optional contains a value.
Definition optional.hpp:196
EncodingAlgorithmFlag
This enumeration represents the supported XCDR encoding algorithms.
Definition CdrEncoding.hpp:38
@ PL_CDR2
Specifies that the content is PL_CDR2.
Definition CdrEncoding.hpp:48
@ PLAIN_CDR
Specifies that the content is PLAIN_CDR.
Definition CdrEncoding.hpp:40
@ PLAIN_CDR2
Specifies that the content is PLAIN_CDR2.
Definition CdrEncoding.hpp:44
static const MemberId MEMBER_ID_INVALID
Definition MemberId.hpp:67
constexpr bool is_multi_array_primitive(...)
Basis.
Definition container_recursive_inspector.hpp:27
void deserialize(Cdr &, _T &)
CdrVersion
This enumeration represents the kinds of CDR serialization supported by eprosima::fastcdr::CDR.
Definition CdrEncoding.hpp:25
@ XCDRv2
XCDRv2 encoding defined by standard DDS X-Types 1.3.
Definition CdrEncoding.hpp:33
void serialize(Cdr &, const _T &)
Template class for non-alloc strings.
Definition fixed_size_string.hpp:45
const char * c_str() const noexcept
Converts to C string.
Definition fixed_size_string.hpp:153