15#ifndef _FASTCDR_FASTCDR_H_
16#define _FASTCDR_FASTCDR_H_
24#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
30#include "fastcdr_dll.h"
31#include "FastBuffer.h"
32#include "exceptions/NotEnoughMemoryException.h"
33#include "exceptions/BadParamException.h"
70 const state&) =
delete;
109 return current_position_ - cdr_buffer_.begin();
132 const uint8_t octet_t)
168 const uint16_t ushort_t)
180 const int16_t short_t)
192 const uint32_t ulong_t)
204 const int32_t long_t)
228 const uint64_t ulonglong_t)
240 const int64_t longlong_t)
264 const double double_t)
276 const long double ldouble_t)
300 const char* string_t)
312 const wchar_t* string_t)
324 const std::string& string_t)
336 const std::wstring& string_t)
347 template<
class _T,
size_t _Size>
349 const std::array<_T, _Size>& array_t)
351 return serialize<_T, _Size>(array_t);
362 const std::vector<_T>& vector_t)
364 return serialize<_T>(vector_t);
484 uint64_t& ulonglong_t)
532 long double& ldouble_t)
572 std::string& string_t)
584 std::wstring& string_t)
595 template<
class _T,
size_t _Size>
597 std::array<_T, _Size>& array_t)
599 return deserialize<_T, _Size>(array_t);
610 std::vector<_T>& vector_t)
612 return deserialize<_T>(vector_t);
637 const uint8_t octet_t)
639 return serialize(
static_cast<char>(octet_t));
652 if (((last_position_ - current_position_) >=
sizeof(char_t)) || resize(
sizeof(char_t)))
654 current_position_++ << char_t;
671 return serialize(
static_cast<char>(int8));
682 const uint16_t ushort_t)
684 return serialize(
static_cast<int16_t
>(ushort_t));
695 const int16_t short_t)
697 if (((last_position_ - current_position_) >=
sizeof(short_t)) || resize(
sizeof(short_t)))
699 current_position_ << short_t;
700 current_position_ +=
sizeof(short_t);
716 const uint32_t ulong_t)
718 return serialize(
static_cast<int32_t
>(ulong_t));
729 const int32_t long_t)
731 if (((last_position_ - current_position_) >=
sizeof(long_t)) || resize(
sizeof(long_t)))
733 current_position_ << long_t;
734 current_position_ +=
sizeof(long_t);
752 return serialize(
static_cast<uint32_t
>(wchar));
763 const uint64_t ulonglong_t)
765 return serialize(
static_cast<int64_t
>(ulonglong_t));
776 const int64_t longlong_t)
778 if (((last_position_ - current_position_) >=
sizeof(longlong_t)) || resize(
sizeof(longlong_t)))
780 current_position_ << longlong_t;
781 current_position_ +=
sizeof(longlong_t);
799 if (((last_position_ - current_position_) >=
sizeof(float_t)) || resize(
sizeof(float_t)))
801 current_position_ << float_t;
802 current_position_ +=
sizeof(float_t);
818 const double double_t)
820 if (((last_position_ - current_position_) >=
sizeof(double_t)) || resize(
sizeof(double_t)))
822 current_position_ << double_t;
823 current_position_ +=
sizeof(double_t);
839 const long double ldouble_t)
841 if (((last_position_ - current_position_) >=
sizeof(ldouble_t)) || resize(
sizeof(ldouble_t)))
843 current_position_ << ldouble_t;
845 current_position_ +=
sizeof(ldouble_t);
846 current_position_ << static_cast<long double>(0);
848 current_position_ +=
sizeof(ldouble_t);
872 const char* string_t);
881 const wchar_t* string_t);
892 const std::string& string_t)
895 const char* c_str = string_t.c_str();
896 const auto str_len = strlen(c_str);
897 if (string_t.size() > str_len)
913 const std::wstring& string_t)
924 template<
class _T,
size_t _Size>
926 const std::array<_T, _Size>& array_t)
928 return serialize_array(array_t.data(), array_t.size());
937 template<
class _T =
bool>
939 const std::vector<bool>& vector_t)
941 return serialize_bool_sequence(vector_t);
952 const std::vector<_T>& vector_t)
954 state state_before_error(*
this);
956 *this << static_cast<int32_t>(vector_t.size());
960 return serialize_array(vector_t.data(), vector_t.size());
964 set_state(state_before_error);
980 const std::vector<bool>& vector_t)
982 return serialize_bool_sequence(vector_t);
1010 const uint8_t* octet_t,
1011 size_t num_elements)
1013 return serialize_array(
reinterpret_cast<const char*
>(octet_t), num_elements);
1025 size_t num_elements);
1037 size_t num_elements)
1039 return serialize_array(
reinterpret_cast<const char*
>(int8), num_elements);
1051 const uint16_t* ushort_t,
1052 size_t num_elements)
1054 return serialize_array(
reinterpret_cast<const int16_t*
>(ushort_t), num_elements);
1065 const int16_t* short_t,
1066 size_t num_elements);
1077 const uint32_t* ulong_t,
1078 size_t num_elements)
1080 return serialize_array(
reinterpret_cast<const int32_t*
>(ulong_t), num_elements);
1091 const int32_t* long_t,
1092 size_t num_elements);
1102 const wchar_t* wchar,
1103 size_t num_elements);
1114 const uint64_t* ulonglong_t,
1115 size_t num_elements)
1117 return serialize_array(
reinterpret_cast<const int64_t*
>(ulonglong_t), num_elements);
1128 const int64_t* longlong_t,
1129 size_t num_elements);
1139 const float* float_t,
1140 size_t num_elements);
1150 const double* double_t,
1151 size_t num_elements);
1161 const long double* ldouble_t,
1162 size_t num_elements);
1173 size_t num_elements);
1184 const std::string* string_t,
1185 size_t num_elements)
1187 for (
size_t count = 0; count < num_elements; ++count)
1203 const std::wstring* string_t,
1204 size_t num_elements)
1206 for (
size_t count = 0; count < num_elements; ++count)
1222 const std::vector<_T>* vector_t,
1223 size_t num_elements)
1225 for (
size_t count = 0; count < num_elements; ++count)
1242 size_t num_elements)
1244 for (
size_t count = 0; count < num_elements; ++count)
1260 const _T* sequence_t,
1261 size_t num_elements)
1263 state state_before_error(*
this);
1265 serialize(
static_cast<int32_t
>(num_elements));
1269 return serialize_array(sequence_t, num_elements);
1273 set_state(state_before_error);
1290 return deserialize(
reinterpret_cast<char&
>(octet_t));
1303 if ((last_position_ - current_position_) >=
sizeof(char_t))
1305 current_position_++ >> char_t;
1322 return deserialize(
reinterpret_cast<char&
>(int8));
1335 return deserialize(
reinterpret_cast<int16_t&
>(ushort_t));
1348 if ((last_position_ - current_position_) >=
sizeof(short_t))
1350 current_position_ >> short_t;
1351 current_position_ +=
sizeof(short_t);
1369 return deserialize(
reinterpret_cast<int32_t&
>(ulong_t));
1382 if ((last_position_ - current_position_) >=
sizeof(long_t))
1384 current_position_ >> long_t;
1385 current_position_ +=
sizeof(long_t);
1405 wchar =
static_cast<wchar_t>(ret);
1417 uint64_t& ulonglong_t)
1419 return deserialize(
reinterpret_cast<int64_t&
>(ulonglong_t));
1430 int64_t& longlong_t)
1432 if ((last_position_ - current_position_) >=
sizeof(longlong_t))
1434 current_position_ >> longlong_t;
1435 current_position_ +=
sizeof(longlong_t);
1453 if ((last_position_ - current_position_) >=
sizeof(float_t))
1455 current_position_ >> float_t;
1456 current_position_ +=
sizeof(float_t);
1474 if ((last_position_ - current_position_) >=
sizeof(double_t))
1476 current_position_ >> double_t;
1477 current_position_ +=
sizeof(double_t);
1493 long double& ldouble_t)
1495 if ((last_position_ - current_position_) >=
sizeof(ldouble_t))
1497 current_position_ >> ldouble_t;
1498 current_position_ +=
sizeof(ldouble_t);
1500 current_position_ +=
sizeof(ldouble_t);
1541 wchar_t*& string_t);
1551 std::string& string_t)
1553 uint32_t length = 0;
1554 const char* str = read_string(length);
1555 string_t.assign(str, length);
1567 std::wstring& string_t)
1569 uint32_t length = 0;
1570 string_t = read_wstring(length);
1580 template<
class _T,
size_t _Size>
1582 std::array<_T, _Size>& array_t)
1584 return deserialize_array(array_t.data(), array_t.size());
1593 template<
class _T =
bool>
1595 std::vector<bool>& vector_t)
1597 return deserialize_bool_sequence(vector_t);
1608 std::vector<_T>& vector_t)
1610 uint32_t sequence_length = 0;
1611 state state_before_error(*
this);
1613 *
this >> sequence_length;
1617 vector_t.resize(sequence_length);
1618 return deserialize_array(vector_t.data(), vector_t.size());
1622 set_state(state_before_error);
1638 std::vector<bool>& vector_t)
1640 return deserialize_bool_sequence(vector_t);
1669 size_t num_elements)
1671 return deserialize_array(
reinterpret_cast<char*
>(octet_t), num_elements);
1683 size_t num_elements);
1695 size_t num_elements)
1697 return deserialize_array(
reinterpret_cast<char*
>(int8), num_elements);
1710 size_t num_elements)
1712 return deserialize_array(
reinterpret_cast<int16_t*
>(ushort_t), num_elements);
1724 size_t num_elements);
1736 size_t num_elements)
1738 return deserialize_array(
reinterpret_cast<int32_t*
>(ulong_t), num_elements);
1750 size_t num_elements);
1761 size_t num_elements);
1772 uint64_t* ulonglong_t,
1773 size_t num_elements)
1775 return deserialize_array(
reinterpret_cast<int64_t*
>(ulonglong_t), num_elements);
1786 int64_t* longlong_t,
1787 size_t num_elements);
1798 size_t num_elements);
1809 size_t num_elements);
1819 long double* ldouble_t,
1820 size_t num_elements);
1831 size_t num_elements);
1842 std::string* string_t,
1843 size_t num_elements)
1845 for (
size_t count = 0; count < num_elements; ++count)
1861 std::wstring* string_t,
1862 size_t num_elements)
1864 for (
size_t count = 0; count < num_elements; ++count)
1880 std::vector<_T>* vector_t,
1881 size_t num_elements)
1883 for (
size_t count = 0; count < num_elements; ++count)
1900 size_t num_elements)
1902 for (
size_t count = 0; count < num_elements; ++count)
1918 template<
class _T = std::
string>
1920 std::string*& sequence_t,
1921 size_t& num_elements)
1923 return deserialize_string_sequence(sequence_t, num_elements);
1935 template<
class _T = std::w
string>
1937 std::wstring*& sequence_t,
1938 size_t& num_elements)
1940 return deserialize_wstring_sequence(sequence_t, num_elements);
1955 size_t& num_elements)
1957 uint32_t sequence_length = 0;
1958 state state_before_error(*
this);
1964 sequence_t =
reinterpret_cast<_T*
>(calloc(sequence_length,
sizeof(_T)));
1965 deserialize_array(sequence_t, sequence_length);
1971 set_state(state_before_error);
1975 num_elements = sequence_length;
1990 FastCdr& deserialize_sequence<std::string>(
1991 std::string*& sequence_t,
1992 size_t& num_elements)
1994 return deserialize_string_sequence(sequence_t, num_elements);
2007 FastCdr& deserialize_sequence<std::wstring>(
2008 std::wstring*& sequence_t,
2009 size_t& num_elements)
2011 return deserialize_wstring_sequence(sequence_t, num_elements);
2019 const FastCdr&) =
delete;
2021 FastCdr& operator =(
2022 const FastCdr&) =
delete;
2024 FastCdr& serialize_bool_sequence(
2025 const std::vector<bool>& vector_t);
2027 FastCdr& deserialize_bool_sequence(
2028 std::vector<bool>& vector_t);
2030 FastCdr& deserialize_string_sequence(
2031 std::string*& sequence_t,
2032 size_t& num_elements);
2034 FastCdr& deserialize_wstring_sequence(
2035 std::wstring*& sequence_t,
2036 size_t& num_elements);
2045 template<
class _T,
size_t _Size>
2046 FastCdr& serialize_array(
2047 const std::array<_T, _Size>* array_t,
2048 size_t num_elements)
2050 return serialize_array(array_t->data(), num_elements * array_t->size());
2060 template<
class _T,
size_t _Size>
2061 FastCdr& deserialize_array(
2062 std::array<_T, _Size>* array_t,
2063 size_t num_elements)
2065 return deserialize_array(array_t->data(), num_elements * array_t->size());
2069 size_t min_size_inc);
2071 const char* read_string(
2074 std::wstring read_wstring(
2078 FastBuffer& cdr_buffer_;
2081 FastBuffer::iterator current_position_;
2084 FastBuffer::iterator last_position_;
This class implements the iterator used to go through a FastBuffer.
Definition FastBuffer.h:43
This class represents a stream of bytes that contains (or will contain) serialized data.
Definition FastBuffer.h:244
This class stores the current state of a CDR serialization.
Definition FastCdr.h:50
state(const FastCdr &fastcdr)
Default constructor.
state(const state &)
Copy constructor.
This class offers an interface to serialize/deserialize some basic types using a modified CDR protoco...
Definition FastCdr.h:43
FastCdr & deserialize_array(float *float_t, size_t num_elements)
This function deserializes an array of floats.
FastCdr & serialize_array(const int8_t *int8, size_t num_elements)
This function serializes an array of int8_t.
Definition FastCdr.h:1035
FastCdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
FastCdr & deserialize_array(std::vector< _T > *vector_t, size_t num_elements)
This function template deserializes an array of sequences.
Definition FastCdr.h:1879
FastCdr & deserialize(char *&string_t)
This function deserializes a string.
FastCdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition FastCdr.h:1319
FastCdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition FastCdr.h:749
FastCdr & deserialize_array(uint8_t *octet_t, size_t num_elements)
This function deserializes an array of octets.
Definition FastCdr.h:1667
FastCdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence.
Definition FastCdr.h:951
FastCdr & serialize_array(const uint32_t *ulong_t, size_t num_elements)
This function serializes an array of unsigned longs.
Definition FastCdr.h:1076
bool jump(size_t num_bytes)
This function skips a number of bytes in the CDR stream buffer.
FastCdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition FastCdr.h:1400
FastCdr & deserialize_array(std::wstring *string_t, size_t num_elements)
This function deserializes an array of wide-strings.
Definition FastCdr.h:1860
FastCdr & serialize_array(const int32_t *long_t, size_t num_elements)
This function serializes an array of longs.
FastCdr & serialize_array(const _T *type_t, size_t num_elements)
This function template serializes an array of non-basic type objects.
Definition FastCdr.h:1240
FastCdr & deserialize_sequence(_T *&sequence_t, size_t &num_elements)
This function template deserializes a raw sequence.
Definition FastCdr.h:1953
FastCdr & serialize(const uint8_t octet_t)
This function serializes an octet.
Definition FastCdr.h:636
FastCdr & deserialize_array(int16_t *short_t, size_t num_elements)
This function deserializes an array of shorts.
FastCdr & deserialize_array(_T *type_t, size_t num_elements)
This function template deserializes an array of non-basic type objects.
Definition FastCdr.h:1898
FastCdr & deserialize(double &double_t)
This function deserializes a double.
Definition FastCdr.h:1471
FastCdr & serialize(const int16_t short_t)
This function serializes a short.
Definition FastCdr.h:694
FastCdr & deserialize(float &float_t)
This function deserializes a float.
Definition FastCdr.h:1450
FastCdr & serialize_array(const int16_t *short_t, size_t num_elements)
This function serializes an array of shorts.
FastCdr & serialize_array(const wchar_t *wchar, size_t num_elements)
This function serializes an array of wide-chars.
FastCdr & deserialize(bool &bool_t)
This function deserializes a boolean.
FastCdr & serialize_array(const uint16_t *ushort_t, size_t num_elements)
This function serializes an array of unsigned shorts.
Definition FastCdr.h:1050
FastCdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition FastCdr.h:1416
FastCdr & deserialize(std::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition FastCdr.h:1581
FastCdr & serialize_array(const std::string *string_t, size_t num_elements)
This function serializes an array of strings.
Definition FastCdr.h:1183
FastCdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
Definition FastCdr.h:1429
FastCdr & deserialize(_T &type_t)
This function template deserializes a non-basic type object.
Definition FastCdr.h:1652
FastCdr & deserialize(int16_t &short_t)
This function deserializes a short.
Definition FastCdr.h:1345
FastCdr & serialize_array(const uint8_t *octet_t, size_t num_elements)
This function serializes an array of octets.
Definition FastCdr.h:1009
FastCdr & serialize(const float float_t)
This function serializes a float.
Definition FastCdr.h:796
FastCdr & deserialize_sequence(std::string *&sequence_t, size_t &num_elements)
This function template deserializes a string sequence.
Definition FastCdr.h:1919
FastCdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition FastCdr.h:668
FastCdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition FastCdr.h:1566
FastCdr & serialize_array(const char *char_t, size_t num_elements)
This function serializes an array of characters.
FastCdr & deserialize(char &char_t)
This function deserializes a character.
Definition FastCdr.h:1300
FastCdr & serialize(const double double_t)
This function serializes a double.
Definition FastCdr.h:817
FastCdr & serialize_array(const std::wstring *string_t, size_t num_elements)
This function serializes an array of wstrings.
Definition FastCdr.h:1202
FastCdr & deserialize_sequence(std::wstring *&sequence_t, size_t &num_elements)
This function template deserializes a wide-string sequence.
Definition FastCdr.h:1936
FastCdr & serialize(const bool bool_t)
This function serializes a boolean.
FastCdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence.
Definition FastCdr.h:1607
FastCdr & serialize_array(const bool *bool_t, size_t num_elements)
This function serializes an array of booleans.
FastCdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
Definition FastCdr.h:1492
FastCdr & serialize_array(const uint64_t *ulonglong_t, size_t num_elements)
This function serializes an array of unsigned long longs.
Definition FastCdr.h:1113
FastCdr & deserialize_array(uint32_t *ulong_t, size_t num_elements)
This function deserializes an array of unsigned longs.
Definition FastCdr.h:1734
FastCdr & deserialize(wchar_t *&string_t)
This function deserializes a wide string.
FastCdr & deserialize_array(long double *ldouble_t, size_t num_elements)
This function deserializes an array of long doubles.
FastCdr & deserialize_array(int64_t *longlong_t, size_t num_elements)
This function deserializes an array of long longs.
FastCdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition FastCdr.h:715
FastCdr(FastBuffer &cdr_buffer)
This constructor creates a eprosima::fastcdr::FastCdr object that can serialize/deserialize the assig...
FastCdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition FastCdr.h:912
FastCdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition FastCdr.h:681
FastCdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition FastCdr.h:925
FastCdr & serialize_sequence(const _T *sequence_t, size_t num_elements)
This function template serializes a raw sequence.
Definition FastCdr.h:1259
FastCdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition FastCdr.h:762
FastCdr & deserialize(int32_t &long_t)
This function deserializes a long.
Definition FastCdr.h:1379
FastCdr & deserialize_array(uint64_t *ulonglong_t, size_t num_elements)
This function deserializes an array of unsigned long longs.
Definition FastCdr.h:1771
FastCdr & serialize_array(const long double *ldouble_t, size_t num_elements)
This function serializes an array of long doubles.
void set_state(FastCdr::state &state)
This function sets a previous state of the CDR stream;.
FastCdr & serialize_array(const double *double_t, size_t num_elements)
This function serializes an array of doubles.
FastCdr & serialize(const char *string_t)
This function serializes a string.
FastCdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition FastCdr.h:1332
FastCdr & deserialize_array(char *char_t, size_t num_elements)
This function deserializes an array of characters.
FastCdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition FastCdr.h:1366
FastCdr & serialize(const int32_t long_t)
This function serializes a long.
Definition FastCdr.h:728
FastCdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition FastCdr.h:938
FastCdr & deserialize_array(int8_t *int8, size_t num_elements)
This function deserializes an array of int8_t.
Definition FastCdr.h:1693
FastCdr & serialize_array(const int64_t *longlong_t, size_t num_elements)
This function serializes an array of long longs.
FastCdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence of booleans.
Definition FastCdr.h:1594
size_t get_serialized_data_length() const
This function returns the length of the serialized data inside the stream.
Definition FastCdr.h:107
void reset()
This function resets the current position in the buffer to the begining.
FastCdr & serialize(const char char_t)
This function serializes a character.
Definition FastCdr.h:649
FastCdr & deserialize_array(uint16_t *ushort_t, size_t num_elements)
This function deserializes an array of unsigned shorts.
Definition FastCdr.h:1708
FastCdr::state get_state()
This function returns the current state of the CDR stream.
FastCdr & serialize_array(const std::vector< _T > *vector_t, size_t num_elements)
This function template serializes an array of sequences.
Definition FastCdr.h:1221
FastCdr & serialize_array(const float *float_t, size_t num_elements)
This function serializes an array of floats.
FastCdr & deserialize_array(bool *bool_t, size_t num_elements)
This function deserializes an array of booleans.
FastCdr & deserialize_array(std::string *string_t, size_t num_elements)
This function deserializes an array of strings.
Definition FastCdr.h:1841
FastCdr & deserialize_array(double *double_t, size_t num_elements)
This function deserializes an array of doubles.
FastCdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition FastCdr.h:1287
FastCdr & deserialize_array(wchar_t *wchar, size_t num_elements)
This function deserializes an array of wide-chars.
FastCdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition FastCdr.h:891
char * get_current_position()
This function returns the current position in the CDR stream.
FastCdr & serialize(const long double ldouble_t)
This function serializes a long double.
Definition FastCdr.h:838
FastCdr & serialize(const int64_t longlong_t)
This function serializes a long long.
Definition FastCdr.h:775
FastCdr & serialize(const _T &type_t)
This function template serializes a non-basic type.
Definition FastCdr.h:994
FastCdr & deserialize_array(int32_t *long_t, size_t num_elements)
This function deserializes an array of longs.
FastCdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition FastCdr.h:1550
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
void deserialize(Cdr &, _T &)
void serialize(Cdr &, const _T &)