Cdr.h

Go to the documentation of this file.

// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef _FASTCDR_CDR_H_
#define _FASTCDR_CDR_H_

#include "fastcdr_dll.h"
#include "FastBuffer.h"
#include "exceptions/NotEnoughMemoryException.h"
#include <stdint.h>
#include <string>
#include <vector>
#include <map>
#include <iostream>

#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
#include <malloc.h>
#else
#include <stdlib.h>
#endif // if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__

#if HAVE_CXX0X
#include <array>
#endif // if HAVE_CXX0X

namespace eprosima {
namespace fastcdr {
class Cdr_DllAPI Cdr
{
public:

    typedef enum
    {
        CORBA_CDR,
        DDS_CDR
    } CdrType;


#ifdef HAVE_CXX0X
    typedef enum : uint8_t
#else
    typedef enum
#endif // ifdef HAVE_CXX0X
    {
        DDS_CDR_WITHOUT_PL = 0x0,
        DDS_CDR_WITH_PL = 0x2
    } DDSCdrPlFlag;

#ifdef HAVE_CXX0X
    typedef enum : uint8_t
#else
    typedef enum
#endif // ifdef HAVE_CXX0X
    {
        BIG_ENDIANNESS = 0x0,
        LITTLE_ENDIANNESS = 0x1
    } Endianness;

    static const Endianness DEFAULT_ENDIAN;

    class Cdr_DllAPI state
    {
        friend class Cdr;

    public:

        state(
                const Cdr& cdr);

        state(
                const state&);

    private:

        state& operator =(
                const state&) = delete;

        const FastBuffer::iterator m_currentPosition;

        const FastBuffer::iterator m_alignPosition;

        bool m_swapBytes;

        size_t m_lastDataSize;
    };

    Cdr(
            FastBuffer& cdrBuffer,
            const Endianness endianness = DEFAULT_ENDIAN,
            const CdrType cdrType = CORBA_CDR);

    Cdr& read_encapsulation();

    Cdr& serialize_encapsulation();

    DDSCdrPlFlag getDDSCdrPlFlag() const;

    void setDDSCdrPlFlag(
            DDSCdrPlFlag plFlag);

    uint16_t getDDSCdrOptions() const;

    void setDDSCdrOptions(
            uint16_t options);

    void changeEndianness(
            Endianness endianness);

    Endianness endianness() const
    {
        return static_cast<Endianness>(m_endianness);
    }

    bool jump(
            size_t numBytes);

    void reset();

    char* getBufferPointer();

    char* getCurrentPosition();

    inline size_t getSerializedDataLength() const
    {
        return m_currentPosition - m_cdrBuffer.begin();
    }

    inline static size_t alignment(
            size_t current_alignment,
            size_t dataSize)
    {
        return (dataSize - (current_alignment % dataSize)) & (dataSize - 1);
    }

    state getState();

    void setState(
            state& state);

    bool moveAlignmentForward(
            size_t numBytes);

    inline void resetAlignment()
    {
        m_alignPosition = m_currentPosition;
    }

    inline Cdr& operator <<(
            const uint8_t octet_t)
    {
        return serialize(octet_t);
    }

    inline Cdr& operator <<(
            const char char_t)
    {
        return serialize(char_t);
    }

    inline Cdr& operator <<(
            const int8_t int8)
    {
        return serialize(int8);
    }

    inline Cdr& operator <<(
            const uint16_t ushort_t)
    {
        return serialize(ushort_t);
    }

    inline Cdr& operator <<(
            const int16_t short_t)
    {
        return serialize(short_t);
    }

    inline Cdr& operator <<(
            const uint32_t ulong_t)
    {
        return serialize(ulong_t);
    }

    inline Cdr& operator <<(
            const int32_t long_t)
    {
        return serialize(long_t);
    }

    inline Cdr& operator <<(
            const wchar_t wchar)
    {
        return serialize(wchar);
    }

    inline Cdr& operator <<(
            const uint64_t ulonglong_t)
    {
        return serialize(ulonglong_t);
    }

    inline Cdr& operator <<(
            const int64_t longlong_t)
    {
        return serialize(longlong_t);
    }

    inline Cdr& operator <<(
            const float float_t)
    {
        return serialize(float_t);
    }

    inline Cdr& operator <<(
            const double double_t)
    {
        return serialize(double_t);
    }

    inline Cdr& operator <<(
            const long double ldouble_t)
    {
        return serialize(ldouble_t);
    }

    inline Cdr& operator <<(
            const bool bool_t)
    {
        return serialize(bool_t);
    }

    inline Cdr& operator <<(
            const char* string_t)
    {
        return serialize(string_t);
    }

    inline Cdr& operator <<(
            char* string_t)
    {
        return serialize(string_t);
    }

    inline Cdr& operator <<(
            const std::string& string_t)
    {
        return serialize(string_t);
    }

    inline Cdr& operator <<(
            const std::wstring& string_t)
    {
        return serialize(string_t);
    }

#if HAVE_CXX0X

    template<class _T, size_t _Size>
    inline Cdr& operator <<(
            const std::array<_T, _Size>& array_t)
    {
        return serialize<_T, _Size>(array_t);
    }

#endif // if HAVE_CXX0X

    template<class _T>
    inline Cdr& operator <<(
            const std::vector<_T>& vector_t)
    {
        return serialize<_T>(vector_t);
    }

    template<class _K, class _T>
    inline Cdr& operator <<(
            const std::map<_K, _T>& map_t)
    {
        return serialize<_K, _T>(map_t);
    }

    template<class _T>
    inline Cdr& operator <<(
            const _T& type_t)
    {
        type_t.serialize(*this);
        return *this;
    }

    inline Cdr& operator >>(
            uint8_t& octet_t)
    {
        return deserialize(octet_t);
    }

    inline Cdr& operator >>(
            char& char_t)
    {
        return deserialize(char_t);
    }

    inline Cdr& operator >>(
            int8_t& int8)
    {
        return deserialize(int8);
    }

    inline Cdr& operator >>(
            uint16_t& ushort_t)
    {
        return deserialize(ushort_t);
    }

    inline Cdr& operator >>(
            int16_t& short_t)
    {
        return deserialize(short_t);
    }

    inline Cdr& operator >>(
            uint32_t& ulong_t)
    {
        return deserialize(ulong_t);
    }

    inline Cdr& operator >>(
            int32_t& long_t)
    {
        return deserialize(long_t);
    }

    // TODO in FastCdr
    inline Cdr& operator >>(
            wchar_t& wchar)
    {
        return deserialize(wchar);
    }

    inline Cdr& operator >>(
            uint64_t& ulonglong_t)
    {
        return deserialize(ulonglong_t);
    }

    inline Cdr& operator >>(
            int64_t& longlong_t)
    {
        return deserialize(longlong_t);
    }

    inline Cdr& operator >>(
            float& float_t)
    {
        return deserialize(float_t);
    }

    inline Cdr& operator >>(
            double& double_t)
    {
        return deserialize(double_t);
    }

    inline Cdr& operator >>(
            long double& ldouble_t)
    {
        return deserialize(ldouble_t);
    }

    inline Cdr& operator >>(
            bool& bool_t)
    {
        return deserialize(bool_t);
    }

    inline Cdr& operator >>(
            char*& string_t)
    {
        return deserialize(string_t);
    }

    inline Cdr& operator >>(
            std::string& string_t)
    {
        return deserialize(string_t);
    }

    inline Cdr& operator >>(
            std::wstring& string_t)
    {
        return deserialize(string_t);
    }

#if HAVE_CXX0X

    template<class _T, size_t _Size>
    inline Cdr& operator >>(
            std::array<_T, _Size>& array_t)
    {
        return deserialize<_T, _Size>(array_t);
    }

#endif // if HAVE_CXX0X

    template<class _T>
    inline Cdr& operator >>(
            std::vector<_T>& vector_t)
    {
        return deserialize<_T>(vector_t);
    }

    template<class _K, class _T>
    inline Cdr& operator >>(
            std::map<_K, _T>& map_t)
    {
        return deserialize<_K, _T>(map_t);
    }

    template<class _T>
    inline Cdr& operator >>(
            _T& type_t)
    {
        type_t.deserialize(*this);
        return *this;
    }

    inline
    Cdr& serialize(
            const uint8_t octet_t)
    {
        return serialize(static_cast<char>(octet_t));
    }

    inline
    Cdr& serialize(
            const uint8_t octet_t,
            Endianness endianness)
    {
        return serialize(static_cast<char>(octet_t), endianness);
    }

    Cdr& serialize(
            const char char_t);

    inline
    Cdr& serialize(
            const char char_t,
            Endianness endianness)
    {
        (void) endianness;
        return serialize(char_t);
    }

    inline
    Cdr& serialize(
            const int8_t int8)
    {
        return serialize(static_cast<char>(int8));
    }

    inline
    Cdr& serialize(
            const int8_t int8,
            Endianness endianness)
    {
        return serialize(static_cast<char>(int8), endianness);
    }

    inline
    Cdr& serialize(
            const uint16_t ushort_t)
    {
        return serialize(static_cast<int16_t>(ushort_t));
    }

    inline
    Cdr& serialize(
            const uint16_t ushort_t,
            Endianness endianness)
    {
        return serialize(static_cast<int16_t>(ushort_t), endianness);
    }

    Cdr& serialize(
            const int16_t short_t);

    Cdr& serialize(
            const int16_t short_t,
            Endianness endianness);

    inline
    Cdr& serialize(
            const uint32_t ulong_t)
    {
        return serialize(static_cast<int32_t>(ulong_t));
    }

    inline
    Cdr& serialize(
            const uint32_t ulong_t,
            Endianness endianness)
    {
        return serialize(static_cast<int32_t>(ulong_t), endianness);
    }

    Cdr& serialize(
            const int32_t long_t);

    Cdr& serialize(
            const int32_t long_t,
            Endianness endianness);

    inline
    Cdr& serialize(
            const wchar_t wchar)
    {
        return serialize(static_cast<uint32_t>(wchar));
    }

    inline
    Cdr& serialize(
            const wchar_t wchar,
            Endianness endianness)
    {
        return serialize(static_cast<uint32_t>(wchar), endianness);
    }

    inline
    Cdr& serialize(
            const uint64_t ulonglong_t)
    {
        return serialize(static_cast<int64_t>(ulonglong_t));
    }

    inline
    Cdr& serialize(
            const uint64_t ulonglong_t,
            Endianness endianness)
    {
        return serialize(static_cast<int64_t>(ulonglong_t), endianness);
    }

    Cdr& serialize(
            const int64_t longlong_t);

    Cdr& serialize(
            const int64_t longlong_t,
            Endianness endianness);

    Cdr& serialize(
            const float float_t);

    Cdr& serialize(
            const float float_t,
            Endianness endianness);

    Cdr& serialize(
            const double double_t);

    Cdr& serialize(
            const double double_t,
            Endianness endianness);


    Cdr& serialize(
            const long double ldouble_t);

    Cdr& serialize(
            const long double ldouble_t,
            Endianness endianness);

    Cdr& serialize(
            const bool bool_t);

    inline
    Cdr& serialize(
            const bool bool_t,
            Endianness endianness)
    {
        (void) endianness;
        return serialize(bool_t);
    }

    inline Cdr& serialize(
            char* string_t)
    {
        return serialize(static_cast<const char*>(string_t));
    }

    Cdr& serialize(
            const char* string_t);

    Cdr& serialize(
            const wchar_t* string_t);

    Cdr& serialize(
            const char* string_t,
            Endianness endianness);

    Cdr& serialize(
            const wchar_t* string_t,
            Endianness endianness);

    inline
    Cdr& serialize(
            const std::string& string_t)
    {
        return serialize(string_t.c_str());
    }

    inline
    Cdr& serialize(
            const std::wstring& string_t)
    {
        return serialize(string_t.c_str());
    }

    inline
    Cdr& serialize(
            const std::string& string_t,
            Endianness endianness)
    {
        return serialize(string_t.c_str(), endianness);
    }

#if HAVE_CXX0X

    template<class _T, size_t _Size>
    inline Cdr& serialize(
            const std::array<_T, _Size>& array_t)
    {
        return serializeArray(array_t.data(), array_t.size());
    }

    template<class _T, size_t _Size>
    inline Cdr& serialize(
            const std::array<_T, _Size>& array_t,
            Endianness endianness)
    {
        return serializeArray(array_t.data(), array_t.size(), endianness);
    }

#endif // if HAVE_CXX0X

#if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T = bool>
    Cdr& serialize(
            const std::vector<bool>& vector_t)
    {
        return serializeBoolSequence(vector_t);
    }

#endif // if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T>
    Cdr& serialize(
            const std::vector<_T>& vector_t)
    {
        state state_before_error(*this);

        *this << static_cast<int32_t>(vector_t.size());

        try
        {
            return serializeArray(vector_t.data(), vector_t.size());
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            setState(state_before_error);
            ex.raise();
        }

        return *this;
    }

    template<class _K, class _T>
    Cdr& serialize(
            const std::map<_K, _T>& map_t)
    {
        state state_(*this);

        *this << static_cast<int32_t>(map_t.size());

        try
        {
            for (auto it_pair = map_t.begin(); it_pair != map_t.end(); ++it_pair)
            {
                *this << it_pair->first;
                *this << it_pair->second;
            }
            //return serializeArray(map_t.data(), map_t.size());
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            setState(state_);
            ex.raise();
        }

        return *this;
    }

#ifdef _MSC_VER

    template<>
    Cdr& serialize<bool>(
            const std::vector<bool>& vector_t)
    {
        return serializeBoolSequence(vector_t);
    }

#endif // ifdef _MSC_VER

    template<class _T>
    Cdr& serialize(
            const std::vector<_T>& vector_t,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            serialize(vector_t);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    inline Cdr& serialize(
            const _T& type_t)
    {
        type_t.serialize(*this);
        return *this;
    }

    inline
    Cdr& serializeArray(
            const uint8_t* octet_t,
            size_t numElements)
    {
        return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
    }

    inline
    Cdr& serializeArray(
            const uint8_t* octet_t,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return serializeArray(reinterpret_cast<const char*>(octet_t), numElements);
    }

    Cdr& serializeArray(
            const char* char_t,
            size_t numElements);

    inline
    Cdr& serializeArray(
            const char* char_t,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return serializeArray(char_t, numElements);
    }

    inline
    Cdr& serializeArray(
            const int8_t* int8,
            size_t numElements)
    {
        return serializeArray(reinterpret_cast<const char*>(int8), numElements);
    }

    inline
    Cdr& serializeArray(
            const int8_t* int8,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return serializeArray(reinterpret_cast<const char*>(int8), numElements);
    }

    inline
    Cdr& serializeArray(
            const uint16_t* ushort_t,
            size_t numElements)
    {
        return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements);
    }

    inline
    Cdr& serializeArray(
            const uint16_t* ushort_t,
            size_t numElements,
            Endianness endianness)
    {
        return serializeArray(reinterpret_cast<const int16_t*>(ushort_t), numElements, endianness);
    }

    Cdr& serializeArray(
            const int16_t* short_t,
            size_t numElements);

    Cdr& serializeArray(
            const int16_t* short_t,
            size_t numElements,
            Endianness endianness);

    inline
    Cdr& serializeArray(
            const uint32_t* ulong_t,
            size_t numElements)
    {
        return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements);
    }

    inline
    Cdr& serializeArray(
            const uint32_t* ulong_t,
            size_t numElements,
            Endianness endianness)
    {
        return serializeArray(reinterpret_cast<const int32_t*>(ulong_t), numElements, endianness);
    }

    Cdr& serializeArray(
            const int32_t* long_t,
            size_t numElements);

    Cdr& serializeArray(
            const int32_t* long_t,
            size_t numElements,
            Endianness endianness);

    Cdr& serializeArray(
            const wchar_t* wchar,
            size_t numElements);

    Cdr& serializeArray(
            const wchar_t* wchar,
            size_t numElements,
            Endianness endianness);

    inline
    Cdr& serializeArray(
            const uint64_t* ulonglong_t,
            size_t numElements)
    {
        return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements);
    }

    inline
    Cdr& serializeArray(
            const uint64_t* ulonglong_t,
            size_t numElements,
            Endianness endianness)
    {
        return serializeArray(reinterpret_cast<const int64_t*>(ulonglong_t), numElements, endianness);
    }

    Cdr& serializeArray(
            const int64_t* longlong_t,
            size_t numElements);

    Cdr& serializeArray(
            const int64_t* longlong_t,
            size_t numElements,
            Endianness endianness);

    Cdr& serializeArray(
            const float* float_t,
            size_t numElements);

    Cdr& serializeArray(
            const float* float_t,
            size_t numElements,
            Endianness endianness);

    Cdr& serializeArray(
            const double* double_t,
            size_t numElements);

    Cdr& serializeArray(
            const double* double_t,
            size_t numElements,
            Endianness endianness);

    Cdr& serializeArray(
            const long double* ldouble_t,
            size_t numElements);

    Cdr& serializeArray(
            const long double* ldouble_t,
            size_t numElements,
            Endianness endianness);

    Cdr& serializeArray(
            const bool* bool_t,
            size_t numElements);

    inline
    Cdr& serializeArray(
            const bool* bool_t,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return serializeArray(bool_t, numElements);
    }

    inline
    Cdr& serializeArray(
            const std::string* string_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            serialize(string_t[count].c_str());
        }
        return *this;
    }

    inline
    Cdr& serializeArray(
            const std::wstring* string_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            serialize(string_t[count].c_str());
        }
        return *this;
    }

    inline
    Cdr& serializeArray(
            const std::string* string_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            serializeArray(string_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    inline
    Cdr& serializeArray(
            const std::wstring* string_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            serializeArray(string_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    Cdr& serializeArray(
            const std::vector<_T>* vector_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            serialize(vector_t[count]);
        }
        return *this;
    }

    template<class _T>
    Cdr& serializeArray(
            const _T* type_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            type_t[count].serialize(*this);
        }
        return *this;
    }

    template<class _T>
    Cdr& serializeArray(
            const _T* type_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            serializeArray(type_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    Cdr& serializeSequence(
            const _T* sequence_t,
            size_t numElements)
    {
        state state_before_error(*this);

        serialize(static_cast<int32_t>(numElements));

        try
        {
            return serializeArray(sequence_t, numElements);
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            setState(state_before_error);
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    Cdr& serializeSequence(
            const _T* sequence_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            serializeSequence(sequence_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    inline
    Cdr& deserialize(
            uint8_t& octet_t)
    {
        return deserialize(reinterpret_cast<char&>(octet_t));
    }

    inline
    Cdr& deserialize(
            uint8_t& octet_t,
            Endianness endianness)
    {
        return deserialize(reinterpret_cast<char&>(octet_t), endianness);
    }

    Cdr& deserialize(
            char& char_t);

    inline
    Cdr& deserialize(
            char& char_t,
            Endianness endianness)
    {
        (void) endianness;
        return deserialize(char_t);
    }

    inline
    Cdr& deserialize(
            int8_t& int8)
    {
        return deserialize(reinterpret_cast<char&>(int8));
    }

    inline
    Cdr& deserialize(
            int8_t& int8,
            Endianness endianness)
    {
        return deserialize(reinterpret_cast<char&>(int8), endianness);
    }

    inline
    Cdr& deserialize(
            uint16_t& ushort_t)
    {
        return deserialize(reinterpret_cast<int16_t&>(ushort_t));
    }

    inline
    Cdr& deserialize(
            uint16_t& ushort_t,
            Endianness endianness)
    {
        return deserialize(reinterpret_cast<int16_t&>(ushort_t), endianness);
    }

    Cdr& deserialize(
            int16_t& short_t);

    Cdr& deserialize(
            int16_t& short_t,
            Endianness endianness);

    inline
    Cdr& deserialize(
            uint32_t& ulong_t)
    {
        return deserialize(reinterpret_cast<int32_t&>(ulong_t));
    }

    inline
    Cdr& deserialize(
            uint32_t& ulong_t,
            Endianness endianness)
    {
        return deserialize(reinterpret_cast<int32_t&>(ulong_t), endianness);
    }

    Cdr& deserialize(
            int32_t& long_t);

    Cdr& deserialize(
            int32_t& long_t,
            Endianness endianness);

    inline
    Cdr& deserialize(
            wchar_t& wchar)
    {
        uint32_t ret;
        deserialize(ret);
        wchar = static_cast<wchar_t>(ret);
        return *this;
    }

    inline
    Cdr& deserialize(
            wchar_t& wchar,
            Endianness endianness)
    {
        uint32_t ret;
        deserialize(ret, endianness);
        wchar = static_cast<wchar_t>(ret);
        return *this;
    }

    inline
    Cdr& deserialize(
            uint64_t& ulonglong_t)
    {
        return deserialize(reinterpret_cast<int64_t&>(ulonglong_t));
    }

    inline
    Cdr& deserialize(
            uint64_t& ulonglong_t,
            Endianness endianness)
    {
        return deserialize(reinterpret_cast<int64_t&>(ulonglong_t), endianness);
    }

    Cdr& deserialize(
            int64_t& longlong_t);

    Cdr& deserialize(
            int64_t& longlong_t,
            Endianness endianness);

    Cdr& deserialize(
            float& float_t);

    Cdr& deserialize(
            float& float_t,
            Endianness endianness);

    Cdr& deserialize(
            double& double_t);

    Cdr& deserialize(
            double& double_t,
            Endianness endianness);

    Cdr& deserialize(
            long double& ldouble_t);

    Cdr& deserialize(
            long double& ldouble_t,
            Endianness endianness);

    Cdr& deserialize(
            bool& bool_t);

    inline
    Cdr& deserialize(
            bool& bool_t,
            Endianness endianness)
    {
        (void) endianness;
        return deserialize(bool_t);
    }

    Cdr& deserialize(
            char*& string_t);

    Cdr& deserialize(
            wchar_t*& string_t);

    Cdr& deserialize(
            char*& string_t,
            Endianness endianness);

    Cdr& deserialize(
            wchar_t*& string_t,
            Endianness endianness);

    inline
    Cdr& deserialize(
            std::string& string_t)
    {
        uint32_t length = 0;
        const char* str = readString(length);
        string_t = std::string(str, length);
        return *this;
    }

    inline
    Cdr& deserialize(
            std::wstring& string_t)
    {
        uint32_t length = 0;
        string_t = readWString(length);
        return *this;
    }

    inline
    Cdr& deserialize(
            std::string& string_t,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserialize(string_t);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    inline
    Cdr& deserialize(
            std::wstring& string_t,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserialize(string_t);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

#if HAVE_CXX0X

    template<class _T, size_t _Size>
    inline Cdr& deserialize(
            std::array<_T, _Size>& array_t)
    {
        return deserializeArray(array_t.data(), array_t.size());
    }

    template<class _T, size_t _Size>
    inline Cdr& deserialize(
            std::array<_T, _Size>& array_t,
            Endianness endianness)
    {
        return deserializeArray(array_t.data(), array_t.size(), endianness);
    }

#endif // if HAVE_CXX0X

#if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T = bool>
    Cdr& deserialize(
            std::vector<bool>& vector_t)
    {
        return deserializeBoolSequence(vector_t);
    }

#endif // if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T>
    Cdr& deserialize(
            std::vector<_T>& vector_t)
    {
        uint32_t seqLength = 0;
        state state_before_error(*this);

        *this >> seqLength;

        if (seqLength == 0)
        {
            vector_t.clear();
            return *this;
        }

        if ((m_lastPosition - m_currentPosition) < seqLength)
        {
            setState(state_before_error);
            throw eprosima::fastcdr::exception::NotEnoughMemoryException(
                      eprosima::fastcdr::exception::NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);
        }

        try
        {
            vector_t.resize(seqLength);
            return deserializeArray(vector_t.data(), vector_t.size());
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            setState(state_before_error);
            ex.raise();
        }

        return *this;
    }

    template<class _K, class _T>
    Cdr& deserialize(
            std::map<_K, _T>& map_t)
    {
        uint32_t seqLength = 0;
        state state_(*this);

        *this >> seqLength;

        try
        {
            for (uint32_t i = 0; i < seqLength; ++i)
            {
                _K key;
                _T value;
                *this >> key;
                *this >> value;
                map_t.emplace(std::pair<_K, _T>(std::move(key), std::move(value)));
            }
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            setState(state_);
            ex.raise();
        }

        return *this;
    }

#ifdef _MSC_VER

    template<>
    Cdr& deserialize<bool>(
            std::vector<bool>& vector_t)
    {
        return deserializeBoolSequence(vector_t);
    }

#endif // ifdef _MSC_VER

    template<class _T>
    Cdr& deserialize(
            std::vector<_T>& vector_t,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserialize(vector_t);
            m_swapBytes = auxSwap;
        }
        catch (exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    inline Cdr& deserialize(
            _T& type_t)
    {
        type_t.deserialize(*this);
        return *this;
    }

    inline
    Cdr& deserializeArray(
            uint8_t* octet_t,
            size_t numElements)
    {
        return deserializeArray(reinterpret_cast<char*>(octet_t), numElements);
    }

    inline
    Cdr& deserializeArray(
            uint8_t* octet_t,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(reinterpret_cast<char*>(octet_t), numElements, endianness);
    }

    Cdr& deserializeArray(
            char* char_t,
            size_t numElements);

    inline
    Cdr& deserializeArray(
            char* char_t,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return deserializeArray(char_t, numElements);
    }

    inline
    Cdr& deserializeArray(
            int8_t* int8,
            size_t numElements)
    {
        return deserializeArray(reinterpret_cast<char*>(int8), numElements);
    }

    inline
    Cdr& deserializeArray(
            int8_t* int8,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(reinterpret_cast<char*>(int8), numElements, endianness);
    }

    inline
    Cdr& deserializeArray(
            uint16_t* ushort_t,
            size_t numElements)
    {
        return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements);
    }

    inline
    Cdr& deserializeArray(
            uint16_t* ushort_t,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(reinterpret_cast<int16_t*>(ushort_t), numElements, endianness);
    }

    Cdr& deserializeArray(
            int16_t* short_t,
            size_t numElements);

    Cdr& deserializeArray(
            int16_t* short_t,
            size_t numElements,
            Endianness endianness);

    inline
    Cdr& deserializeArray(
            uint32_t* ulong_t,
            size_t numElements)
    {
        return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements);
    }

    inline
    Cdr& deserializeArray(
            uint32_t* ulong_t,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(reinterpret_cast<int32_t*>(ulong_t), numElements, endianness);
    }

    Cdr& deserializeArray(
            int32_t* long_t,
            size_t numElements);

    Cdr& deserializeArray(
            int32_t* long_t,
            size_t numElements,
            Endianness endianness);

    Cdr& deserializeArray(
            wchar_t* wchar,
            size_t numElements);

    Cdr& deserializeArray(
            wchar_t* wchar,
            size_t numElements,
            Endianness endianness);

    inline
    Cdr& deserializeArray(
            uint64_t* ulonglong_t,
            size_t numElements)
    {
        return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements);
    }

    inline
    Cdr& deserializeArray(
            uint64_t* ulonglong_t,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(reinterpret_cast<int64_t*>(ulonglong_t), numElements, endianness);
    }

    Cdr& deserializeArray(
            int64_t* longlong_t,
            size_t numElements);

    Cdr& deserializeArray(
            int64_t* longlong_t,
            size_t numElements,
            Endianness endianness);

    Cdr& deserializeArray(
            float* float_t,
            size_t numElements);

    Cdr& deserializeArray(
            float* float_t,
            size_t numElements,
            Endianness endianness);

    Cdr& deserializeArray(
            double* double_t,
            size_t numElements);

    Cdr& deserializeArray(
            double* double_t,
            size_t numElements,
            Endianness endianness);

    Cdr& deserializeArray(
            long double* ldouble_t,
            size_t numElements);

    Cdr& deserializeArray(
            long double* ldouble_t,
            size_t numElements,
            Endianness endianness);

    Cdr& deserializeArray(
            bool* bool_t,
            size_t numElements);

    inline
    Cdr& deserializeArray(
            bool* bool_t,
            size_t numElements,
            Endianness endianness)
    {
        (void) endianness;
        return deserializeArray(bool_t, numElements);
    }

    inline
    Cdr& deserializeArray(
            std::string* string_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            deserialize(string_t[count]);
        }
        return *this;
    }

    inline
    Cdr& deserializeArray(
            std::wstring* string_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            deserialize(string_t[count]);
        }
        return *this;
    }

    inline
    Cdr& deserializeArray(
            std::string* string_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserializeArray(string_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    inline
    Cdr& deserializeArray(
            std::wstring* string_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserializeArray(string_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

    template<class _T>
    Cdr& deserializeArray(
            std::vector<_T>* vector_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            deserialize(vector_t[count]);
        }
        return *this;
    }

    template<class _T>
    Cdr& deserializeArray(
            _T* type_t,
            size_t numElements)
    {
        for (size_t count = 0; count < numElements; ++count)
        {
            type_t[count].deserialize(*this);
        }
        return *this;
    }

    template<class _T>
    Cdr& deserializeArray(
            _T* type_t,
            size_t numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserializeArray(type_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

#if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T = std::string>
    Cdr& deserializeSequence(
            std::string*& sequence_t,
            size_t& numElements)
    {
        return deserializeStringSequence(sequence_t, numElements);
    }

    template<class _T = std::wstring>
    Cdr& deserializeSequence(
            std::wstring*& sequence_t,
            size_t& numElements)
    {
        return deserializeWStringSequence(sequence_t, numElements);
    }

#endif // if !defined(_MSC_VER) && HAVE_CXX0X

    template<class _T>
    Cdr& deserializeSequence(
            _T*& sequence_t,
            size_t& numElements)
    {
        uint32_t seqLength = 0;
        state state_before_error(*this);

        deserialize(seqLength);

        try
        {
            sequence_t = reinterpret_cast<_T*>(calloc(seqLength, sizeof(_T)));
            deserializeArray(sequence_t, seqLength);
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            free(sequence_t);
            sequence_t = NULL;
            setState(state_before_error);
            ex.raise();
        }

        numElements = seqLength;
        return *this;
    }

#ifdef _MSC_VER

    template<>
    Cdr& deserializeSequence<std::string>(
            std::string*& sequence_t,
            size_t& numElements)
    {
        return deserializeStringSequence(sequence_t, numElements);
    }

    template<>
    Cdr& deserializeSequence<std::wstring>(
            std::wstring*& sequence_t,
            size_t& numElements)
    {
        return deserializeWStringSequence(sequence_t, numElements);
    }

#endif // ifdef _MSC_VER

    template<class _T>
    Cdr& deserializeSequence(
            _T*& sequence_t,
            size_t& numElements,
            Endianness endianness)
    {
        bool auxSwap = m_swapBytes;
        m_swapBytes = (m_swapBytes && (m_endianness == endianness)) || (!m_swapBytes && (m_endianness != endianness));

        try
        {
            deserializeSequence(sequence_t, numElements);
            m_swapBytes = auxSwap;
        }
        catch (eprosima::fastcdr::exception::Exception& ex)
        {
            m_swapBytes = auxSwap;
            ex.raise();
        }

        return *this;
    }

private:

    Cdr(
            const Cdr&) = delete;

    Cdr& operator =(
            const Cdr&) = delete;

    Cdr& serializeBoolSequence(
            const std::vector<bool>& vector_t);

    Cdr& deserializeBoolSequence(
            std::vector<bool>& vector_t);

    Cdr& deserializeStringSequence(
            std::string*& sequence_t,
            size_t& numElements);

    Cdr& deserializeWStringSequence(
            std::wstring*& sequence_t,
            size_t& numElements);

#if HAVE_CXX0X

    template<class _T, size_t _Size>
    Cdr& serializeArray(
            const std::array<_T, _Size>* array_t,
            size_t numElements)
    {
        return serializeArray(array_t->data(), numElements * array_t->size());
    }

    template<class _T, size_t _Size>
    Cdr& serializeArray(
            const std::array<_T, _Size>* array_t,
            size_t numElements,
            Endianness endianness)
    {
        return serializeArray(array_t->data(), numElements * array_t->size(), endianness);
    }

    template<class _T, size_t _Size>
    Cdr& deserializeArray(
            std::array<_T, _Size>* array_t,
            size_t numElements)
    {
        return deserializeArray(array_t->data(), numElements * array_t->size());
    }

    template<class _T, size_t _Size>
    Cdr& deserializeArray(
            std::array<_T, _Size>* array_t,
            size_t numElements,
            Endianness endianness)
    {
        return deserializeArray(array_t->data(), numElements * array_t->size(), endianness);
    }

#endif // if HAVE_CXX0X

    inline size_t alignment(
            size_t dataSize) const
    {
        return dataSize >
               m_lastDataSize ? (dataSize - ((m_currentPosition - m_alignPosition) % dataSize)) &
               (dataSize - 1) : 0;
    }

    inline void makeAlign(
            size_t align)
    {
        m_currentPosition += align;
    }

    bool resize(
            size_t minSizeInc);

    //TODO
    const char* readString(
            uint32_t& length);
    const std::wstring readWString(
            uint32_t& length);

    FastBuffer& m_cdrBuffer;

    CdrType m_cdrType;

    DDSCdrPlFlag m_plFlag;

    uint16_t m_options;

    uint8_t m_endianness;

    bool m_swapBytes;

    size_t m_lastDataSize;

    FastBuffer::iterator m_currentPosition;

    FastBuffer::iterator m_alignPosition;

    FastBuffer::iterator m_lastPosition;
};
}     //namespace fastcdr
} //namespace eprosima

#endif // _CDR_CDR_H_