xsdatapacket.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSDATAPACKET_H
#define XSDATAPACKET_H
 
#include "xstypedefs.h"
#include "pstdint.h"
#include "xsmessage.h"
#include "xstimestamp.h"
#include "xsdataidentifier.h"
#include "xsushortvector.h"
#include "xsscrdata.h"
#include "xscalibrateddata.h"
#include "xspressure.h"
#include "xssdidata.h"
#include "xsvector.h"
#include "xsquaternion.h"
#include "xsmatrix.h"
#include "xseuler.h"
#include "xsanalogindata.h"
#include "xstimeinfo.h"
#include "xsrawgnsspvtdata.h"
#include "xsrawgnsssatinfo.h"
#include "xsdeviceid.h"
#include "xsrange.h"
#include "xstriggerindicationdata.h"
#include "xssnapshot.h"
#include "xsglovesnapshot.h"
#include "xsglovedata.h"
#include "xshandid.h"
 
#ifndef XSNOEXPORT
        #define XSNOEXPORT
#endif
 
//AUTO namespace xstypes {
struct XsDataPacket;
//AUTO }
struct XSNOEXPORT DataPacketPrivate;
 
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
typedef struct XsDataPacket XsDataPacket;
//#define XSDATAPACKET_INITIALIZER      { 0, 0, XSDEVICEID_INITIALIZER, -1 } //Use XsDataPacket_construct in all cases because of dynamic initialization
#endif
 
XSTYPES_DLL_API void XsDataPacket_construct(XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_copyConstruct(XsDataPacket* thisPtr, XsDataPacket const* src);
XSTYPES_DLL_API void XsDataPacket_destruct(XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_clear(XsDataPacket* thisPtr, XsDataIdentifier id);
XSTYPES_DLL_API void XsDataPacket_copy(XsDataPacket* copy, XsDataPacket const* src);
XSTYPES_DLL_API void XsDataPacket_swap(XsDataPacket* thisPtr, XsDataPacket* other);
XSTYPES_DLL_API int XsDataPacket_empty(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_itemCount(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setMessage(XsDataPacket* thisPtr, const XsMessage* msg);
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_dataFormat(const XsDataPacket* thisPtr, XsDataIdentifier id);
XSTYPES_DLL_API XsUShortVector* XsDataPacket_rawAcceleration(const XsDataPacket* thisPtr, XsUShortVector* returnVal);
XSTYPES_DLL_API XsVector* XsDataPacket_rawAccelerationConverted(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawAcceleration(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawAcceleration(XsDataPacket* thisPtr, const XsUShortVector* vec);
XSTYPES_DLL_API XsUShortVector* XsDataPacket_rawGyroscopeData(const XsDataPacket* thisPtr, XsUShortVector* returnVal);
XSTYPES_DLL_API XsVector* XsDataPacket_rawGyroscopeDataConverted(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawGyroscopeData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawGyroscopeData(XsDataPacket* thisPtr, const XsUShortVector* vec);
XSTYPES_DLL_API XsUShortVector* XsDataPacket_rawGyroscopeTemperatureData(const XsDataPacket* thisPtr, XsUShortVector* returnVal);
XSTYPES_DLL_API XsVector* XsDataPacket_rawGyroscopeTemperatureDataConverted(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawGyroscopeTemperatureData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawGyroscopeTemperatureData(XsDataPacket* thisPtr, const XsUShortVector* vec);
XSTYPES_DLL_API XsUShortVector* XsDataPacket_rawMagneticField(const XsDataPacket* thisPtr, XsUShortVector* returnVal);
XSTYPES_DLL_API XsVector* XsDataPacket_rawMagneticFieldConverted(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawMagneticField(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawMagneticField(XsDataPacket* thisPtr, const XsUShortVector* vec);
XSTYPES_DLL_API uint16_t XsDataPacket_rawTemperature(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsRawTemperature(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawTemperature(XsDataPacket* thisPtr, uint16_t temp);
XSTYPES_DLL_API XsScrData* XsDataPacket_rawData(const XsDataPacket* thisPtr, XsScrData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawData(XsDataPacket* thisPtr, const XsScrData* data);
XSTYPES_DLL_API XsVector* XsDataPacket_velocityIncrement(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsVelocityIncrement(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setVelocityIncrement(XsDataPacket* thisPtr, const XsVector* vec);
XSTYPES_DLL_API XsVector* XsDataPacket_calibratedAcceleration(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsCalibratedAcceleration(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setCalibratedAcceleration(XsDataPacket* thisPtr, const XsVector* vec);
XSTYPES_DLL_API XsQuaternion* XsDataPacket_orientationIncrement(const XsDataPacket* thisPtr, XsQuaternion* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsOrientationIncrement(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setOrientationIncrement(XsDataPacket* thisPtr, const XsQuaternion* quat);
XSTYPES_DLL_API XsVector* XsDataPacket_calibratedGyroscopeData(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsCalibratedGyroscopeData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setCalibratedGyroscopeData(XsDataPacket* thisPtr, const XsVector* vec);
XSTYPES_DLL_API XsVector* XsDataPacket_calibratedMagneticField(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsCalibratedMagneticField(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setCalibratedMagneticField(XsDataPacket* thisPtr, const XsVector* vec);
XSTYPES_DLL_API XsVector* XsDataPacket_correctedMagneticField(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsCorrectedMagneticField(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setCorrectedMagneticField(XsDataPacket* thisPtr, const XsVector* vec);
XSTYPES_DLL_API XsCalibratedData* XsDataPacket_calibratedData(const XsDataPacket* thisPtr, XsCalibratedData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsCalibratedData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setCalibratedData(XsDataPacket* thisPtr, const XsCalibratedData* data);
XSTYPES_DLL_API XsQuaternion* XsDataPacket_orientationQuaternion(const XsDataPacket* thisPtr, XsQuaternion* returnVal, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API void XsDataPacket_setOrientationQuaternion(XsDataPacket* thisPtr, const XsQuaternion* data, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API XsEuler* XsDataPacket_orientationEuler(const XsDataPacket* thisPtr, XsEuler* returnVal, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API void XsDataPacket_setOrientationEuler(XsDataPacket* thisPtr, const XsEuler* data, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API XsMatrix* XsDataPacket_orientationMatrix(const XsDataPacket* thisPtr, XsMatrix* returnVal, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API void XsDataPacket_setOrientationMatrix(XsDataPacket* thisPtr, const XsMatrix* data, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API int XsDataPacket_containsOrientation(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_orientationIdentifier(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_coordinateSystemOrientation(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsSdiData* XsDataPacket_sdiData(const XsDataPacket* thisPtr, XsSdiData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsSdiData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setSdiData(XsDataPacket* thisPtr, const XsSdiData* data);
XSTYPES_DLL_API XsGloveData* XsDataPacket_gloveData(const XsDataPacket* thisPtr, XsGloveData* returnVal, XsHandId hand);
XSTYPES_DLL_API int XsDataPacket_containsGloveData(const XsDataPacket* thisPtr, XsHandId hand);
XSTYPES_DLL_API void XsDataPacket_setGloveData(XsDataPacket* thisPtr, const XsGloveData* data, XsHandId hand);
XSTYPES_DLL_API XsDeviceId* XsDataPacket_storedDeviceId(const XsDataPacket* thisPtr, XsDeviceId* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsStoredDeviceId(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setStoredDeviceId(XsDataPacket* thisPtr, const XsDeviceId* data);
XSTYPES_DLL_API uint16_t XsDataPacket_storedLocationId(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsStoredLocationId(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setStoredLocationId(XsDataPacket* thisPtr, uint16_t data);
XSTYPES_DLL_API uint32_t XsDataPacket_status(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsStatus(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsDetailedStatus(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setStatus(XsDataPacket* thisPtr, uint32_t data);
XSTYPES_DLL_API void XsDataPacket_setStatusByte(XsDataPacket* thisPtr, uint8_t data);
XSTYPES_DLL_API uint8_t XsDataPacket_packetCounter8(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsPacketCounter8(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setPacketCounter8(XsDataPacket* thisPtr, uint8_t counter);
XSTYPES_DLL_API uint16_t XsDataPacket_packetCounter(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsPacketCounter(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setPacketCounter(XsDataPacket* thisPtr, uint16_t counter);
XSTYPES_DLL_API uint32_t XsDataPacket_sampleTimeFine(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsSampleTimeFine(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setSampleTimeFine(XsDataPacket* thisPtr, uint32_t counter);
XSTYPES_DLL_API uint32_t XsDataPacket_sampleTimeCoarse(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsSampleTimeCoarse(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setSampleTimeCoarse(XsDataPacket* thisPtr, uint32_t counter);
XSTYPES_DLL_API uint64_t XsDataPacket_sampleTime64(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsSampleTime64(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setSampleTime64(XsDataPacket* thisPtr, uint64_t counter);
XSTYPES_DLL_API XsVector* XsDataPacket_freeAcceleration(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsFreeAcceleration(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setFreeAcceleration(XsDataPacket* thisPtr, const XsVector* g);
XSTYPES_DLL_API double XsDataPacket_temperature(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsTemperature(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setTemperature(XsDataPacket* thisPtr, double temperature);
XSTYPES_DLL_API int XsDataPacket_containsPressure(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsPressure* XsDataPacket_pressure(const XsDataPacket* thisPtr, XsPressure* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsPressureAge(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setPressure(XsDataPacket* thisPtr, const XsPressure* data);
XSTYPES_DLL_API XsAnalogInData* XsDataPacket_analogIn1Data(const XsDataPacket* thisPtr, XsAnalogInData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsAnalogIn1Data(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setAnalogIn1Data(XsDataPacket* thisPtr, const XsAnalogInData* data);
XSTYPES_DLL_API XsAnalogInData* XsDataPacket_analogIn2Data(const XsDataPacket* thisPtr, XsAnalogInData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsAnalogIn2Data(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setAnalogIn2Data(XsDataPacket* thisPtr, const XsAnalogInData* data);
XSTYPES_DLL_API XsVector* XsDataPacket_positionLLA(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsPositionLLA(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setPositionLLA(XsDataPacket* thisPtr, const XsVector* data);
XSTYPES_DLL_API XsVector* XsDataPacket_latitudeLongitude(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsLatitudeLongitude(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setLatitudeLongitude(XsDataPacket* thisPtr, const XsVector* data);
XSTYPES_DLL_API double XsDataPacket_altitude(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsAltitude(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setAltitude(XsDataPacket* thisPtr, double data);
XSTYPES_DLL_API double XsDataPacket_altitudeMsl(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsAltitudeMsl(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setAltitudeMsl(XsDataPacket* thisPtr, double data);
XSTYPES_DLL_API XsVector* XsDataPacket_velocity(const XsDataPacket* thisPtr, XsVector* returnVal, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API int XsDataPacket_containsVelocity(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setVelocity(XsDataPacket* thisPtr, const XsVector* data, XsDataIdentifier coordinateSystem);
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_velocityIdentifier(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsDataIdentifier XsDataPacket_coordinateSystemVelocity(const XsDataPacket* thisPtr);
XSTYPES_DLL_API XsTimeInfo* XsDataPacket_utcTime(const XsDataPacket* thisPtr, XsTimeInfo* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsUtcTime(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setUtcTime(XsDataPacket* thisPtr, const XsTimeInfo* data);
XSTYPES_DLL_API XsRange* XsDataPacket_frameRange(const XsDataPacket* thisPtr, XsRange* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsFrameRange(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setFrameRange(XsDataPacket* thisPtr, const XsRange* r);
XSTYPES_DLL_API int XsDataPacket_rssi(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsRssi(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRssi(XsDataPacket* thisPtr, int r);
 
XSTYPES_DLL_API XsRawGnssPvtData* XsDataPacket_rawGnssPvtData(const XsDataPacket* thisPtr, XsRawGnssPvtData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawGnssPvtData(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawGnssPvtData(XsDataPacket* thisPtr, const XsRawGnssPvtData* r);
XSTYPES_DLL_API uint8_t XsDataPacket_gnssAge(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsGnssAge(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setGnssAge(XsDataPacket* thisPtr, uint8_t age);
XSTYPES_DLL_API XsRawGnssSatInfo* XsDataPacket_rawGnssSatInfo(const XsDataPacket* thisPtr, XsRawGnssSatInfo* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawGnssSatInfo(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRawGnssSatInfo(XsDataPacket* thisPtr, const XsRawGnssSatInfo* r);
XSTYPES_DLL_API uint32_t XsDataPacket_gnssPvtPulse(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_containsGnssPvtPulse(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setGnssPvtPulse(XsDataPacket* thisPtr, uint32_t counter);
 
XSTYPES_DLL_API XsDataPacket* XsDataPacket_merge(XsDataPacket* thisPtr, const XsDataPacket* other, int overwrite);
XSTYPES_DLL_API void XsDataPacket_setTriggerIndication(XsDataPacket* thisPtr, XsDataIdentifier triggerId, const XsTriggerIndicationData* triggerIndicationData);
XSTYPES_DLL_API XsTriggerIndicationData* XsDataPacket_triggerIndication(const XsDataPacket* thisPtr, XsDataIdentifier triggerId, XsTriggerIndicationData* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsTriggerIndication(const XsDataPacket* thisPtr, XsDataIdentifier triggerId);
XSTYPES_DLL_API void XsDataPacket_toMessage(const XsDataPacket* thisPtr, XsMessage* msg);
 
XSTYPES_DLL_API void XsDataPacket_setAwindaSnapshot(XsDataPacket* thisPtr, XsSnapshot const* data, int retransmission);
XSTYPES_DLL_API XsSnapshot* XsDataPacket_awindaSnapshot(const XsDataPacket* thisPtr, XsSnapshot* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsAwindaSnapshot(const XsDataPacket* thisPtr);
XSTYPES_DLL_API int XsDataPacket_isAwindaSnapshotARetransmission(const XsDataPacket* thisPtr);
 
XSTYPES_DLL_API void XsDataPacket_setFullSnapshot(XsDataPacket* thisPtr, XsSnapshot const* data, int retransmission);
XSTYPES_DLL_API XsSnapshot* XsDataPacket_fullSnapshot(const XsDataPacket* thisPtr, XsSnapshot* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsFullSnapshot(const XsDataPacket* thisPtr);
 
XSTYPES_DLL_API void XsDataPacket_setGloveSnapshot(XsDataPacket* thisPtr, XsGloveSnapshot const* data, int retransmission, XsHandId hand);
XSTYPES_DLL_API XsGloveSnapshot* XsDataPacket_gloveSnapshot(const XsDataPacket* thisPtr, XsGloveSnapshot* returnVal, XsHandId hand);
XSTYPES_DLL_API int XsDataPacket_containsGloveSnapshot(const XsDataPacket* thisPtr, XsHandId hand);
 
XSTYPES_DLL_API void XsDataPacket_setRawBlob(XsDataPacket* thisPtr, const XsByteArray* data);
XSTYPES_DLL_API XsByteArray* XsDataPacket_rawBlob(const XsDataPacket* thisPtr, XsByteArray* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRawBlob(const XsDataPacket* thisPtr);
 
XSTYPES_DLL_API XsVector* XsDataPacket_accelerationHR(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsAccelerationHR(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setAccelerationHR(XsDataPacket* thisPtr, const XsVector* vec);
 
XSTYPES_DLL_API XsVector* XsDataPacket_rateOfTurnHR(const XsDataPacket* thisPtr, XsVector* returnVal);
XSTYPES_DLL_API int XsDataPacket_containsRateOfTurnHR(const XsDataPacket* thisPtr);
XSTYPES_DLL_API void XsDataPacket_setRateOfTurnHR(XsDataPacket* thisPtr, const XsVector* vec);
 
XSTYPES_DLL_API int XsDataPacket_privateCount();
 
#ifdef __cplusplus
} // extern "C"
#ifndef XSENS_NO_STL
        #include <map>  // only needed for simplifiedContents()
#endif
#endif
 
struct XsDataPacket
{
#ifdef __cplusplus
 
        inline explicit XsDataPacket(const XsMessage* msg = 0)
        {
                XsDataPacket_construct(this);
                if (msg)
                        XsDataPacket_setMessage(this, msg);
        }
 
        inline XsDataPacket(const XsDataPacket& pack)
        {
                XsDataPacket_copyConstruct(this, &pack);
        }
 
        inline ~XsDataPacket()
        {
                XsDataPacket_destruct(this);
        }
 
        inline XsDataPacket& operator = (const XsDataPacket& other)
        {
                if (this != &other)
                        XsDataPacket_copy(this, &other);
                return *this;
        }
 
        inline void swap(XsDataPacket& other)
        {
                XsDataPacket_swap(this, &other);
        }
 
#ifndef SWIG
 
        XSNOEXPORT inline friend void swap(XsDataPacket& first, XsDataPacket& second)
        {
                first.swap(second);
        }
#endif
 
        inline void clear(XsDataIdentifier id = XDI_None)
        {
                XsDataPacket_clear(this, id);
        }
 
        inline bool empty(void) const
        {
                return 0 != XsDataPacket_empty(this);
        }
 
        inline XsDeviceId deviceId() const
        {
                return m_deviceId;
        }
 
        inline uint16_t itemCount() const
        {
                return static_cast<uint16_t>(static_cast<unsigned int>(XsDataPacket_itemCount(this)));
        }
 
        inline void setMessage(const XsMessage& msg)
        {
                XsDataPacket_setMessage(this, &msg);
        }
 
        inline XsMessage toMessage() const
        {
                XsMessage msg;
                XsDataPacket_toMessage(this, &msg);
                return msg;
        }
 
        inline void setDeviceId(const XsDeviceId id)
        {
                m_deviceId = id;
        }
 
        inline XsDataIdentifier dataFormat(XsDataIdentifier id) const
        {
                return XsDataPacket_dataFormat(this, id);
        }
 
        inline XsUShortVector rawAcceleration(void) const
        {
                XsUShortVector returnVal;
                return *XsDataPacket_rawAcceleration(this, &returnVal);
        }
 
        inline XsVector rawAccelerationConverted(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_rawAccelerationConverted(this, &returnVal);
        }
 
        inline bool containsRawAcceleration(void) const
        {
                return 0 != XsDataPacket_containsRawAcceleration(this);
        }
 
        inline void setRawAcceleration(const XsUShortVector& vec)
        {
                XsDataPacket_setRawAcceleration(this, &vec);
        }
 
        inline XsUShortVector rawGyroscopeData(void) const
        {
                XsUShortVector returnVal;
                return *XsDataPacket_rawGyroscopeData(this, &returnVal);
        }
 
        inline XsVector rawGyroscopeDataConverted(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_rawGyroscopeDataConverted(this, &returnVal);
        }
 
        inline bool containsRawGyroscopeData(void) const
        {
                return 0 != XsDataPacket_containsRawGyroscopeData(this);
        }
 
        inline void setRawGyroscopeData(const XsUShortVector& vec)
        {
                XsDataPacket_setRawGyroscopeData(this, &vec);
        }
 
        inline XsUShortVector rawGyroscopeTemperatureData(void) const
        {
                XsUShortVector returnVal;
                return *XsDataPacket_rawGyroscopeTemperatureData(this, &returnVal);
        }
 
        inline XsVector rawGyroscopeTemperatureDataConverted(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_rawGyroscopeTemperatureDataConverted(this, &returnVal);
        }
 
        inline bool containsRawGyroscopeTemperatureData(void) const
        {
                return 0 != XsDataPacket_containsRawGyroscopeTemperatureData(this);
        }
 
        inline void setRawGyroscopeTemperatureData(const XsUShortVector& vec)
        {
                XsDataPacket_setRawGyroscopeTemperatureData(this, &vec);
        }
 
        inline XsUShortVector rawMagneticField(void) const
        {
                XsUShortVector returnVal;
                return *XsDataPacket_rawMagneticField(this, &returnVal);
        }
 
        inline XsVector rawMagneticFieldConverted(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_rawMagneticFieldConverted(this, &returnVal);
        }
 
        inline bool containsRawMagneticField(void) const
        {
                return 0 != XsDataPacket_containsRawMagneticField(this);
        }
 
        inline void setRawMagneticField(const XsUShortVector& vec)
        {
                XsDataPacket_setRawMagneticField(this, &vec);
        }
 
        inline uint16_t rawTemperature(void) const
        {
                return XsDataPacket_rawTemperature(this);
        }
 
        inline bool containsRawTemperature(void) const
        {
                return 0 != XsDataPacket_containsRawTemperature(this);
        }
 
        inline void setRawTemperature(uint16_t temp)
        {
                XsDataPacket_setRawTemperature(this, temp);
        }
 
        inline XsScrData rawData(void) const
        {
                XsScrData returnVal;
                return *XsDataPacket_rawData(this, &returnVal);
        }
 
        inline bool containsRawData(void) const
        {
                return 0 != XsDataPacket_containsRawData(this);
        }
 
        inline void setRawData(const XsScrData& data)
        {
                XsDataPacket_setRawData(this, &data);
        }
 
        inline XsVector velocityIncrement(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_velocityIncrement(this, &returnVal);
        }
 
        inline bool containsVelocityIncrement(void) const
        {
                return 0 != XsDataPacket_containsVelocityIncrement(this);
        }
 
        inline void setVelocityIncrement(const XsVector& vec)
        {
                XsDataPacket_setVelocityIncrement(this, &vec);
        }
 
        inline XsVector calibratedAcceleration(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_calibratedAcceleration(this, &returnVal);
        }
 
        inline bool containsCalibratedAcceleration(void) const
        {
                return 0 != XsDataPacket_containsCalibratedAcceleration(this);
        }
 
        inline void setCalibratedAcceleration(const XsVector& vec)
        {
                XsDataPacket_setCalibratedAcceleration(this, &vec);
        }
 
        inline XsQuaternion orientationIncrement(void) const
        {
                XsQuaternion returnVal;
                return *XsDataPacket_orientationIncrement(this, &returnVal);
        }
 
        inline bool containsOrientationIncrement(void) const
        {
                return 0 != XsDataPacket_containsOrientationIncrement(this);
        }
 
        inline void setOrientationIncrement(const XsQuaternion& quat)
        {
                XsDataPacket_setOrientationIncrement(this, &quat);
        }
 
        inline XsVector calibratedGyroscopeData(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_calibratedGyroscopeData(this, &returnVal);
        }
 
        inline bool containsCalibratedGyroscopeData(void) const
        {
                return 0 != XsDataPacket_containsCalibratedGyroscopeData(this);
        }
 
        inline void setCalibratedGyroscopeData(const XsVector& vec)
        {
                XsDataPacket_setCalibratedGyroscopeData(this, &vec);
        }
 
        inline XsVector calibratedMagneticField(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_calibratedMagneticField(this, &returnVal);
        }
 
        inline bool containsCalibratedMagneticField(void) const
        {
                return 0 != XsDataPacket_containsCalibratedMagneticField(this);
        }
 
        inline void setCalibratedMagneticField(const XsVector& vec)
        {
                XsDataPacket_setCalibratedMagneticField(this, &vec);
        }
 
        XSNOEXPORT inline XsVector correctedMagneticField(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_correctedMagneticField(this, &returnVal);
        }
 
        XSNOEXPORT inline bool containsCorrectedMagneticField(void) const
        {
                return 0 != XsDataPacket_containsCorrectedMagneticField(this);
        }
 
        XSNOEXPORT inline void setCorrectedMagneticField(const XsVector& vec)
        {
                XsDataPacket_setCorrectedMagneticField(this, &vec);
        }
 
        inline XsCalibratedData calibratedData(void) const
        {
                XsCalibratedData returnVal;
                return *XsDataPacket_calibratedData(this, &returnVal);
        }
 
        inline bool containsCalibratedData(void) const
        {
                return 0 != XsDataPacket_containsCalibratedData(this);
        }
 
        inline void setCalibratedData(const XsCalibratedData& data)
        {
                XsDataPacket_setCalibratedData(this, &data);
        }
 
        inline XsQuaternion orientationQuaternion(XsDataIdentifier coordinateSystem) const
        {
                XsQuaternion returnVal;
                return *XsDataPacket_orientationQuaternion(this, &returnVal, coordinateSystem);
        }
 
        inline XsQuaternion orientationQuaternion() const
        {
                XsQuaternion returnVal;
                return *XsDataPacket_orientationQuaternion(this, &returnVal, coordinateSystemOrientation());
        }
 
        inline void setOrientationQuaternion(const XsQuaternion& data, XsDataIdentifier coordinateSystem)
        {
                XsDataPacket_setOrientationQuaternion(this, &data, coordinateSystem);
        }
 
        inline XsEuler orientationEuler(XsDataIdentifier coordinateSystem) const
        {
                XsEuler returnVal;
                return *XsDataPacket_orientationEuler(this, &returnVal, coordinateSystem);
        }
 
        inline XsEuler orientationEuler() const
        {
                XsEuler returnVal;
                return *XsDataPacket_orientationEuler(this, &returnVal, coordinateSystemOrientation());
        }
 
        inline void setOrientationEuler(const XsEuler& data, XsDataIdentifier coordinateSystem)
        {
                XsDataPacket_setOrientationEuler(this, &data, coordinateSystem);
        }
 
        inline XsMatrix orientationMatrix(XsDataIdentifier coordinateSystem) const
        {
                XsMatrix returnVal;
                return *XsDataPacket_orientationMatrix(this, &returnVal, coordinateSystem);
        }
 
        inline XsMatrix orientationMatrix() const
        {
                XsMatrix returnVal;
                return *XsDataPacket_orientationMatrix(this, &returnVal, coordinateSystemOrientation());
        }
 
        inline void setOrientationMatrix(const XsMatrix& data, XsDataIdentifier coordinateSystem)
        {
                XsDataPacket_setOrientationMatrix(this, &data, coordinateSystem);
        }
 
        inline bool containsOrientation(void) const
        {
                return 0 != XsDataPacket_containsOrientation(this);
        }
 
        inline XsDataIdentifier orientationIdentifier() const
        {
                return XsDataPacket_orientationIdentifier(this);
        }
 
        inline XsDataIdentifier coordinateSystemOrientation() const
        {
                return XsDataPacket_coordinateSystemOrientation(this);
        }
 
        inline XsSdiData sdiData(void) const
        {
                XsSdiData returnVal;
                return *XsDataPacket_sdiData(this, &returnVal);
        }
 
        inline bool containsSdiData(void) const
        {
                return 0 != XsDataPacket_containsSdiData(this);
        }
 
        inline void setSdiData(const XsSdiData& data)
        {
                XsDataPacket_setSdiData(this, &data);
        }
 
        XSNOCOMEXPORT inline XsGloveData gloveData(XsHandId hand) const
        {
                XsGloveData returnVal;
                return *XsDataPacket_gloveData(this, &returnVal, hand);
        }
 
        XSNOCOMEXPORT inline bool containsGloveData(XsHandId hand = XHI_Unknown) const
        {
                return 0 != XsDataPacket_containsGloveData(this, hand);
        }
 
        XSNOEXPORT inline void setGloveData(const XsGloveData& data, XsHandId hand)
        {
                XsDataPacket_setGloveData(this, &data, hand);
        }
 
        inline XsDeviceId storedDeviceId(void) const
        {
                XsDeviceId returnVal;
                return *XsDataPacket_storedDeviceId(this, &returnVal);
        }
 
        inline bool containsStoredDeviceId(void) const
        {
                return 0 != XsDataPacket_containsStoredDeviceId(this);
        }
 
        inline void setStoredDeviceId(const XsDeviceId& data)
        {
                XsDataPacket_setStoredDeviceId(this, &data);
        }
 
        inline uint16_t storedLocationId(void) const
        {
                return XsDataPacket_storedLocationId(this);
        }
 
        inline bool containsStoredLocationId(void) const
        {
                return 0 != XsDataPacket_containsStoredLocationId(this);
        }
 
        inline void setStoredLocationId(uint16_t data)
        {
                XsDataPacket_setStoredLocationId(this, data);
        }
 
 
        inline uint32_t status(void) const
        {
                return XsDataPacket_status(this);
        }
 
        inline bool containsStatus(void) const
        {
                return 0 != XsDataPacket_containsStatus(this);
        }
 
        inline bool containsDetailedStatus(void) const
        {
                return 0 != XsDataPacket_containsDetailedStatus(this);
        }
 
        inline void setStatus(const uint32_t data)
        {
                XsDataPacket_setStatus(this, data);
        }
 
        inline void setStatusByte(const uint8_t data)
        {
                XsDataPacket_setStatusByte(this, data);
        }
 
        inline uint8_t packetCounter8(void) const
        {
                return XsDataPacket_packetCounter8(this);
        }
 
        inline bool containsPacketCounter8(void) const
        {
                return 0 != XsDataPacket_containsPacketCounter8(this);
        }
 
        inline void setPacketCounter8(uint8_t counter)
        {
                XsDataPacket_setPacketCounter8(this, counter);
        }
 
        inline uint16_t packetCounter(void) const
        {
                return XsDataPacket_packetCounter(this);
        }
 
        inline bool containsPacketCounter(void) const
        {
                return 0 != XsDataPacket_containsPacketCounter(this);
        }
 
        inline void setPacketCounter(uint16_t counter)
        {
                XsDataPacket_setPacketCounter(this, counter);
        }
 
        inline uint32_t sampleTimeFine(void) const
        {
                return XsDataPacket_sampleTimeFine(this);
        }
 
        inline bool containsSampleTimeFine(void) const
        {
                return 0 != XsDataPacket_containsSampleTimeFine(this);
        }
 
        inline void setSampleTimeFine(uint32_t counter)
        {
                XsDataPacket_setSampleTimeFine(this, counter);
        }
 
        inline uint32_t sampleTimeCoarse(void) const
        {
                return XsDataPacket_sampleTimeCoarse(this);
        }
 
        inline bool containsSampleTimeCoarse(void) const
        {
                return 0 != XsDataPacket_containsSampleTimeCoarse(this);
        }
 
        inline void setSampleTimeCoarse(uint32_t counter)
        {
                XsDataPacket_setSampleTimeCoarse(this, counter);
        }
 
        inline uint64_t sampleTime64(void) const
        {
                return XsDataPacket_sampleTime64(this);
        }
 
        inline bool containsSampleTime64(void) const
        {
                return 0 != XsDataPacket_containsSampleTime64(this);
        }
 
        inline void setSampleTime64(uint64_t counter)
        {
                XsDataPacket_setSampleTime64(this, counter);
        }
 
        inline XsVector freeAcceleration(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_freeAcceleration(this, &returnVal);
        }
 
        inline bool containsFreeAcceleration(void) const
        {
                return 0 != XsDataPacket_containsFreeAcceleration(this);
        }
 
        inline void setFreeAcceleration(const XsVector& g)
        {
                XsDataPacket_setFreeAcceleration(this, &g);
        }
 
        inline double temperature(void) const
        {
                return XsDataPacket_temperature(this);
        }
 
        inline bool containsTemperature(void) const
        {
                return 0 != XsDataPacket_containsTemperature(this);
        }
 
        inline void setTemperature(double temperature)
        {
                XsDataPacket_setTemperature(this, temperature);
        }
 
        inline XsPressure pressure(void) const
        {
                XsPressure returnVal;
                return *XsDataPacket_pressure(this, &returnVal);
        }
 
        inline bool containsPressure(void) const
        {
                return 0 != XsDataPacket_containsPressure(this);
        }
 
        inline bool containsPressureAge(void) const
        {
                return 0 != XsDataPacket_containsPressureAge(this);
        }
 
        inline void setPressure(const XsPressure& data)
        {
                XsDataPacket_setPressure(this, &data);
        }
 
        inline XsAnalogInData analogIn1Data(void) const
        {
                XsAnalogInData returnVal;
                return *XsDataPacket_analogIn1Data(this, &returnVal);
        }
 
        inline bool containsAnalogIn1Data(void) const
        {
                return 0 != XsDataPacket_containsAnalogIn1Data(this);
        }
 
        inline void setAnalogIn1Data(const XsAnalogInData& data)
        {
                XsDataPacket_setAnalogIn1Data(this, &data);
        }
 
        inline XsAnalogInData analogIn2Data(void) const
        {
                XsAnalogInData returnVal;
                return *XsDataPacket_analogIn2Data(this, &returnVal);
        }
 
        inline bool containsAnalogIn2Data(void) const
        {
                return 0 != XsDataPacket_containsAnalogIn2Data(this);
        }
 
        inline void setAnalogIn2Data(const XsAnalogInData& data)
        {
                XsDataPacket_setAnalogIn2Data(this, &data);
        }
 
        inline XsVector positionLLA(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_positionLLA(this, &returnVal);
        }
 
        inline bool containsPositionLLA(void) const
        {
                return 0 != XsDataPacket_containsPositionLLA(this);
        }
 
        inline void setPositionLLA(const XsVector& data)
        {
                XsDataPacket_setPositionLLA(this, &data);
        }
 
        inline XsVector latitudeLongitude(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_latitudeLongitude(this, &returnVal);
        }
 
        inline bool containsLatitudeLongitude(void) const
        {
                return 0 != XsDataPacket_containsLatitudeLongitude(this);
        }
 
        inline void setLatitudeLongitude(const XsVector& data)
        {
                XsDataPacket_setLatitudeLongitude(this, &data);
        }
 
        inline double altitude(void) const
        {
                return XsDataPacket_altitude(this);
        }
 
        inline bool containsAltitude(void) const
        {
                return 0 != XsDataPacket_containsAltitude(this);
        }
 
        inline void setAltitude(double data)
        {
                XsDataPacket_setAltitude(this, data);
        }
 
        inline double altitudeMsl(void) const
        {
                return XsDataPacket_altitudeMsl(this);
        }
 
        inline bool containsAltitudeMsl(void) const
        {
                return 0 != XsDataPacket_containsAltitudeMsl(this);
        }
 
        inline void setAltitudeMsl(double data)
        {
                XsDataPacket_setAltitudeMsl(this, data);
        }
 
        inline XsVector velocity(XsDataIdentifier coordinateSystem) const
        {
                XsVector returnVal;
                return *XsDataPacket_velocity(this, &returnVal, coordinateSystem);
        }
 
        inline XsVector velocity(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_velocity(this, &returnVal, coordinateSystemVelocity());
        }
 
        inline bool containsVelocity(void) const
        {
                return 0 != XsDataPacket_containsVelocity(this);
        }
 
        inline void setVelocity(const XsVector& data, XsDataIdentifier coordinateSystem)
        {
                XsDataPacket_setVelocity(this, &data, coordinateSystem);
        }
 
        inline XsDataIdentifier velocityIdentifier() const
        {
                return XsDataPacket_velocityIdentifier(this);
        }
 
        inline XsDataIdentifier coordinateSystemVelocity() const
        {
                return XsDataPacket_coordinateSystemVelocity(this);
        }
 
        inline XsTimeInfo utcTime(void) const
        {
                XsTimeInfo returnVal;
                return *XsDataPacket_utcTime(this, &returnVal);
        }
 
        inline bool containsUtcTime(void) const
        {
                return 0 != XsDataPacket_containsUtcTime(this);
        }
 
        inline void setUtcTime(const XsTimeInfo& data)
        {
                XsDataPacket_setUtcTime(this, &data);
        }
 
        inline XsRange frameRange() const
        {
                XsRange returnVal;
                return *XsDataPacket_frameRange(this, &returnVal);
        }
 
        inline bool containsFrameRange() const
        {
                return 0 != XsDataPacket_containsFrameRange(this);
        }
 
        inline void setFrameRange(const XsRange& r)
        {
                XsDataPacket_setFrameRange(this, &r);
        }
 
        inline int rssi() const
        {
                return XsDataPacket_rssi(this);
        }
 
        inline bool containsRssi() const
        {
                return 0 != XsDataPacket_containsRssi(this);
        }
 
        inline void setRssi(int r)
        {
                XsDataPacket_setRssi(this, r);
        }
 
        inline XsRawGnssPvtData rawGnssPvtData(void) const
        {
                XsRawGnssPvtData returnVal;
                return *XsDataPacket_rawGnssPvtData(this, &returnVal);
        }
 
        inline bool containsRawGnssPvtData(void) const
        {
                return 0 != XsDataPacket_containsRawGnssPvtData(this);
        }
 
        XSNOEXPORT inline void setRawGnssPvtData(XsRawGnssPvtData const& raw)
        {
                XsDataPacket_setRawGnssPvtData(this, &raw);
        }
 
        inline uint8_t gnssAge(void) const
        {
                return XsDataPacket_gnssAge(this);
        }
 
        inline bool containsGnssAge(void) const
        {
                return 0 != XsDataPacket_containsGnssAge(this);
        }
 
        XSNOEXPORT inline void setGnssAge(uint8_t age)
        {
                XsDataPacket_setGnssAge(this, age);
        }
 
        inline XsRawGnssSatInfo rawGnssSatInfo(void) const
        {
                XsRawGnssSatInfo returnVal;
                return *XsDataPacket_rawGnssSatInfo(this, &returnVal);
        }
 
        inline bool containsRawGnssSatInfo(void) const
        {
                return 0 != XsDataPacket_containsRawGnssSatInfo(this);
        }
 
        XSNOEXPORT inline void setRawGnssSatInfo(XsRawGnssSatInfo const& data)
        {
                XsDataPacket_setRawGnssSatInfo(this, &data);
        }
 
        inline uint32_t gnssPvtPulse(void) const
        {
                return XsDataPacket_gnssPvtPulse(this);
        }
 
        inline bool containsGnssPvtPulse(void) const
        {
                return 0 != XsDataPacket_containsGnssPvtPulse(this);
        }
 
        inline void setGnssPvtPulse(uint32_t counter)
        {
                XsDataPacket_setGnssPvtPulse(this, counter);
        }
 
        inline XsSnapshot fullSnapshot(void) const
        {
                XsSnapshot returnVal;
                return *XsDataPacket_fullSnapshot(this, &returnVal);
        }
 
        inline bool containsFullSnapshot(void) const
        {
                return 0 != XsDataPacket_containsFullSnapshot(this);
        }
 
        XSNOEXPORT inline void setFullSnapshot(XsSnapshot const& data, bool retransmission)
        {
                XsDataPacket_setFullSnapshot(this, &data, retransmission ? 1 : 0);
        }
        XSNOEXPORT inline XsSnapshot awindaSnapshot(void) const
        {
                XsSnapshot returnVal;
                return *XsDataPacket_awindaSnapshot(this, &returnVal);
        }
 
        XSNOEXPORT inline bool containsAwindaSnapshot(void) const
        {
                return 0 != XsDataPacket_containsAwindaSnapshot(this);
        }
 
        XSNOEXPORT inline void setAwindaSnapshot(XsSnapshot const& raw, bool retransmission)
        {
                XsDataPacket_setAwindaSnapshot(this, &raw, retransmission ? 1 : 0);
        }
 
        inline bool isAwindaSnapshotARetransmission(void) const
        {
                return 0 != XsDataPacket_isAwindaSnapshotARetransmission(this);
        }
 
        XSNOEXPORT inline XsGloveSnapshot gloveSnapshot(XsHandId hand) const
        {
                XsGloveSnapshot returnVal;
                return *XsDataPacket_gloveSnapshot(this, &returnVal, hand);
        }
 
        XSNOEXPORT inline bool containsGloveSnapshot(XsHandId hand = XHI_Unknown) const
        {
                return 0 != XsDataPacket_containsGloveSnapshot(this, hand);
        }
 
        XSNOEXPORT inline void setGloveSnapshot(XsGloveSnapshot const& data, bool retransmission, XsHandId hand)
        {
                XsDataPacket_setGloveSnapshot(this, &data, retransmission ? 1 : 0, hand);
        }
 
        inline XsDataPacket& merge(const XsDataPacket& other, bool overwrite = true)
        {
                return *XsDataPacket_merge(this, &other, overwrite ? 1 : 0);
        }
 
        inline void setTimeOfArrival(const XsTimeStamp& t)
        {
                m_toa = t;
        }
 
        inline XsTimeStamp timeOfArrival() const
        {
                return m_toa;
        }
 
        inline void setEstimatedTimeOfSampling(const XsTimeStamp& t)
        {
                m_etos = t;
        }
 
        inline XsTimeStamp estimatedTimeOfSampling() const
        {
                return m_etos;
        }
 
        inline void setPacketId(int64_t t)
        {
                m_packetId = t;
        }
 
        inline int64_t packetId() const
        {
                return m_packetId;
        }
 
        void setTriggerIndication(XsDataIdentifier triggerId, const XsTriggerIndicationData& triggerIndicationData)
        {
                XsDataPacket_setTriggerIndication(this, triggerId, &triggerIndicationData);
        }
 
        inline bool containsTriggerIndication(XsDataIdentifier triggerId) const
        {
                return 0 != XsDataPacket_containsTriggerIndication(this, triggerId);
        }
 
        XsTriggerIndicationData triggerIndication(XsDataIdentifier triggerId) const
        {
                XsTriggerIndicationData returnVal;
                return *XsDataPacket_triggerIndication(this, triggerId, &returnVal);
        }
 
        inline XsByteArray rawBlob(void) const
        {
                XsByteArray returnVal;
                return *XsDataPacket_rawBlob(this, &returnVal);
        }
 
        inline bool containsRawBlob(void) const
        {
                return 0 != XsDataPacket_containsRawBlob(this);
        }
 
        inline void setRawBlob(const XsByteArray& data)
        {
                XsDataPacket_setRawBlob(this, &data);
        }
 
        inline XsVector accelerationHR(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_accelerationHR(this, &returnVal);
        }
 
        inline bool containsAccelerationHR(void) const
        {
                return 0 != XsDataPacket_containsAccelerationHR(this);
        }
 
        inline void setAccelerationHR(const XsVector& vec)
        {
                XsDataPacket_setAccelerationHR(this, &vec);
        }
 
        inline XsVector rateOfTurnHR(void) const
        {
                XsVector returnVal;
                return *XsDataPacket_rateOfTurnHR(this, &returnVal);
        }
 
        inline bool containsRateOfTurnHR(void) const
        {
                return 0 != XsDataPacket_containsRateOfTurnHR(this);
        }
 
        inline void setRateOfTurnHR(const XsVector& vec)
        {
                XsDataPacket_setRateOfTurnHR(this, &vec);
        }
 
#ifndef XSENS_NO_STL
 
        inline std::map<XsDataIdentifier, void*> simplifiedContents() const
        {
                return *((std::map<XsDataIdentifier, void*>*)(void*)d);
        }
#endif
 
        //protected:
#endif // __cplusplus
        struct XSNOEXPORT DataPacketPrivate* d;
 
        XsDeviceId                      m_deviceId;                                     
        XsTimeStamp                     m_toa;                                          
        int64_t                         m_packetId;                                     
        XsTimeStamp                     m_etos;                                         
};
 
#endif