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);
2029 for (uint32_t i = 0; i < sequence_length; ++i)
2035 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2054 template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value ||
2055 std::is_arithmetic<_T>::value>::type* =
nullptr>
2057 std::map<_K, _T>& map_t)
2059 uint32_t sequence_length = 0;
2060 state state_(*
this);
2066 for (uint32_t i = 0; i < sequence_length; ++i)
2072 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2091 template<
size_t N,
typename std::enable_if < (N < 9) > ::type* =
nullptr>
2093 std::bitset<N>& value)
2095 u
int8_t decode_value {0};
2096 deserialize(decode_value);
2097 value = decode_value;
2101 template<
size_t N,
typename std::enable_if < (8 < N && N < 17) > ::type* =
nullptr>
2103 std::bitset<N>& value)
2105 u
int16_t decode_value {0};
2106 deserialize(decode_value);
2107 value = decode_value;
2111 template<
size_t N,
typename std::enable_if < (16 < N && N < 33) > ::type* =
nullptr>
2113 std::bitset<N>& value)
2115 u
int32_t decode_value {0};
2116 deserialize(decode_value);
2117 value = decode_value;
2121 template<
size_t N,
typename std::enable_if < (32 < N && N < 65) > ::type* =
nullptr>
2123 std::bitset<N>& value)
2125 u
int64_t decode_value {0};
2126 deserialize(decode_value);
2127 value = decode_value;
2145 size_t num_elements)
2147 for (
size_t count = 0; count < num_elements; ++count)
2165 size_t num_elements,
2168 bool aux_swap = swap_bytes_;
2175 swap_bytes_ = aux_swap;
2179 swap_bytes_ = aux_swap;
2196 size_t num_elements)
2210 size_t num_elements);
2222 size_t num_elements)
2237 size_t num_elements)
2251 size_t num_elements);
2263 size_t num_elements)
2277 size_t num_elements);
2288 size_t num_elements);
2299 uint64_t* ulonglong_t,
2300 size_t num_elements)
2302 return deserialize_array(
reinterpret_cast<int64_t*
>(ulonglong_t), num_elements);
2313 int64_t* longlong_t,
2314 size_t num_elements);
2325 size_t num_elements);
2336 size_t num_elements);
2347 long double* ldouble_t,
2348 size_t num_elements);
2359 size_t num_elements);
2371 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2372 std::is_arithmetic<_T>::value>::type* =
nullptr>
2374 std::vector<_T>& value)
2391 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2392 !std::is_arithmetic<_T>::value>::type* =
nullptr>
2394 std::vector<_T>& value)
2398 uint32_t dheader {0};
2402 auto offset = offset_;
2403 while (offset_ - offset < dheader && count < value.size())
2409 if (offset_ - offset != dheader)
2435 std::vector<_T>& value,
2438 bool aux_swap = swap_bytes_;
2445 swap_bytes_ = aux_swap;
2449 swap_bytes_ = aux_swap;
2468 std::vector<bool>& value)
2470 deserialize_bool_array(value);
2484 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2485 !std::is_arithmetic<_T>::value>::type* =
nullptr>
2488 size_t& num_elements)
2490 uint32_t sequence_length {0};
2494 uint32_t dheader {0};
2497 auto offset = offset_;
2503 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2506 while (offset_ - offset < dheader && count < sequence_length)
2512 if (offset_ - offset != dheader)
2526 state state_before_error(*
this);
2530 if ((end_ - offset_) < sequence_length)
2539 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2551 num_elements = sequence_length;
2564 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2565 std::is_arithmetic<_T>::value>::type* =
nullptr>
2568 size_t& num_elements)
2570 uint32_t sequence_length = 0;
2571 state state_before_error(*
this);
2577 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2588 num_elements = sequence_length;
2605 size_t& num_elements,
2608 bool aux_swap = swap_bytes_;
2615 swap_bytes_ = aux_swap;
2619 swap_bytes_ = aux_swap;
2637 std::string*& sequence_t,
2638 size_t& num_elements)
2640 return deserialize_string_sequence(sequence_t, num_elements);
2654 std::wstring*& sequence_t,
2655 size_t& num_elements)
2657 return deserialize_wstring_sequence(sequence_t, num_elements);
2677 const _T& member_value,
2681 (this->*begin_serialize_member_)(member_id,
true, current_state, header_selection);
2683 return (this->*end_serialize_member_)(current_state);
2703 (this->*begin_serialize_opt_member_)(member_id, member_value.
has_value(), current_state, header_selection);
2705 return (this->*end_serialize_opt_member_)(current_state);
2737 xcdr1_deserialize_member_header(member_id, current_state);
2738 auto prev_offset = offset_;
2739 if (0 < current_state.member_size_)
2743 if (current_state.member_size_ != offset_ - prev_offset)
2746 "Member size provided by member header is not equal to the real decoded member size");
2768 return (this->*begin_serialize_type_)(current_state, type_encoding);
2781 return (this->*end_serialize_type_)(current_state);
2794 std::function<
bool (
Cdr&,
const MemberId&)> functor)
2796 return (this->*deserialize_type_)(type_encoding, functor);
2858 next_member_id_ = member_id;
2873 bool is_present =
true;
2878 value.
reset(is_present);
2924 if (value.has_value() && value.value().is_locked())
2929 bool is_present =
true;
2934 value.reset(is_present);
2961 const Cdr&) =
delete;
2964 const Cdr&) =
delete;
2966 Cdr_DllAPI
Cdr& serialize_bool_array(
2967 const std::vector<bool>& vector_t);
2969 Cdr_DllAPI
Cdr& serialize_bool_sequence(
2970 const std::vector<bool>& vector_t);
2972 Cdr_DllAPI
Cdr& deserialize_bool_array(
2973 std::vector<bool>& vector_t);
2975 Cdr_DllAPI
Cdr& deserialize_bool_sequence(
2976 std::vector<bool>& vector_t);
2978 Cdr_DllAPI
Cdr& deserialize_string_sequence(
2979 std::string*& sequence_t,
2980 size_t& num_elements);
2982 Cdr_DllAPI
Cdr& deserialize_wstring_sequence(
2983 std::wstring*& sequence_t,
2984 size_t& num_elements);
2993 template<
class _T,
size_t _Size>
2995 const std::array<_T, _Size>* array_t,
2996 size_t num_elements)
2998 return serialize_array(array_t->data(), num_elements * array_t->size());
3008 template<
class _T,
size_t _Size>
3010 std::array<_T, _Size>* array_t,
3011 size_t num_elements)
3024 template<
class _T,
size_t _Size>
3026 std::array<_T, _Size>* array_t,
3027 size_t num_elements,
3040 size_t data_size)
const
3042 return data_size > last_data_size_ ? (data_size - ((offset_ - origin_) % data_size)) & (data_size - 1) : 0;
3049 inline void make_alignment(
3053 last_data_size_ = 0;
3062 size_t min_size_inc);
3064 Cdr_DllAPI
const char* read_string(
3066 Cdr_DllAPI
const std::wstring read_wstring(
3079 void xcdr1_serialize_short_member_header(
3080 const MemberId& member_id);
3091 void xcdr1_end_short_member_header(
3092 const MemberId& member_id,
3093 size_t member_serialized_size);
3101 void xcdr1_serialize_long_member_header(
3102 const MemberId& member_id);
3111 void xcdr1_end_long_member_header(
3112 const MemberId& member_id,
3113 size_t member_serialized_size);
3124 void xcdr1_change_to_short_member_header(
3125 const MemberId& member_id,
3126 size_t member_serialized_size);
3135 void xcdr1_change_to_long_member_header(
3136 const MemberId& member_id,
3137 size_t member_serialized_size);
3147 Cdr_DllAPI
bool xcdr1_deserialize_member_header(
3148 MemberId& member_id,
3149 Cdr::state& current_state);
3158 void xcdr2_serialize_short_member_header(
3159 const MemberId& member_id);
3170 void xcdr2_end_short_member_header(
3171 const MemberId& member_id,
3172 size_t member_serialized_size);
3181 void xcdr2_serialize_long_member_header(
3182 const MemberId& member_id);
3192 void xcdr2_end_long_member_header(
3193 const MemberId& member_id,
3194 size_t member_serialized_size);
3205 void xcdr2_change_to_short_member_header(
3206 const MemberId& member_id,
3207 size_t member_serialized_size);
3217 void xcdr2_change_to_long_member_header(
3218 const MemberId& member_id,
3219 size_t member_serialized_size);
3229 void xcdr2_shrink_to_long_member_header(
3230 const MemberId& member_id,
3241 void xcdr2_deserialize_member_header(
3242 MemberId& member_id,
3243 Cdr::state& current_state);
3261 Cdr& xcdr1_begin_serialize_member(
3262 const MemberId& member_id,
3264 Cdr::state& current_state,
3277 Cdr& xcdr1_end_serialize_member(
3278 const Cdr::state& current_state);
3295 Cdr& xcdr1_begin_serialize_opt_member(
3296 const MemberId& member_id,
3298 Cdr::state& current_state,
3311 Cdr& xcdr1_end_serialize_opt_member(
3312 const Cdr::state& current_state);
3330 Cdr& xcdr2_begin_serialize_member(
3331 const MemberId& member_id,
3333 Cdr::state& current_state,
3346 Cdr& xcdr2_end_serialize_member(
3347 const Cdr::state& current_state);
3358 Cdr& xcdr1_begin_serialize_type(
3359 Cdr::state& current_state,
3370 Cdr& xcdr1_end_serialize_type(
3371 const Cdr::state& current_state);
3386 Cdr& xcdr2_begin_serialize_type(
3387 Cdr::state& current_state,
3399 Cdr& xcdr2_end_serialize_type(
3400 const Cdr::state& current_state);
3414 Cdr& xcdr1_deserialize_type(
3416 std::function<
bool (Cdr&,
const MemberId&)> functor);
3431 Cdr& xcdr2_deserialize_type(
3433 std::function<
bool (Cdr&,
const MemberId&)> functor);
3435 Cdr& cdr_begin_serialize_member(
3436 const MemberId& member_id,
3438 Cdr::state& current_state,
3441 Cdr& cdr_end_serialize_member(
3442 const Cdr::state& current_state);
3444 Cdr& cdr_begin_serialize_type(
3445 Cdr::state& current_state,
3448 Cdr& cdr_end_serialize_type(
3449 const Cdr::state& current_state);
3451 Cdr& cdr_deserialize_type(
3453 std::function<
bool (Cdr&,
const MemberId&)> functor);
3458 void reset_callbacks();
3460 using begin_serialize_member_functor =
Cdr& (
Cdr::*)(
3465 begin_serialize_member_functor begin_serialize_member_ {
nullptr };
3467 using end_serialize_member_functor =
Cdr& (
Cdr::*)(
3469 end_serialize_member_functor end_serialize_member_ {
nullptr };
3471 using begin_serialize_opt_member_functor =
Cdr& (
Cdr::*)(
3476 begin_serialize_opt_member_functor begin_serialize_opt_member_ {
nullptr };
3478 using end_serialize_memberopt__functor =
Cdr& (
Cdr::*)(
3480 end_serialize_member_functor end_serialize_opt_member_ {
nullptr };
3482 using begin_serialize_type_functor =
Cdr& (
Cdr::*)(
3485 begin_serialize_type_functor begin_serialize_type_ {
nullptr };
3487 using end_serialize_type_functor =
Cdr& (
Cdr::*)(
3489 end_serialize_type_functor end_serialize_type_ {
nullptr };
3491 using deserialize_type_functor =
Cdr& (
Cdr::*)(
3493 std::function<
bool (Cdr&,
const MemberId&)>);
3494 deserialize_type_functor deserialize_type_ {
nullptr };
3497 FastBuffer& cdr_buffer_;
3509 std::array<uint8_t, 2> options_{{0}};
3515 bool swap_bytes_ {
false};
3518 size_t last_data_size_ {0};
3530 MemberId next_member_id_;
3533 size_t align64_ {4};
3539 enum SerializedMemberSizeForNextInt
3541 NO_SERIALIZED_MEMBER_SIZE,
3542 SERIALIZED_MEMBER_SIZE,
3543 SERIALIZED_MEMBER_SIZE_4,
3544 SERIALIZED_MEMBER_SIZE_8
3547 serialized_member_size_ {NO_SERIALIZED_MEMBER_SIZE};
3550 uint32_t get_long_lc(
3551 SerializedMemberSizeForNextInt serialized_member_size);
3553 uint32_t get_short_lc(
3554 size_t member_serialized_size);
3556 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
3557 std::is_arithmetic<_T>::value>::type* =
nullptr>
3558 constexpr SerializedMemberSizeForNextInt get_serialized_member_size()
const
3560 return (1 ==
sizeof(_T) ? SERIALIZED_MEMBER_SIZE :
3561 (4 == sizeof(_T) ? SERIALIZED_MEMBER_SIZE_4 :
3562 (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:2807
TEMPLATE_SPEC Cdr & deserialize_array(uint16_t *ushort_t, size_t num_elements)
This function deserializes an array of unsigned shorts.
Definition Cdr.h:2235
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:2764
Cdr & deserialize_array(std::vector< _T > &value)
Decodes an array of primitives on a std::vector.
Definition Cdr.h:2373
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:2730
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:2603
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:2778
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:2921
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:2716
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:2220
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:2163
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:2486
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:2143
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:2194
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:2298
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:2636
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:2467
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:2792
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:2870
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:2675
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:2261
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:2434
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:2895
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:2697
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:2831
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:2653
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