taf_mngdConn_messages.h

Go to the documentation of this file.

/*
 * ====================== WARNING ======================
 *
 * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
 * DO NOT MODIFY IN ANY WAY.
 *
 * ====================== WARNING ======================
 */


#ifndef TAF_MNGDCONN_MESSAGES_H_INCLUDE_GUARD
#define TAF_MNGDCONN_MESSAGES_H_INCLUDE_GUARD


#include "taf_mngdConn_common.h"

#define _MAX_MSG_SIZE IFGEN_TAF_MNGDCONN_MSG_SIZE

// Define the message type for communicating between client and server
typedef struct __attribute__((packed))
{
    uint32_t id;
    uint8_t buffer[_MAX_MSG_SIZE];
}
_Message_t;

#define _MSGID_taf_mngdConn_AddDataStateHandler 0
#define _MSGID_taf_mngdConn_RemoveDataStateHandler 1
#define _MSGID_taf_mngdConn_AddRecoveryStateHandler 2
#define _MSGID_taf_mngdConn_RemoveRecoveryStateHandler 3
#define _MSGID_taf_mngdConn_GetData 4
#define _MSGID_taf_mngdConn_GetDataByName 5
#define _MSGID_taf_mngdConn_GetDataIdByRef 6
#define _MSGID_taf_mngdConn_GetDataNameByRef 7
#define _MSGID_taf_mngdConn_StartData 8
#define _MSGID_taf_mngdConn_StopData 9
#define _MSGID_taf_mngdConn_GetDataConnectionState 10
#define _MSGID_taf_mngdConn_GetDataConnectionIPAddresses 11
#define _MSGID_taf_mngdConn_StartDataRetry 12
#define _MSGID_taf_mngdConn_CancelL1Recovery 13
#define _MSGID_taf_mngdConn_CancelL2Recovery 14


// Define type-safe pack/unpack functions for all enums, including included types

static inline bool taf_mngdConn_PackDataState
(
    uint8_t **bufferPtr,
    taf_mngdConn_DataState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_mngdConn_UnpackDataState
(
    uint8_t **bufferPtr,
    taf_mngdConn_DataState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_mngdConn_DataState_t)value;
    }
    return result;
}

static inline bool taf_mngdConn_PackRecoveryState
(
    uint8_t **bufferPtr,
    taf_mngdConn_RecoveryState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_mngdConn_UnpackRecoveryState
(
    uint8_t **bufferPtr,
    taf_mngdConn_RecoveryState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_mngdConn_RecoveryState_t)value;
    }
    return result;
}

static inline bool taf_sim_PackStates
(
    uint8_t **bufferPtr,
    taf_sim_States_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackStates
(
    uint8_t **bufferPtr,
    taf_sim_States_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_States_t)value;
    }
    return result;
}

static inline bool taf_sim_PackId
(
    uint8_t **bufferPtr,
    taf_sim_Id_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackId
(
    uint8_t **bufferPtr,
    taf_sim_Id_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_Id_t)value;
    }
    return result;
}

static inline bool taf_sim_PackLockType
(
    uint8_t **bufferPtr,
    taf_sim_LockType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackLockType
(
    uint8_t **bufferPtr,
    taf_sim_LockType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_LockType_t)value;
    }
    return result;
}

static inline bool taf_sim_PackLockResponse
(
    uint8_t **bufferPtr,
    taf_sim_LockResponse_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackLockResponse
(
    uint8_t **bufferPtr,
    taf_sim_LockResponse_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_LockResponse_t)value;
    }
    return result;
}

static inline bool taf_sim_PackAppType
(
    uint8_t **bufferPtr,
    taf_sim_AppType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackAppType
(
    uint8_t **bufferPtr,
    taf_sim_AppType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_AppType_t)value;
    }
    return result;
}

static inline bool taf_sim_PackManufacturer
(
    uint8_t **bufferPtr,
    taf_sim_Manufacturer_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackManufacturer
(
    uint8_t **bufferPtr,
    taf_sim_Manufacturer_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_Manufacturer_t)value;
    }
    return result;
}

static inline bool taf_sim_PackCommand
(
    uint8_t **bufferPtr,
    taf_sim_Command_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_sim_UnpackCommand
(
    uint8_t **bufferPtr,
    taf_sim_Command_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_sim_Command_t)value;
    }
    return result;
}

static inline bool taf_radio_PackRat
(
    uint8_t **bufferPtr,
    taf_radio_Rat_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackRat
(
    uint8_t **bufferPtr,
    taf_radio_Rat_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_Rat_t)value;
    }
    return result;
}

static inline bool taf_radio_PackRatSvcStatus
(
    uint8_t **bufferPtr,
    taf_radio_RatSvcStatus_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackRatSvcStatus
(
    uint8_t **bufferPtr,
    taf_radio_RatSvcStatus_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_RatSvcStatus_t)value;
    }
    return result;
}

static inline bool taf_radio_PackCsCap
(
    uint8_t **bufferPtr,
    taf_radio_CsCap_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackCsCap
(
    uint8_t **bufferPtr,
    taf_radio_CsCap_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_CsCap_t)value;
    }
    return result;
}

static inline bool taf_radio_PackNetRejCause
(
    uint8_t **bufferPtr,
    taf_radio_NetRejCause_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackNetRejCause
(
    uint8_t **bufferPtr,
    taf_radio_NetRejCause_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_NetRejCause_t)value;
    }
    return result;
}

static inline bool taf_radio_PackNetRegState
(
    uint8_t **bufferPtr,
    taf_radio_NetRegState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackNetRegState
(
    uint8_t **bufferPtr,
    taf_radio_NetRegState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_NetRegState_t)value;
    }
    return result;
}

static inline bool taf_radio_PackServiceDomainState
(
    uint8_t **bufferPtr,
    taf_radio_ServiceDomainState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackServiceDomainState
(
    uint8_t **bufferPtr,
    taf_radio_ServiceDomainState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_ServiceDomainState_t)value;
    }
    return result;
}

static inline bool taf_radio_PackSigType
(
    uint8_t **bufferPtr,
    taf_radio_SigType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackSigType
(
    uint8_t **bufferPtr,
    taf_radio_SigType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_SigType_t)value;
    }
    return result;
}

static inline bool taf_radio_PackImsRegStatus
(
    uint8_t **bufferPtr,
    taf_radio_ImsRegStatus_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackImsRegStatus
(
    uint8_t **bufferPtr,
    taf_radio_ImsRegStatus_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_ImsRegStatus_t)value;
    }
    return result;
}

static inline bool taf_radio_PackImsSvcType
(
    uint8_t **bufferPtr,
    taf_radio_ImsSvcType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackImsSvcType
(
    uint8_t **bufferPtr,
    taf_radio_ImsSvcType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_ImsSvcType_t)value;
    }
    return result;
}

static inline bool taf_radio_PackImsSvcStatus
(
    uint8_t **bufferPtr,
    taf_radio_ImsSvcStatus_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackImsSvcStatus
(
    uint8_t **bufferPtr,
    taf_radio_ImsSvcStatus_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_ImsSvcStatus_t)value;
    }
    return result;
}

static inline bool taf_radio_PackPdpError
(
    uint8_t **bufferPtr,
    taf_radio_PdpError_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackPdpError
(
    uint8_t **bufferPtr,
    taf_radio_PdpError_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_PdpError_t)value;
    }
    return result;
}

static inline bool taf_radio_PackOpMode
(
    uint8_t **bufferPtr,
    taf_radio_OpMode_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackOpMode
(
    uint8_t **bufferPtr,
    taf_radio_OpMode_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_OpMode_t)value;
    }
    return result;
}

static inline bool taf_radio_PackNREndcAvailability
(
    uint8_t **bufferPtr,
    taf_radio_NREndcAvailability_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackNREndcAvailability
(
    uint8_t **bufferPtr,
    taf_radio_NREndcAvailability_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_NREndcAvailability_t)value;
    }
    return result;
}

static inline bool taf_radio_PackNRDcnrRestriction
(
    uint8_t **bufferPtr,
    taf_radio_NRDcnrRestriction_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackNRDcnrRestriction
(
    uint8_t **bufferPtr,
    taf_radio_NRDcnrRestriction_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_NRDcnrRestriction_t)value;
    }
    return result;
}

static inline bool taf_radio_PackCellInfoStatus
(
    uint8_t **bufferPtr,
    taf_radio_CellInfoStatus_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackCellInfoStatus
(
    uint8_t **bufferPtr,
    taf_radio_CellInfoStatus_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_CellInfoStatus_t)value;
    }
    return result;
}

static inline bool taf_radio_PackRatBitMask
(
    uint8_t **bufferPtr,
    taf_radio_RatBitMask_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackRatBitMask
(
    uint8_t **bufferPtr,
    taf_radio_RatBitMask_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_RatBitMask_t)value;
    }
    return result;
}

static inline bool taf_radio_PackBandBitMask
(
    uint8_t **bufferPtr,
    taf_radio_BandBitMask_t value
)
{
    return le_pack_PackUint64(bufferPtr, (uint64_t)value);
}

static inline bool taf_radio_UnpackBandBitMask
(
    uint8_t **bufferPtr,
    taf_radio_BandBitMask_t* valuePtr
)
{
    bool result;
    uint64_t value = 0;
    result = le_pack_UnpackUint64(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_BandBitMask_t)value;
    }
    return result;
}

static inline bool taf_radio_PackImsIndBitMask
(
    uint8_t **bufferPtr,
    taf_radio_ImsIndBitMask_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackImsIndBitMask
(
    uint8_t **bufferPtr,
    taf_radio_ImsIndBitMask_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_ImsIndBitMask_t)value;
    }
    return result;
}

static inline bool taf_radio_PackNetStatusIndBitMask
(
    uint8_t **bufferPtr,
    taf_radio_NetStatusIndBitMask_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_radio_UnpackNetStatusIndBitMask
(
    uint8_t **bufferPtr,
    taf_radio_NetStatusIndBitMask_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_radio_NetStatusIndBitMask_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackDataBearerTechnology
(
    uint8_t **bufferPtr,
    taf_dcs_DataBearerTechnology_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackDataBearerTechnology
(
    uint8_t **bufferPtr,
    taf_dcs_DataBearerTechnology_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_DataBearerTechnology_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackConState
(
    uint8_t **bufferPtr,
    taf_dcs_ConState_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackConState
(
    uint8_t **bufferPtr,
    taf_dcs_ConState_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_ConState_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackPdp
(
    uint8_t **bufferPtr,
    taf_dcs_Pdp_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackPdp
(
    uint8_t **bufferPtr,
    taf_dcs_Pdp_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Pdp_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackRoamingType
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackRoamingType
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_RoamingType_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackAuth
(
    uint8_t **bufferPtr,
    taf_dcs_Auth_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackAuth
(
    uint8_t **bufferPtr,
    taf_dcs_Auth_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Auth_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackApnType
(
    uint8_t **bufferPtr,
    taf_dcs_ApnType_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackApnType
(
    uint8_t **bufferPtr,
    taf_dcs_ApnType_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_ApnType_t)value;
    }
    return result;
}

static inline bool taf_dcs_PackTech
(
    uint8_t **bufferPtr,
    taf_dcs_Tech_t value
)
{
    return le_pack_PackUint32(bufferPtr, (uint32_t)value);
}

static inline bool taf_dcs_UnpackTech
(
    uint8_t **bufferPtr,
    taf_dcs_Tech_t* valuePtr
)
{
    bool result;
    uint32_t value = 0;
    result = le_pack_UnpackUint32(bufferPtr, &value);
    if (result)
    {
        *valuePtr = (taf_dcs_Tech_t)value;
    }
    return result;
}

// Define pack/unpack functions for all structures, including included types


static inline bool taf_radio_PackNetRegRejInd
(
    uint8_t **bufferPtr,
    const taf_radio_NetRegRejInd_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = taf_radio_PackRat( bufferPtr,
                                                 valuePtr->rat );
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->mcc, 4);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->mnc, 4);
    result = result && subResult;
    subResult = taf_radio_PackNetRejCause( bufferPtr,
                                                 valuePtr->cause );
    result = result && subResult;
    subResult = taf_radio_PackServiceDomainState( bufferPtr,
                                                 valuePtr->domain );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->phoneId );
    result = result && subResult;

    return result;
}

static inline bool taf_radio_UnpackNetRegRejInd
(
    uint8_t **bufferPtr,
    taf_radio_NetRegRejInd_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_radio_UnpackRat(bufferPtr,
                                                   &valuePtr->rat );
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->mcc,
                                      sizeof(valuePtr->mcc),
                                      4);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->mnc,
                                      sizeof(valuePtr->mnc),
                                      4);
    }
    if (result)
    {
        result = taf_radio_UnpackNetRejCause(bufferPtr,
                                                   &valuePtr->cause );
    }
    if (result)
    {
        result = taf_radio_UnpackServiceDomainState(bufferPtr,
                                                   &valuePtr->domain );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->phoneId );
    }
    return result;
}

static inline bool taf_radio_PackRatChangeInd
(
    uint8_t **bufferPtr,
    const taf_radio_RatChangeInd_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = taf_radio_PackRat( bufferPtr,
                                                 valuePtr->rat );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->phoneId );
    result = result && subResult;

    return result;
}

static inline bool taf_radio_UnpackRatChangeInd
(
    uint8_t **bufferPtr,
    taf_radio_RatChangeInd_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_radio_UnpackRat(bufferPtr,
                                                   &valuePtr->rat );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->phoneId );
    }
    return result;
}

static inline bool taf_radio_PackNetRegStateInd
(
    uint8_t **bufferPtr,
    const taf_radio_NetRegStateInd_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = taf_radio_PackNetRegState( bufferPtr,
                                                 valuePtr->state );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->phoneId );
    result = result && subResult;

    return result;
}

static inline bool taf_radio_UnpackNetRegStateInd
(
    uint8_t **bufferPtr,
    taf_radio_NetRegStateInd_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_radio_UnpackNetRegState(bufferPtr,
                                                   &valuePtr->state );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->phoneId );
    }
    return result;
}

static inline bool taf_dcs_PackDefaultGatewayAddresses
(
    uint8_t **bufferPtr,
    const taf_dcs_DefaultGatewayAddresses_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr, 46);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackDefaultGatewayAddresses
(
    uint8_t **bufferPtr,
    taf_dcs_DefaultGatewayAddresses_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr,
                                      sizeof(valuePtr->ipv4Addr),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr,
                                      sizeof(valuePtr->ipv6Addr),
                                      46);
    }
    return result;
}

static inline bool taf_dcs_PackDnsServerAddresses
(
    uint8_t **bufferPtr,
    const taf_dcs_DnsServerAddresses_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr1, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv4Addr2, 16);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr1, 46);
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->ipv6Addr2, 46);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackDnsServerAddresses
(
    uint8_t **bufferPtr,
    taf_dcs_DnsServerAddresses_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr1,
                                      sizeof(valuePtr->ipv4Addr1),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv4Addr2,
                                      sizeof(valuePtr->ipv4Addr2),
                                      16);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr1,
                                      sizeof(valuePtr->ipv6Addr1),
                                      46);
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->ipv6Addr2,
                                      sizeof(valuePtr->ipv6Addr2),
                                      46);
    }
    return result;
}

static inline bool taf_dcs_PackStateInfo
(
    uint8_t **bufferPtr,
    const taf_dcs_StateInfo_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = taf_dcs_PackPdp( bufferPtr,
                                                 valuePtr->ipType );
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackStateInfo
(
    uint8_t **bufferPtr,
    taf_dcs_StateInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_dcs_UnpackPdp(bufferPtr,
                                                   &valuePtr->ipType );
    }
    return result;
}

static inline bool taf_dcs_PackRoamingStatusInd
(
    uint8_t **bufferPtr,
    const taf_dcs_RoamingStatusInd_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->phoneId );
    result = result && subResult;
    subResult = le_pack_PackBool( bufferPtr,
                                                 valuePtr->isRoaming );
    result = result && subResult;
    subResult = taf_dcs_PackRoamingType( bufferPtr,
                                                 valuePtr->type );
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackRoamingStatusInd
(
    uint8_t **bufferPtr,
    taf_dcs_RoamingStatusInd_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->phoneId );
    }
    if (result)
    {
        result = le_pack_UnpackBool(bufferPtr,
                                                   &valuePtr->isRoaming );
    }
    if (result)
    {
        result = taf_dcs_UnpackRoamingType(bufferPtr,
                                                   &valuePtr->type );
    }
    return result;
}

static inline bool taf_dcs_PackProfileInfo
(
    uint8_t **bufferPtr,
    const taf_dcs_ProfileInfo_t *valuePtr
)
{
    __attribute__((unused))
    bool subResult, result = true;

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->index );
    result = result && subResult;
    subResult = taf_dcs_PackTech( bufferPtr,
                                                 valuePtr->tech );
    result = result && subResult;
    subResult = le_pack_PackString( bufferPtr,
                                    valuePtr->name, 64);
    result = result && subResult;

    return result;
}

static inline bool taf_dcs_UnpackProfileInfo
(
    uint8_t **bufferPtr,
    taf_dcs_ProfileInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->index );
    }
    if (result)
    {
        result = taf_dcs_UnpackTech(bufferPtr,
                                                   &valuePtr->tech );
    }
    if (result)
    {
        result = le_pack_UnpackString(bufferPtr,
                                      valuePtr->name,
                                      sizeof(valuePtr->name),
                                      64);
    }
    return result;
}

#endif // TAF_MNGDCONN_MESSAGES_H_INCLUDE_GUARD