taf_locPos_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_LOCPOS_MESSAGES_H_INCLUDE_GUARD
#define TAF_LOCPOS_MESSAGES_H_INCLUDE_GUARD


#include "taf_locPos_common.h"

#define _MAX_MSG_SIZE IFGEN_TAF_LOCPOS_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_locPos_AddMovementHandler 0
#define _MSGID_taf_locPos_RemoveMovementHandler 1
#define _MSGID_taf_locPos_Get2DLocation 2
#define _MSGID_taf_locPos_GetDate 3
#define _MSGID_taf_locPos_GetFixState 4
#define _MSGID_taf_locPos_GetMotion 5
#define _MSGID_taf_locPos_GetDirection 6
#define _MSGID_taf_locPos_GetTime 7
#define _MSGID_taf_locPos_SetAcquisitionRate 8
#define _MSGID_taf_locPos_GetAcquisitionRate 9
#define _MSGID_taf_locPos_sample_Release 10
#define _MSGID_taf_locPos_Get3DLocation 11
#define _MSGID_taf_locPos_sample_Get2DLocation 12
#define _MSGID_taf_locPos_sample_GetAltitude 13
#define _MSGID_taf_locPos_sample_GetTime 14
#define _MSGID_taf_locPos_sample_GetHorizontalSpeed 15
#define _MSGID_taf_locPos_sample_GetDirection 16
#define _MSGID_taf_locPos_sample_GetVerticalSpeed 17
#define _MSGID_taf_locPos_SetDistanceResolution 18
#define _MSGID_taf_locPos_sample_GetFixState 19
#define _MSGID_taf_locPos_sample_GetDate 20


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

    LE_ASSERT(valuePtr);
    subResult = taf_locGnss_PackConstellation( bufferPtr,
                                                 valuePtr->satConst );
    result = result && subResult;
    subResult = le_pack_PackBool( bufferPtr,
                                                 valuePtr->satUsed );
    result = result && subResult;
    subResult = le_pack_PackBool( bufferPtr,
                                                 valuePtr->satTracked );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->satSnr );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->satElev );
    result = result && subResult;
    subResult = le_pack_PackUint16( bufferPtr,
                                                 valuePtr->satId );
    result = result && subResult;
    subResult = le_pack_PackUint16( bufferPtr,
                                                 valuePtr->satAzim );
    result = result && subResult;
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->signalType );
    result = result && subResult;
    subResult = le_pack_PackUint16( bufferPtr,
                                                 valuePtr->glonassFcn );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->baseBandCnr );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackSvInfo
(
    uint8_t **bufferPtr,
    taf_locGnss_SvInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = taf_locGnss_UnpackConstellation(bufferPtr,
                                                   &valuePtr->satConst );
    }
    if (result)
    {
        result = le_pack_UnpackBool(bufferPtr,
                                                   &valuePtr->satUsed );
    }
    if (result)
    {
        result = le_pack_UnpackBool(bufferPtr,
                                                   &valuePtr->satTracked );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->satSnr );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->satElev );
    }
    if (result)
    {
        result = le_pack_UnpackUint16(bufferPtr,
                                                   &valuePtr->satId );
    }
    if (result)
    {
        result = le_pack_UnpackUint16(bufferPtr,
                                                   &valuePtr->satAzim );
    }
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->signalType );
    }
    if (result)
    {
        result = le_pack_UnpackUint16(bufferPtr,
                                                   &valuePtr->glonassFcn );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->baseBandCnr );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->rollOffset );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->yawOffset );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->pitchOffset );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->offsetUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->speedFactor );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->speedFactorUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->gyroFactor );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->gyroFactorUnc );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackDrParams
(
    uint8_t **bufferPtr,
    taf_locGnss_DrParams_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->rollOffset );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->yawOffset );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->pitchOffset );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->offsetUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->speedFactor );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->speedFactorUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->gyroFactor );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->gyroFactorUnc );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->forwardOffsetMeters );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->sidewaysOffsetMeters );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->upOffsetMeters );
    result = result && subResult;
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->levArmType );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackLeverArmParams
(
    uint8_t **bufferPtr,
    taf_locGnss_LeverArmParams_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->forwardOffsetMeters );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->sidewaysOffsetMeters );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->upOffsetMeters );
    }
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->levArmType );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->bodyFrameDataMask );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->longAccel );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->latAccel );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->vertAccel );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->yawRate );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->pitch );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->longAccelUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->latAccelUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->vertAccelUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->yawRateUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->pitchUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->pitchRate );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->pitchRateUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->roll );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->rollUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->rollRate );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->rollRateUnc );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->yaw );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->yawUnc );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackKinematicsData
(
    uint8_t **bufferPtr,
    taf_locGnss_KinematicsData_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->bodyFrameDataMask );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->longAccel );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->latAccel );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->vertAccel );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->yawRate );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->pitch );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->longAccelUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->latAccelUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->vertAccelUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->yawRateUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->pitchUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->pitchRate );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->pitchRateUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->roll );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->rollUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->rollRate );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->rollRateUnc );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->yaw );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->yawUnc );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->gps );
    result = result && subResult;
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->glo );
    result = result && subResult;
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->gal );
    result = result && subResult;
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->bds );
    result = result && subResult;
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->qzss );
    result = result && subResult;
    subResult = le_pack_PackUint64( bufferPtr,
                                                 valuePtr->navic );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackSvUsedInPosition
(
    uint8_t **bufferPtr,
    taf_locGnss_SvUsedInPosition_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->gps );
    }
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->glo );
    }
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->gal );
    }
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->bds );
    }
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->qzss );
    }
    if (result)
    {
        result = le_pack_UnpackUint64(bufferPtr,
                                                   &valuePtr->navic );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->gnssSignalType );
    result = result && subResult;
    subResult = taf_locGnss_PackGnssSystem( bufferPtr,
                                                 valuePtr->gnssConstellation );
    result = result && subResult;
    subResult = le_pack_PackUint16( bufferPtr,
                                                 valuePtr->gnssSvId );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackGnssMeasurementInfo
(
    uint8_t **bufferPtr,
    taf_locGnss_GnssMeasurementInfo_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->gnssSignalType );
    }
    if (result)
    {
        result = taf_locGnss_UnpackGnssSystem(bufferPtr,
                                                   &valuePtr->gnssConstellation );
    }
    if (result)
    {
        result = le_pack_UnpackUint16(bufferPtr,
                                                   &valuePtr->gnssSvId );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->gnssDataMask );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->jammerInd );
    result = result && subResult;
    subResult = le_pack_PackDouble( bufferPtr,
                                                 valuePtr->agc );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackGnssData
(
    uint8_t **bufferPtr,
    taf_locGnss_GnssData_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->gnssDataMask );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->jammerInd );
    }
    if (result)
    {
        result = le_pack_UnpackDouble(bufferPtr,
                                                   &valuePtr->agc );
    }
    return result;
}

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

    LE_ASSERT(valuePtr);
    subResult = le_pack_PackUint8( bufferPtr,
                                                 valuePtr->featureEnabled );
    result = result && subResult;
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->xtraDataStatus );
    result = result && subResult;
    subResult = le_pack_PackUint32( bufferPtr,
                                                 valuePtr->xtraValidForHours );
    result = result && subResult;

    return result;
}

static inline bool taf_locGnss_UnpackXtraStatusParams
(
    uint8_t **bufferPtr,
    taf_locGnss_XtraStatusParams_t *valuePtr
)
{
    bool result = true;
    if (result)
    {
        result = le_pack_UnpackUint8(bufferPtr,
                                                   &valuePtr->featureEnabled );
    }
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->xtraDataStatus );
    }
    if (result)
    {
        result = le_pack_UnpackUint32(bufferPtr,
                                                   &valuePtr->xtraValidForHours );
    }
    return result;
}

#endif // TAF_LOCPOS_MESSAGES_H_INCLUDE_GUARD