Class Cdr

Defined in File Cdr.h

Nested Relationships

Nested Types

Class Cdr::state

Class Documentation

class Cdr

This class offers an interface to serialize/deserialize some basic types using CDR protocol inside an eprosima::fastcdr::FastBuffer.

Public Types

enum Endianness

This enumeration represents endianness types.

Values:

enumerator BIG_ENDIANNESS: Big endianness.

enumerator LITTLE_ENDIANNESS: Little endianness.

enum XCdrHeaderSelection

Used to decide, in encoding algorithms where member headers support a short header version and a long header version, which one will be used.

Values:

enumerator SHORT_HEADER: Initially a short member header is allocated and cannot be changed. This option may cause an exception.

enumerator LONG_HEADER: Initially a long member header is allocated and cannot be changed.

enumerator AUTO_WITH_SHORT_HEADER_BY_DEFAULT: Initially a short member header is allocated but can be changed to the longer version.

enumerator AUTO_WITH_LONG_HEADER_BY_DEFAULT: Initially a long member header is allocated but can be changed to the shorter version.

Public Functions

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 buffer.

Parameters:

cdr_buffer – A reference to the buffer that contains (or will contain) the CDR representation.
endianness – The initial endianness that will be used. The default value is the endianness of the system.
cdr_version – Represents the type of encoding algorithm that will be used for the encoding. The default value is CdrVersion::XCDRv2.

Cdr_DllAPI Cdr & read_encapsulation ()

This function reads the encapsulation of the CDR stream. If the CDR stream contains an encapsulation, then this function should be called before starting to deserialize. CdrVersion and EncodingAlgorithmFlag internal values will be changed to the ones specified by the encapsulation.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
exception::BadParamException – This exception is thrown when trying to deserialize an invalid value.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_encapsulation ()

This function writes the encapsulation of the CDR stream. If the CDR stream should contain an encapsulation, then this function should be called before starting to serialize.

Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI CdrVersion get_cdr_version () const

Retrieves the CdrVersion used by the instance.

Returns:: Configured CdrVersion.

Cdr_DllAPI EncodingAlgorithmFlag get_encoding_flag () const

Returns the EncodingAlgorithmFlag set in the encapsulation when the CDR type is CdrVersion::DDS_CDR, CdrVersion::XCDRv1 or CdrVersion::XCDRv2.

Returns:: The specified flag in the encapsulation.

Cdr_DllAPI bool set_encoding_flag (EncodingAlgorithmFlag encoding_flag)

Sets the EncodingAlgorithmFlag for the encapsulation when the CDR type is CdrVersion::DDS_CDR, CdrVersion::XCDRv1 or CdrVersion::XCDRv2. This function only works when is called before starting the encoding/decoding.

Parameters:: encoding_flag – [in] Value to be used in the encapsulation.
Returns:: Indicates whether the setting was successful.

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.

Returns:: The option flags.

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.

Parameters:: options – New value for the option flags.

Cdr_DllAPI void change_endianness (Endianness endianness)

This function sets the current endianness used by the CDR type.

Parameters:: endianness – The new endianness value.

Cdr_DllAPI Endianness endianness () const

This function returns the current endianness used by the CDR type.

Returns:: The endianness.

Cdr_DllAPI bool jump (size_t num_bytes)

This function skips a number of bytes in the CDR stream buffer.

Parameters:: num_bytes – The number of bytes that will be jumped.
Returns:: True is returned when it works successfully. Otherwise, false is returned.

Cdr_DllAPI void reset (): This function resets the current position in the buffer to the beginning.

Cdr_DllAPI char * get_buffer_pointer ()

This function returns the pointer to the current used buffer.

Returns:: Pointer to the starting position of the buffer.

Cdr_DllAPI char * get_current_position ()

This function returns the current position in the CDR stream.

Returns:: Pointer to the current position in the buffer.

Cdr_DllAPI size_t get_serialized_data_length () const

This function returns the length of the serialized data inside the stream.

Returns:: The length of the serialized data.

Cdr_DllAPI state get_state () const

Returns the current state of the CDR serialization process.

Returns:: The current state of the CDR serialization process.

Cdr_DllAPI void set_state (const state &state)

Sets a previous state of the CDR serialization process;.

Parameters:: state – Previous state that will be set.

Cdr_DllAPI bool move_alignment_forward (size_t num_bytes)

This function moves the alignment forward.

Parameters:: num_bytes – The number of bytes the alignment should advance.
Returns:: True If alignment was moved successfully.

inline void reset_alignment(): This function resets the alignment to the current position in the buffer.

template<class _T> inline Cdr &operator<<(const _T &value)

Encodes the value into the buffer.

If previously a MemberId was set using operator<<, this operator will encode the value as a member of a type consistent with the set member identifier and according to the encoding algorithm used.

In other case, the operator will simply encode the value.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &operator>>(_T &value)

Decodes the value from the buffer.

If this operator is called while decoding members of a type, this operator will decode the value as a member according to the encoding algorithm used.

In other case, the operator will simply decode the value.

Parameters:: value – [out] Reference to the variable where the value will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void> inline Cdr &serialize(const _T &value)

Encodes the value of a type into the buffer.

To do that, the encoder expects a function serialize to be provided by the type.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize(const _T &value, Endianness endianness)

Encodes the value of a type with a different endianness.

Parameters:

value – [in] A reference to the value which will be encoded in the buffer.
endianness – Endianness that will be used in the serialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int32_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint32_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int16_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint16_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int8_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint8_t>::value>::type* = nullptr> inline Cdr &serialize(const _T &value)

Encodes the value of a enumerator into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const uint8_t &octet_t)

This function serializes an octet.

Parameters:: octet_t – The value of the octet that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const char char_t)

This function serializes a character.

Parameters:: char_t – The value of the character that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const int8_t int8)

This function serializes an int8_t.

Parameters:: int8 – The value of the int8_t that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const uint16_t ushort_t)

This function serializes an unsigned short.

Parameters:: ushort_t – The value of the unsigned short that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const int16_t short_t)

This function serializes a short.

Parameters:: short_t – The value of the short that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const uint32_t ulong_t)

This function serializes an unsigned long.

Parameters:: ulong_t – The value of the unsigned long that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const int32_t long_t)

This function serializes a long.

Parameters:: long_t – The value of the long that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const wchar_t wchar)

This function serializes a wide-char.

Parameters:: wchar – The value of the wide-char that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const uint64_t ulonglong_t)

This function serializes an unsigned long long.

Parameters:: ulonglong_t – The value of the unsigned long long that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const int64_t longlong_t)

This function serializes a long long.

Parameters:: longlong_t – The value of the long long that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const float float_t)

This function serializes a float.

Parameters:: float_t – The value of the float that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const double double_t)

This function serializes a double.

Parameters:: double_t – The value of the double that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const long double ldouble_t)

This function serializes a long double.

Note

Due to internal representation differences, WIN32 and *NIX like systems are not compatible.

Parameters:: ldouble_t – The value of the long double that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const bool bool_t)

This function serializes a boolean.

Parameters:: bool_t – The value of the boolean that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (char *string_t)

This function serializes a string.

Parameters:: string_t – The pointer to the string that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const char *string_t)

This function serializes a string.

Parameters:: string_t – The pointer to the string that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize (const wchar_t *string_t)

This function serializes a wstring.

Parameters:: string_t – The pointer to the wstring that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize (const std::string &string_t)

This function serializes a std::string.

Parameters:

string_t – The string that will be serialized in the buffer.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
exception::BadParamException – This exception is thrown when trying to serialize a string with null characters.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize (const std::wstring &string_t)

This function serializes a std::wstring.

Parameters:: string_t – The wstring that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t MAX_CHARS> inline Cdr &serialize(const fixed_string<MAX_CHARS> &value)

Encodes a eprosima::fastcdr::fixed_string in the buffer.

Parameters:: value – [in] A reference to the fixed string which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, size_t _Size> inline Cdr &serialize(const std::array<_T, _Size> &array_t)

This function template serializes an array.

Parameters:: array_t – The array that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize(const std::vector<_T> &vector_t)

This function template serializes a sequence of non-primitive.

Parameters:: vector_t – The sequence that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize(const std::vector<_T> &vector_t)

This function template serializes a sequence of primitive.

Parameters:: vector_t – The sequence that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize (const std::vector< bool > &vector_t)

This function template serializes a sequence of booleans.

Parameters:: vector_t – The sequence that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize(const std::map<_K, _T> &map_t)

This function template serializes a map of non-primitive.

Parameters:: map_t – The map that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize(const std::map<_K, _T> &map_t)

This function template serializes a map of primitive.

Parameters:: map_t – The map that will be serialized in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t N, typename std::enable_if<(N < 9)>::type* = nullptr> inline Cdr &serialize(const std::bitset<N> &value)

Encodes the value of a bitset into the buffer.

Parameters:: value – [in] A reference to the value which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t N, typename std::enable_if<(8 < N && N < 17)>::type* = nullptr> inline Cdr &serialize(const std::bitset<N> &value)

template<size_t N, typename std::enable_if<(16 < N && N < 33)>::type* = nullptr> inline Cdr &serialize(const std::bitset<N> &value)

template<size_t N, typename std::enable_if<(32 < N && N < 65)>::type* = nullptr> inline Cdr &serialize(const std::bitset<N> &value)

template<class _T> inline Cdr &serialize_array(const _T *value, size_t num_elements)

Encodes an array of a type not managed by this encoder into the buffer.

To do that, the encoder expects a function serialize to be provided by the type.

Parameters:

value – [in] Array which will be encoded in the buffer.
num_elements – [in] Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline 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.

Parameters:

type_t – The array of objects that will be serialized in the buffer.
num_elements – Number of the elements in the array.
endianness – Endianness that will be used in the serialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const uint8_t *octet_t, size_t num_elements)

This function serializes an array of octets.

Parameters:

octet_t – The sequence of octets that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const char *char_t, size_t num_elements)

This function serializes an array of characters.

Parameters:

char_t – The array of characters that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const int8_t *int8, size_t num_elements)

This function serializes an array of int8_t.

Parameters:

int8 – The sequence of int8_t that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const uint16_t *ushort_t, size_t num_elements)

This function serializes an array of unsigned shorts.

Parameters:

ushort_t – The array of unsigned shorts that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const int16_t *short_t, size_t num_elements)

This function serializes an array of shorts.

Parameters:

short_t – The array of shorts that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const uint32_t *ulong_t, size_t num_elements)

This function serializes an array of unsigned longs.

Parameters:

ulong_t – The array of unsigned longs that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const int32_t *long_t, size_t num_elements)

This function serializes an array of longs.

Parameters:

long_t – The array of longs that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const wchar_t *wchar, size_t num_elements)

This function serializes an array of wide-chars.

Parameters:

wchar – The array of wide-chars that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const uint64_t *ulonglong_t, size_t num_elements)

This function serializes an array of unsigned long longs.

Parameters:

ulonglong_t – The array of unsigned long longs that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const int64_t *longlong_t, size_t num_elements)

This function serializes an array of long longs.

Parameters:

longlong_t – The array of long longs that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const float *float_t, size_t num_elements)

This function serializes an array of floats.

Parameters:

float_t – The array of floats that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const double *double_t, size_t num_elements)

This function serializes an array of doubles.

Parameters:

double_t – The array of doubles that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const long double *ldouble_t, size_t num_elements)

This function serializes an array of long doubles.

Note

Due to internal representation differences, WIN32 and *NIX like systems are not compatible.

Parameters:

ldouble_t – The array of long doubles that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & serialize_array (const bool *bool_t, size_t num_elements)

This function serializes an array of booleans.

Parameters:

bool_t – The array of booleans that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const std::string *string_t, size_t num_elements)

This function serializes an array of strings.

Parameters:

string_t – The array of strings that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const std::wstring *string_t, size_t num_elements)

This function serializes an array of wide-strings.

Parameters:

string_t – The array of wide-strings that will be serialized in the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<size_t MAX_CHARS> inline Cdr &serialize_array(const fixed_string<MAX_CHARS> *value, size_t num_elements)

Encodes an array of fixed strings.

Parameters:

value – [in] Array of fixed strings which will be encoded in the buffer.
num_elements – [in] Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize_array(const std::vector<_T> &value)

Encodes an std::vector of primitives as an array.

Parameters:: value – [in] Reference to a std::vector.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize_array(const std::vector<_T> &value)

Encodes an std::vector of non-primitives as an array.

Parameters:: value – [in] Reference to a std::vector.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize_array(const std::vector<_T> &value, Endianness endianness)

Encodes an std::vector as an array with a different endianness.

Parameters:

value – [in] Reference to a std::vector.
endianness – [in] Endianness that will be used in the serialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & serialize_array (const std::vector< bool > &value)

Encodes an std::vector of booleans as an array.

Parameters:: value – [in] Reference to a std::vector.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize_sequence(const _T *sequence_t, size_t num_elements)

This function template serializes a raw sequence of non-primitives.

Parameters:

sequence_t – Pointer to the sequence that will be serialized in the buffer.
num_elements – The number of elements contained in the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &serialize_sequence(const _T *sequence_t, size_t num_elements)

This function template serializes a raw sequence of primitives.

Parameters:

sequence_t – Pointer to the sequence that will be serialized in the buffer.
num_elements – The number of elements contained in the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize_sequence(const _T *sequence_t, size_t num_elements, Endianness endianness)

This function template serializes a raw sequence with a different endianness.

Parameters:

sequence_t – Pointer to the sequence that will be serialized in the buffer.
num_elements – The number of elements contained in the sequence.
endianness – Endianness that will be used in the serialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to serialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value>::type* = nullptr, typename = void> inline Cdr &deserialize(_T &value)

Decodes the value of a type from the buffer.

To do that, the encoder expects a function deserialize to be provided by the type.

Parameters:: value – [out] Reference to the variable where the value will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize(_T &value, Endianness endianness)

Decodes the value of a type with a different endianness.

Parameters:

value – [out] Reference to the variable where the value will be stored after decoding from the buffer.
endianness – Endianness that will be used in the deserialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int32_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint32_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int16_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint16_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, int8_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value>::type* = nullptr, typename std::enable_if<std::is_same<typename std::underlying_type<_T>::type, uint8_t>::value>::type* = nullptr> inline Cdr &deserialize(_T &value)

Decodes an enumeration from the buffer.

Parameters:: value – [out] Reference to the variable where the enumeration will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (uint8_t &octet_t)

This function deserializes an octet.

Parameters:: octet_t – The variable that will store the octet read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (char &char_t)

This function deserializes a character.

Parameters:: char_t – The variable that will store the character read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (int8_t &int8)

This function deserializes an int8_t.

Parameters:: int8 – The variable that will store the int8_t read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (uint16_t &ushort_t)

This function deserializes an unsigned short.

Parameters:: ushort_t – The variable that will store the unsigned short read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (int16_t &short_t)

This function deserializes a short.

Parameters:: short_t – The variable that will store the short read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (uint32_t &ulong_t)

This function deserializes an unsigned long.

Parameters:: ulong_t – The variable that will store the unsigned long read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (int32_t &long_t)

This function deserializes a long.

Parameters:: long_t – The variable that will store the long read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (wchar_t &wchar)

This function deserializes a wide-char.

Parameters:: wchar – The variable that will store the wide-char read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (uint64_t &ulonglong_t)

This function deserializes an unsigned long long.

Parameters:: ulonglong_t – The variable that will store the unsigned long long read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (int64_t &longlong_t)

This function deserializes a long long.

Parameters:: longlong_t – The variable that will store the long long read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (float &float_t)

This function deserializes a float.

Parameters:: float_t – The variable that will store the float read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (double &double_t)

This function deserializes a double.

Parameters:: double_t – The variable that will store the double read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (long double &ldouble_t)

This function deserializes a long double.

Note

Due to internal representation differences, WIN32 and *NIX like systems are not compatible.

Parameters:: ldouble_t – The variable that will store the long double read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (bool &bool_t)

This function deserializes a boolean.

Parameters:

bool_t – The variable that will store the boolean read from the buffer.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
exception::BadParamException – This exception is thrown when trying to deserialize an invalid value.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (char *&string_t)

This function deserializes a string. This function allocates memory to store the string. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:: string_t – The pointer that will point to the string read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize (wchar_t *&string_t)

This function deserializes a wide-string. This function allocates memory to store the wide string. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:: string_t – The pointer that will point to the wide string read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (std::string &string_t)

This function deserializes a std::string.

Parameters:: string_t – The variable that will store the string read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (std::wstring &string_t)

This function deserializes a std::wstring.

Parameters:: string_t – The variable that will store the string read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t MAX_CHARS> inline Cdr &deserialize(fixed_string<MAX_CHARS> &value)

Decodes a fixed string.

Parameters:: value – [out] Reference to the variable where the fixed string will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, size_t _Size> inline Cdr &deserialize(std::array<_T, _Size> &array_t)

This function template deserializes an array.

Parameters:: array_t – The variable that will store the array read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize(std::vector<_T> &vector_t)

This function template deserializes a sequence of non-primitive.

Parameters:: vector_t – The variable that will store the sequence read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize(std::vector<_T> &vector_t)

This function template deserializes a sequence of primitive.

Parameters:: vector_t – The variable that will store the sequence read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize (std::vector< bool > &vector_t)

This function template deserializes a sequence.

Parameters:: vector_t – The variable that will store the sequence read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _K, class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize(std::map<_K, _T> &map_t)

This function template deserializes a map of non-primitive.

Parameters:: map_t – The variable that will store the map read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _K, class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize(std::map<_K, _T> &map_t)

This function template deserializes a map of primitive.

Parameters:: map_t – The variable that will store the map read from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t N, typename std::enable_if<(N < 9)>::type* = nullptr> inline Cdr &deserialize(std::bitset<N> &value)

Decodes a bitset from the buffer.

Parameters:: value – [out] Reference to the variable where the bitset will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<size_t N, typename std::enable_if<(8 < N && N < 17)>::type* = nullptr> inline Cdr &deserialize(std::bitset<N> &value)

template<size_t N, typename std::enable_if<(16 < N && N < 33)>::type* = nullptr> inline Cdr &deserialize(std::bitset<N> &value)

template<size_t N, typename std::enable_if<(32 < N && N < 65)>::type* = nullptr> inline Cdr &deserialize(std::bitset<N> &value)

template<class _T> inline Cdr &deserialize_array(_T *value, size_t num_elements)

Decodes an array of a type not managed by this encoder from the buffer.

To do that, the encoder expects a function deserialize to be provided by the type.

Parameters:

value – [out] Reference to the variable where the array will be stored after decoding from the buffer.
num_elements – [in] Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline 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.

Parameters:

type_t – The variable that will store the array of objects read from the buffer.
num_elements – Number of the elements in the array.
endianness – Endianness that will be used in the deserialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (uint8_t *octet_t, size_t num_elements)

This function deserializes an array of octets.

Parameters:

octet_t – The variable that will store the array of octets read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (char *char_t, size_t num_elements)

This function deserializes an array of characters.

Parameters:

char_t – The variable that will store the array of characters read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (int8_t *int8, size_t num_elements)

This function deserializes an array of int8_t.

Parameters:

int8 – The variable that will store the array of int8_t read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (uint16_t *ushort_t, size_t num_elements)

This function deserializes an array of unsigned shorts.

Parameters:

ushort_t – The variable that will store the array of unsigned shorts read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (int16_t *short_t, size_t num_elements)

This function deserializes an array of shorts.

Parameters:

short_t – The variable that will store the array of shorts read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (uint32_t *ulong_t, size_t num_elements)

This function deserializes an array of unsigned longs.

Parameters:

ulong_t – The variable that will store the array of unsigned longs read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (int32_t *long_t, size_t num_elements)

This function deserializes an array of longs.

Parameters:

long_t – The variable that will store the array of longs read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (wchar_t *wchar, size_t num_elements)

This function deserializes an array of wide-chars.

Parameters:

wchar – The variable that will store the array of wide-chars read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (uint64_t *ulonglong_t, size_t num_elements)

This function deserializes an array of unsigned long longs.

Parameters:

ulonglong_t – The variable that will store the array of unsigned long longs read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (int64_t *longlong_t, size_t num_elements)

This function deserializes an array of long longs.

Parameters:

longlong_t – The variable that will store the array of long longs read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (float *float_t, size_t num_elements)

This function deserializes an array of floats.

Parameters:

float_t – The variable that will store the array of floats read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (double *double_t, size_t num_elements)

This function deserializes an array of doubles.

Parameters:

double_t – The variable that will store the array of doubles read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (long double *ldouble_t, size_t num_elements)

This function deserializes an array of long doubles.

Note

Due to internal representation differences, WIN32 and *NIX like systems are not compatible.

Parameters:

ldouble_t – The variable that will store the array of long doubles read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & deserialize_array (bool *bool_t, size_t num_elements)

This function deserializes an array of booleans.

Parameters:

bool_t – The variable that will store the array of booleans read from the buffer.
num_elements – Number of the elements in the array.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize_array(std::vector<_T> &value)

Decodes an array of primitives on a std::vector.

std::vector must have allocated the number of element of the array.

Parameters:: value – [out] Reference to the std::vector where the array will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize_array(std::vector<_T> &value)

Decodes an array of non-primitives on a std::vector.

std::vector must have allocated the number of element of the array.

Parameters:: value – [out] Reference to the std::vector where the array will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize_array(std::vector<_T> &value, Endianness endianness)

Decodes an array of non-primitives on a std::vector with a different endianness.

std::vector must have allocated the number of element of the array.

Parameters:

value – [out] Reference to the std::vector where the array will be stored after decoding from the buffer.
endianness – [in] Endianness that will be used in the serialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_array (std::vector< bool > &value)

Decodes an array of booleans on a std::vector.

std::vector must have allocated the number of element of the array.

Parameters:: value – [out] Reference to the std::vector where the array will be stored after decoding from the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<!std::is_enum<_T>::value && !std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize_sequence(_T *&sequence_t, size_t &num_elements)

This function template deserializes a raw sequence of non-primitives. This function allocates memory to store the sequence. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:

sequence_t – The pointer that will store the sequence read from the buffer.
num_elements – This variable return the number of elements of the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T, typename std::enable_if<std::is_enum<_T>::value || std::is_arithmetic<_T>::value>::type* = nullptr> inline Cdr &deserialize_sequence(_T *&sequence_t, size_t &num_elements)

This function template deserializes a raw sequence of primitives. This function allocates memory to store the sequence. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:

sequence_t – The pointer that will store the sequence read from the buffer.
num_elements – This variable return the number of elements of the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize_sequence(_T *&sequence_t, size_t &num_elements, Endianness endianness)

This function template deserializes a raw sequence with a different endianness. This function allocates memory to store the sequence. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:

sequence_t – The pointer that will store the sequence read from the buffer.
num_elements – This variable return the number of elements of the sequence.
endianness – Endianness that will be used in the deserialization of this value.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_sequence (std::string *&sequence_t, size_t &num_elements)

This function template deserializes a string sequence. This function allocates memory to store the sequence. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:

sequence_t – The pointer that will store the sequence read from the buffer.
num_elements – This variable return the number of elements of the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

inline TEMPLATE_SPEC Cdr & deserialize_sequence (std::wstring *&sequence_t, size_t &num_elements)

This function template deserializes a wide-string sequence. This function allocates memory to store the sequence. The user pointer will be set to point this allocated memory. The user will have to free this allocated memory using free()

Parameters:

sequence_t – The pointer that will store the sequence read from the buffer.
num_elements – This variable return the number of elements of the sequence.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to deserialize a position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize_member(const MemberId &member_id, const _T &member_value, XCdrHeaderSelection header_selection = XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT)

XCDR extensions.

Encodes a member of a type according to the encoding algorithm used.

Parameters:

member_id – [in] Member identifier.
member_value – [in] Member value.
header_selection – [in] Selects which member header will be used to allocate space. Default: XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline 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.

Parameters:

member_id – [in] Member identifier.
member_value – [in] Optional member value.
header_selection – [in] Selects which member header will be used to allocate space. Default: XCdrHeaderSelection::AUTO_WITH_SHORT_HEADER_BY_DEFAULT.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize_member(_T &member_value)

Decodes a member of a type according to the encoding algorithm used.

Parameters:: member_value – [out] A reference of the variable where the member value will be stored.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize_member(optional<_T> &member_value)

Decodes an optional member of a type according to the encoding algorithm used.

Parameters:: member_value – [out] A reference of the variable where the optional member value will be stored.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

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.

Parameters:

current_state – [inout] State of the encoder previous of calling this function.
type_encoding – [in] The encoding algorithm used to encode the type and its members.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & end_serialize_type (Cdr::state &current_state)

Tells to the encoder the encoding of the type finishes.

Parameters:: current_state – [in] State of the encoder previous of calling the function begin_serialize_type.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

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.

Parameters:

type_encoding – [in] The encoding algorithm used to decode the type and its members.
functor – [in] Functor called each time a member has to be decoded.

Throws:

exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize(const optional<_T> &value)

Encodes an optional in the buffer.

Parameters:: value – [in] A reference to the optional which will be encoded in the buffer.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &serialize(const external<_T> &value)

Encodes an external in the buffer.

Parameters:

value – [in] A reference to the external which will be encoded in the buffer.

Throws:

exception::BadParamException – This exception is thrown when external is null.
exception::NotEnoughMemoryException – This exception is thrown when trying to encode into a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI Cdr & operator<< (const MemberId &member_id)

Tells the encoder the member identifier for the next member to be encoded.

Parameters:: member_id – [in] Member identifier.
Throws:: exception::BadParamException – This exception is thrown when a member id is already set without being encoded.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize(optional<_T> &value)

Decodes an optional from the buffer.

Parameters:: value – [out] A reference to the variable where the optional will be stored.
Throws:: exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.
Returns:: Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize(external<_T> &value)

Decodes an external from the buffer.

Parameters:

value – [out] A reference to the variable where the external will be stored.

Throws:

exception::BadParamException – This exception is thrown when the external is locked.
exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

template<class _T> inline Cdr &deserialize(optional<external<_T>> &value)

Decodes an optional of an external from the buffer.

Parameters:

value – [out] A reference to the variable where the optional will be stored.

Throws:

exception::BadParamException – This exception is thrown when the external is locked.
exception::NotEnoughMemoryException – This exception is thrown when trying to decode from a buffer position that exceeds the internal memory size.

Returns:

Reference to the eprosima::fastcdr::Cdr object.

Cdr_DllAPI state allocate_xcdrv2_dheader (): Encodes an empty DHEADER if the encoding version is XCDRv2. After serializing the members’s type, set_xcdrv2_dheader must be called to set the correct DHEADER value using the state returned by this function.

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 DHEADER.

Parameters:: state – [in] state used to calculate the member’s type size.

Public Static Functions

static inline 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.

Parameters:

current_alignment – Position to be aligned.
data_size – Size of next data to process (should be power of two).

Returns:

Number of required alignment bytes.

Public Static Attributes

static Cdr_DllAPI const Endianness DEFAULT_ENDIAN: Default endianess in the system.

class state

This class stores the current state of a CDR serialization.

Public Functions

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.