15 #ifndef _FASTCDR_FASTCDR_H_
16 #define _FASTCDR_FASTCDR_H_
18 #include "fastcdr_dll.h"
19 #include "FastBuffer.h"
20 #include "exceptions/NotEnoughMemoryException.h"
25 #if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
70 const state&) =
delete;
109 return m_currentPosition - m_cdrBuffer.begin();
132 const uint8_t octet_t)
134 return serialize(octet_t);
146 return serialize(char_t);
158 return serialize(int8);
168 const uint16_t ushort_t)
170 return serialize(ushort_t);
180 const int16_t short_t)
182 return serialize(short_t);
192 const uint32_t ulong_t)
194 return serialize(ulong_t);
204 const int32_t long_t)
206 return serialize(long_t);
218 return serialize(wchar);
228 const uint64_t ulonglong_t)
230 return serialize(ulonglong_t);
240 const int64_t longlong_t)
242 return serialize(longlong_t);
254 return serialize(float_t);
264 const double double_t)
266 return serialize(double_t);
276 const long double ldouble_t)
278 return serialize(ldouble_t);
290 return serialize(bool_t);
300 const char* string_t)
302 return serialize(string_t);
312 const wchar_t* string_t)
314 return serialize(string_t);
324 const std::string& string_t)
326 return serialize(string_t);
336 const std::wstring& string_t)
338 return serialize(string_t);
348 template<
class _T,
size_t _Size>
350 const std::array<_T, _Size>& array_t)
352 return serialize<_T, _Size>(array_t);
365 const std::vector<_T>& vector_t)
367 return serialize<_T>(vector_t);
393 return deserialize(octet_t);
405 return deserialize(char_t);
417 return deserialize(int8);
429 return deserialize(ushort_t);
441 return deserialize(short_t);
453 return deserialize(ulong_t);
465 return deserialize(long_t);
477 return deserialize(wchar);
487 uint64_t& ulonglong_t)
489 return deserialize(ulonglong_t);
501 return deserialize(longlong_t);
513 return deserialize(float_t);
525 return deserialize(double_t);
535 long double& ldouble_t)
537 return deserialize(ldouble_t);
550 return deserialize(bool_t);
565 return deserialize(string_t);
575 std::string& string_t)
577 return deserialize(string_t);
587 std::wstring& string_t)
589 return deserialize(string_t);
599 template<
class _T,
size_t _Size>
601 std::array<_T, _Size>& array_t)
603 return deserialize<_T, _Size>(array_t);
616 std::vector<_T>& vector_t)
618 return deserialize<_T>(vector_t);
643 const uint8_t octet_t)
645 return serialize(
static_cast<char>(octet_t));
658 if (((m_lastPosition - m_currentPosition) >=
sizeof(char_t)) || resize(
sizeof(char_t)))
660 m_currentPosition++ << char_t;
677 return serialize(
static_cast<char>(int8));
688 const uint16_t ushort_t)
690 return serialize(
static_cast<int16_t
>(ushort_t));
701 const int16_t short_t)
703 if (((m_lastPosition - m_currentPosition) >=
sizeof(short_t)) || resize(
sizeof(short_t)))
705 m_currentPosition << short_t;
706 m_currentPosition +=
sizeof(short_t);
722 const uint32_t ulong_t)
724 return serialize(
static_cast<int32_t
>(ulong_t));
735 const int32_t long_t)
737 if (((m_lastPosition - m_currentPosition) >=
sizeof(long_t)) || resize(
sizeof(long_t)))
739 m_currentPosition << long_t;
740 m_currentPosition +=
sizeof(long_t);
758 return serialize(
static_cast<uint32_t
>(wchar));
769 const uint64_t ulonglong_t)
771 return serialize(
static_cast<int64_t
>(ulonglong_t));
782 const int64_t longlong_t)
784 if (((m_lastPosition - m_currentPosition) >=
sizeof(longlong_t)) || resize(
sizeof(longlong_t)))
786 m_currentPosition << longlong_t;
787 m_currentPosition +=
sizeof(longlong_t);
805 if (((m_lastPosition - m_currentPosition) >=
sizeof(float_t)) || resize(
sizeof(float_t)))
807 m_currentPosition << float_t;
808 m_currentPosition +=
sizeof(float_t);
824 const double double_t)
826 if (((m_lastPosition - m_currentPosition) >=
sizeof(double_t)) || resize(
sizeof(double_t)))
828 m_currentPosition << double_t;
829 m_currentPosition +=
sizeof(double_t);
845 const long double ldouble_t)
847 if (((m_lastPosition - m_currentPosition) >=
sizeof(ldouble_t)) || resize(
sizeof(ldouble_t)))
849 m_currentPosition << ldouble_t;
851 m_currentPosition +=
sizeof(ldouble_t);
852 m_currentPosition << static_cast<long double>(0);
854 m_currentPosition +=
sizeof(ldouble_t);
878 const char* string_t);
887 const wchar_t* string_t);
897 const std::string& string_t)
899 return serialize(string_t.c_str());
910 const std::wstring& string_t)
912 return serialize(string_t.c_str());
922 template<
class _T,
size_t _Size>
924 const std::array<_T, _Size>& array_t)
926 return serializeArray(array_t.data(), array_t.size());
931 #if !defined(_MSC_VER) && HAVE_CXX0X
938 template<
class _T =
bool>
940 const std::vector<bool>& vector_t)
942 return serializeBoolSequence(vector_t);
955 const std::vector<_T>& vector_t)
957 state state_before_error(*
this);
959 *this << static_cast<int32_t>(vector_t.size());
963 return serializeArray(vector_t.data(), vector_t.size());
967 setState(state_before_error);
983 const std::vector<bool>& vector_t)
985 return serializeBoolSequence(vector_t);
1013 const uint8_t* octet_t,
1016 return serializeArray(
reinterpret_cast<const char*
>(octet_t), numElements);
1028 size_t numElements);
1042 return serializeArray(
reinterpret_cast<const char*
>(int8), numElements);
1054 const uint16_t* ushort_t,
1057 return serializeArray(
reinterpret_cast<const int16_t*
>(ushort_t), numElements);
1068 const int16_t* short_t,
1069 size_t numElements);
1080 const uint32_t* ulong_t,
1083 return serializeArray(
reinterpret_cast<const int32_t*
>(ulong_t), numElements);
1094 const int32_t* long_t,
1095 size_t numElements);
1105 const wchar_t* wchar,
1106 size_t numElements);
1117 const uint64_t* ulonglong_t,
1120 return serializeArray(
reinterpret_cast<const int64_t*
>(ulonglong_t), numElements);
1131 const int64_t* longlong_t,
1132 size_t numElements);
1142 const float* float_t,
1143 size_t numElements);
1153 const double* double_t,
1154 size_t numElements);
1164 const long double* ldouble_t,
1165 size_t numElements);
1176 size_t numElements);
1187 const std::string* string_t,
1190 for (
size_t count = 0; count < numElements; ++count)
1192 serialize(string_t[count].c_str());
1206 const std::wstring* string_t,
1209 for (
size_t count = 0; count < numElements; ++count)
1211 serialize(string_t[count].c_str());
1225 const std::vector<_T>* vector_t,
1228 for (
size_t count = 0; count < numElements; ++count)
1230 serialize(vector_t[count]);
1247 for (
size_t count = 0; count < numElements; ++count)
1263 const _T* sequence_t,
1266 state state_before_error(*
this);
1268 serialize(
static_cast<int32_t
>(numElements));
1272 return serializeArray(sequence_t, numElements);
1276 setState(state_before_error);
1293 return deserialize(
reinterpret_cast<char&
>(octet_t));
1306 if ((m_lastPosition - m_currentPosition) >=
sizeof(char_t))
1308 m_currentPosition++ >> char_t;
1325 return deserialize(
reinterpret_cast<char&
>(int8));
1338 return deserialize(
reinterpret_cast<int16_t&
>(ushort_t));
1351 if ((m_lastPosition - m_currentPosition) >=
sizeof(short_t))
1353 m_currentPosition >> short_t;
1354 m_currentPosition +=
sizeof(short_t);
1372 return deserialize(
reinterpret_cast<int32_t&
>(ulong_t));
1385 if ((m_lastPosition - m_currentPosition) >=
sizeof(long_t))
1387 m_currentPosition >> long_t;
1388 m_currentPosition +=
sizeof(long_t);
1408 wchar =
static_cast<wchar_t>(ret);
1420 uint64_t& ulonglong_t)
1422 return deserialize(
reinterpret_cast<int64_t&
>(ulonglong_t));
1433 int64_t& longlong_t)
1435 if ((m_lastPosition - m_currentPosition) >=
sizeof(longlong_t))
1437 m_currentPosition >> longlong_t;
1438 m_currentPosition +=
sizeof(longlong_t);
1456 if ((m_lastPosition - m_currentPosition) >=
sizeof(float_t))
1458 m_currentPosition >> float_t;
1459 m_currentPosition +=
sizeof(float_t);
1477 if ((m_lastPosition - m_currentPosition) >=
sizeof(double_t))
1479 m_currentPosition >> double_t;
1480 m_currentPosition +=
sizeof(double_t);
1496 long double& ldouble_t)
1498 if ((m_lastPosition - m_currentPosition) >=
sizeof(ldouble_t))
1500 m_currentPosition >> ldouble_t;
1501 m_currentPosition +=
sizeof(ldouble_t);
1503 m_currentPosition +=
sizeof(ldouble_t);
1544 wchar_t*& string_t);
1554 std::string& string_t)
1556 uint32_t length = 0;
1557 const char* str = readString(length);
1558 string_t = std::string(str, length);
1570 std::wstring& string_t)
1572 uint32_t length = 0;
1573 string_t = readWString(length);
1584 template<
class _T,
size_t _Size>
1586 std::array<_T, _Size>& array_t)
1588 return deserializeArray(array_t.data(), array_t.size());
1593 #if !defined(_MSC_VER) && HAVE_CXX0X
1600 template<
class _T =
bool>
1601 FastCdr& deserialize(
1602 std::vector<bool>& vector_t)
1604 return deserializeBoolSequence(vector_t);
1617 std::vector<_T>& vector_t)
1619 uint32_t seqLength = 0;
1620 state state_before_error(*
this);
1626 vector_t.resize(seqLength);
1627 return deserializeArray(vector_t.data(), vector_t.size());
1631 setState(state_before_error);
1647 std::vector<bool>& vector_t)
1649 return deserializeBoolSequence(vector_t);
1680 return deserializeArray(
reinterpret_cast<char*
>(octet_t), numElements);
1692 size_t numElements);
1706 return deserializeArray(
reinterpret_cast<char*
>(int8), numElements);
1721 return deserializeArray(
reinterpret_cast<int16_t*
>(ushort_t), numElements);
1733 size_t numElements);
1747 return deserializeArray(
reinterpret_cast<int32_t*
>(ulong_t), numElements);
1759 size_t numElements);
1770 size_t numElements);
1781 uint64_t* ulonglong_t,
1784 return deserializeArray(
reinterpret_cast<int64_t*
>(ulonglong_t), numElements);
1795 int64_t* longlong_t,
1796 size_t numElements);
1807 size_t numElements);
1818 size_t numElements);
1828 long double* ldouble_t,
1829 size_t numElements);
1840 size_t numElements);
1851 std::string* string_t,
1854 for (
size_t count = 0; count < numElements; ++count)
1856 deserialize(string_t[count]);
1870 std::wstring* string_t,
1873 for (
size_t count = 0; count < numElements; ++count)
1875 deserialize(string_t[count]);
1889 std::vector<_T>* vector_t,
1892 for (
size_t count = 0; count < numElements; ++count)
1894 deserialize(vector_t[count]);
1911 for (
size_t count = 0; count < numElements; ++count)
1918 #if !defined(_MSC_VER) && HAVE_CXX0X
1928 template<
class _T = std::
string>
1930 std::string*& sequence_t,
1931 size_t& numElements)
1933 return deserializeStringSequence(sequence_t, numElements);
1945 template<
class _T = std::w
string>
1946 FastCdr& deserializeSequence(
1947 std::wstring*& sequence_t,
1948 size_t& numElements)
1950 return deserializeWStringSequence(sequence_t, numElements);
1967 size_t& numElements)
1969 uint32_t seqLength = 0;
1970 state state_before_error(*
this);
1972 deserialize(seqLength);
1976 sequence_t =
reinterpret_cast<_T*
>(calloc(seqLength,
sizeof(_T)));
1977 deserializeArray(sequence_t, seqLength);
1983 setState(state_before_error);
1987 numElements = seqLength;
2002 FastCdr& deserializeSequence<std::string>(
2003 std::string*& sequence_t,
2004 size_t& numElements)
2006 return deserializeStringSequence(sequence_t, numElements);
2019 FastCdr& deserializeSequence<std::wstring>(
2020 std::wstring*& sequence_t,
2021 size_t& numElements)
2023 return deserializeWStringSequence(sequence_t, numElements);
2031 const FastCdr&) =
delete;
2033 FastCdr& operator =(
2034 const FastCdr&) =
delete;
2036 FastCdr& serializeBoolSequence(
2037 const std::vector<bool>& vector_t);
2039 FastCdr& deserializeBoolSequence(
2040 std::vector<bool>& vector_t);
2042 FastCdr& deserializeStringSequence(
2043 std::string*& sequence_t,
2044 size_t& numElements);
2046 FastCdr& deserializeWStringSequence(
2047 std::wstring*& sequence_t,
2048 size_t& numElements);
2058 template<
class _T,
size_t _Size>
2059 FastCdr& serializeArray(
2060 const std::array<_T, _Size>* array_t,
2063 return serializeArray(array_t->data(), numElements * array_t->size());
2073 template<
class _T,
size_t _Size>
2074 FastCdr& deserializeArray(
2075 std::array<_T, _Size>* array_t,
2078 return deserializeArray(array_t->data(), numElements * array_t->size());
2086 const char* readString(
2089 std::wstring readWString(
2093 FastBuffer& m_cdrBuffer;
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:229
_FastBuffer_iterator iterator
Definition: FastBuffer.h:232
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::state getState()
This function returns the current state of the CDR stream.
FastCdr & serializeArray(const double *double_t, size_t numElements)
This function serializes an array of doubles.
FastCdr & serializeSequence(const _T *sequence_t, size_t numElements)
This function template serializes a raw sequence.
Definition: FastCdr.h:1262
FastCdr & deserializeArray(int32_t *long_t, size_t numElements)
This function deserializes an array of longs.
FastCdr & serializeArray(const uint8_t *octet_t, size_t numElements)
This function serializes an array of octets.
Definition: FastCdr.h:1012
FastCdr & deserialize(int32_t &long_t)
This function deserializes a long.
Definition: FastCdr.h:1382
FastCdr & serializeArray(const std::vector< _T > *vector_t, size_t numElements)
This function template serializes an array of sequences.
Definition: FastCdr.h:1224
FastCdr & serialize(const int16_t short_t)
This function serializes a short.
Definition: FastCdr.h:700
FastCdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition: FastCdr.h:1290
FastCdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition: FastCdr.h:1569
FastCdr & deserialize(int16_t &short_t)
This function deserializes a short.
Definition: FastCdr.h:1348
FastCdr & deserializeArray(uint8_t *octet_t, size_t numElements)
This function deserializes an array of octets.
Definition: FastCdr.h:1676
FastCdr & deserialize(wchar_t *&string_t)
This function deserializes a wide string.
FastCdr & serialize(const uint8_t octet_t)
This function serializes an octet.
Definition: FastCdr.h:642
FastCdr & serialize(const float float_t)
This function serializes a float.
Definition: FastCdr.h:802
FastCdr & serializeArray(const std::wstring *string_t, size_t numElements)
This function serializes an array of wstrings.
Definition: FastCdr.h:1205
FastCdr & deserialize(char *&string_t)
This function deserializes a string.
FastCdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition: FastCdr.h:768
FastCdr(FastBuffer &cdrBuffer)
This constructor creates a eprosima::fastcdr::FastCdr object that can serialize/deserialize the assig...
FastCdr & deserializeArray(std::string *string_t, size_t numElements)
This function deserializes an array of strings.
Definition: FastCdr.h:1850
FastCdr & serialize(const _T &type_t)
This function template serializes a non-basic type.
Definition: FastCdr.h:997
FastCdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition: FastCdr.h:1553
FastCdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
Definition: FastCdr.h:1495
size_t getSerializedDataLength() const
This function returns the length of the serialized data inside the stream.
Definition: FastCdr.h:107
FastCdr & deserialize(double &double_t)
This function deserializes a double.
Definition: FastCdr.h:1474
FastCdr & deserialize(char &char_t)
This function deserializes a character.
Definition: FastCdr.h:1303
FastCdr & serialize(const bool bool_t)
This function serializes a boolean.
FastCdr & deserializeArray(int64_t *longlong_t, size_t numElements)
This function deserializes an array of long longs.
FastCdr & serializeArray(const bool *bool_t, size_t numElements)
This function serializes an array of booleans.
FastCdr & serializeArray(const char *char_t, size_t numElements)
This function serializes an array of characters.
FastCdr & serializeArray(const float *float_t, size_t numElements)
This function serializes an array of floats.
FastCdr & deserializeArray(int8_t *int8, size_t numElements)
This function deserializes an array of int8_t.
Definition: FastCdr.h:1702
FastCdr & deserializeArray(std::vector< _T > *vector_t, size_t numElements)
This function template deserializes an array of sequences.
Definition: FastCdr.h:1888
FastCdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: FastCdr.h:1403
FastCdr & deserializeArray(float *float_t, size_t numElements)
This function deserializes an array of floats.
FastCdr & serializeArray(const int32_t *long_t, size_t numElements)
This function serializes an array of longs.
FastCdr & deserializeArray(_T *type_t, size_t numElements)
This function template deserializes an array of non-basic type objects.
Definition: FastCdr.h:1907
FastCdr & deserializeArray(char *char_t, size_t numElements)
This function deserializes an array of characters.
FastCdr & serializeArray(const _T *type_t, size_t numElements)
This function template serializes an array of non-basic type objects.
Definition: FastCdr.h:1243
FastCdr & serializeArray(const wchar_t *wchar, size_t numElements)
This function serializes an array of wide-chars.
FastCdr & serialize(const long double ldouble_t)
This function serializes a long double.
Definition: FastCdr.h:844
FastCdr & deserialize(float &float_t)
This function deserializes a float.
Definition: FastCdr.h:1453
FastCdr & deserializeSequence(_T *&sequence_t, size_t &numElements)
This function template deserializes a raw sequence.
Definition: FastCdr.h:1965
FastCdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence.
Definition: FastCdr.h:954
FastCdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition: FastCdr.h:674
FastCdr & serializeArray(const int64_t *longlong_t, size_t numElements)
This function serializes an array of long longs.
FastCdr & deserializeArray(int16_t *short_t, size_t numElements)
This function deserializes an array of shorts.
FastCdr & serializeArray(const uint16_t *ushort_t, size_t numElements)
This function serializes an array of unsigned shorts.
Definition: FastCdr.h:1053
FastCdr & deserialize(bool &bool_t)
This function deserializes a boolean.
FastCdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence.
Definition: FastCdr.h:1616
FastCdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition: FastCdr.h:755
FastCdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: FastCdr.h:1369
FastCdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition: FastCdr.h:687
FastCdr & serializeArray(const long double *ldouble_t, size_t numElements)
This function serializes an array of long doubles.
FastCdr & deserialize(_T &type_t)
This function template deserializes a non-basic type object.
Definition: FastCdr.h:1661
FastCdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
void setState(FastCdr::state &state)
This function sets a previous state of the CDR stream;.
FastCdr & serializeArray(const std::string *string_t, size_t numElements)
This function serializes an array of strings.
Definition: FastCdr.h:1186
FastCdr & deserializeArray(bool *bool_t, size_t numElements)
This function deserializes an array of booleans.
FastCdr & deserializeArray(double *double_t, size_t numElements)
This function deserializes an array of doubles.
FastCdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
Definition: FastCdr.h:1432
FastCdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition: FastCdr.h:721
FastCdr & deserializeArray(uint16_t *ushort_t, size_t numElements)
This function deserializes an array of unsigned shorts.
Definition: FastCdr.h:1717
FastCdr & serialize(const int64_t longlong_t)
This function serializes a long long.
Definition: FastCdr.h:781
FastCdr & deserializeArray(wchar_t *wchar, size_t numElements)
This function deserializes an array of wide-chars.
FastCdr & serialize(const char *string_t)
This function serializes a string.
FastCdr & deserializeArray(std::wstring *string_t, size_t numElements)
This function deserializes an array of wide-strings.
Definition: FastCdr.h:1869
void reset()
This function resets the current position in the buffer to the begining.
FastCdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition: FastCdr.h:909
bool jump(size_t numBytes)
This function skips a number of bytes in the CDR stream buffer.
char * getCurrentPosition()
This function returns the current position in the CDR stream.
FastCdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements)
This function serializes an array of unsigned long longs.
Definition: FastCdr.h:1116
FastCdr & serializeArray(const int8_t *int8, size_t numElements)
This function serializes an array of int8_t.
Definition: FastCdr.h:1038
FastCdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition: FastCdr.h:1322
FastCdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: FastCdr.h:1335
FastCdr & deserializeArray(long double *ldouble_t, size_t numElements)
This function deserializes an array of long doubles.
FastCdr & serialize(const int32_t long_t)
This function serializes a long.
Definition: FastCdr.h:734
FastCdr & deserializeArray(uint32_t *ulong_t, size_t numElements)
This function deserializes an array of unsigned longs.
Definition: FastCdr.h:1743
FastCdr & serialize(const double double_t)
This function serializes a double.
Definition: FastCdr.h:823
FastCdr & serializeArray(const uint32_t *ulong_t, size_t numElements)
This function serializes an array of unsigned longs.
Definition: FastCdr.h:1079
FastCdr & serializeArray(const int16_t *short_t, size_t numElements)
This function serializes an array of shorts.
FastCdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition: FastCdr.h:896
FastCdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements)
This function deserializes an array of unsigned long longs.
Definition: FastCdr.h:1780
FastCdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition: FastCdr.h:1419
FastCdr & serialize(const char char_t)
This function serializes a character.
Definition: FastCdr.h:655
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:82