15#ifndef _FASTCDR_CDR_H_
16#define _FASTCDR_CDR_H_
30#include "fastcdr_dll.h"
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"
43#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
75 typedef enum : uint8_t
122 const state& other_state)
const;
136 bool swap_bytes_ {
false};
139 size_t last_data_size_ {0};
145 uint32_t member_size_ {0};
223 const std::array<uint8_t, 2>& options);
276 size_t current_alignment,
279 return (data_size - (current_alignment % data_size)) & (data_size - 1);
380 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* =
nullptr,
typename =
void>
401 bool aux_swap = swap_bytes_;
408 swap_bytes_ = aux_swap;
412 swap_bytes_ = aux_swap;
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>
434 return serialize(
static_cast<int32_t
>(value));
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>
452 return serialize(
static_cast<uint32_t
>(value));
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>
470 return serialize(
static_cast<int16_t
>(value));
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>
488 return serialize(
static_cast<uint16_t
>(value));
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>
506 return serialize(
static_cast<int8_t
>(value));
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>
524 return serialize(
static_cast<uint8_t
>(value));
534 const uint8_t& octet_t);
561 const uint16_t ushort_t);
570 const int16_t short_t);
579 const uint32_t ulong_t);
588 const int32_t long_t);
597 const wchar_t wchar);
606 const uint64_t ulonglong_t);
615 const int64_t longlong_t);
624 const float float_t);
633 const double double_t);
643 const long double ldouble_t);
670 const char* string_t);
679 const wchar_t* string_t);
690 const std::string& string_t)
693 const char* c_str = string_t.c_str();
694 const auto str_len = strlen(c_str);
695 if (string_t.size() > str_len)
711 const std::wstring& string_t)
723 template <
size_t MAX_CHARS>
736 template<
class _T,
size_t _Size>
738 const std::array<_T, _Size>& array_t)
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)
769 serialize(
static_cast<int32_t
>(vector_t.size()));
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)
797 state state_before_error(*
this);
799 serialize(
static_cast<int32_t
>(vector_t.size()));
813 serialized_member_size_ = get_serialized_member_size<_T>();
827 const std::vector<bool>& vector_t)
829 return serialize_bool_sequence(vector_t);
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)
845 serialize(
static_cast<int32_t
>(map_t.size()));
849 for (
auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
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)
879 serialize(
static_cast<int32_t
>(map_t.size()));
883 for (
auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
906 template<
size_t N,
typename std::enable_if < (N < 9) > ::type* =
nullptr>
908 const std::bitset<N>& value)
910 return serialize(static_cast<u
int8_t>(value.to_u
long()));
913 template<
size_t N,
typename std::enable_if < (8 < N && N < 17) > ::type* =
nullptr>
915 const std::bitset<N>& value)
917 return serialize(static_cast<u
int16_t>(value.to_u
long()));
920 template<
size_t N,
typename std::enable_if < (16 < N && N < 33) > ::type* =
nullptr>
922 const std::bitset<N>& value)
924 return serialize(static_cast<u
int32_t>(value.to_u
long()));
927 template<
size_t N,
typename std::enable_if < (32 < N && N < 65) > ::type* =
nullptr>
929 const std::bitset<N>& value)
931 return serialize(static_cast<u
int64_t>(value.to_ul
long()));
950 for (
size_t count = 0; count < num_elements; ++count)
971 bool aux_swap = swap_bytes_;
978 swap_bytes_ = aux_swap;
982 swap_bytes_ = aux_swap;
998 const uint8_t* octet_t,
1001 return serialize_array(
reinterpret_cast<const char*
>(octet_t), num_elements);
1013 size_t num_elements);
1025 size_t num_elements)
1027 return serialize_array(
reinterpret_cast<const char*
>(int8), num_elements);
1039 const uint16_t* ushort_t,
1040 size_t num_elements)
1042 return serialize_array(
reinterpret_cast<const int16_t*
>(ushort_t), num_elements);
1053 const int16_t* short_t,
1054 size_t num_elements);
1065 const uint32_t* ulong_t,
1066 size_t num_elements)
1068 return serialize_array(
reinterpret_cast<const int32_t*
>(ulong_t), num_elements);
1079 const int32_t* long_t,
1080 size_t num_elements);
1090 const wchar_t* wchar,
1091 size_t num_elements);
1102 const uint64_t* ulonglong_t,
1103 size_t num_elements)
1105 return serialize_array(
reinterpret_cast<const int64_t*
>(ulonglong_t), num_elements);
1116 const int64_t* longlong_t,
1117 size_t num_elements);
1127 const float* float_t,
1128 size_t num_elements);
1138 const double* double_t,
1139 size_t num_elements);
1150 const long double* ldouble_t,
1151 size_t num_elements);
1162 size_t num_elements);
1173 const std::string* string_t,
1174 size_t num_elements)
1176 for (
size_t count = 0; count < num_elements; ++count)
1192 const std::wstring* string_t,
1193 size_t num_elements)
1195 for (
size_t count = 0; count < num_elements; ++count)
1210 template<
size_t MAX_CHARS>
1213 size_t num_elements)
1215 for (
size_t count = 0; count < num_elements; ++count)
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)
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)
1270 const std::vector<_T>& value,
1273 bool aux_swap = swap_bytes_;
1280 swap_bytes_ = aux_swap;
1284 swap_bytes_ = aux_swap;
1300 const std::vector<bool>& value)
1302 serialize_bool_array(value);
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)
1322 serialize(
static_cast<int32_t
>(num_elements));
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)
1352 state state_before_error(*
this);
1354 serialize(
static_cast<int32_t
>(num_elements));
1368 serialized_member_size_ = get_serialized_member_size<_T>();
1384 const _T* sequence_t,
1385 size_t num_elements,
1388 bool aux_swap = swap_bytes_;
1395 swap_bytes_ = aux_swap;
1399 swap_bytes_ = aux_swap;
1416 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* =
nullptr,
typename =
void>
1437 bool aux_swap = swap_bytes_;
1444 swap_bytes_ = aux_swap;
1448 swap_bytes_ = aux_swap;
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>
1469 int32_t decode_value {0};
1471 value =
static_cast<_T
>(decode_value);
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>
1489 uint32_t decode_value {0};
1491 value =
static_cast<_T
>(decode_value);
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>
1509 int16_t decode_value {0};
1511 value =
static_cast<_T
>(decode_value);
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>
1529 uint16_t decode_value {0};
1531 value =
static_cast<_T
>(decode_value);
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>
1549 int8_t decode_value {0};
1551 value =
static_cast<_T
>(decode_value);
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>
1569 uint8_t decode_value {0};
1571 value =
static_cast<_T
>(decode_value);
1585 return deserialize(
reinterpret_cast<char&
>(octet_t));
1607 return deserialize(
reinterpret_cast<char&
>(int8));
1620 return deserialize(
reinterpret_cast<int16_t&
>(ushort_t));
1642 return deserialize(
reinterpret_cast<int32_t&
>(ulong_t));
1666 wchar =
static_cast<wchar_t>(ret);
1678 uint64_t& ulonglong_t)
1680 return deserialize(
reinterpret_cast<int64_t&
>(ulonglong_t));
1690 int64_t& longlong_t);
1718 long double& ldouble_t);
1750 wchar_t*& string_t);
1760 std::string& string_t)
1762 uint32_t length = 0;
1763 const char* str = read_string(length);
1764 string_t.assign(str, length);
1776 std::wstring& string_t)
1778 uint32_t length = 0;
1779 string_t = read_wstring(length);
1790 template <
size_t MAX_CHARS>
1794 uint32_t length = 0;
1795 const char* str = read_string(length);
1796 value.
assign(str, length);
1806 template<
class _T,
size_t _Size>
1808 std::array<_T, _Size>& array_t)
1812 uint32_t dheader {0};
1816 auto offset = offset_;
1817 while (offset_ - offset < dheader && count < _Size)
1823 if (offset_ - offset != dheader)
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)
1847 uint32_t sequence_length {0};
1851 uint32_t dheader {0};
1854 auto offset = offset_;
1858 if (0 == sequence_length)
1865 vector_t.resize(sequence_length);
1869 while (offset_ - offset < dheader && count < sequence_length)
1875 if (offset_ - offset != dheader)
1882 state state_before_error(*
this);
1886 if (sequence_length == 0)
1892 if ((end_ - offset_) < sequence_length)
1901 vector_t.resize(sequence_length);
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)
1925 uint32_t sequence_length = 0;
1926 state state_before_error(*
this);
1930 if (sequence_length == 0)
1936 if ((end_ - offset_) < sequence_length)
1945 vector_t.resize(sequence_length);
1965 std::vector<bool>& vector_t)
1967 return deserialize_bool_sequence(vector_t);
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)
1983 uint32_t dheader {0};
1986 auto offset = offset_;
1988 uint32_t map_length {0};
1994 while (offset_ - offset < dheader && count < map_length)
2000 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(val)));
2004 if (offset_ - offset != dheader)
2011 uint32_t sequence_length = 0;
2012 state state_(*
this);
2020 for (uint32_t i = 0; i < sequence_length; ++i)
2026 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
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)
2050 uint32_t sequence_length = 0;
2051 state state_(*
this);
2057 for (uint32_t i = 0; i < sequence_length; ++i)
2063 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2082 template<
size_t N,
typename std::enable_if < (N < 9) > ::type* =
nullptr>
2084 std::bitset<N>& value)
2086 u
int8_t decode_value {0};
2087 deserialize(decode_value);
2088 value = decode_value;
2092 template<
size_t N,
typename std::enable_if < (8 < N && N < 17) > ::type* =
nullptr>
2094 std::bitset<N>& value)
2096 u
int16_t decode_value {0};
2097 deserialize(decode_value);
2098 value = decode_value;
2102 template<
size_t N,
typename std::enable_if < (16 < N && N < 33) > ::type* =
nullptr>
2104 std::bitset<N>& value)
2106 u
int32_t decode_value {0};
2107 deserialize(decode_value);
2108 value = decode_value;
2112 template<
size_t N,
typename std::enable_if < (32 < N && N < 65) > ::type* =
nullptr>
2114 std::bitset<N>& value)
2116 u
int64_t decode_value {0};
2117 deserialize(decode_value);
2118 value = decode_value;
2136 size_t num_elements)
2138 for (
size_t count = 0; count < num_elements; ++count)
2156 size_t num_elements,
2159 bool aux_swap = swap_bytes_;
2166 swap_bytes_ = aux_swap;
2170 swap_bytes_ = aux_swap;
2187 size_t num_elements)
2201 size_t num_elements);
2213 size_t num_elements)
2228 size_t num_elements)
2242 size_t num_elements);
2254 size_t num_elements)
2268 size_t num_elements);
2279 size_t num_elements);
2290 uint64_t* ulonglong_t,
2291 size_t num_elements)
2293 return deserialize_array(
reinterpret_cast<int64_t*
>(ulonglong_t), num_elements);
2304 int64_t* longlong_t,
2305 size_t num_elements);
2316 size_t num_elements);
2327 size_t num_elements);
2338 long double* ldouble_t,
2339 size_t num_elements);
2350 size_t num_elements);
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)
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)
2389 uint32_t dheader {0};
2393 auto offset = offset_;
2394 while (offset_ - offset < dheader && count < value.size())
2400 if (offset_ - offset != dheader)
2426 std::vector<_T>& value,
2429 bool aux_swap = swap_bytes_;
2436 swap_bytes_ = aux_swap;
2440 swap_bytes_ = aux_swap;
2459 std::vector<bool>& value)
2461 deserialize_bool_array(value);
2475 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2476 !std::is_arithmetic<_T>::value>::type* =
nullptr>
2479 size_t& num_elements)
2481 uint32_t sequence_length {0};
2485 uint32_t dheader {0};
2488 auto offset = offset_;
2494 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2497 while (offset_ - offset < dheader && count < sequence_length)
2503 if (offset_ - offset != dheader)
2517 state state_before_error(*
this);
2521 if ((end_ - offset_) < sequence_length)
2530 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2542 num_elements = sequence_length;
2555 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2556 std::is_arithmetic<_T>::value>::type* =
nullptr>
2559 size_t& num_elements)
2561 uint32_t sequence_length = 0;
2562 state state_before_error(*
this);
2568 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
2579 num_elements = sequence_length;
2596 size_t& num_elements,
2599 bool aux_swap = swap_bytes_;
2606 swap_bytes_ = aux_swap;
2610 swap_bytes_ = aux_swap;
2628 std::string*& sequence_t,
2629 size_t& num_elements)
2631 return deserialize_string_sequence(sequence_t, num_elements);
2645 std::wstring*& sequence_t,
2646 size_t& num_elements)
2648 return deserialize_wstring_sequence(sequence_t, num_elements);
2668 const _T& member_value,
2672 (this->*begin_serialize_member_)(member_id,
true, current_state, header_selection);
2674 return (this->*end_serialize_member_)(current_state);
2694 (this->*begin_serialize_opt_member_)(member_id, member_value.
has_value(), current_state, header_selection);
2696 return (this->*end_serialize_opt_member_)(current_state);
2728 xcdr1_deserialize_member_header(member_id, current_state);
2729 auto prev_offset = offset_;
2730 if (0 < current_state.member_size_)
2734 if (current_state.member_size_ != offset_ - prev_offset)
2737 "Member size provided by member header is not equal to the real decoded member size");
2779 std::function<
bool (
Cdr&,
const MemberId&)> functor);
2846 bool is_present =
true;
2851 value.
reset(is_present);
2897 if (value.has_value() && value.value().is_locked())
2902 bool is_present =
true;
2907 value.reset(is_present);
2934 const Cdr&) =
delete;
2937 const Cdr&) =
delete;
2939 Cdr_DllAPI
Cdr& serialize_bool_array(
2940 const std::vector<bool>& vector_t);
2942 Cdr_DllAPI
Cdr& serialize_bool_sequence(
2943 const std::vector<bool>& vector_t);
2945 Cdr_DllAPI
Cdr& deserialize_bool_array(
2946 std::vector<bool>& vector_t);
2948 Cdr_DllAPI
Cdr& deserialize_bool_sequence(
2949 std::vector<bool>& vector_t);
2951 Cdr_DllAPI
Cdr& deserialize_string_sequence(
2952 std::string*& sequence_t,
2953 size_t& num_elements);
2955 Cdr_DllAPI
Cdr& deserialize_wstring_sequence(
2956 std::wstring*& sequence_t,
2957 size_t& num_elements);
2966 template<
class _T,
size_t _Size>
2968 const std::array<_T, _Size>* array_t,
2969 size_t num_elements)
2971 return serialize_array(array_t->data(), num_elements * array_t->size());
2981 template<
class _T,
size_t _Size>
2983 std::array<_T, _Size>* array_t,
2984 size_t num_elements)
2997 template<
class _T,
size_t _Size>
2999 std::array<_T, _Size>* array_t,
3000 size_t num_elements,
3013 size_t data_size)
const
3015 return data_size > last_data_size_ ? (data_size - ((offset_ - origin_) % data_size)) & (data_size - 1) : 0;
3022 inline void make_alignment(
3026 last_data_size_ = 0;
3035 size_t min_size_inc);
3037 Cdr_DllAPI
const char* read_string(
3039 Cdr_DllAPI
const std::wstring read_wstring(
3052 void xcdr1_serialize_short_member_header(
3053 const MemberId& member_id);
3064 void xcdr1_end_short_member_header(
3065 const MemberId& member_id,
3066 size_t member_serialized_size);
3074 void xcdr1_serialize_long_member_header(
3075 const MemberId& member_id);
3084 void xcdr1_end_long_member_header(
3085 const MemberId& member_id,
3086 size_t member_serialized_size);
3097 void xcdr1_change_to_short_member_header(
3098 const MemberId& member_id,
3099 size_t member_serialized_size);
3108 void xcdr1_change_to_long_member_header(
3109 const MemberId& member_id,
3110 size_t member_serialized_size);
3120 Cdr_DllAPI
bool xcdr1_deserialize_member_header(
3121 MemberId& member_id,
3122 Cdr::state& current_state);
3131 void xcdr2_serialize_short_member_header(
3132 const MemberId& member_id);
3143 void xcdr2_end_short_member_header(
3144 const MemberId& member_id,
3145 size_t member_serialized_size);
3154 void xcdr2_serialize_long_member_header(
3155 const MemberId& member_id);
3165 void xcdr2_end_long_member_header(
3166 const MemberId& member_id,
3167 size_t member_serialized_size);
3178 void xcdr2_change_to_short_member_header(
3179 const MemberId& member_id,
3180 size_t member_serialized_size);
3190 void xcdr2_change_to_long_member_header(
3191 const MemberId& member_id,
3192 size_t member_serialized_size);
3202 void xcdr2_shrink_to_long_member_header(
3203 const MemberId& member_id,
3214 void xcdr2_deserialize_member_header(
3215 MemberId& member_id,
3216 Cdr::state& current_state);
3234 Cdr& xcdr1_begin_serialize_member(
3235 const MemberId& member_id,
3237 Cdr::state& current_state,
3250 Cdr& xcdr1_end_serialize_member(
3251 const Cdr::state& current_state);
3268 Cdr& xcdr1_begin_serialize_opt_member(
3269 const MemberId& member_id,
3271 Cdr::state& current_state,
3284 Cdr& xcdr1_end_serialize_opt_member(
3285 const Cdr::state& current_state);
3303 Cdr& xcdr2_begin_serialize_member(
3304 const MemberId& member_id,
3306 Cdr::state& current_state,
3319 Cdr& xcdr2_end_serialize_member(
3320 const Cdr::state& current_state);
3331 Cdr& xcdr1_begin_serialize_type(
3332 Cdr::state& current_state,
3343 Cdr& xcdr1_end_serialize_type(
3344 const Cdr::state& current_state);
3359 Cdr& xcdr2_begin_serialize_type(
3360 Cdr::state& current_state,
3372 Cdr& xcdr2_end_serialize_type(
3373 const Cdr::state& current_state);
3387 Cdr& xcdr1_deserialize_type(
3389 std::function<
bool (Cdr&,
const MemberId&)> functor);
3404 Cdr& xcdr2_deserialize_type(
3406 std::function<
bool (Cdr&,
const MemberId&)> functor);
3408 Cdr& cdr_begin_serialize_member(
3409 const MemberId& member_id,
3411 Cdr::state& current_state,
3414 Cdr& cdr_end_serialize_member(
3415 const Cdr::state& current_state);
3417 Cdr& cdr_begin_serialize_type(
3418 Cdr::state& current_state,
3421 Cdr& cdr_end_serialize_type(
3422 const Cdr::state& current_state);
3424 Cdr& cdr_deserialize_type(
3426 std::function<
bool (Cdr&,
const MemberId&)> functor);
3431 void reset_callbacks();
3433 using begin_serialize_member_functor =
Cdr& (
Cdr::*)(
3438 begin_serialize_member_functor begin_serialize_member_ {
nullptr };
3440 using end_serialize_member_functor =
Cdr& (
Cdr::*)(
3442 end_serialize_member_functor end_serialize_member_ {
nullptr };
3444 using begin_serialize_opt_member_functor =
Cdr& (
Cdr::*)(
3449 begin_serialize_opt_member_functor begin_serialize_opt_member_ {
nullptr };
3451 using end_serialize_memberopt__functor =
Cdr& (
Cdr::*)(
3453 end_serialize_member_functor end_serialize_opt_member_ {
nullptr };
3455 using begin_serialize_type_functor =
Cdr& (
Cdr::*)(
3458 begin_serialize_type_functor begin_serialize_type_ {
nullptr };
3460 using end_serialize_type_functor =
Cdr& (
Cdr::*)(
3462 end_serialize_type_functor end_serialize_type_ {
nullptr };
3464 using deserialize_type_functor =
Cdr& (
Cdr::*)(
3466 std::function<
bool (Cdr&,
const MemberId&)>);
3467 deserialize_type_functor deserialize_type_ {
nullptr };
3470 FastBuffer& cdr_buffer_;
3482 std::array<uint8_t, 2> options_{{0}};
3488 bool swap_bytes_ {
false};
3491 size_t last_data_size_ {0};
3503 MemberId next_member_id_;
3506 size_t align64_ {4};
3512 enum SerializedMemberSizeForNextInt
3514 NO_SERIALIZED_MEMBER_SIZE,
3515 SERIALIZED_MEMBER_SIZE,
3516 SERIALIZED_MEMBER_SIZE_4,
3517 SERIALIZED_MEMBER_SIZE_8
3520 serialized_member_size_ {NO_SERIALIZED_MEMBER_SIZE};
3523 state initial_state_;
3526 bool encapsulation_serialized_ {
false};
3529 uint32_t get_long_lc(
3530 SerializedMemberSizeForNextInt serialized_member_size);
3532 uint32_t get_short_lc(
3533 size_t member_serialized_size);
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
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)));
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:106
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:69
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:306
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_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:710
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:2789
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 & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition Cdr.h:1617
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.
Cdr & deserialize_array(std::vector< _T > &value)
Decodes an array of primitives on a std::vector.
Definition Cdr.h:2364
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
static Cdr_DllAPI const Endianness DEFAULT_ENDIAN
Default endianess in the system.
Definition Cdr.h:84
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
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 & 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:1807
TEMPLATE_SPEC Cdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition Cdr.h:1604
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:1759
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:764
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.
XCdrHeaderSelection
Used to decide, in encoding algorithms where member headers support a short header version and a long...
Definition Cdr.h:91
@ AUTO_WITH_SHORT_HEADER_BY_DEFAULT
Initially a short member header is allocated but can be changed to the longer version.
Definition Cdr.h:97
@ SHORT_HEADER
Initially a short member header is allocated and cannot be changed. This option may cause an exceptio...
Definition Cdr.h:93
@ AUTO_WITH_LONG_HEADER_BY_DEFAULT
Initially a long member header is allocated but can be changed to the shorter version.
Definition Cdr.h:99
@ LONG_HEADER
Initially a long member header is allocated and cannot be changed.
Definition Cdr.h:95
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:1639
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:2594
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(std::map< _K, _T > &map_t)
This function template deserializes a map of non-primitive.
Definition Cdr.h:1978
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.
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:1661
Cdr & deserialize(optional< external< _T > > &value)
Decodes an optional of an external from the buffer.
Definition Cdr.h:2894
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_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:2707
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:1433
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_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:1417
Cdr_DllAPI Cdr & deserialize(wchar_t *&string_t)
This function deserializes a wide-string.
Endianness
This enumeration represents endianness types.
Definition Cdr.h:76
@ LITTLE_ENDIANNESS
Little endianness.
Definition Cdr.h:80
@ BIG_ENDIANNESS
Big endianness.
Definition Cdr.h:78
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(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition Cdr.h:1677
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:840
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:1023
TEMPLATE_SPEC Cdr & serialize_array(const std::vector< bool > &value)
Encodes an std::vector of booleans as an array.
Definition Cdr.h:1299
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:2154
Cdr & serialize_array(const fixed_string< MAX_CHARS > *value, size_t num_elements)
Encodes an array of fixed strings.
Definition Cdr.h:1211
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
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:2477
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
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:2185
Cdr_DllAPI Cdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Cdr & serialize_array(const std::vector< _T > &value)
Encodes an std::vector of primitives as an array.
Definition Cdr.h:1231
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:2289
Cdr & serialize(const fixed_string< MAX_CHARS > &value)
Encodes a eprosima::fastcdr::fixed_string in the buffer.
Definition Cdr.h:724
TEMPLATE_SPEC Cdr & deserialize_sequence(std::string *&sequence_t, size_t &num_elements)
This function template deserializes a string sequence.
Definition Cdr.h:2627
TEMPLATE_SPEC Cdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence.
Definition Cdr.h:1964
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:2458
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:1582
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.
TEMPLATE_SPEC Cdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition Cdr.h:689
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:2843
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.
Cdr & operator>>(_T &value)
Decodes the value from the buffer.
Definition Cdr.h:356
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:2666
Cdr_DllAPI Cdr & serialize(char *string_t)
This function serializes a string.
Cdr & deserialize(fixed_string< MAX_CHARS > &value)
Decodes a fixed string.
Definition Cdr.h:1791
Cdr_DllAPI Cdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Cdr & serialize(const _T &value)
Encodes the value of a type into the buffer.
Definition Cdr.h:381
Cdr_DllAPI Cdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
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:2252
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:2425
Cdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence of non-primitive.
Definition Cdr.h:1844
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:2868
Cdr_DllAPI Cdr & serialize(const int8_t int8)
This function serializes an int8_t.
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
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
TEMPLATE_SPEC Cdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition Cdr.h:1775
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_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:326
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:966
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
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
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:737
Cdr & serialize(const external< _T > &value)
Encodes an external in the buffer.
Definition Cdr.h:2813
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:397
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:2644
TEMPLATE_SPEC Cdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition Cdr.h:826
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
fixed_string & assign(const char *c_array, size_t n_chars) noexcept
Assigns from a char array.
Definition fixed_size_string.hpp:78