// 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 WeighingDDSTypeCdrAux.ipp
 * This source file contains some declarations of CDR related functions.
 *
 * This file was generated by the tool fastddsgen.
 */

#ifndef FAST_DDS_GENERATED__QUEUE_WEIGHINGDDSTYPECDRAUX_IPP
#define FAST_DDS_GENERATED__QUEUE_WEIGHINGDDSTYPECDRAUX_IPP

#include "WeighingDDSTypeCdrAux.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 WeighingSystem::ScaleInfo& data,
        size_t& current_alignment)
{
    using namespace WeighingSystem;

    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.HasVehicle(), current_alignment);

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4),
                data.StableValue(), 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 WeighingSystem::ScaleInfo& data)
{
    using namespace WeighingSystem;

    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.HasVehicle()
        << eprosima::fastcdr::MemberId(1) << data.WeightOK()
        << eprosima::fastcdr::MemberId(2) << data.State()
        << eprosima::fastcdr::MemberId(3) << data.Value()
        << eprosima::fastcdr::MemberId(4) << data.StableValue()
;
    scdr.end_serialize_type(current_state);
}

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

    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.HasVehicle();
                                            break;

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

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

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

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::ScaleInfo& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.WeightOK();

                        scdr << data.State();

                        scdr << data.Value();

                        scdr << data.StableValue();

}


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

    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.Enable(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.ResetZero(), 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 WeighingSystem::ScaleCommand& data)
{
    using namespace WeighingSystem;

    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.Enable()
        << eprosima::fastcdr::MemberId(1) << data.ResetZero()
;
    scdr.end_serialize_type(current_state);
}

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

    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.Enable();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::ScaleCommand& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.ResetZero();

}


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

    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.GrossDeviceID(), current_alignment);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(31),
                data.TransportCompany(), 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 WeighingSystem::WeightInfoOk& data)
{
    using namespace WeighingSystem;

    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.GrossDeviceID()
        << eprosima::fastcdr::MemberId(1) << data.GrossDeviceName()
        << eprosima::fastcdr::MemberId(2) << data.GrossDeviceType()
        << eprosima::fastcdr::MemberId(3) << data.TareDeviceID()
        << eprosima::fastcdr::MemberId(4) << data.TareDeviceName()
        << eprosima::fastcdr::MemberId(5) << data.TareDeviceType()
        << eprosima::fastcdr::MemberId(6) << data.EnterpriseName()
        << eprosima::fastcdr::MemberId(7) << data.BillNumber()
        << eprosima::fastcdr::MemberId(8) << data.CarNumber()
        << eprosima::fastcdr::MemberId(9) << data.Supplier()
        << eprosima::fastcdr::MemberId(10) << data.GoodsType()
        << eprosima::fastcdr::MemberId(11) << data.GrossWeight()
        << eprosima::fastcdr::MemberId(12) << data.GrossTime()
        << eprosima::fastcdr::MemberId(13) << data.GrossOperater()
        << eprosima::fastcdr::MemberId(14) << data.Tare()
        << eprosima::fastcdr::MemberId(15) << data.TareTime()
        << eprosima::fastcdr::MemberId(16) << data.TareOperater()
        << eprosima::fastcdr::MemberId(17) << data.Suttle()
        << eprosima::fastcdr::MemberId(18) << data.duduction1()
        << eprosima::fastcdr::MemberId(19) << data.duduction2()
        << eprosima::fastcdr::MemberId(20) << data.duduction3()
        << eprosima::fastcdr::MemberId(21) << data.INCoalYard()
        << eprosima::fastcdr::MemberId(22) << data.OutCoalYard()
        << eprosima::fastcdr::MemberId(23) << data.BatchNumber()
        << eprosima::fastcdr::MemberId(24) << data.Warning()
        << eprosima::fastcdr::MemberId(25) << data.Tips()
        << eprosima::fastcdr::MemberId(26) << data.TicketType()
        << eprosima::fastcdr::MemberId(27) << data.IsPrintTicker()
        << eprosima::fastcdr::MemberId(28) << data.OrderNumber()
        << eprosima::fastcdr::MemberId(29) << data.VehicleAndVesselNumber()
        << eprosima::fastcdr::MemberId(30) << data.ReceiveCompany()
        << eprosima::fastcdr::MemberId(31) << data.TransportCompany()
;
    scdr.end_serialize_type(current_state);
}

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

    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.GrossDeviceID();
                                            break;

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

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

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

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

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

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

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

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

                                        case 9:
                                                dcdr >> data.Supplier();
                                            break;

                                        case 10:
                                                dcdr >> data.GoodsType();
                                            break;

                                        case 11:
                                                dcdr >> data.GrossWeight();
                                            break;

                                        case 12:
                                                dcdr >> data.GrossTime();
                                            break;

                                        case 13:
                                                dcdr >> data.GrossOperater();
                                            break;

                                        case 14:
                                                dcdr >> data.Tare();
                                            break;

                                        case 15:
                                                dcdr >> data.TareTime();
                                            break;

                                        case 16:
                                                dcdr >> data.TareOperater();
                                            break;

                                        case 17:
                                                dcdr >> data.Suttle();
                                            break;

                                        case 18:
                                                dcdr >> data.duduction1();
                                            break;

                                        case 19:
                                                dcdr >> data.duduction2();
                                            break;

                                        case 20:
                                                dcdr >> data.duduction3();
                                            break;

                                        case 21:
                                                dcdr >> data.INCoalYard();
                                            break;

                                        case 22:
                                                dcdr >> data.OutCoalYard();
                                            break;

                                        case 23:
                                                dcdr >> data.BatchNumber();
                                            break;

                                        case 24:
                                                dcdr >> data.Warning();
                                            break;

                                        case 25:
                                                dcdr >> data.Tips();
                                            break;

                                        case 26:
                                                dcdr >> data.TicketType();
                                            break;

                                        case 27:
                                                dcdr >> data.IsPrintTicker();
                                            break;

                                        case 28:
                                                dcdr >> data.OrderNumber();
                                            break;

                                        case 29:
                                                dcdr >> data.VehicleAndVesselNumber();
                                            break;

                                        case 30:
                                                dcdr >> data.ReceiveCompany();
                                            break;

                                        case 31:
                                                dcdr >> data.TransportCompany();
                                            break;

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::WeightInfoOk& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.GrossDeviceName();

                        scdr << data.GrossDeviceType();

                        scdr << data.TareDeviceID();

                        scdr << data.TareDeviceName();

                        scdr << data.TareDeviceType();

                        scdr << data.EnterpriseName();

                        scdr << data.BillNumber();

                        scdr << data.CarNumber();

                        scdr << data.Supplier();

                        scdr << data.GoodsType();

                        scdr << data.GrossWeight();

                        scdr << data.GrossTime();

                        scdr << data.GrossOperater();

                        scdr << data.Tare();

                        scdr << data.TareTime();

                        scdr << data.TareOperater();

                        scdr << data.Suttle();

                        scdr << data.duduction1();

                        scdr << data.duduction2();

                        scdr << data.duduction3();

                        scdr << data.INCoalYard();

                        scdr << data.OutCoalYard();

                        scdr << data.BatchNumber();

                        scdr << data.Warning();

                        scdr << data.Tips();

                        scdr << data.TicketType();

                        scdr << data.IsPrintTicker();

                        scdr << data.OrderNumber();

                        scdr << data.VehicleAndVesselNumber();

                        scdr << data.ReceiveCompany();

                        scdr << data.TransportCompany();

}


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

    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.CarNumber(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.Warning(), 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 WeighingSystem::WeightInfoError& data)
{
    using namespace WeighingSystem;

    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.CarNumber()
        << eprosima::fastcdr::MemberId(1) << data.Warning()
;
    scdr.end_serialize_type(current_state);
}

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

    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.CarNumber();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::WeightInfoError& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.Warning();

}


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

    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.FrontBarSignalUp(), current_alignment);

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

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5),
                data.BackBarEnable(), 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 WeighingSystem::BarCommandUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontBarSignalUp()
        << eprosima::fastcdr::MemberId(1) << data.FrontBarSignalDown()
        << eprosima::fastcdr::MemberId(2) << data.FrontBarEnable()
        << eprosima::fastcdr::MemberId(3) << data.BackBarSignalUp()
        << eprosima::fastcdr::MemberId(4) << data.BackBarSignalDown()
        << eprosima::fastcdr::MemberId(5) << data.BackBarEnable()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontBarSignalUp();
                                            break;

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

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

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

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

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::BarCommandUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.FrontBarSignalDown();

                        scdr << data.FrontBarEnable();

                        scdr << data.BackBarSignalUp();

                        scdr << data.BackBarSignalDown();

                        scdr << data.BackBarEnable();

}


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

    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.FrontLEDSignal(), current_alignment);

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.BackLEDEnable(), 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 WeighingSystem::LightsCommandUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontLEDSignal()
        << eprosima::fastcdr::MemberId(1) << data.FrontLEDEnable()
        << eprosima::fastcdr::MemberId(2) << data.BackLEDSignal()
        << eprosima::fastcdr::MemberId(3) << data.BackLEDEnable()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontLEDSignal();
                                            break;

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

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

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::LightsCommandUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.FrontLEDEnable();

                        scdr << data.BackLEDSignal();

                        scdr << data.BackLEDEnable();

}


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

    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.FrontResistanceUnLock(), current_alignment);

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3),
                data.BackResistanceEnable(), 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 WeighingSystem::InfraredCommandUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontResistanceUnLock()
        << eprosima::fastcdr::MemberId(1) << data.FrontResistanceEnable()
        << eprosima::fastcdr::MemberId(2) << data.BackResistanceUnLock()
        << eprosima::fastcdr::MemberId(3) << data.BackResistanceEnable()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontResistanceUnLock();
                                            break;

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

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

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::InfraredCommandUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.FrontResistanceEnable();

                        scdr << data.BackResistanceUnLock();

                        scdr << data.BackResistanceEnable();

}


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

    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.FrontBarState(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.BackBarState(), 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 WeighingSystem::BarUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontBarState()
        << eprosima::fastcdr::MemberId(1) << data.BackBarState()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontBarState();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::BarUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.BackBarState();

}


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

    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.FrontLEDState(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.BackLEDState(), 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 WeighingSystem::LightsUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontLEDState()
        << eprosima::fastcdr::MemberId(1) << data.BackLEDState()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontLEDState();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::LightsUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.BackLEDState();

}


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

    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.FrontResistanceSignal(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.BackResistanceSignal(), 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 WeighingSystem::InfraredUpdate& data)
{
    using namespace WeighingSystem;

    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.FrontResistanceSignal()
        << eprosima::fastcdr::MemberId(1) << data.BackResistanceSignal()
;
    scdr.end_serialize_type(current_state);
}

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

    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.FrontResistanceSignal();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::InfraredUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.BackResistanceSignal();

}


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

    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.NewTag(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.License(), 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 WeighingSystem::LicenseSnapUpdate& data)
{
    using namespace WeighingSystem;

    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.NewTag()
        << eprosima::fastcdr::MemberId(1) << data.License()
;
    scdr.end_serialize_type(current_state);
}

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

    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.NewTag();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::LicenseSnapUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.License();

}


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

    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.VoiceID(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.VoiceContent(), 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 WeighingSystem::Voice& data)
{
    using namespace WeighingSystem;

    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.VoiceID()
        << eprosima::fastcdr::MemberId(1) << data.VoiceContent()
;
    scdr.end_serialize_type(current_state);
}

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

    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.VoiceID();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::Voice& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.VoiceContent();

}


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

    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.License(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.StableValue(), 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 WeighingSystem::SummaryUpdate& data)
{
    using namespace WeighingSystem;

    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.License()
        << eprosima::fastcdr::MemberId(1) << data.StableValue()
;
    scdr.end_serialize_type(current_state);
}

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

    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.License();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::SummaryUpdate& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.StableValue();

}


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

    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.index(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.msg(), 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 WeighingSystem::ReadCardReq& data)
{
    using namespace WeighingSystem;

    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.index()
        << eprosima::fastcdr::MemberId(1) << data.msg()
;
    scdr.end_serialize_type(current_state);
}

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

    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.index();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::ReadCardReq& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.msg();

}


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

    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.index(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.msg(), 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 WeighingSystem::ReadCardRsp& data)
{
    using namespace WeighingSystem;

    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.index()
        << eprosima::fastcdr::MemberId(1) << data.msg()
;
    scdr.end_serialize_type(current_state);
}

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

    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.index();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::ReadCardRsp& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.msg();

}


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

    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.index(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.msg(), 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 WeighingSystem::PrintReq& data)
{
    using namespace WeighingSystem;

    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.index()
        << eprosima::fastcdr::MemberId(1) << data.msg()
;
    scdr.end_serialize_type(current_state);
}

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

    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.index();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::PrintReq& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.msg();

}


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

    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.index(), current_alignment);

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1),
                data.msg(), 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 WeighingSystem::PrintRsp& data)
{
    using namespace WeighingSystem;

    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.index()
        << eprosima::fastcdr::MemberId(1) << data.msg()
;
    scdr.end_serialize_type(current_state);
}

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

    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.index();
                                            break;

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

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const WeighingSystem::PrintRsp& data)
{
    using namespace WeighingSystem;

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

                        scdr << data.msg();

}


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

    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.message_id(), current_alignment);

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

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

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

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

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

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

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(10),
                data.electronic_tag_snapshot(), 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 Queue::QueueTrigger& data)
{
    using namespace Queue;

    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.message_id()
        << eprosima::fastcdr::MemberId(1) << data.card_number()
        << eprosima::fastcdr::MemberId(2) << data.device_id()
        << eprosima::fastcdr::MemberId(3) << data.trigger_time()
        << eprosima::fastcdr::MemberId(4) << data.vehicle_number_snapshot()
        << eprosima::fastcdr::MemberId(5) << data.supplier_identity_id_snapshot()
        << eprosima::fastcdr::MemberId(6) << data.goods_id_snapshot()
        << eprosima::fastcdr::MemberId(7) << data.ship_net_weight_snapshot()
        << eprosima::fastcdr::MemberId(8) << data.card_flow_no_snapshot()
        << eprosima::fastcdr::MemberId(9) << data.card_type_snapshot()
        << eprosima::fastcdr::MemberId(10) << data.electronic_tag_snapshot()
;
    scdr.end_serialize_type(current_state);
}

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

    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.message_id();
                                            break;

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

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

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

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

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

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

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

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

                                        case 9:
                                                dcdr >> data.card_type_snapshot();
                                            break;

                                        case 10:
                                                dcdr >> data.electronic_tag_snapshot();
                                            break;

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const Queue::QueueTrigger& data)
{
    using namespace Queue;

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

                        scdr << data.card_number();

                        scdr << data.device_id();

                        scdr << data.trigger_time();

                        scdr << data.vehicle_number_snapshot();

                        scdr << data.supplier_identity_id_snapshot();

                        scdr << data.goods_id_snapshot();

                        scdr << data.ship_net_weight_snapshot();

                        scdr << data.card_flow_no_snapshot();

                        scdr << data.card_type_snapshot();

                        scdr << data.electronic_tag_snapshot();

}


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

    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.message_id(), current_alignment);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(39),
                data.card_write_status(), 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 Queue::QueueSuccess& data)
{
    using namespace Queue;

    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.message_id()
        << eprosima::fastcdr::MemberId(1) << data.card_number()
        << eprosima::fastcdr::MemberId(2) << data.device_id()
        << eprosima::fastcdr::MemberId(3) << data.result_code()
        << eprosima::fastcdr::MemberId(4) << data.queue_record_id()
        << eprosima::fastcdr::MemberId(5) << data.queue_number()
        << eprosima::fastcdr::MemberId(6) << data.sample_machine()
        << eprosima::fastcdr::MemberId(7) << data.queue_time()
        << eprosima::fastcdr::MemberId(8) << data.ticket_number()
        << eprosima::fastcdr::MemberId(9) << data.sample_code()
        << eprosima::fastcdr::MemberId(10) << data.vehicle_number()
        << eprosima::fastcdr::MemberId(11) << data.vehicle_self_no()
        << eprosima::fastcdr::MemberId(12) << data.vehicle_type_id()
        << eprosima::fastcdr::MemberId(13) << data.supplier_identity_id()
        << eprosima::fastcdr::MemberId(14) << data.supplier_identity_name()
        << eprosima::fastcdr::MemberId(15) << data.supplier_id()
        << eprosima::fastcdr::MemberId(16) << data.supplier_name()
        << eprosima::fastcdr::MemberId(17) << data.goods_id()
        << eprosima::fastcdr::MemberId(18) << data.goods_name()
        << eprosima::fastcdr::MemberId(19) << data.unit_id()
        << eprosima::fastcdr::MemberId(20) << data.transport_company_id()
        << eprosima::fastcdr::MemberId(21) << data.sample_type()
        << eprosima::fastcdr::MemberId(22) << data.unloading_point_name()
        << eprosima::fastcdr::MemberId(23) << data.ship_gross_weight()
        << eprosima::fastcdr::MemberId(24) << data.ship_tare_weight()
        << eprosima::fastcdr::MemberId(25) << data.ship_net_weight()
        << eprosima::fastcdr::MemberId(26) << data.sample_machine_id()
        << eprosima::fastcdr::MemberId(27) << data.vehicle_lane()
        << eprosima::fastcdr::MemberId(28) << data.vehicle_lane_id()
        << eprosima::fastcdr::MemberId(29) << data.strategy_desc()
        << eprosima::fastcdr::MemberId(30) << data.committed_at()
        << eprosima::fastcdr::MemberId(31) << data.display_text()
        << eprosima::fastcdr::MemberId(32) << data.print_content()
        << eprosima::fastcdr::MemberId(33) << data.print_required()
        << eprosima::fastcdr::MemberId(34) << data.print_count()
        << eprosima::fastcdr::MemberId(35) << data.voice_id()
        << eprosima::fastcdr::MemberId(36) << data.voice_text()
        << eprosima::fastcdr::MemberId(37) << data.is_reprint()
        << eprosima::fastcdr::MemberId(38) << data.physical_card_state()
        << eprosima::fastcdr::MemberId(39) << data.card_write_status()
;
    scdr.end_serialize_type(current_state);
}

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

    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.message_id();
                                            break;

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

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

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

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

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

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

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

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

                                        case 9:
                                                dcdr >> data.sample_code();
                                            break;

                                        case 10:
                                                dcdr >> data.vehicle_number();
                                            break;

                                        case 11:
                                                dcdr >> data.vehicle_self_no();
                                            break;

                                        case 12:
                                                dcdr >> data.vehicle_type_id();
                                            break;

                                        case 13:
                                                dcdr >> data.supplier_identity_id();
                                            break;

                                        case 14:
                                                dcdr >> data.supplier_identity_name();
                                            break;

                                        case 15:
                                                dcdr >> data.supplier_id();
                                            break;

                                        case 16:
                                                dcdr >> data.supplier_name();
                                            break;

                                        case 17:
                                                dcdr >> data.goods_id();
                                            break;

                                        case 18:
                                                dcdr >> data.goods_name();
                                            break;

                                        case 19:
                                                dcdr >> data.unit_id();
                                            break;

                                        case 20:
                                                dcdr >> data.transport_company_id();
                                            break;

                                        case 21:
                                                dcdr >> data.sample_type();
                                            break;

                                        case 22:
                                                dcdr >> data.unloading_point_name();
                                            break;

                                        case 23:
                                                dcdr >> data.ship_gross_weight();
                                            break;

                                        case 24:
                                                dcdr >> data.ship_tare_weight();
                                            break;

                                        case 25:
                                                dcdr >> data.ship_net_weight();
                                            break;

                                        case 26:
                                                dcdr >> data.sample_machine_id();
                                            break;

                                        case 27:
                                                dcdr >> data.vehicle_lane();
                                            break;

                                        case 28:
                                                dcdr >> data.vehicle_lane_id();
                                            break;

                                        case 29:
                                                dcdr >> data.strategy_desc();
                                            break;

                                        case 30:
                                                dcdr >> data.committed_at();
                                            break;

                                        case 31:
                                                dcdr >> data.display_text();
                                            break;

                                        case 32:
                                                dcdr >> data.print_content();
                                            break;

                                        case 33:
                                                dcdr >> data.print_required();
                                            break;

                                        case 34:
                                                dcdr >> data.print_count();
                                            break;

                                        case 35:
                                                dcdr >> data.voice_id();
                                            break;

                                        case 36:
                                                dcdr >> data.voice_text();
                                            break;

                                        case 37:
                                                dcdr >> data.is_reprint();
                                            break;

                                        case 38:
                                                dcdr >> data.physical_card_state();
                                            break;

                                        case 39:
                                                dcdr >> data.card_write_status();
                                            break;

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const Queue::QueueSuccess& data)
{
    using namespace Queue;

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

                        scdr << data.card_number();

                        scdr << data.device_id();

                        scdr << data.result_code();

                        scdr << data.queue_record_id();

                        scdr << data.queue_number();

                        scdr << data.sample_machine();

                        scdr << data.queue_time();

                        scdr << data.ticket_number();

                        scdr << data.sample_code();

                        scdr << data.vehicle_number();

                        scdr << data.vehicle_self_no();

                        scdr << data.vehicle_type_id();

                        scdr << data.supplier_identity_id();

                        scdr << data.supplier_identity_name();

                        scdr << data.supplier_id();

                        scdr << data.supplier_name();

                        scdr << data.goods_id();

                        scdr << data.goods_name();

                        scdr << data.unit_id();

                        scdr << data.transport_company_id();

                        scdr << data.sample_type();

                        scdr << data.unloading_point_name();

                        scdr << data.ship_gross_weight();

                        scdr << data.ship_tare_weight();

                        scdr << data.ship_net_weight();

                        scdr << data.sample_machine_id();

                        scdr << data.vehicle_lane();

                        scdr << data.vehicle_lane_id();

                        scdr << data.strategy_desc();

                        scdr << data.committed_at();

                        scdr << data.display_text();

                        scdr << data.print_content();

                        scdr << data.print_required();

                        scdr << data.print_count();

                        scdr << data.voice_id();

                        scdr << data.voice_text();

                        scdr << data.is_reprint();

                        scdr << data.physical_card_state();

                        scdr << data.card_write_status();

}


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

    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.message_id(), current_alignment);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(21),
                data.card_write_status(), 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 Queue::QueueFailure& data)
{
    using namespace Queue;

    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.message_id()
        << eprosima::fastcdr::MemberId(1) << data.card_number()
        << eprosima::fastcdr::MemberId(2) << data.device_id()
        << eprosima::fastcdr::MemberId(3) << data.error_code()
        << eprosima::fastcdr::MemberId(4) << data.failed_step()
        << eprosima::fastcdr::MemberId(5) << data.message()
        << eprosima::fastcdr::MemberId(6) << data.vehicle_number()
        << eprosima::fastcdr::MemberId(7) << data.queue_record_id()
        << eprosima::fastcdr::MemberId(8) << data.queue_number()
        << eprosima::fastcdr::MemberId(9) << data.sample_machine()
        << eprosima::fastcdr::MemberId(10) << data.ticket_number()
        << eprosima::fastcdr::MemberId(11) << data.existing_queue_record_id()
        << eprosima::fastcdr::MemberId(12) << data.existing_queue_number()
        << eprosima::fastcdr::MemberId(13) << data.existing_sample_machine()
        << eprosima::fastcdr::MemberId(14) << data.cache_state()
        << eprosima::fastcdr::MemberId(15) << data.database_state()
        << eprosima::fastcdr::MemberId(16) << data.physical_card_state()
        << eprosima::fastcdr::MemberId(17) << data.retryable()
        << eprosima::fastcdr::MemberId(18) << data.retry_after_ms()
        << eprosima::fastcdr::MemberId(19) << data.voice_id()
        << eprosima::fastcdr::MemberId(20) << data.voice_text()
        << eprosima::fastcdr::MemberId(21) << data.card_write_status()
;
    scdr.end_serialize_type(current_state);
}

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

    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.message_id();
                                            break;

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

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

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

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

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

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

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

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

                                        case 9:
                                                dcdr >> data.sample_machine();
                                            break;

                                        case 10:
                                                dcdr >> data.ticket_number();
                                            break;

                                        case 11:
                                                dcdr >> data.existing_queue_record_id();
                                            break;

                                        case 12:
                                                dcdr >> data.existing_queue_number();
                                            break;

                                        case 13:
                                                dcdr >> data.existing_sample_machine();
                                            break;

                                        case 14:
                                                dcdr >> data.cache_state();
                                            break;

                                        case 15:
                                                dcdr >> data.database_state();
                                            break;

                                        case 16:
                                                dcdr >> data.physical_card_state();
                                            break;

                                        case 17:
                                                dcdr >> data.retryable();
                                            break;

                                        case 18:
                                                dcdr >> data.retry_after_ms();
                                            break;

                                        case 19:
                                                dcdr >> data.voice_id();
                                            break;

                                        case 20:
                                                dcdr >> data.voice_text();
                                            break;

                                        case 21:
                                                dcdr >> data.card_write_status();
                                            break;

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

void serialize_key(
        eprosima::fastcdr::Cdr& scdr,
        const Queue::QueueFailure& data)
{
    using namespace Queue;

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

                        scdr << data.card_number();

                        scdr << data.device_id();

                        scdr << data.error_code();

                        scdr << data.failed_step();

                        scdr << data.message();

                        scdr << data.vehicle_number();

                        scdr << data.queue_record_id();

                        scdr << data.queue_number();

                        scdr << data.sample_machine();

                        scdr << data.ticket_number();

                        scdr << data.existing_queue_record_id();

                        scdr << data.existing_queue_number();

                        scdr << data.existing_sample_machine();

                        scdr << data.cache_state();

                        scdr << data.database_state();

                        scdr << data.physical_card_state();

                        scdr << data.retryable();

                        scdr << data.retry_after_ms();

                        scdr << data.voice_id();

                        scdr << data.voice_text();

                        scdr << data.card_write_status();

}



} // namespace fastcdr
} // namespace eprosima

#endif // FAST_DDS_GENERATED__QUEUE_WEIGHINGDDSTYPECDRAUX_IPP