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

/*!
 * @file XNSimStatusCdrAux.ipp
 * This source file contains some declarations of CDR related functions.
 *
 * This file was generated by the tool fastddsgen.
 */

#ifndef FAST_DDS_GENERATED__XNSIM_XNSIMCONTROL_XNSIMSTATUSCDRAUX_IPP
#define FAST_DDS_GENERATED__XNSIM_XNSIMCONTROL_XNSIMSTATUSCDRAUX_IPP

#include "XNSimStatusCdrAux.hpp"

#include <fastcdr/Cdr.h>
#include <fastcdr/CdrSizeCalculator.hpp>


#include <fastcdr/exceptions/BadParamException.h>
using namespace eprosima::fastcdr::exception;

namespace eprosima {
namespace fastcdr {

template<>
eProsima_user_DllExport size_t calculate_serialized_size(
        eprosima::fastcdr::CdrSizeCalculator& calculator,
        const XNSim::XNSimStatus::XNCoreStatus& data,
        size_t& current_alignment)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(data);

    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
                                current_alignment)};


        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
                data.XNFWStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.XNTMStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
                data.XNEMStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.XNSDStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
                data.XNThMStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
                data.XNMMStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6),
                data.XNSMStatus(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7),
                data.XNDMStatus(), current_alignment);


    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);

    return calculated_size;
}

template<>
eProsima_user_DllExport void serialize(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNCoreStatus& data)
{
    using namespace XNSim::XNSimStatus;

    eprosima::fastcdr::Cdr::state current_state(scdr);
    scdr.begin_serialize_type(current_state,
            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);

    scdr
        << eprosima::fastcdr::MemberId(0) << data.XNFWStatus()
        << eprosima::fastcdr::MemberId(1) << data.XNTMStatus()
        << eprosima::fastcdr::MemberId(2) << data.XNEMStatus()
        << eprosima::fastcdr::MemberId(3) << data.XNSDStatus()
        << eprosima::fastcdr::MemberId(4) << data.XNThMStatus()
        << eprosima::fastcdr::MemberId(5) << data.XNMMStatus()
        << eprosima::fastcdr::MemberId(6) << data.XNSMStatus()
        << eprosima::fastcdr::MemberId(7) << data.XNDMStatus()
;
    scdr.end_serialize_type(current_state);
}

template<>
eProsima_user_DllExport void deserialize(
        eprosima::fastcdr::Cdr& cdr,
        XNSim::XNSimStatus::XNCoreStatus& data)
{
    using namespace XNSim::XNSimStatus;

    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
            {
                bool ret_value = true;
                switch (mid.id)
                {
                                        case 0:
                                                dcdr >> data.XNFWStatus();
                                            break;

                                        case 1:
                                                dcdr >> data.XNTMStatus();
                                            break;

                                        case 2:
                                                dcdr >> data.XNEMStatus();
                                            break;

                                        case 3:
                                                dcdr >> data.XNSDStatus();
                                            break;

                                        case 4:
                                                dcdr >> data.XNThMStatus();
                                            break;

                                        case 5:
                                                dcdr >> data.XNMMStatus();
                                            break;

                                        case 6:
                                                dcdr >> data.XNSMStatus();
                                            break;

                                        case 7:
                                                dcdr >> data.XNDMStatus();
                                            break;

                    default:
                        ret_value = false;
                        break;
                }
                return ret_value;
            });
}

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNCoreStatus& data)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(scdr);
    static_cast<void>(data);
                        scdr << data.XNFWStatus();

                        scdr << data.XNTMStatus();

                        scdr << data.XNEMStatus();

                        scdr << data.XNSDStatus();

                        scdr << data.XNThMStatus();

                        scdr << data.XNMMStatus();

                        scdr << data.XNSMStatus();

                        scdr << data.XNDMStatus();

}


template<>
eProsima_user_DllExport size_t calculate_serialized_size(
        eprosima::fastcdr::CdrSizeCalculator& calculator,
        const XNSim::XNSimStatus::XNEngineStatus& data,
        size_t& current_alignment)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(data);

    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
                                current_alignment)};


        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
                data.XNEngineName(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.XNEngineID(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
                data.XNEngineSt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.XNEngineAff(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
                data.XNThCnt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
                data.XNCoreSt(), current_alignment);


    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);

    return calculated_size;
}

template<>
eProsima_user_DllExport void serialize(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNEngineStatus& data)
{
    using namespace XNSim::XNSimStatus;

    eprosima::fastcdr::Cdr::state current_state(scdr);
    scdr.begin_serialize_type(current_state,
            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);

    scdr
        << eprosima::fastcdr::MemberId(0) << data.XNEngineName()
        << eprosima::fastcdr::MemberId(1) << data.XNEngineID()
        << eprosima::fastcdr::MemberId(2) << data.XNEngineSt()
        << eprosima::fastcdr::MemberId(3) << data.XNEngineAff()
        << eprosima::fastcdr::MemberId(4) << data.XNThCnt()
        << eprosima::fastcdr::MemberId(5) << data.XNCoreSt()
;
    scdr.end_serialize_type(current_state);
}

template<>
eProsima_user_DllExport void deserialize(
        eprosima::fastcdr::Cdr& cdr,
        XNSim::XNSimStatus::XNEngineStatus& data)
{
    using namespace XNSim::XNSimStatus;

    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
            {
                bool ret_value = true;
                switch (mid.id)
                {
                                        case 0:
                                                dcdr >> data.XNEngineName();
                                            break;

                                        case 1:
                                                dcdr >> data.XNEngineID();
                                            break;

                                        case 2:
                                                dcdr >> data.XNEngineSt();
                                            break;

                                        case 3:
                                                dcdr >> data.XNEngineAff();
                                            break;

                                        case 4:
                                                dcdr >> data.XNThCnt();
                                            break;

                                        case 5:
                                                dcdr >> data.XNCoreSt();
                                            break;

                    default:
                        ret_value = false;
                        break;
                }
                return ret_value;
            });
}

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNEngineStatus& data)
{
    using namespace XNSim::XNSimStatus;
            extern void serialize_key(
                    Cdr& scdr,
                    const XNSim::XNSimStatus::XNCoreStatus& data);


    static_cast<void>(scdr);
    static_cast<void>(data);
                        scdr << data.XNEngineName();

                        scdr << data.XNEngineID();

                        scdr << data.XNEngineSt();

                        scdr << data.XNEngineAff();

                        scdr << data.XNThCnt();

                        serialize_key(scdr, data.XNCoreSt());

}


template<>
eProsima_user_DllExport size_t calculate_serialized_size(
        eprosima::fastcdr::CdrSizeCalculator& calculator,
        const XNSim::XNSimStatus::XNThreadStatus& data,
        size_t& current_alignment)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(data);

    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
                                current_alignment)};


        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
                data.XNThreadName(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.XNThreadID(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
                data.XNThreadSt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.XNThreadAff(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
                data.XNThreadPro(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
                data.XNThRunCnt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6),
                data.XNThCurFreq(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7),
                data.XNThSetFreq(), current_alignment);


    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);

    return calculated_size;
}

template<>
eProsima_user_DllExport void serialize(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNThreadStatus& data)
{
    using namespace XNSim::XNSimStatus;

    eprosima::fastcdr::Cdr::state current_state(scdr);
    scdr.begin_serialize_type(current_state,
            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);

    scdr
        << eprosima::fastcdr::MemberId(0) << data.XNThreadName()
        << eprosima::fastcdr::MemberId(1) << data.XNThreadID()
        << eprosima::fastcdr::MemberId(2) << data.XNThreadSt()
        << eprosima::fastcdr::MemberId(3) << data.XNThreadAff()
        << eprosima::fastcdr::MemberId(4) << data.XNThreadPro()
        << eprosima::fastcdr::MemberId(5) << data.XNThRunCnt()
        << eprosima::fastcdr::MemberId(6) << data.XNThCurFreq()
        << eprosima::fastcdr::MemberId(7) << data.XNThSetFreq()
;
    scdr.end_serialize_type(current_state);
}

template<>
eProsima_user_DllExport void deserialize(
        eprosima::fastcdr::Cdr& cdr,
        XNSim::XNSimStatus::XNThreadStatus& data)
{
    using namespace XNSim::XNSimStatus;

    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
            {
                bool ret_value = true;
                switch (mid.id)
                {
                                        case 0:
                                                dcdr >> data.XNThreadName();
                                            break;

                                        case 1:
                                                dcdr >> data.XNThreadID();
                                            break;

                                        case 2:
                                                dcdr >> data.XNThreadSt();
                                            break;

                                        case 3:
                                                dcdr >> data.XNThreadAff();
                                            break;

                                        case 4:
                                                dcdr >> data.XNThreadPro();
                                            break;

                                        case 5:
                                                dcdr >> data.XNThRunCnt();
                                            break;

                                        case 6:
                                                dcdr >> data.XNThCurFreq();
                                            break;

                                        case 7:
                                                dcdr >> data.XNThSetFreq();
                                            break;

                    default:
                        ret_value = false;
                        break;
                }
                return ret_value;
            });
}

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNThreadStatus& data)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(scdr);
    static_cast<void>(data);
                        scdr << data.XNThreadName();

                        scdr << data.XNThreadID();

                        scdr << data.XNThreadSt();

                        scdr << data.XNThreadAff();

                        scdr << data.XNThreadPro();

                        scdr << data.XNThRunCnt();

                        scdr << data.XNThCurFreq();

                        scdr << data.XNThSetFreq();

}


template<>
eProsima_user_DllExport size_t calculate_serialized_size(
        eprosima::fastcdr::CdrSizeCalculator& calculator,
        const XNSim::XNSimStatus::XNModelStatus& data,
        size_t& current_alignment)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(data);

    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
                                current_alignment)};


        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
                data.XNModelName(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.XNModelID(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2),
                data.XNModelSt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.XNModelThID(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
                data.XNModelNode(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
                data.XNModelPro(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6),
                data.XNModelRunCnt(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7),
                data.XNMdlCurFreq(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(8),
                data.XNMdlSetFreq(), current_alignment);


    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);

    return calculated_size;
}

template<>
eProsima_user_DllExport void serialize(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNModelStatus& data)
{
    using namespace XNSim::XNSimStatus;

    eprosima::fastcdr::Cdr::state current_state(scdr);
    scdr.begin_serialize_type(current_state,
            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);

    scdr
        << eprosima::fastcdr::MemberId(0) << data.XNModelName()
        << eprosima::fastcdr::MemberId(1) << data.XNModelID()
        << eprosima::fastcdr::MemberId(2) << data.XNModelSt()
        << eprosima::fastcdr::MemberId(3) << data.XNModelThID()
        << eprosima::fastcdr::MemberId(4) << data.XNModelNode()
        << eprosima::fastcdr::MemberId(5) << data.XNModelPro()
        << eprosima::fastcdr::MemberId(6) << data.XNModelRunCnt()
        << eprosima::fastcdr::MemberId(7) << data.XNMdlCurFreq()
        << eprosima::fastcdr::MemberId(8) << data.XNMdlSetFreq()
;
    scdr.end_serialize_type(current_state);
}

template<>
eProsima_user_DllExport void deserialize(
        eprosima::fastcdr::Cdr& cdr,
        XNSim::XNSimStatus::XNModelStatus& data)
{
    using namespace XNSim::XNSimStatus;

    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
            {
                bool ret_value = true;
                switch (mid.id)
                {
                                        case 0:
                                                dcdr >> data.XNModelName();
                                            break;

                                        case 1:
                                                dcdr >> data.XNModelID();
                                            break;

                                        case 2:
                                                dcdr >> data.XNModelSt();
                                            break;

                                        case 3:
                                                dcdr >> data.XNModelThID();
                                            break;

                                        case 4:
                                                dcdr >> data.XNModelNode();
                                            break;

                                        case 5:
                                                dcdr >> data.XNModelPro();
                                            break;

                                        case 6:
                                                dcdr >> data.XNModelRunCnt();
                                            break;

                                        case 7:
                                                dcdr >> data.XNMdlCurFreq();
                                            break;

                                        case 8:
                                                dcdr >> data.XNMdlSetFreq();
                                            break;

                    default:
                        ret_value = false;
                        break;
                }
                return ret_value;
            });
}

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimStatus::XNModelStatus& data)
{
    using namespace XNSim::XNSimStatus;

    static_cast<void>(scdr);
    static_cast<void>(data);
                        scdr << data.XNModelName();

                        scdr << data.XNModelID();

                        scdr << data.XNModelSt();

                        scdr << data.XNModelThID();

                        scdr << data.XNModelNode();

                        scdr << data.XNModelPro();

                        scdr << data.XNModelRunCnt();

                        scdr << data.XNMdlCurFreq();

                        scdr << data.XNMdlSetFreq();

}


template<>
eProsima_user_DllExport size_t calculate_serialized_size(
        eprosima::fastcdr::CdrSizeCalculator& calculator,
        const XNSim::XNSimControl::XNRuntimeControl& data,
        size_t& current_alignment)
{
    using namespace XNSim::XNSimControl;

    static_cast<void>(data);

    eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding();
    size_t calculated_size {calculator.begin_calculate_type_serialized_size(
                                eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ?
                                eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
                                eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
                                current_alignment)};


        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0),
                data.XNSimCmd(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.XNThrCmd(), current_alignment);


    calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment);

    return calculated_size;
}

template<>
eProsima_user_DllExport void serialize(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimControl::XNRuntimeControl& data)
{
    using namespace XNSim::XNSimControl;

    eprosima::fastcdr::Cdr::state current_state(scdr);
    scdr.begin_serialize_type(current_state,
            eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);

    scdr
        << eprosima::fastcdr::MemberId(0) << data.XNSimCmd()
        << eprosima::fastcdr::MemberId(1) << data.XNThrCmd()
;
    scdr.end_serialize_type(current_state);
}

template<>
eProsima_user_DllExport void deserialize(
        eprosima::fastcdr::Cdr& cdr,
        XNSim::XNSimControl::XNRuntimeControl& data)
{
    using namespace XNSim::XNSimControl;

    cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ?
            eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 :
            eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR,
            [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool
            {
                bool ret_value = true;
                switch (mid.id)
                {
                                        case 0:
                                                dcdr >> data.XNSimCmd();
                                            break;

                                        case 1:
                                                dcdr >> data.XNThrCmd();
                                            break;

                    default:
                        ret_value = false;
                        break;
                }
                return ret_value;
            });
}

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const XNSim::XNSimControl::XNRuntimeControl& data)
{
    using namespace XNSim::XNSimControl;

    static_cast<void>(scdr);
    static_cast<void>(data);
                        scdr << data.XNSimCmd();

                        scdr << data.XNThrCmd();

}



} // namespace fastcdr
} // namespace eprosima

#endif // FAST_DDS_GENERATED__XNSIM_XNSIMCONTROL_XNSIMSTATUSCDRAUX_IPP