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

#include <cstring>

#include <limits>

#include <fastcdr/Cdr.h>

namespace eprosima {

namespace fastcdr {

using namespace exception;

#if FASTCDR_IS_BIG_ENDIAN_TARGET

const Cdr::Endianness Cdr::DEFAULT_ENDIAN = BIG_ENDIANNESS;

#else

const Cdr::Endianness Cdr::DEFAULT_ENDIAN = LITTLE_ENDIANNESS;

#endif // if FASTCDR_IS_BIG_ENDIAN_TARGET

constexpr uint16_t PID_EXTENDED = 0x3F01;

constexpr uint16_t PID_EXTENDED_LENGTH = 0x8;

constexpr uint16_t PID_SENTINEL = 0x3F02;

constexpr uint16_t PID_SENTINEL_LENGTH = 0x0;

constexpr uint8_t operator ""_8u(

        unsigned long long int value)

{

    return static_cast<uint8_t>(value);

}

inline size_t alignment_on_state(

        const FastBuffer::iterator& origin,

        const FastBuffer::iterator& offset,

        size_t data_size)

{

    return (data_size - ((offset - origin) % data_size)) & (data_size - 1);

}

inline uint32_t Cdr::get_long_lc(

        SerializedMemberSizeForNextInt serialized_member_size)

{

    uint32_t lc {0x40000000};

    switch (serialized_member_size)

    {

        case SERIALIZED_MEMBER_SIZE_8:

            lc =  0x70000000u;

            break;

        case SERIALIZED_MEMBER_SIZE_4:

            lc =  0x60000000u;

            break;

        case SERIALIZED_MEMBER_SIZE:

            lc = 0x50000000u;

            break;

        default:

            break;

    }

    return lc;

}

inline uint32_t Cdr::get_short_lc(

        size_t member_serialized_size)

{

    uint32_t lc {0xFFFFFFFFu};

    switch (member_serialized_size)

    {

        case 1:

            lc = 0x00000000u;

            break;

        case 2:

            lc = 0x10000000u;

            break;

        case 4:

            lc = 0x20000000u;

            break;

        case 8:

            lc = 0x30000000u;

            break;

        default:

            break;

    }

    return lc;

}

Cdr::state::state(

        const Cdr& cdr)

    : offset_(cdr.offset_)

    , origin_(cdr.origin_)

    , swap_bytes_(cdr.swap_bytes_)

    , last_data_size_(cdr.last_data_size_)

    , next_member_id_(cdr.next_member_id_)

    , previous_encoding_(cdr.current_encoding_)

{

}

Cdr::state::state(

        const state& current_state)

    : offset_(current_state.offset_)

    , origin_(current_state.origin_)

    , swap_bytes_(current_state.swap_bytes_)

    , last_data_size_(current_state.last_data_size_)

    , next_member_id_(current_state.next_member_id_)

    , previous_encoding_(current_state.previous_encoding_)

{

}

bool Cdr::state::operator ==(

        const Cdr::state& other_state) const

{

    return

        other_state.offset_ == offset_ &&

        other_state.origin_ == origin_ &&

        other_state.swap_bytes_ == swap_bytes_ &&

        (0 == other_state.last_data_size_ ||

        0 == last_data_size_ ||

        other_state.last_data_size_ == last_data_size_

        );

}

Cdr::Cdr(

        FastBuffer& cdr_buffer,

        const Endianness endianness,

        const CdrVersion cdr_version)

    : cdr_buffer_(cdr_buffer)

    , cdr_version_(cdr_version)

    , endianness_(endianness)

    , swap_bytes_(endianness == DEFAULT_ENDIAN ? false : true)

    , offset_(cdr_buffer.begin())

    , origin_(cdr_buffer.begin())

    , end_(cdr_buffer.end())

    , initial_state_(*this)

{

    switch (cdr_version_)

    {

        case CdrVersion::XCDRv2:

            break;

        case CdrVersion::XCDRv1:

            align64_ = 8;

            encoding_flag_ = EncodingAlgorithmFlag::PLAIN_CDR;

            current_encoding_ = EncodingAlgorithmFlag::PLAIN_CDR;

            break;

        default:

            align64_ = 8;

            encoding_flag_ = EncodingAlgorithmFlag::PLAIN_CDR;

            current_encoding_ = EncodingAlgorithmFlag::PLAIN_CDR;

            break;

    }

    reset_callbacks();

}

void Cdr::reset_callbacks()

{

    switch (cdr_version_)

    {

        case CdrVersion::XCDRv2:

            begin_serialize_member_ = &Cdr::xcdr2_begin_serialize_member;

            end_serialize_member_ = &Cdr::xcdr2_end_serialize_member;

            begin_serialize_opt_member_ = &Cdr::xcdr2_begin_serialize_member;

            end_serialize_opt_member_ = &Cdr::xcdr2_end_serialize_member;

            begin_serialize_type_ = &Cdr::xcdr2_begin_serialize_type;

            end_serialize_type_ = &Cdr::xcdr2_end_serialize_type;

            deserialize_type_ = &Cdr::xcdr2_deserialize_type;

            break;

        case CdrVersion::XCDRv1:

            begin_serialize_member_ = &Cdr::xcdr1_begin_serialize_member;

            end_serialize_member_ = &Cdr::xcdr1_end_serialize_member;

            begin_serialize_opt_member_ = &Cdr::xcdr1_begin_serialize_opt_member;

            end_serialize_opt_member_ = &Cdr::xcdr1_end_serialize_opt_member;

            begin_serialize_type_ = &Cdr::xcdr1_begin_serialize_type;

            end_serialize_type_ = &Cdr::xcdr1_end_serialize_type;

            deserialize_type_ = &Cdr::xcdr1_deserialize_type;

            break;

        default:

            begin_serialize_member_ = &Cdr::cdr_begin_serialize_member;

            end_serialize_member_ = &Cdr::cdr_end_serialize_member;

            begin_serialize_opt_member_ = &Cdr::cdr_begin_serialize_member;

            end_serialize_opt_member_ = &Cdr::cdr_end_serialize_member;

            begin_serialize_type_ = &Cdr::cdr_begin_serialize_type;

            end_serialize_type_ = &Cdr::cdr_end_serialize_type;

            deserialize_type_ = &Cdr::cdr_deserialize_type;

            break;

    }

}

Cdr& Cdr::read_encapsulation()

{

    uint8_t dummy {0};

    uint8_t encapsulation {0};

    state state_before_error(*this);

    try

    {

        // If it is DDS_CDR, the first step is to get the dummy byte.

        if (CdrVersion::CORBA_CDR < cdr_version_)

        {

            (*this) >> dummy;

            if (0 != dummy)

            {

                throw BadParamException("Unexpected non-zero initial byte received in Cdr::read_encapsulation");

            }

        }

        // Get the ecampsulation byte.

        (*this) >> encapsulation;

        // If it is a different endianness, make changes.

        const uint8_t endianness = encapsulation & 0x1_8u;

        if (endianness_ != endianness)

        {

            swap_bytes_ = !swap_bytes_;

            endianness_ = endianness;

        }

        // Check encapsulationKind correctness

        const uint8_t encoding_flag = encapsulation & static_cast<uint8_t>(~0x1);

        switch (encoding_flag)

        {

            case EncodingAlgorithmFlag::PLAIN_CDR2:

            case EncodingAlgorithmFlag::DELIMIT_CDR2:

            case EncodingAlgorithmFlag::PL_CDR2:

                if (CdrVersion::XCDRv1 <= cdr_version_)

                {

                    cdr_version_ = CdrVersion::XCDRv2;

                    align64_ = 4;

                }

                else

                {

                    throw BadParamException(

                              "Unexpected encoding algorithm received in Cdr::read_encapsulation. XCDRv2 should be selected.");

                }

                break;

            case EncodingAlgorithmFlag::PL_CDR:

                if (CdrVersion::XCDRv1 <= cdr_version_)

                {

                    cdr_version_ = CdrVersion::XCDRv1;

                    align64_ = 8;

                }

                else

                {

                    throw BadParamException(

                              "Unexpected encoding algorithm received in Cdr::read_encapsulation. XCDRv1 should be selected");

                }

                break;

            case EncodingAlgorithmFlag::PLAIN_CDR:

                if (CdrVersion::XCDRv1 <= cdr_version_)

                {

                    cdr_version_ = CdrVersion::XCDRv1;

                    align64_ = 8;

                }

                break;

            default:

                throw BadParamException("Unexpected encoding algorithm received in Cdr::read_encapsulation for DDS CDR");

        }

        reset_callbacks();

        encoding_flag_ = static_cast<EncodingAlgorithmFlag>(encoding_flag);

        current_encoding_ = encoding_flag_;

        if (CdrVersion::CORBA_CDR < cdr_version_)

        {

            deserialize(options_);

            uint8_t option_align {static_cast<uint8_t>(options_[1] & 0x3u)};

            if (0 < option_align)

            {

                auto length {end_ - cdr_buffer_.begin()};

                auto alignment = ((length + 3u) & ~3u) - length;

                if (0 == alignment)

                {

                    end_ -= option_align;

                }

            }

        }

    }

    catch (Exception& ex)

    {

        set_state(state_before_error);

        ex.raise();

    }

    reset_alignment();

    return *this;

}

Cdr& Cdr::serialize_encapsulation()

{

    uint8_t dummy = 0;

    uint8_t encapsulation = 0;

    state state_before_error(*this);

    try

    {

        // If it is DDS_CDR, the first step is to serialize the dummy byte.

        if (CdrVersion::CORBA_CDR < cdr_version_)

        {

            (*this) << dummy;

        }

        // Construct encapsulation byte.

        encapsulation = (encoding_flag_ | endianness_);

        // Serialize the encapsulation byte.

        (*this) << encapsulation;

        current_encoding_ = encoding_flag_;

    }

    catch (Exception& ex)

    {

        set_state(state_before_error);

        ex.raise();

    }

    try

    {

        if (CdrVersion::CORBA_CDR < cdr_version_)

        {

            serialize(options_);

        }

    }

    catch (Exception& ex)

    {

        set_state(state_before_error);

        ex.raise();

    }

    reset_alignment();

    encapsulation_serialized_ = true;

    return *this;

}

CdrVersion Cdr::get_cdr_version() const

{

    return cdr_version_;

}

EncodingAlgorithmFlag Cdr::get_encoding_flag() const

{

    return encoding_flag_;

}

bool Cdr::set_encoding_flag(

        EncodingAlgorithmFlag encoding_flag)

{

    bool ret_value = false;

    if (CdrVersion::CORBA_CDR != cdr_version_)

    {

        if (offset_ == cdr_buffer_.begin())

        {

            encoding_flag_ = encoding_flag;

            ret_value = true;

        }

    }

    return ret_value;

}

std::array<uint8_t, 2> Cdr::get_dds_cdr_options() const

{

    return options_;

}

void Cdr::set_dds_cdr_options(

        const std::array<uint8_t, 2>& options)

{

    options_ = options;

    if (CdrVersion::XCDRv1 == cdr_version_ ||

            CdrVersion::XCDRv2 == cdr_version_)

    {

        auto length {offset_ - cdr_buffer_.begin()};

        auto alignment = ((length + 3u) & ~3u) - length;

        options_[1] = static_cast<uint8_t>(options_[1] & 0xC) + static_cast<uint8_t>(alignment & 0x3);

    }

    if (encapsulation_serialized_ && CdrVersion::CORBA_CDR < cdr_version_)

    {

        state previous_state(*this);

        set_state(initial_state_);

        jump(2);

        serialize(options_);

        set_state(previous_state);

    }

}

void Cdr::change_endianness(

        Endianness endianness)

{

    if (endianness_ != endianness)

    {

        swap_bytes_ = !swap_bytes_;

        endianness_ = endianness;

    }

}

Cdr::Endianness Cdr::endianness() const

{

    return static_cast<Endianness>(endianness_);

}

bool Cdr::jump(

        size_t num_bytes)

{

    bool ret_value = false;

    if (((end_ - offset_) >= num_bytes) || resize(num_bytes))

    {

        offset_ += num_bytes;

        last_data_size_ = 0;

        ret_value = true;

    }

    return ret_value;

}

char* Cdr::get_buffer_pointer()

{

    return cdr_buffer_.getBuffer();

}

char* Cdr::get_current_position()

{

    return &offset_;

}

size_t Cdr::get_serialized_data_length() const

{

    return offset_ - cdr_buffer_.begin();

}

Cdr::state Cdr::get_state() const

{

    return Cdr::state(*this);

}

void Cdr::set_state(

        const state& current_state)

{

    offset_ >> current_state.offset_;

    origin_ >> current_state.origin_;

    swap_bytes_ = current_state.swap_bytes_;

    last_data_size_ = current_state.last_data_size_;

    next_member_id_ = current_state.next_member_id_;

}

void Cdr::reset()

{

    offset_ = cdr_buffer_.begin();

    origin_ = cdr_buffer_.begin();

    swap_bytes_ = endianness_ == DEFAULT_ENDIAN ? false : true;

    last_data_size_ = 0;

    encoding_flag_ = CdrVersion::XCDRv2 ==

            cdr_version_ ? EncodingAlgorithmFlag::PLAIN_CDR2 : EncodingAlgorithmFlag::PLAIN_CDR;

    current_encoding_ = encoding_flag_;

    next_member_id_ = MEMBER_ID_INVALID;

    options_ = {0, 0};

}

bool Cdr::move_alignment_forward(

        size_t num_bytes)

{

    bool ret_value = false;

    if (((end_ - origin_) >= num_bytes) || resize(num_bytes))

    {

        origin_ += num_bytes;

        last_data_size_ = 0;

        ret_value = true;

    }

    return ret_value;

}

bool Cdr::resize(

        size_t min_size_inc)

{

    if (cdr_buffer_.resize(min_size_inc))

    {

        offset_ << cdr_buffer_.begin();

        origin_ << cdr_buffer_.begin();

        end_ = cdr_buffer_.end();

        return true;

    }

    return false;

}

Cdr& Cdr::serialize(

        const uint8_t& octet_t)

{

    return serialize(static_cast<char>(octet_t));

}

Cdr& Cdr::serialize(

        const char char_t)

{

    if (((end_ - offset_) >= sizeof(char_t)) || resize(sizeof(char_t)))

    {

        // Save last datasize.

        last_data_size_ = sizeof(char_t);

        offset_++ << char_t;

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const int8_t int8)

{

    return serialize(static_cast<char>(int8));

}

Cdr& Cdr::serialize(

        const uint16_t ushort_t)

{

    return serialize(static_cast<int16_t>(ushort_t));

}

Cdr& Cdr::serialize(

        const int16_t short_t)

{

    size_t align = alignment(sizeof(short_t));

    size_t size_aligned = sizeof(short_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = sizeof(short_t);

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

            const char* dst = reinterpret_cast<const char*>(&short_t);

            offset_++ << dst[1];

            offset_++ << dst[0];

        }

        else

        {

            offset_ << short_t;

            offset_ += sizeof(short_t);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const uint32_t ulong_t)

{

    return serialize(static_cast<int32_t>(ulong_t));

}

Cdr& Cdr::serialize(

        const int32_t long_t)

{

    size_t align = alignment(sizeof(long_t));

    size_t size_aligned = sizeof(long_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = sizeof(long_t);

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

            const char* dst = reinterpret_cast<const char*>(&long_t);

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

        }

        else

        {

            offset_ << long_t;

            offset_ += sizeof(long_t);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const wchar_t wchar)

{

    return serialize(static_cast<uint16_t>(wchar));

}

Cdr& Cdr::serialize(

        const uint64_t ulonglong_t)

{

    return serialize(static_cast<int64_t>(ulonglong_t));

}

Cdr& Cdr::serialize(

        const int64_t longlong_t)

{

    size_t align = alignment(align64_);

    size_t size_aligned = sizeof(longlong_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = align64_;

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

            const char* dst = reinterpret_cast<const char*>(&longlong_t);

            offset_++ << dst[7];

            offset_++ << dst[6];

            offset_++ << dst[5];

            offset_++ << dst[4];

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

        }

        else

        {

            offset_ << longlong_t;

            offset_ += sizeof(longlong_t);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const float float_t)

{

    size_t align = alignment(sizeof(float_t));

    size_t size_aligned = sizeof(float_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = sizeof(float_t);

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

            const char* dst = reinterpret_cast<const char*>(&float_t);

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

        }

        else

        {

            offset_ << float_t;

            offset_ += sizeof(float_t);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const double double_t)

{

    size_t align = alignment(align64_);

    size_t size_aligned = sizeof(double_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = align64_;

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

            const char* dst = reinterpret_cast<const char*>(&double_t);

            offset_++ << dst[7];

            offset_++ << dst[6];

            offset_++ << dst[5];

            offset_++ << dst[4];

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

        }

        else

        {

            offset_ << double_t;

            offset_ += sizeof(double_t);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const long double ldouble_t)

{

    size_t align = alignment(align64_);

    size_t size_aligned = sizeof(ldouble_t) + align;

    if (((end_ - offset_) >= size_aligned) || resize(size_aligned))

    {

        // Save last datasize.

        last_data_size_ = align64_;

        // Align.

        make_alignment(align);

        if (swap_bytes_)

        {

#if FASTCDR_HAVE_FLOAT128 && FASTCDR_SIZEOF_LONG_DOUBLE < 16

            __float128 tmp = ldouble_t;

            const char* dst = reinterpret_cast<const char*>(&tmp);

#else

            const char* dst = reinterpret_cast<const char*>(&ldouble_t);

#endif // FASTCDR_HAVE_FLOAT128 && FASTCDR_SIZEOF_LONG_DOUBLE < 16

#if FASTCDR_HAVE_FLOAT128 || FASTCDR_SIZEOF_LONG_DOUBLE == 16

            offset_++ << dst[15];

            offset_++ << dst[14];

            offset_++ << dst[13];

            offset_++ << dst[12];

            offset_++ << dst[11];

            offset_++ << dst[10];

            offset_++ << dst[9];

            offset_++ << dst[8];

            offset_++ << dst[7];

            offset_++ << dst[6];

            offset_++ << dst[5];

            offset_++ << dst[4];

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

#else

#if FASTCDR_SIZEOF_LONG_DOUBLE == 8

            // Filled with 0's.

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << static_cast<char>(0);

            offset_++ << dst[7];

            offset_++ << dst[6];

            offset_++ << dst[5];

            offset_++ << dst[4];

            offset_++ << dst[3];

            offset_++ << dst[2];

            offset_++ << dst[1];

            offset_++ << dst[0];

#else

#error unsupported long double type and no __float128 available

#endif // FASTCDR_SIZEOF_LONG_DOUBLE == 8

#endif // FASTCDR_HAVE_FLOAT128 || FASTCDR_SIZEOF_LONG_DOUBLE == 16

        }

        else

        {

#if FASTCDR_HAVE_FLOAT128 && FASTCDR_SIZEOF_LONG_DOUBLE < 16

            __float128 tmp = ldouble_t;

            offset_ << tmp;

            offset_ += 16;

#else

#if FASTCDR_SIZEOF_LONG_DOUBLE == 8

            offset_ << static_cast<long double>(0);

            offset_ += sizeof(ldouble_t);

#endif // FASTCDR_SIZEOF_LONG_DOUBLE == 8

#if FASTCDR_SIZEOF_LONG_DOUBLE == 8 || FASTCDR_SIZEOF_LONG_DOUBLE == 16

            offset_ << ldouble_t;

            offset_ += sizeof(ldouble_t);

#else

#error unsupported long double type and no __float128 available

#endif // FASTCDR_SIZEOF_LONG_DOUBLE == 8 || FASTCDR_SIZEOF_LONG_DOUBLE == 16

#endif // FASTCDR_HAVE_FLOAT128 && FASTCDR_SIZEOF_LONG_DOUBLE < 16

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        const bool bool_t)

{

    if (((end_ - offset_) >= sizeof(uint8_t)) || resize(sizeof(uint8_t)))

    {

        // Save last datasize.

        last_data_size_ = sizeof(uint8_t);

        if (bool_t)

        {

            offset_++ << static_cast<uint8_t>(1);

        }

        else

        {

            offset_++ << static_cast<uint8_t>(0);

        }

        return *this;

    }

    throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

}

Cdr& Cdr::serialize(

        char* string_t)

{

    return serialize(static_cast<const char*>(string_t));

}

Cdr& Cdr::serialize(

        const char* string_t)

{

    uint32_t length = 0;

    if (string_t != nullptr)

    {

        length = size_to_uint32(strlen(string_t)) + 1;

    }

    if (length > 0)

    {

        Cdr::state state_before_error(*this);

        serialize(length);

        if (((end_ - offset_) >= length) || resize(length))

        {

            // Save last datasize.

            last_data_size_ = sizeof(uint8_t);

            offset_.memcopy(string_t, length);

            offset_ += length;

        }

        else

        {

            set_state(state_before_error);

            throw NotEnoughMemoryException(NotEnoughMemoryException::NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT);

        }

    }

    else

    {

        serialize(length);

    }

    serialized_member_size_ = SERIALIZED_MEMBER_SIZE;

    return *this;

}

Cdr& Cdr::serialize(

        const wchar_t* string_t)

{

    uint32_t bytes_length = 0;

    size_t wstrlen = 0;

    if (string_t != nullptr)

    {

        wstrlen = wcslen(string_t);

        bytes_length = size_to_uint32(wstrlen * 2);

    }

    if (bytes_length > 0)

    {

        Cdr::state state_(*this);

        serialize(size_to_uint32(wstrlen));

        if (((end_ - offset_) >= bytes_length) || resize(bytes_length))

        {

            serialize_array(string_t, wstrlen);