Fast CDR  Version 2.2.5
Fast CDR
Loading...
Searching...
No Matches
Cdr.h
1// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#ifndef _FASTCDR_CDR_H_
16#define _FASTCDR_CDR_H_
17
18#include <array>
19#include <bitset>
20#include <cassert>
21#include <cstdint>
22#include <functional>
23#include <map>
24#include <string>
25#include <type_traits>
26#include <utility>
27#include <vector>
28
29#include "fastcdr_dll.h"
30
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"
41
42#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
43#include <malloc.h>
44#else
45#include <stdlib.h>
46#endif // if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
47
48namespace eprosima {
49namespace fastcdr {
50
51class Cdr;
52
53template<class _T>
54extern void serialize(
55 Cdr&,
56 const _T&);
57
58template<class _T>
59extern void deserialize(
60 Cdr&,
61 _T&);
62
67class Cdr
68{
69public:
70
74 typedef enum : uint8_t
75 {
81
83 Cdr_DllAPI static const Endianness DEFAULT_ENDIAN;
84
100
104 class state
105 {
106 friend class Cdr;
107
108 public:
109
111 Cdr_DllAPI state(
112 const Cdr& cdr);
113
115 Cdr_DllAPI state(
116 const state& state);
117
118
120 Cdr_DllAPI bool operator ==(
121 const state& other_state) const;
122
123 private:
124
125 state& operator =(
126 const state& state) = delete;
127
129 const FastBuffer::iterator offset_;
130
132 const FastBuffer::iterator origin_;
133
135 bool swap_bytes_ {false};
136
138 size_t last_data_size_ {0};
139
141 MemberId next_member_id_;
142
144 uint32_t member_size_ {0};
145
148
151
154 };
155
164 Cdr_DllAPI Cdr(
165 FastBuffer& cdr_buffer,
167 const CdrVersion cdr_version = XCDRv2);
168
178 Cdr_DllAPI Cdr& read_encapsulation();
179
187
192 Cdr_DllAPI CdrVersion get_cdr_version() const;
193
200
208 Cdr_DllAPI bool set_encoding_flag(
209 EncodingAlgorithmFlag encoding_flag);
210
215 Cdr_DllAPI std::array<uint8_t, 2> get_dds_cdr_options() const;
216
221 Cdr_DllAPI void set_dds_cdr_options(
222 const std::array<uint8_t, 2>& options);
223
228 Cdr_DllAPI void change_endianness(
230
235 Cdr_DllAPI Endianness endianness() const;
236
242 Cdr_DllAPI bool jump(
243 size_t num_bytes);
244
248 Cdr_DllAPI void reset();
249
254 Cdr_DllAPI char* get_buffer_pointer();
255
260 Cdr_DllAPI char* get_current_position();
261
266 Cdr_DllAPI size_t get_serialized_data_length() const;
267
274 inline static size_t alignment(
275 size_t current_alignment,
276 size_t data_size)
277 {
278 return (data_size - (current_alignment % data_size)) & (data_size - 1);
279 }
280
285 Cdr_DllAPI state get_state() const;
286
291 Cdr_DllAPI void set_state(
292 const state& state);
293
299 Cdr_DllAPI bool move_alignment_forward(
300 size_t num_bytes);
301
305 inline void reset_alignment()
306 {
307 origin_ = offset_;
308 last_data_size_ = 0;
309 }
310
324 template<class _T>
326 const _T& value)
327 {
328 if (MEMBER_ID_INVALID == next_member_id_)
329 {
330 serialize(value);
331 }
332 else
333 {
334 serialize_member(next_member_id_, value);
335
336 }
337
338 return *this;
339 }
340
354 template<class _T>
356 _T& value)
357 {
358 if (MEMBER_ID_INVALID == next_member_id_)
359 {
360 deserialize(value);
361 }
362 else
363 {
364 deserialize_member(value);
365 }
366 return *this;
367 }
368
379 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void>
381 const _T& value)
382 {
383 eprosima::fastcdr::serialize(*this, value);
384 return *this;
385 }
386
395 template<class _T>
397 const _T& value,
399 {
400 bool aux_swap = swap_bytes_;
401 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
402 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
403
404 try
405 {
406 serialize(value);
407 swap_bytes_ = aux_swap;
408 }
409 catch (exception::Exception& ex)
410 {
411 swap_bytes_ = aux_swap;
412 ex.raise();
413 }
414
415 return *this;
416 }
417
426 template<class _T,
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>
431 const _T& value)
432 {
433 return serialize(static_cast<int32_t>(value));
434 }
435
444 template<class _T,
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>
449 const _T& value)
450 {
451 return serialize(static_cast<uint32_t>(value));
452 }
453
462 template<class _T,
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>
467 const _T& value)
468 {
469 return serialize(static_cast<int16_t>(value));
470 }
471
480 template<class _T,
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>
485 const _T& value)
486 {
487 return serialize(static_cast<uint16_t>(value));
488 }
489
498 template<class _T,
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>
503 const _T& value)
504 {
505 return serialize(static_cast<int8_t>(value));
506 }
507
516 template<class _T,
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>
521 const _T& value)
522 {
523 return serialize(static_cast<uint8_t>(value));
524 }
525
532 Cdr_DllAPI Cdr& serialize(
533 const uint8_t& octet_t)
534 {
535 return serialize(static_cast<char>(octet_t));
536 }
537
544 Cdr_DllAPI Cdr& serialize(
545 const char char_t);
546
553 Cdr_DllAPI Cdr& serialize(
554 const int8_t int8)
555 {
556 return serialize(static_cast<char>(int8));
557 }
558
565 Cdr_DllAPI Cdr& serialize(
566 const uint16_t ushort_t)
567 {
568 return serialize(static_cast<int16_t>(ushort_t));
569 }
570
577 Cdr_DllAPI Cdr& serialize(
578 const int16_t short_t);
579
586 Cdr_DllAPI Cdr& serialize(
587 const uint32_t ulong_t)
588 {
589 return serialize(static_cast<int32_t>(ulong_t));
590 }
591
598 Cdr_DllAPI Cdr& serialize(
599 const int32_t long_t);
600
607 Cdr_DllAPI Cdr& serialize(
608 const wchar_t wchar)
609 {
610 return serialize(static_cast<uint16_t>(wchar));
611 }
612
619 Cdr_DllAPI Cdr& serialize(
620 const uint64_t ulonglong_t)
621 {
622 return serialize(static_cast<int64_t>(ulonglong_t));
623 }
624
631 Cdr_DllAPI Cdr& serialize(
632 const int64_t longlong_t);
633
640 Cdr_DllAPI Cdr& serialize(
641 const float float_t);
642
649 Cdr_DllAPI Cdr& serialize(
650 const double double_t);
651
659 Cdr_DllAPI Cdr& serialize(
660 const long double ldouble_t);
661
668 Cdr_DllAPI Cdr& serialize(
669 const bool bool_t);
670
677 Cdr_DllAPI Cdr& serialize(
678 char* string_t)
679 {
680 return serialize(static_cast<const char*>(string_t));
681 }
682
689 Cdr_DllAPI Cdr& serialize(
690 const char* string_t);
691
698 Cdr_DllAPI Cdr& serialize(
699 const wchar_t* string_t);
700
707 TEMPLATE_SPEC
709 const std::string& string_t)
710 {
711 return serialize(string_t.c_str());
712 }
713
720 TEMPLATE_SPEC
722 const std::wstring& string_t)
723 {
724 return serialize(string_t.c_str());
725 }
726
734 template <size_t MAX_CHARS>
736 const fixed_string<MAX_CHARS>& value)
737 {
738 return serialize(value.c_str());
739 }
740
747 template<class _T, size_t _Size>
749 const std::array<_T, _Size>& array_t)
750 {
751 if (!is_multi_array_primitive(&array_t))
752 {
753 Cdr::state dheader_state {allocate_xcdrv2_dheader()};
754
755 serialize_array(array_t.data(), array_t.size());
756
757 set_xcdrv2_dheader(dheader_state);
758 }
759 else
760 {
761 serialize_array(array_t.data(), array_t.size());
762 }
763
764 return *this;
765 }
766
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)
777 {
778 Cdr::state dheader_state {allocate_xcdrv2_dheader()};
779
780 serialize(static_cast<int32_t>(vector_t.size()));
781
782 try
783 {
784 serialize_array(vector_t.data(), vector_t.size());
785 }
786 catch (exception::Exception& ex)
787 {
788 set_state(dheader_state);
789 ex.raise();
790 }
791
792 set_xcdrv2_dheader(dheader_state);
793
794 return *this;
795 }
796
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)
807 {
808 state state_before_error(*this);
809
810 serialize(static_cast<int32_t>(vector_t.size()));
811
812 try
813 {
814 serialize_array(vector_t.data(), vector_t.size());
815 }
816 catch (exception::Exception& ex)
817 {
818 set_state(state_before_error);
819 ex.raise();
820 }
821
822 if (CdrVersion::XCDRv2 == cdr_version_)
823 {
824 serialized_member_size_ = get_serialized_member_size<_T>();
825 }
826
827 return *this;
828 }
829
836 TEMPLATE_SPEC
838 const std::vector<bool>& vector_t)
839 {
840 return serialize_bool_sequence(vector_t);
841 }
842
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)
853 {
854 Cdr::state dheader_state {allocate_xcdrv2_dheader()};
855
856 serialize(static_cast<int32_t>(map_t.size()));
857
858 try
859 {
860 for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
861 {
862 serialize(it_pair->first);
863 serialize(it_pair->second);
864 }
865 }
866 catch (exception::Exception& ex)
867 {
868 set_state(dheader_state);
869 ex.raise();
870 }
871
872 set_xcdrv2_dheader(dheader_state);
873
874 return *this;
875 }
876
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)
887 {
888 state state_(*this);
889
890 serialize(static_cast<int32_t>(map_t.size()));
891
892 try
893 {
894 for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
895 {
896 serialize(it_pair->first);
897 serialize(it_pair->second);
898 }
899 }
900 catch (exception::Exception& ex)
901 {
902 set_state(state_);
903 ex.raise();
904 }
905
906 return *this;
907 }
908
917 template<size_t N, typename std::enable_if < (N < 9) > ::type* = nullptr>
918 Cdr& serialize(
919 const std::bitset<N>& value)
920 {
921 return serialize(static_cast<uint8_t>(value.to_ulong()));
922 }
923
924 template<size_t N, typename std::enable_if < (8 < N && N < 17) > ::type* = nullptr>
925 Cdr& serialize(
926 const std::bitset<N>& value)
927 {
928 return serialize(static_cast<uint16_t>(value.to_ulong()));
929 }
930
931 template<size_t N, typename std::enable_if < (16 < N && N < 33) > ::type* = nullptr>
932 Cdr& serialize(
933 const std::bitset<N>& value)
934 {
935 return serialize(static_cast<uint32_t>(value.to_ulong()));
936 }
937
938 template<size_t N, typename std::enable_if < (32 < N && N < 65) > ::type* = nullptr>
939 Cdr& serialize(
940 const std::bitset<N>& value)
941 {
942 return serialize(static_cast<uint64_t>(value.to_ullong()));
943 }
944
956 template<class _T>
958 const _T* value,
959 size_t num_elements)
960 {
961 for (size_t count = 0; count < num_elements; ++count)
962 {
963 serialize(value[count]);
964 }
965 return *this;
966 }
967
976 template<class _T>
978 const _T* type_t,
979 size_t num_elements,
981 {
982 bool aux_swap = swap_bytes_;
983 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
984 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
985
986 try
987 {
988 serialize_array(type_t, num_elements);
989 swap_bytes_ = aux_swap;
990 }
991 catch (exception::Exception& ex)
992 {
993 swap_bytes_ = aux_swap;
994 ex.raise();
995 }
996
997 return *this;
998 }
999
1007 TEMPLATE_SPEC
1009 const uint8_t* octet_t,
1010 size_t num_elements)
1011 {
1012 return serialize_array(reinterpret_cast<const char*>(octet_t), num_elements);
1013 }
1014
1023 const char* char_t,
1024 size_t num_elements);
1025
1033 TEMPLATE_SPEC
1035 const int8_t* int8,
1036 size_t num_elements)
1037 {
1038 return serialize_array(reinterpret_cast<const char*>(int8), num_elements);
1039 }
1040
1048 TEMPLATE_SPEC
1050 const uint16_t* ushort_t,
1051 size_t num_elements)
1052 {
1053 return serialize_array(reinterpret_cast<const int16_t*>(ushort_t), num_elements);
1054 }
1055
1064 const int16_t* short_t,
1065 size_t num_elements);
1066
1074 TEMPLATE_SPEC
1076 const uint32_t* ulong_t,
1077 size_t num_elements)
1078 {
1079 return serialize_array(reinterpret_cast<const int32_t*>(ulong_t), num_elements);
1080 }
1081
1090 const int32_t* long_t,
1091 size_t num_elements);
1092
1101 const wchar_t* wchar,
1102 size_t num_elements);
1103
1111 TEMPLATE_SPEC
1113 const uint64_t* ulonglong_t,
1114 size_t num_elements)
1115 {
1116 return serialize_array(reinterpret_cast<const int64_t*>(ulonglong_t), num_elements);
1117 }
1118
1127 const int64_t* longlong_t,
1128 size_t num_elements);
1129
1138 const float* float_t,
1139 size_t num_elements);
1140
1149 const double* double_t,
1150 size_t num_elements);
1151
1161 const long double* ldouble_t,
1162 size_t num_elements);
1163
1172 const bool* bool_t,
1173 size_t num_elements);
1174
1182 TEMPLATE_SPEC
1184 const std::string* string_t,
1185 size_t num_elements)
1186 {
1187 for (size_t count = 0; count < num_elements; ++count)
1188 {
1189 serialize(string_t[count].c_str());
1190 }
1191 return *this;
1192 }
1193
1201 TEMPLATE_SPEC
1203 const std::wstring* string_t,
1204 size_t num_elements)
1205 {
1206 for (size_t count = 0; count < num_elements; ++count)
1207 {
1208 serialize(string_t[count].c_str());
1209 }
1210 return *this;
1211 }
1212
1221 template<size_t MAX_CHARS>
1223 const fixed_string<MAX_CHARS>* value,
1224 size_t num_elements)
1225 {
1226 for (size_t count = 0; count < num_elements; ++count)
1227 {
1228 serialize(value[count].c_str());
1229 }
1230 return *this;
1231 }
1232
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)
1244 {
1245 serialize_array(value.data(), value.size());
1246
1247 return *this;
1248 }
1249
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)
1261 {
1262 Cdr::state dheader_state {allocate_xcdrv2_dheader()};
1263
1264 serialize_array(value.data(), value.size());
1265
1266 set_xcdrv2_dheader(dheader_state);
1267
1268 return *this;
1269 }
1270
1279 template<class _T>
1281 const std::vector<_T>& value,
1283 {
1284 bool aux_swap = swap_bytes_;
1285 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1286 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1287
1288 try
1289 {
1290 serialize_array(value);
1291 swap_bytes_ = aux_swap;
1292 }
1293 catch (exception::Exception& ex)
1294 {
1295 swap_bytes_ = aux_swap;
1296 ex.raise();
1297 }
1298
1299 return *this;
1300 }
1301
1309 TEMPLATE_SPEC
1311 const std::vector<bool>& value)
1312 {
1313 serialize_bool_array(value);
1314
1315 return *this;
1316 }
1317
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)
1330 {
1331 Cdr::state dheader_state {allocate_xcdrv2_dheader()};
1332
1333 serialize(static_cast<int32_t>(num_elements));
1334
1335 try
1336 {
1337 serialize_array(sequence_t, num_elements);
1338 }
1339 catch (exception::Exception& ex)
1340 {
1341 set_state(dheader_state);
1342 ex.raise();
1343 }
1344
1345 set_xcdrv2_dheader(dheader_state);
1346
1347 return *this;
1348 }
1349
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)
1362 {
1363 state state_before_error(*this);
1364
1365 serialize(static_cast<int32_t>(num_elements));
1366
1367 try
1368 {
1369 serialize_array(sequence_t, num_elements);
1370 }
1371 catch (exception::Exception& ex)
1372 {
1373 set_state(state_before_error);
1374 ex.raise();
1375 }
1376
1377 if (CdrVersion::XCDRv2 == cdr_version_)
1378 {
1379 serialized_member_size_ = get_serialized_member_size<_T>();
1380 }
1381
1382 return *this;
1383 }
1384
1393 template<class _T>
1395 const _T* sequence_t,
1396 size_t num_elements,
1398 {
1399 bool aux_swap = swap_bytes_;
1400 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1401 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1402
1403 try
1404 {
1405 serialize_sequence(sequence_t, num_elements);
1406 swap_bytes_ = aux_swap;
1407 }
1408 catch (exception::Exception& ex)
1409 {
1410 swap_bytes_ = aux_swap;
1411 ex.raise();
1412 }
1413
1414 return *this;
1415 }
1416
1427 template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void>
1429 _T& value)
1430 {
1431 eprosima::fastcdr::deserialize(*this, value);
1432 return *this;
1433 }
1434
1443 template<class _T>
1445 _T& value,
1447 {
1448 bool aux_swap = swap_bytes_;
1449 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
1450 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
1451
1452 try
1453 {
1454 deserialize(value);
1455 swap_bytes_ = aux_swap;
1456 }
1457 catch (exception::Exception& ex)
1458 {
1459 swap_bytes_ = aux_swap;
1460 ex.raise();
1461 }
1462
1463 return *this;
1464 }
1465
1473 template<class _T,
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>
1478 _T& value)
1479 {
1480 int32_t decode_value {0};
1481 deserialize(decode_value);
1482 value = static_cast<_T>(decode_value);
1483 return *this;
1484 }
1485
1493 template<class _T,
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>
1498 _T& value)
1499 {
1500 uint32_t decode_value {0};
1501 deserialize(decode_value);
1502 value = static_cast<_T>(decode_value);
1503 return *this;
1504 }
1505
1513 template<class _T,
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>
1518 _T& value)
1519 {
1520 int16_t decode_value {0};
1521 deserialize(decode_value);
1522 value = static_cast<_T>(decode_value);
1523 return *this;
1524 }
1525
1533 template<class _T,
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>
1538 _T& value)
1539 {
1540 uint16_t decode_value {0};
1541 deserialize(decode_value);
1542 value = static_cast<_T>(decode_value);
1543 return *this;
1544 }
1545
1553 template<class _T,
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>
1558 _T& value)
1559 {
1560 int8_t decode_value {0};
1561 deserialize(decode_value);
1562 value = static_cast<_T>(decode_value);
1563 return *this;
1564 }
1565
1573 template<class _T,
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>
1578 _T& value)
1579 {
1580 uint8_t decode_value {0};
1581 deserialize(decode_value);
1582 value = static_cast<_T>(decode_value);
1583 return *this;
1584 }
1585
1592 TEMPLATE_SPEC
1594 uint8_t& octet_t)
1595 {
1596 return deserialize(reinterpret_cast<char&>(octet_t));
1597 }
1598
1605 Cdr_DllAPI Cdr& deserialize(
1606 char& char_t);
1607
1614 TEMPLATE_SPEC
1616 int8_t& int8)
1617 {
1618 return deserialize(reinterpret_cast<char&>(int8));
1619 }
1620
1627 TEMPLATE_SPEC
1629 uint16_t& ushort_t)
1630 {
1631 return deserialize(reinterpret_cast<int16_t&>(ushort_t));
1632 }
1633
1640 Cdr_DllAPI Cdr& deserialize(
1641 int16_t& short_t);
1642
1649 TEMPLATE_SPEC
1651 uint32_t& ulong_t)
1652 {
1653 return deserialize(reinterpret_cast<int32_t&>(ulong_t));
1654 }
1655
1662 Cdr_DllAPI Cdr& deserialize(
1663 int32_t& long_t);
1664
1671 TEMPLATE_SPEC
1673 wchar_t& wchar)
1674 {
1675 uint16_t ret;
1676 deserialize(ret);
1677 wchar = static_cast<wchar_t>(ret);
1678 return *this;
1679 }
1680
1687 TEMPLATE_SPEC
1689 uint64_t& ulonglong_t)
1690 {
1691 return deserialize(reinterpret_cast<int64_t&>(ulonglong_t));
1692 }
1693
1700 Cdr_DllAPI Cdr& deserialize(
1701 int64_t& longlong_t);
1702
1709 Cdr_DllAPI Cdr& deserialize(
1710 float& float_t);
1711
1718 Cdr_DllAPI Cdr& deserialize(
1719 double& double_t);
1720
1728 Cdr_DllAPI Cdr& deserialize(
1729 long double& ldouble_t);
1730
1738 Cdr_DllAPI Cdr& deserialize(
1739 bool& bool_t);
1740
1749 Cdr_DllAPI Cdr& deserialize(
1750 char*& string_t);
1751
1760 Cdr_DllAPI Cdr& deserialize(
1761 wchar_t*& string_t);
1762
1769 TEMPLATE_SPEC
1771 std::string& string_t)
1772 {
1773 uint32_t length = 0;
1774 const char* str = read_string(length);
1775 string_t.assign(str, length);
1776 return *this;
1777 }
1778
1785 TEMPLATE_SPEC
1787 std::wstring& string_t)
1788 {
1789 uint32_t length = 0;
1790 string_t = read_wstring(length);
1791 return *this;
1792 }
1793
1801 template <size_t MAX_CHARS>
1804 {
1805 uint32_t length = 0;
1806 const char* str = read_string(length);
1807 value = std::string(str, length);
1808 return *this;
1809 }
1810
1817 template<class _T, size_t _Size>
1819 std::array<_T, _Size>& array_t)
1820 {
1821 if (CdrVersion::XCDRv2 == cdr_version_ && !is_multi_array_primitive(&array_t))
1822 {
1823 uint32_t dheader {0};
1824 deserialize(dheader);
1825
1826 uint32_t count {0};
1827 auto offset = offset_;
1828 while (offset_ - offset < dheader && count < _Size)
1829 {
1830 deserialize_array(&array_t.data()[count], 1);
1831 ++count;
1832 }
1833
1834 if (offset_ - offset != dheader)
1835 {
1836 throw exception::BadParamException("Member size greater than size specified by DHEADER");
1837 }
1838 }
1839 else
1840 {
1841 return deserialize_array(array_t.data(), array_t.size());
1842 }
1843
1844 return *this;
1845 }
1846
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)
1857 {
1858 uint32_t sequence_length {0};
1859
1860 if (CdrVersion::XCDRv2 == cdr_version_)
1861 {
1862 uint32_t dheader {0};
1863 deserialize(dheader);
1864
1865 auto offset = offset_;
1866
1867 deserialize(sequence_length);
1868
1869 if (0 == sequence_length)
1870 {
1871 vector_t.clear();
1872 return *this;
1873 }
1874 else
1875 {
1876 vector_t.resize(sequence_length);
1877 }
1878
1879 uint32_t count {0};
1880 while (offset_ - offset < dheader && count < sequence_length)
1881 {
1882 deserialize(vector_t.data()[count]);
1883 ++count;
1884 }
1885
1886 if (offset_ - offset != dheader)
1887 {
1888 throw exception::BadParamException("Member size differs from the size specified by DHEADER");
1889 }
1890 }
1891 else
1892 {
1893 state state_before_error(*this);
1894
1895 deserialize(sequence_length);
1896
1897 if (sequence_length == 0)
1898 {
1899 vector_t.clear();
1900 return *this;
1901 }
1902
1903 if ((end_ - offset_) < sequence_length)
1904 {
1905 set_state(state_before_error);
1908 }
1909
1910 try
1911 {
1912 vector_t.resize(sequence_length);
1913 return deserialize_array(vector_t.data(), vector_t.size());
1914 }
1915 catch (exception::Exception& ex)
1916 {
1917 set_state(state_before_error);
1918 ex.raise();
1919 }
1920 }
1921
1922 return *this;
1923 }
1924
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)
1935 {
1936 uint32_t sequence_length = 0;
1937 state state_before_error(*this);
1938
1939 deserialize(sequence_length);
1940
1941 if (sequence_length == 0)
1942 {
1943 vector_t.clear();
1944 return *this;
1945 }
1946
1947 if ((end_ - offset_) < sequence_length)
1948 {
1949 set_state(state_before_error);
1952 }
1953
1954 try
1955 {
1956 vector_t.resize(sequence_length);
1957 return deserialize_array(vector_t.data(), vector_t.size());
1958 }
1959 catch (exception::Exception& ex)
1960 {
1961 set_state(state_before_error);
1962 ex.raise();
1963 }
1964
1965 return *this;
1966 }
1967
1974 TEMPLATE_SPEC
1976 std::vector<bool>& vector_t)
1977 {
1978 return deserialize_bool_sequence(vector_t);
1979 }
1980
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)
1991 {
1992 if (CdrVersion::XCDRv2 == cdr_version_)
1993 {
1994 uint32_t dheader {0};
1995 deserialize(dheader);
1996
1997 auto offset = offset_;
1998
1999 uint32_t map_length {0};
2000 deserialize(map_length);
2001
2002 map_t.clear();
2003
2004 uint32_t count {0};
2005 while (offset_ - offset < dheader && count < map_length)
2006 {
2007 _K key;
2008 _T val;
2009 deserialize(key);
2010 deserialize(val);
2011 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(val)));
2012 ++count;
2013 }
2014
2015 if (offset_ - offset != dheader)
2016 {
2017 throw exception::BadParamException("Member size greater than size specified by DHEADER");
2018 }
2019 }
2020 else
2021 {
2022 uint32_t sequence_length = 0;
2023 state state_(*this);
2024
2025 deserialize(sequence_length);
2026
2027 map_t.clear();
2028
2029 try
2030 {
2031 for (uint32_t i = 0; i < sequence_length; ++i)
2032 {
2033 _K key;
2034 _T value;
2035 deserialize(key);
2036 deserialize(value);
2037 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2038 }
2039 }
2040 catch (exception::Exception& ex)
2041 {
2042 set_state(state_);
2043 ex.raise();
2044 }
2045 }
2046
2047 return *this;
2048 }
2049
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)
2060 {
2061 uint32_t sequence_length = 0;
2062 state state_(*this);
2063
2064 deserialize(sequence_length);
2065
2066 try
2067 {
2068 for (uint32_t i = 0; i < sequence_length; ++i)
2069 {
2070 _K key;
2071 _T value;
2072 deserialize(key);
2073 deserialize(value);
2074 map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
2075 }
2076 }
2077 catch (exception::Exception& ex)
2078 {
2079 set_state(state_);
2080 ex.raise();
2081 }
2082
2083 return *this;
2084 }
2085
2093 template<size_t N, typename std::enable_if < (N < 9) > ::type* = nullptr>
2094 Cdr& deserialize(
2095 std::bitset<N>& value)
2096 {
2097 uint8_t decode_value {0};
2098 deserialize(decode_value);
2099 value = decode_value;
2100 return *this;
2101 }
2102
2103 template<size_t N, typename std::enable_if < (8 < N && N < 17) > ::type* = nullptr>
2104 Cdr& deserialize(
2105 std::bitset<N>& value)
2106 {
2107 uint16_t decode_value {0};
2108 deserialize(decode_value);
2109 value = decode_value;
2110 return *this;
2111 }
2112
2113 template<size_t N, typename std::enable_if < (16 < N && N < 33) > ::type* = nullptr>
2114 Cdr& deserialize(
2115 std::bitset<N>& value)
2116 {
2117 uint32_t decode_value {0};
2118 deserialize(decode_value);
2119 value = decode_value;
2120 return *this;
2121 }
2122
2123 template<size_t N, typename std::enable_if < (32 < N && N < 65) > ::type* = nullptr>
2124 Cdr& deserialize(
2125 std::bitset<N>& value)
2126 {
2127 uint64_t decode_value {0};
2128 deserialize(decode_value);
2129 value = decode_value;
2130 return *this;
2131 }
2132
2144 template<class _T>
2146 _T* value,
2147 size_t num_elements)
2148 {
2149 for (size_t count = 0; count < num_elements; ++count)
2150 {
2151 deserialize(value[count]);
2152 }
2153 return *this;
2154 }
2155
2164 template<class _T>
2166 _T* type_t,
2167 size_t num_elements,
2169 {
2170 bool aux_swap = swap_bytes_;
2171 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2172 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2173
2174 try
2175 {
2176 deserialize_array(type_t, num_elements);
2177 swap_bytes_ = aux_swap;
2178 }
2179 catch (exception::Exception& ex)
2180 {
2181 swap_bytes_ = aux_swap;
2182 ex.raise();
2183 }
2184
2185 return *this;
2186 }
2187
2195 TEMPLATE_SPEC
2197 uint8_t* octet_t,
2198 size_t num_elements)
2199 {
2200 return deserialize_array(reinterpret_cast<char*>(octet_t), num_elements);
2201 }
2202
2211 char* char_t,
2212 size_t num_elements);
2213
2221 TEMPLATE_SPEC
2223 int8_t* int8,
2224 size_t num_elements)
2225 {
2226 return deserialize_array(reinterpret_cast<char*>(int8), num_elements);
2227 }
2228
2236 TEMPLATE_SPEC
2238 uint16_t* ushort_t,
2239 size_t num_elements)
2240 {
2241 return deserialize_array(reinterpret_cast<int16_t*>(ushort_t), num_elements);
2242 }
2243
2252 int16_t* short_t,
2253 size_t num_elements);
2254
2262 TEMPLATE_SPEC
2264 uint32_t* ulong_t,
2265 size_t num_elements)
2266 {
2267 return deserialize_array(reinterpret_cast<int32_t*>(ulong_t), num_elements);
2268 }
2269
2278 int32_t* long_t,
2279 size_t num_elements);
2280
2289 wchar_t* wchar,
2290 size_t num_elements);
2291
2299 TEMPLATE_SPEC
2301 uint64_t* ulonglong_t,
2302 size_t num_elements)
2303 {
2304 return deserialize_array(reinterpret_cast<int64_t*>(ulonglong_t), num_elements);
2305 }
2306
2315 int64_t* longlong_t,
2316 size_t num_elements);
2317
2326 float* float_t,
2327 size_t num_elements);
2328
2337 double* double_t,
2338 size_t num_elements);
2339
2349 long double* ldouble_t,
2350 size_t num_elements);
2351
2360 bool* bool_t,
2361 size_t num_elements);
2362
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)
2377 {
2378 deserialize_array(value.data(), value.size());
2379
2380 return *this;
2381 }
2382
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)
2397 {
2398 if (CdrVersion::XCDRv2 == cdr_version_)
2399 {
2400 uint32_t dheader {0};
2401 deserialize(dheader);
2402
2403 uint32_t count {0};
2404 auto offset = offset_;
2405 while (offset_ - offset < dheader && count < value.size())
2406 {
2407 deserialize_array(&value.data()[count], 1);
2408 ++count;
2409 }
2410
2411 if (offset_ - offset != dheader)
2412 {
2413 throw exception::BadParamException("Member size greater than size specified by DHEADER");
2414 }
2415 }
2416 else
2417 {
2418 return deserialize_array(value.data(), value.size());
2419 }
2420
2421 return *this;
2422 }
2423
2435 template<class _T>
2437 std::vector<_T>& value,
2439 {
2440 bool aux_swap = swap_bytes_;
2441 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2442 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2443
2444 try
2445 {
2446 deserialize_array(value);
2447 swap_bytes_ = aux_swap;
2448 }
2449 catch (exception::Exception& ex)
2450 {
2451 swap_bytes_ = aux_swap;
2452 ex.raise();
2453 }
2454
2455 return *this;
2456 }
2457
2468 TEMPLATE_SPEC
2470 std::vector<bool>& value)
2471 {
2472 deserialize_bool_array(value);
2473
2474 return *this;
2475 }
2476
2486 template<class _T, typename std::enable_if<!std::is_enum<_T>::value &&
2487 !std::is_arithmetic<_T>::value>::type* = nullptr>
2489 _T*& sequence_t,
2490 size_t& num_elements)
2491 {
2492 uint32_t sequence_length {0};
2493
2494 if (CdrVersion::XCDRv2 == cdr_version_)
2495 {
2496 uint32_t dheader {0};
2497 deserialize(dheader);
2498
2499 auto offset = offset_;
2500
2501 deserialize(sequence_length);
2502
2503 try
2504 {
2505 sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2506
2507 uint32_t count {0};
2508 while (offset_ - offset < dheader && count < sequence_length)
2509 {
2510 deserialize(sequence_t[count]);
2511 ++count;
2512 }
2513
2514 if (offset_ - offset != dheader)
2515 {
2516 throw exception::BadParamException("Member size greater than size specified by DHEADER");
2517 }
2518 }
2519 catch (exception::Exception& ex)
2520 {
2521 free(sequence_t);
2522 sequence_t = NULL;
2523 ex.raise();
2524 }
2525 }
2526 else
2527 {
2528 state state_before_error(*this);
2529
2530 deserialize(sequence_length);
2531
2532 if ((end_ - offset_) < sequence_length)
2533 {
2534 set_state(state_before_error);
2537 }
2538
2539 try
2540 {
2541 sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2542 deserialize_array(sequence_t, sequence_length);
2543 }
2544 catch (exception::Exception& ex)
2545 {
2546 free(sequence_t);
2547 sequence_t = NULL;
2548 set_state(state_before_error);
2549 ex.raise();
2550 }
2551 }
2552
2553 num_elements = sequence_length;
2554 return *this;
2555 }
2556
2566 template<class _T, typename std::enable_if<std::is_enum<_T>::value ||
2567 std::is_arithmetic<_T>::value>::type* = nullptr>
2569 _T*& sequence_t,
2570 size_t& num_elements)
2571 {
2572 uint32_t sequence_length = 0;
2573 state state_before_error(*this);
2574
2575 deserialize(sequence_length);
2576
2577 try
2578 {
2579 sequence_t = reinterpret_cast<_T*>(calloc(sequence_length, sizeof(_T)));
2580 deserialize_array(sequence_t, sequence_length);
2581 }
2582 catch (exception::Exception& ex)
2583 {
2584 free(sequence_t);
2585 sequence_t = NULL;
2586 set_state(state_before_error);
2587 ex.raise();
2588 }
2589
2590 num_elements = sequence_length;
2591 return *this;
2592 }
2593
2604 template<class _T>
2606 _T*& sequence_t,
2607 size_t& num_elements,
2609 {
2610 bool aux_swap = swap_bytes_;
2611 swap_bytes_ = (swap_bytes_ && (static_cast<Endianness>(endianness_) == endianness)) ||
2612 (!swap_bytes_ && (static_cast<Endianness>(endianness_) != endianness));
2613
2614 try
2615 {
2616 deserialize_sequence(sequence_t, num_elements);
2617 swap_bytes_ = aux_swap;
2618 }
2619 catch (exception::Exception& ex)
2620 {
2621 swap_bytes_ = aux_swap;
2622 ex.raise();
2623 }
2624
2625 return *this;
2626 }
2627
2637 TEMPLATE_SPEC
2639 std::string*& sequence_t,
2640 size_t& num_elements)
2641 {
2642 return deserialize_string_sequence(sequence_t, num_elements);
2643 }
2644
2654 TEMPLATE_SPEC
2656 std::wstring*& sequence_t,
2657 size_t& num_elements)
2658 {
2659 return deserialize_wstring_sequence(sequence_t, num_elements);
2660 }
2661
2665
2676 template<class _T>
2678 const MemberId& member_id,
2679 const _T& member_value,
2681 {
2682 Cdr::state current_state(*this);
2683 (this->*begin_serialize_member_)(member_id, true, current_state, header_selection);
2684 serialize(member_value);
2685 return (this->*end_serialize_member_)(current_state);
2686 }
2687
2698 template<class _T>
2700 const MemberId& member_id,
2701 const optional<_T>& member_value,
2703 {
2704 Cdr::state current_state(*this);
2705 (this->*begin_serialize_opt_member_)(member_id, member_value.has_value(), current_state, header_selection);
2706 serialize(member_value);
2707 return (this->*end_serialize_opt_member_)(current_state);
2708 }
2709
2717 template<class _T>
2719 _T& member_value)
2720 {
2721 return deserialize(member_value);
2722 }
2723
2731 template<class _T>
2733 optional<_T>& member_value)
2734 {
2735 if (EncodingAlgorithmFlag::PLAIN_CDR == current_encoding_)
2736 {
2737 Cdr::state current_state(*this);
2738 MemberId member_id;
2739 xcdr1_deserialize_member_header(member_id, current_state);
2740 auto prev_offset = offset_;
2741 if (0 < current_state.member_size_)
2742 {
2743 deserialize(member_value);
2744 }
2745 if (current_state.member_size_ != offset_ - prev_offset)
2746 {
2748 "Member size provided by member header is not equal to the real decoded member size");
2749 }
2750 }
2751 else
2752 {
2753 deserialize(member_value);
2754 }
2755 return *this;
2756 }
2757
2767 Cdr::state& current_state,
2768 EncodingAlgorithmFlag type_encoding)
2769 {
2770 return (this->*begin_serialize_type_)(current_state, type_encoding);
2771 }
2772
2781 Cdr::state& current_state)
2782 {
2783 return (this->*end_serialize_type_)(current_state);
2784 }
2785
2795 EncodingAlgorithmFlag type_encoding,
2796 std::function<bool (Cdr&, const MemberId&)> functor)
2797 {
2798 return (this->*deserialize_type_)(type_encoding, functor);
2799 }
2800
2808 template<class _T>
2810 const optional<_T>& value)
2811 {
2812 if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2813 {
2814 serialize(value.has_value());
2815 }
2816
2817 if (value.has_value())
2818 {
2819 serialize(*value);
2820 }
2821 return *this;
2822 }
2823
2832 template<class _T>
2834 const external<_T>& value)
2835 {
2836 if (!value)
2837 {
2838 throw exception::BadParamException("External member is null");
2839 }
2840
2841 serialize(*value);
2842 return *this;
2843 }
2844
2852 Cdr_DllAPI Cdr& operator <<(
2853 const MemberId& member_id)
2854 {
2855 if (next_member_id_ != MEMBER_ID_INVALID)
2856 {
2857 throw exception::BadParamException("Member id already set and not encoded");
2858 }
2859
2860 next_member_id_ = member_id;
2861 return *this;
2862 }
2863
2871 template<class _T>
2873 optional<_T>& value)
2874 {
2875 bool is_present = true;
2876 if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2877 {
2878 deserialize(is_present);
2879 }
2880 value.reset(is_present);
2881 if (is_present)
2882 {
2883 deserialize(*value);
2884 }
2885 return *this;
2886 }
2887
2896 template<class _T>
2898 external<_T>& value)
2899 {
2900 if (value.is_locked())
2901 {
2902 throw exception::BadParamException("External member is locked");
2903 }
2904
2905 if (!value)
2906 {
2907 value = external<_T>{new typename external<_T>::type()};
2908 }
2909
2910 deserialize(*value);
2911 return *this;
2912 }
2913
2922 template<class _T>
2924 optional<external<_T>>& value)
2925 {
2926 if (value.has_value() && value.value().is_locked())
2927 {
2928 throw exception::BadParamException("External member is locked");
2929 }
2930
2931 bool is_present = true;
2932 if (CdrVersion::XCDRv2 == cdr_version_ && EncodingAlgorithmFlag::PL_CDR2 != current_encoding_)
2933 {
2934 deserialize(is_present);
2935 }
2936 value.reset(is_present);
2937 if (is_present)
2938 {
2939 deserialize(*value);
2940 }
2941 return *this;
2942 }
2943
2950
2957 Cdr_DllAPI void set_xcdrv2_dheader(
2958 const state& state);
2959
2960private:
2961
2962 Cdr(
2963 const Cdr&) = delete;
2964
2965 Cdr& operator =(
2966 const Cdr&) = delete;
2967
2968 Cdr_DllAPI Cdr& serialize_bool_array(
2969 const std::vector<bool>& vector_t);
2970
2971 Cdr_DllAPI Cdr& serialize_bool_sequence(
2972 const std::vector<bool>& vector_t);
2973
2974 Cdr_DllAPI Cdr& deserialize_bool_array(
2975 std::vector<bool>& vector_t);
2976
2977 Cdr_DllAPI Cdr& deserialize_bool_sequence(
2978 std::vector<bool>& vector_t);
2979
2980 Cdr_DllAPI Cdr& deserialize_string_sequence(
2981 std::string*& sequence_t,
2982 size_t& num_elements);
2983
2984 Cdr_DllAPI Cdr& deserialize_wstring_sequence(
2985 std::wstring*& sequence_t,
2986 size_t& num_elements);
2987
2995 template<class _T, size_t _Size>
2997 const std::array<_T, _Size>* array_t,
2998 size_t num_elements)
2999 {
3000 return serialize_array(array_t->data(), num_elements * array_t->size());
3001 }
3002
3010 template<class _T, size_t _Size>
3012 std::array<_T, _Size>* array_t,
3013 size_t num_elements)
3014 {
3015 return deserialize_array(array_t->data(), num_elements * array_t->size());
3016 }
3017
3026 template<class _T, size_t _Size>
3027 Cdr& deserialize_array(
3028 std::array<_T, _Size>* array_t,
3029 size_t num_elements,
3031 {
3032 return deserialize_array(array_t->data(), num_elements * array_t->size(), endianness);
3033 }
3034
3041 inline size_t alignment(
3042 size_t data_size) const
3043 {
3044 return data_size > last_data_size_ ? (data_size - ((offset_ - origin_) % data_size)) & (data_size - 1) : 0;
3045 }
3046
3051 inline void make_alignment(
3052 size_t align)
3053 {
3054 offset_ += align;
3055 last_data_size_ = 0;
3056 }
3057
3063 bool resize(
3064 size_t min_size_inc);
3065
3066 Cdr_DllAPI const char* read_string(
3067 uint32_t& length);
3068 Cdr_DllAPI const std::wstring read_wstring(
3069 uint32_t& length);
3070
3074
3081 void xcdr1_serialize_short_member_header(
3082 const MemberId& member_id);
3083
3093 void xcdr1_end_short_member_header(
3094 const MemberId& member_id,
3095 size_t member_serialized_size);
3096
3103 void xcdr1_serialize_long_member_header(
3104 const MemberId& member_id);
3105
3113 void xcdr1_end_long_member_header(
3114 const MemberId& member_id,
3115 size_t member_serialized_size);
3116
3126 void xcdr1_change_to_short_member_header(
3127 const MemberId& member_id,
3128 size_t member_serialized_size);
3129
3137 void xcdr1_change_to_long_member_header(
3138 const MemberId& member_id,
3139 size_t member_serialized_size);
3140
3149 Cdr_DllAPI bool xcdr1_deserialize_member_header(
3150 MemberId& member_id,
3151 Cdr::state& current_state);
3152
3160 void xcdr2_serialize_short_member_header(
3161 const MemberId& member_id);
3162
3172 void xcdr2_end_short_member_header(
3173 const MemberId& member_id,
3174 size_t member_serialized_size);
3175
3183 void xcdr2_serialize_long_member_header(
3184 const MemberId& member_id);
3185
3194 void xcdr2_end_long_member_header(
3195 const MemberId& member_id,
3196 size_t member_serialized_size);
3197
3207 void xcdr2_change_to_short_member_header(
3208 const MemberId& member_id,
3209 size_t member_serialized_size);
3210
3219 void xcdr2_change_to_long_member_header(
3220 const MemberId& member_id,
3221 size_t member_serialized_size);
3222
3231 void xcdr2_shrink_to_long_member_header(
3232 const MemberId& member_id,
3233 const FastBuffer::iterator& offset);
3234
3243 void xcdr2_deserialize_member_header(
3244 MemberId& member_id,
3245 Cdr::state& current_state);
3246
3263 Cdr& xcdr1_begin_serialize_member(
3264 const MemberId& member_id,
3265 bool is_present,
3266 Cdr::state& current_state,
3267 XCdrHeaderSelection header_selection);
3268
3279 Cdr& xcdr1_end_serialize_member(
3280 const Cdr::state& current_state);
3281
3297 Cdr& xcdr1_begin_serialize_opt_member(
3298 const MemberId& member_id,
3299 bool is_present,
3300 Cdr::state& current_state,
3301 XCdrHeaderSelection header_selection);
3302
3313 Cdr& xcdr1_end_serialize_opt_member(
3314 const Cdr::state& current_state);
3315
3332 Cdr& xcdr2_begin_serialize_member(
3333 const MemberId& member_id,
3334 bool is_present,
3335 Cdr::state& current_state,
3336 XCdrHeaderSelection header_selection);
3337
3348 Cdr& xcdr2_end_serialize_member(
3349 const Cdr::state& current_state);
3350
3360 Cdr& xcdr1_begin_serialize_type(
3361 Cdr::state& current_state,
3362 EncodingAlgorithmFlag type_encoding) noexcept;
3363
3372 Cdr& xcdr1_end_serialize_type(
3373 const Cdr::state& current_state);
3374
3388 Cdr& xcdr2_begin_serialize_type(
3389 Cdr::state& current_state,
3390 EncodingAlgorithmFlag type_encoding);
3391
3401 Cdr& xcdr2_end_serialize_type(
3402 const Cdr::state& current_state);
3403
3416 Cdr& xcdr1_deserialize_type(
3417 EncodingAlgorithmFlag type_encoding,
3418 std::function<bool (Cdr&, const MemberId&)> functor);
3419
3433 Cdr& xcdr2_deserialize_type(
3434 EncodingAlgorithmFlag type_encoding,
3435 std::function<bool (Cdr&, const MemberId&)> functor);
3436
3437 Cdr& cdr_begin_serialize_member(
3438 const MemberId& member_id,
3439 bool is_present,
3440 Cdr::state& current_state,
3441 XCdrHeaderSelection header_selection);
3442
3443 Cdr& cdr_end_serialize_member(
3444 const Cdr::state& current_state);
3445
3446 Cdr& cdr_begin_serialize_type(
3447 Cdr::state& current_state,
3448 EncodingAlgorithmFlag type_encoding);
3449
3450 Cdr& cdr_end_serialize_type(
3451 const Cdr::state& current_state);
3452
3453 Cdr& cdr_deserialize_type(
3454 EncodingAlgorithmFlag type_encoding,
3455 std::function<bool (Cdr&, const MemberId&)> functor);
3456
3460 void reset_callbacks();
3461
3462 using begin_serialize_member_functor = Cdr& (Cdr::*)(
3463 const MemberId&,
3464 bool,
3465 Cdr::state&,
3467 begin_serialize_member_functor begin_serialize_member_ { nullptr };
3468
3469 using end_serialize_member_functor = Cdr& (Cdr::*)(
3470 const Cdr::state&);
3471 end_serialize_member_functor end_serialize_member_ { nullptr };
3472
3473 using begin_serialize_opt_member_functor = Cdr& (Cdr::*)(
3474 const MemberId&,
3475 bool,
3476 Cdr::state&,
3478 begin_serialize_opt_member_functor begin_serialize_opt_member_ { nullptr };
3479
3480 using end_serialize_memberopt__functor = Cdr& (Cdr::*)(
3481 const Cdr::state&);
3482 end_serialize_member_functor end_serialize_opt_member_ { nullptr };
3483
3484 using begin_serialize_type_functor = Cdr& (Cdr::*)(
3485 Cdr::state&,
3487 begin_serialize_type_functor begin_serialize_type_ { nullptr };
3488
3489 using end_serialize_type_functor = Cdr& (Cdr::*)(
3490 const Cdr::state&);
3491 end_serialize_type_functor end_serialize_type_ { nullptr };
3492
3493 using deserialize_type_functor = Cdr& (Cdr::*)(
3495 std::function<bool (Cdr&, const MemberId&)>);
3496 deserialize_type_functor deserialize_type_ { nullptr };
3497
3499 FastBuffer& cdr_buffer_;
3500
3502 CdrVersion cdr_version_ {CdrVersion::XCDRv2};
3503
3506
3509
3511 std::array<uint8_t, 2> options_{{0}};
3512
3514 uint8_t endianness_ {Endianness::LITTLE_ENDIANNESS};
3515
3517 bool swap_bytes_ {false};
3518
3520 size_t last_data_size_ {0};
3521
3523 FastBuffer::iterator offset_;
3524
3526 FastBuffer::iterator origin_;
3527
3530
3532 MemberId next_member_id_;
3533
3535 size_t align64_ {4};
3536
3541 enum SerializedMemberSizeForNextInt
3542 {
3543 NO_SERIALIZED_MEMBER_SIZE,
3544 SERIALIZED_MEMBER_SIZE,
3545 SERIALIZED_MEMBER_SIZE_4,
3546 SERIALIZED_MEMBER_SIZE_8
3547 }
3549 serialized_member_size_ {NO_SERIALIZED_MEMBER_SIZE};
3550
3551
3552 uint32_t get_long_lc(
3553 SerializedMemberSizeForNextInt serialized_member_size);
3554
3555 uint32_t get_short_lc(
3556 size_t member_serialized_size);
3557
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
3561 {
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)));
3565 }
3566
3567};
3568
3569} //namespace fastcdr
3570} //namespace eprosima
3571
3572#endif // _CDR_CDR_H_
This class implements the iterator used to go through a FastBuffer.
Definition FastBuffer.h:43
This class stores the current state of a CDR serialization.
Definition Cdr.h: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 &current_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 &current_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 &)
Definition Cdr.h:48
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