RecordMessagePrivate Class Reference

Inheritance diagram for RecordMessagePrivate:

Collaboration diagram for RecordMessagePrivate:

Public Member Functions
	RecordMessagePrivate (RecordMessage *const q)
virtual	~RecordMessagePrivate ()
Public Member Functions inherited from AbstractDataMessagePrivate
	AbstractDataMessagePrivate (AbstractDataMessage *const q)
virtual	~AbstractDataMessagePrivate ()
bool	setFields (const DataDefinition *const defn, const QByteArray &record)

Public Attributes
DateTime	timestamp
	The RecordMessage FIT message's timestamp field.
qint32	positionLat
	The RecordMessage FIT message's positionLat field.
qint32	positionLong
	The RecordMessage FIT message's positionLong field.
quint16	altitude
	The RecordMessage FIT message's altitude field.
quint8	heartRate
	The RecordMessage FIT message's heartRate field.
quint8	cadence
	The RecordMessage FIT message's cadence field.
quint32	distance
	The RecordMessage FIT message's distance field.
quint16	speed
	The RecordMessage FIT message's speed field.
quint16	power
	The RecordMessage FIT message's power field.
quint8	compressedSpeedDistance
	The RecordMessage FIT message's compressedSpeedDistance field.
qint16	grade
	The RecordMessage FIT message's grade field.
quint8	resistance
	The RecordMessage FIT message's resistance field. More...
qint32	timeFromCourse
	The RecordMessage FIT message's timeFromCourse field.
quint8	cycleLength
	The RecordMessage FIT message's cycleLength field.
qint8	temperature
	The RecordMessage FIT message's temperature field.
quint8	speed1s
	The RecordMessage FIT message's speed1s field. More...
quint8	cycles
	The RecordMessage FIT message's cycles field.
quint32	totalCycles
	The RecordMessage FIT message's totalCycles field.
quint16	compressedAccumulatedPower
	The RecordMessage FIT message's compressedAccumulatedPower field.
quint32	accumulatedPower
	The RecordMessage FIT message's accumulatedPower field.
LeftRightBalance	leftRightBalance
	The RecordMessage FIT message's leftRightBalance field.
quint8	gpsAccuracy
	The RecordMessage FIT message's gpsAccuracy field.
qint16	verticalSpeed
	The RecordMessage FIT message's verticalSpeed field.
quint16	calories
	The RecordMessage FIT message's calories field.
quint16	verticalOscillation
	The RecordMessage FIT message's verticalOscillation field.
quint16	stanceTimePercent
	The RecordMessage FIT message's stanceTimePercent field.
quint16	stanceTime
	The RecordMessage FIT message's stanceTime field.
ActivityType	activityType
	The RecordMessage FIT message's activityType field.
quint8	leftTorqueEffectiveness
	The RecordMessage FIT message's leftTorqueEffectiveness field.
quint8	rightTorqueEffectiveness
	The RecordMessage FIT message's rightTorqueEffectiveness field.
quint8	leftPedalSmoothness
	The RecordMessage FIT message's leftPedalSmoothness field.
quint8	rightPedalSmoothness
	The RecordMessage FIT message's rightPedalSmoothness field.
quint8	combinedPedalSmoothness
	The RecordMessage FIT message's combinedPedalSmoothness field.
quint8	time128
	The RecordMessage FIT message's time128 field.
StrokeType	strokeType
	The RecordMessage FIT message's strokeType field.
quint8	zone
	The RecordMessage FIT message's zone field.
quint16	ballSpeed
	The RecordMessage FIT message's ballSpeed field.
quint16	cadence256
	The RecordMessage FIT message's cadence256 field. More...
quint8	fractionalCadence
	The RecordMessage FIT message's fractionalCadence field.
quint16	totalHemoglobinConc
	The RecordMessage FIT message's totalHemoglobinConc field. More...
quint16	totalHemoglobinConcMin
	The RecordMessage FIT message's totalHemoglobinConcMin field. More...
quint16	totalHemoglobinConcMax
	The RecordMessage FIT message's totalHemoglobinConcMax field. More...
quint16	saturatedHemoglobinPercent
	The RecordMessage FIT message's saturatedHemoglobinPercent field. More...
quint16	saturatedHemoglobinPercentMin
	The RecordMessage FIT message's saturatedHemoglobinPercentMin field. More...
quint16	saturatedHemoglobinPercentMax
	The RecordMessage FIT message's saturatedHemoglobinPercentMax field. More...
DeviceIndex	deviceIndex
	The RecordMessage FIT message's deviceIndex field.
qint8	leftPco
	The RecordMessage FIT message's leftPco field. More...
qint8	rightPco
	The RecordMessage FIT message's rightPco field. More...
quint8	leftPowerPhase
	The RecordMessage FIT message's leftPowerPhase field. More...
quint8	leftPowerPhasePeak
	The RecordMessage FIT message's leftPowerPhasePeak field. More...
quint8	rightPowerPhase
	The RecordMessage FIT message's rightPowerPhase field. More...
quint8	rightPowerPhasePeak
	The RecordMessage FIT message's rightPowerPhasePeak field. More...
quint32	enhancedSpeed
	The RecordMessage FIT message's enhancedSpeed field.
quint32	enhancedAltitude
	The RecordMessage FIT message's enhancedAltitude field.
quint8	batterySoc
	The RecordMessage FIT message's batterySoc field. More...
quint16	motorPower
	The RecordMessage FIT message's motorPower field. More...
quint16	verticalRatio
	The RecordMessage FIT message's verticalRatio field.
quint16	stanceTimeBalance
	The RecordMessage FIT message's stanceTimeBalance field.
quint16	stepLength
	The RecordMessage FIT message's stepLength field.
quint32	absolutePressure
	The RecordMessage FIT message's absolutePressure field. More...
quint32	depth
	The RecordMessage FIT message's depth field. More...
quint32	nextStopDepth
	The RecordMessage FIT message's nextStopDepth field. More...
quint32	nextStopTime
	The RecordMessage FIT message's nextStopTime field.
quint32	timeToSurface
	The RecordMessage FIT message's timeToSurface field.
quint32	ndlTime
	The RecordMessage FIT message's ndlTime field.
quint8	cnsLoad
	The RecordMessage FIT message's cnsLoad field.
quint16	n2Load
	The RecordMessage FIT message's n2Load field.
float	grit
	The RecordMessage FIT message's grit field. More...
float	flow
	The RecordMessage FIT message's flow field. More...
quint16	ebikeTravelRange
	The RecordMessage FIT message's ebikeTravelRange field.
quint8	ebikeBatteryLevel
	The RecordMessage FIT message's ebikeBatteryLevel field.
quint8	ebikeAssistMode
	The RecordMessage FIT message's ebikeAssistMode field.
quint8	ebikeAssistLevelPercent
	The RecordMessage FIT message's ebikeAssistLevelPercent field.
quint16	coreTemperature
	The RecordMessage FIT message's coreTemperature field.
Public Attributes inherited from AbstractDataMessagePrivate
MesgNum	globalMessageNumber
	FIT Globla Message Number for this FIT Data Message.

Protected Member Functions
bool	setField (const int fieldId, const QByteArray &data, const FitBaseType baseType, const bool bigEndian) override
Protected Member Functions inherited from AbstractDataMessagePrivate
bool	verify (const QByteArray &data, const FitBaseType actualType, const int expectedSize, const FitBaseType expectedType, const char *messageFieldName)

Additional Inherited Members
Protected Attributes inherited from AbstractDataMessagePrivate
AbstractDataMessage *const	q_ptr
	Internal q-pointer.

Detailed Description

The RecordMessagePrivate class provides private implementation for the RecordMessage.

See also

RecordMessage

Definition at line 38 of file recordmessage_p.h.

Constructor & Destructor Documentation

RecordMessagePrivate()

RecordMessagePrivate::RecordMessagePrivate ( RecordMessage *const  q )

explicit

Constructs a RecordMessagePrivate object with public implementation q.

Parameters

q	Pointer to public implementaton.

Definition at line 1689 of file recordmessage.cpp.

  : AbstractDataMessagePrivate(q)
  , timestamp(static_cast<DateTime>(-1))
  , positionLat(0x7FFFFFFF)
  , positionLong(0x7FFFFFFF)
  , altitude(0xFFFF)
  , heartRate(0xFF)
  , cadence(0xFF)
  , distance(0xFFFFFFFF)
  , speed(0xFFFF)
  , power(0xFFFF)
  , compressedSpeedDistance(0xFF)
  , grade(0x7FFF)
  , resistance(0xFF)
  , timeFromCourse(0x7FFFFFFF)
  , cycleLength(0xFF)
  , temperature(0x7F)
  , speed1s(0xFF)
  , cycles(0xFF)
  , totalCycles(0xFFFFFFFF)
  , compressedAccumulatedPower(0xFFFF)
  , accumulatedPower(0xFFFFFFFF)
  , leftRightBalance(static_cast<LeftRightBalance>(-1))
  , gpsAccuracy(0xFF)
  , verticalSpeed(0x7FFF)
  , calories(0xFFFF)
  , verticalOscillation(0xFFFF)
  , stanceTimePercent(0xFFFF)
  , stanceTime(0xFFFF)
  , activityType(static_cast<ActivityType>(-1))
  , leftTorqueEffectiveness(0xFF)
  , rightTorqueEffectiveness(0xFF)
  , leftPedalSmoothness(0xFF)
  , rightPedalSmoothness(0xFF)
  , combinedPedalSmoothness(0xFF)
  , time128(0xFF)
  , strokeType(static_cast<StrokeType>(-1))
  , zone(0xFF)
  , ballSpeed(0xFFFF)
  , cadence256(0xFFFF)
  , fractionalCadence(0xFF)
  , totalHemoglobinConc(0xFFFF)
  , totalHemoglobinConcMin(0xFFFF)
  , totalHemoglobinConcMax(0xFFFF)
  , saturatedHemoglobinPercent(0xFFFF)
  , saturatedHemoglobinPercentMin(0xFFFF)
  , saturatedHemoglobinPercentMax(0xFFFF)
  , deviceIndex(static_cast<DeviceIndex>(-1))
  , leftPco(0x7F)
  , rightPco(0x7F)
  , leftPowerPhase(0xFF)
  , leftPowerPhasePeak(0xFF)
  , rightPowerPhase(0xFF)
  , rightPowerPhasePeak(0xFF)
  , enhancedSpeed(0xFFFFFFFF)
  , enhancedAltitude(0xFFFFFFFF)
  , batterySoc(0xFF)
  , motorPower(0xFFFF)
  , verticalRatio(0xFFFF)
  , stanceTimeBalance(0xFFFF)
  , stepLength(0xFFFF)
  , absolutePressure(0xFFFFFFFF)
  , depth(0xFFFFFFFF)
  , nextStopDepth(0xFFFFFFFF)
  , nextStopTime(0xFFFFFFFF)
  , timeToSurface(0xFFFFFFFF)
  , ndlTime(0xFFFFFFFF)
  , cnsLoad(0xFF)
  , n2Load(0xFFFF)
  , grit(static_cast<float>(-1))
  , flow(static_cast<float>(-1))
  , ebikeTravelRange(0xFFFF)
  , ebikeBatteryLevel(0xFF)
  , ebikeAssistMode(0xFF)
  , ebikeAssistLevelPercent(0xFF)
  , coreTemperature(0xFFFF)
{
    globalMessageNumber = MesgNum::Record;
}

References AbstractDataMessagePrivate::globalMessageNumber.

~RecordMessagePrivate()

RecordMessagePrivate::~RecordMessagePrivate ( )

virtual

Destroys the RecordMessagePrivate object.

Definition at line 1774 of file recordmessage.cpp.

{
 
}

Member Function Documentation

setField()

bool RecordMessagePrivate::setField ( const int  fieldId, const QByteArray &  data, const FitBaseType  baseType, const bool  bigEndian  )

overrideprotectedvirtual

Sets the value of the fieldId field.

Derived classes must implement this method to extract the baseType value from data, and assign the extracted value the fieldId field.

Parameters

fieldId	The field number within the given FIT data message.
data	The raw data to extract the field value from.
baseType	The FIT base type for the field.
bigEndian	Whether or not multibyte values in record are big-endian.

Returns

true if the field was set, or safely ignored; false otherwise.

Implements AbstractDataMessagePrivate.

Definition at line 1779 of file recordmessage.cpp.

{
    switch (fieldId) {
    case 253: // See Profile.xlsx::Messages:record.timestamp
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.timestamp")) return false;
        this->timestamp = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 0: // See Profile.xlsx::Messages:record.positionLat
        if (!verify(data, baseType, 4, FitBaseType::Sint32, "record.positionLat")) return false;
        this->positionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
        break;
    case 1: // See Profile.xlsx::Messages:record.positionLong
        if (!verify(data, baseType, 4, FitBaseType::Sint32, "record.positionLong")) return false;
        this->positionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
        break;
    case 2: // See Profile.xlsx::Messages:record.altitude
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.altitude")) return false;
        this->altitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 3: // See Profile.xlsx::Messages:record.heartRate
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.heartRate")) return false;
        this->heartRate = static_cast<quint8>(data.at(0));
        break;
    case 4: // See Profile.xlsx::Messages:record.cadence
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.cadence")) return false;
        this->cadence = static_cast<quint8>(data.at(0));
        break;
    case 5: // See Profile.xlsx::Messages:record.distance
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.distance")) return false;
        this->distance = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 6: // See Profile.xlsx::Messages:record.speed
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.speed")) return false;
        this->speed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 7: // See Profile.xlsx::Messages:record.power
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.power")) return false;
        this->power = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 8: // See Profile.xlsx::Messages:record.compressedSpeedDistance
        if (!verify(data, baseType, 1, FitBaseType::Byte, "record.compressedSpeedDistance")) return false;
        this->compressedSpeedDistance = static_cast<quint8>(data.at(0));
        break;
    case 9: // See Profile.xlsx::Messages:record.grade
        if (!verify(data, baseType, 2, FitBaseType::Sint16, "record.grade")) return false;
        this->grade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
        break;
    case 10: // See Profile.xlsx::Messages:record.resistance
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.resistance")) return false;
        this->resistance = static_cast<quint8>(data.at(0));
        break;
    case 11: // See Profile.xlsx::Messages:record.timeFromCourse
        if (!verify(data, baseType, 4, FitBaseType::Sint32, "record.timeFromCourse")) return false;
        this->timeFromCourse = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
        break;
    case 12: // See Profile.xlsx::Messages:record.cycleLength
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.cycleLength")) return false;
        this->cycleLength = static_cast<quint8>(data.at(0));
        break;
    case 13: // See Profile.xlsx::Messages:record.temperature
        if (!verify(data, baseType, 1, FitBaseType::Sint8, "record.temperature")) return false;
        this->temperature = static_cast<qint8>(data.at(0));
        break;
    case 17: // See Profile.xlsx::Messages:record.speed1s
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.speed1s")) return false;
        this->speed1s = static_cast<quint8>(data.at(0));
        break;
    case 18: // See Profile.xlsx::Messages:record.cycles
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.cycles")) return false;
        this->cycles = static_cast<quint8>(data.at(0));
        break;
    case 19: // See Profile.xlsx::Messages:record.totalCycles
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.totalCycles")) return false;
        this->totalCycles = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 28: // See Profile.xlsx::Messages:record.compressedAccumulatedPower
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.compressedAccumulatedPower")) return false;
        this->compressedAccumulatedPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 29: // See Profile.xlsx::Messages:record.accumulatedPower
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.accumulatedPower")) return false;
        this->accumulatedPower = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 30: // See Profile.xlsx::Messages:record.leftRightBalance
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.leftRightBalance")) return false;
        this->leftRightBalance = static_cast<LeftRightBalance>(data.at(0));
        break;
    case 31: // See Profile.xlsx::Messages:record.gpsAccuracy
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.gpsAccuracy")) return false;
        this->gpsAccuracy = static_cast<quint8>(data.at(0));
        break;
    case 32: // See Profile.xlsx::Messages:record.verticalSpeed
        if (!verify(data, baseType, 2, FitBaseType::Sint16, "record.verticalSpeed")) return false;
        this->verticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
        break;
    case 33: // See Profile.xlsx::Messages:record.calories
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.calories")) return false;
        this->calories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 39: // See Profile.xlsx::Messages:record.verticalOscillation
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.verticalOscillation")) return false;
        this->verticalOscillation = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 40: // See Profile.xlsx::Messages:record.stanceTimePercent
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.stanceTimePercent")) return false;
        this->stanceTimePercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 41: // See Profile.xlsx::Messages:record.stanceTime
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.stanceTime")) return false;
        this->stanceTime = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 42: // See Profile.xlsx::Messages:record.activityType
        if (!verify(data, baseType, 1, FitBaseType::Enum, "record.activityType")) return false;
        this->activityType = static_cast<ActivityType>(data.at(0));
        break;
    case 43: // See Profile.xlsx::Messages:record.leftTorqueEffectiveness
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.leftTorqueEffectiveness")) return false;
        this->leftTorqueEffectiveness = static_cast<quint8>(data.at(0));
        break;
    case 44: // See Profile.xlsx::Messages:record.rightTorqueEffectiveness
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.rightTorqueEffectiveness")) return false;
        this->rightTorqueEffectiveness = static_cast<quint8>(data.at(0));
        break;
    case 45: // See Profile.xlsx::Messages:record.leftPedalSmoothness
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.leftPedalSmoothness")) return false;
        this->leftPedalSmoothness = static_cast<quint8>(data.at(0));
        break;
    case 46: // See Profile.xlsx::Messages:record.rightPedalSmoothness
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.rightPedalSmoothness")) return false;
        this->rightPedalSmoothness = static_cast<quint8>(data.at(0));
        break;
    case 47: // See Profile.xlsx::Messages:record.combinedPedalSmoothness
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.combinedPedalSmoothness")) return false;
        this->combinedPedalSmoothness = static_cast<quint8>(data.at(0));
        break;
    case 48: // See Profile.xlsx::Messages:record.time128
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.time128")) return false;
        this->time128 = static_cast<quint8>(data.at(0));
        break;
    case 49: // See Profile.xlsx::Messages:record.strokeType
        if (!verify(data, baseType, 1, FitBaseType::Enum, "record.strokeType")) return false;
        this->strokeType = static_cast<StrokeType>(data.at(0));
        break;
    case 50: // See Profile.xlsx::Messages:record.zone
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.zone")) return false;
        this->zone = static_cast<quint8>(data.at(0));
        break;
    case 51: // See Profile.xlsx::Messages:record.ballSpeed
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.ballSpeed")) return false;
        this->ballSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 52: // See Profile.xlsx::Messages:record.cadence256
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.cadence256")) return false;
        this->cadence256 = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 53: // See Profile.xlsx::Messages:record.fractionalCadence
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.fractionalCadence")) return false;
        this->fractionalCadence = static_cast<quint8>(data.at(0));
        break;
    case 54: // See Profile.xlsx::Messages:record.totalHemoglobinConc
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.totalHemoglobinConc")) return false;
        this->totalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 55: // See Profile.xlsx::Messages:record.totalHemoglobinConcMin
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.totalHemoglobinConcMin")) return false;
        this->totalHemoglobinConcMin = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 56: // See Profile.xlsx::Messages:record.totalHemoglobinConcMax
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.totalHemoglobinConcMax")) return false;
        this->totalHemoglobinConcMax = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 57: // See Profile.xlsx::Messages:record.saturatedHemoglobinPercent
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.saturatedHemoglobinPercent")) return false;
        this->saturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 58: // See Profile.xlsx::Messages:record.saturatedHemoglobinPercentMin
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.saturatedHemoglobinPercentMin")) return false;
        this->saturatedHemoglobinPercentMin = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 59: // See Profile.xlsx::Messages:record.saturatedHemoglobinPercentMax
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.saturatedHemoglobinPercentMax")) return false;
        this->saturatedHemoglobinPercentMax = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 62: // See Profile.xlsx::Messages:record.deviceIndex
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.deviceIndex")) return false;
        this->deviceIndex = static_cast<DeviceIndex>(data.at(0));
        break;
    case 67: // See Profile.xlsx::Messages:record.leftPco
        if (!verify(data, baseType, 1, FitBaseType::Sint8, "record.leftPco")) return false;
        this->leftPco = static_cast<qint8>(data.at(0));
        break;
    case 68: // See Profile.xlsx::Messages:record.rightPco
        if (!verify(data, baseType, 1, FitBaseType::Sint8, "record.rightPco")) return false;
        this->rightPco = static_cast<qint8>(data.at(0));
        break;
    case 69: // See Profile.xlsx::Messages:record.leftPowerPhase
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.leftPowerPhase")) return false;
        this->leftPowerPhase = static_cast<quint8>(data.at(0));
        break;
    case 70: // See Profile.xlsx::Messages:record.leftPowerPhasePeak
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.leftPowerPhasePeak")) return false;
        this->leftPowerPhasePeak = static_cast<quint8>(data.at(0));
        break;
    case 71: // See Profile.xlsx::Messages:record.rightPowerPhase
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.rightPowerPhase")) return false;
        this->rightPowerPhase = static_cast<quint8>(data.at(0));
        break;
    case 72: // See Profile.xlsx::Messages:record.rightPowerPhasePeak
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.rightPowerPhasePeak")) return false;
        this->rightPowerPhasePeak = static_cast<quint8>(data.at(0));
        break;
    case 73: // See Profile.xlsx::Messages:record.enhancedSpeed
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.enhancedSpeed")) return false;
        this->enhancedSpeed = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 78: // See Profile.xlsx::Messages:record.enhancedAltitude
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.enhancedAltitude")) return false;
        this->enhancedAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 81: // See Profile.xlsx::Messages:record.batterySoc
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.batterySoc")) return false;
        this->batterySoc = static_cast<quint8>(data.at(0));
        break;
    case 82: // See Profile.xlsx::Messages:record.motorPower
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.motorPower")) return false;
        this->motorPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 83: // See Profile.xlsx::Messages:record.verticalRatio
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.verticalRatio")) return false;
        this->verticalRatio = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 84: // See Profile.xlsx::Messages:record.stanceTimeBalance
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.stanceTimeBalance")) return false;
        this->stanceTimeBalance = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 85: // See Profile.xlsx::Messages:record.stepLength
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.stepLength")) return false;
        this->stepLength = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 91: // See Profile.xlsx::Messages:record.absolutePressure
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.absolutePressure")) return false;
        this->absolutePressure = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 92: // See Profile.xlsx::Messages:record.depth
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.depth")) return false;
        this->depth = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 93: // See Profile.xlsx::Messages:record.nextStopDepth
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.nextStopDepth")) return false;
        this->nextStopDepth = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 94: // See Profile.xlsx::Messages:record.nextStopTime
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.nextStopTime")) return false;
        this->nextStopTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 95: // See Profile.xlsx::Messages:record.timeToSurface
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.timeToSurface")) return false;
        this->timeToSurface = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 96: // See Profile.xlsx::Messages:record.ndlTime
        if (!verify(data, baseType, 4, FitBaseType::Uint32, "record.ndlTime")) return false;
        this->ndlTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
        break;
    case 97: // See Profile.xlsx::Messages:record.cnsLoad
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.cnsLoad")) return false;
        this->cnsLoad = static_cast<quint8>(data.at(0));
        break;
    case 98: // See Profile.xlsx::Messages:record.n2Load
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.n2Load")) return false;
        this->n2Load = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 114: // See Profile.xlsx::Messages:record.grit
        if (!verify(data, baseType, 4, FitBaseType::Float32, "record.grit")) return false;
        #if QT_VERSION < QT_VERSION_CHECK(5, 12, 0)
        {   // Qt's from-endian functions have no float/double specialisations prior to Qt 5.12.
            const quint32 localEndian = bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data);
            static_assert(sizeof(localEndian) == 4, "src not expected size");
            static_assert(sizeof(this->grit) == 4, "src and dst not the same size");
            memcpy(&this->grit, &localEndian, data.size());
        }
        #else
        this->grit = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
        #endif
        break;
    case 115: // See Profile.xlsx::Messages:record.flow
        if (!verify(data, baseType, 4, FitBaseType::Float32, "record.flow")) return false;
        #if QT_VERSION < QT_VERSION_CHECK(5, 12, 0)
        {   // Qt's from-endian functions have no float/double specialisations prior to Qt 5.12.
            const quint32 localEndian = bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data);
            static_assert(sizeof(localEndian) == 4, "src not expected size");
            static_assert(sizeof(this->flow) == 4, "src and dst not the same size");
            memcpy(&this->flow, &localEndian, data.size());
        }
        #else
        this->flow = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
        #endif
        break;
    case 117: // See Profile.xlsx::Messages:record.ebikeTravelRange
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.ebikeTravelRange")) return false;
        this->ebikeTravelRange = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    case 118: // See Profile.xlsx::Messages:record.ebikeBatteryLevel
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.ebikeBatteryLevel")) return false;
        this->ebikeBatteryLevel = static_cast<quint8>(data.at(0));
        break;
    case 119: // See Profile.xlsx::Messages:record.ebikeAssistMode
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.ebikeAssistMode")) return false;
        this->ebikeAssistMode = static_cast<quint8>(data.at(0));
        break;
    case 120: // See Profile.xlsx::Messages:record.ebikeAssistLevelPercent
        if (!verify(data, baseType, 1, FitBaseType::Uint8, "record.ebikeAssistLevelPercent")) return false;
        this->ebikeAssistLevelPercent = static_cast<quint8>(data.at(0));
        break;
    case 139: // See Profile.xlsx::Messages:record.coreTemperature
        if (!verify(data, baseType, 2, FitBaseType::Uint16, "record.coreTemperature")) return false;
        this->coreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
        break;
    default:
        qWarning() << "ignoring unknown record message field number" << fieldId << bigEndian;
        // Fall through to return true, as its still 'safe' to continue parsing data messages.
    }
    return true;
}

References AbstractDataMessagePrivate::verify().

Here is the call graph for this function:

Member Data Documentation

absolutePressure

quint32 RecordMessagePrivate::absolutePressure

The RecordMessage FIT message's absolutePressure field.

Includes atmospheric pressure

Definition at line 375 of file recordmessage_p.h.

batterySoc

quint8 RecordMessagePrivate::batterySoc

The RecordMessage FIT message's batterySoc field.

lev battery state of charge

Definition at line 346 of file recordmessage_p.h.

cadence256

quint16 RecordMessagePrivate::cadence256

The RecordMessage FIT message's cadence256 field.

Log cadence and fractional cadence for backwards compatability

Definition at line 235 of file recordmessage_p.h.

depth

quint32 RecordMessagePrivate::depth

The RecordMessage FIT message's depth field.

0 if above water

Definition at line 382 of file recordmessage_p.h.

flow

float RecordMessagePrivate::flow

The RecordMessage FIT message's flow field.

The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.

Definition at line 430 of file recordmessage_p.h.

grit

float RecordMessagePrivate::grit

The RecordMessage FIT message's grit field.

The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.

Definition at line 422 of file recordmessage_p.h.

leftPco

qint8 RecordMessagePrivate::leftPco

The RecordMessage FIT message's leftPco field.

Left platform center offset

Definition at line 294 of file recordmessage_p.h.

leftPowerPhase

quint8 RecordMessagePrivate::leftPowerPhase

The RecordMessage FIT message's leftPowerPhase field.

Left power phase angles. Data value indexes defined by power_phase_type.

Definition at line 308 of file recordmessage_p.h.

leftPowerPhasePeak

quint8 RecordMessagePrivate::leftPowerPhasePeak

The RecordMessage FIT message's leftPowerPhasePeak field.

Left power phase peak angles. Data value indexes defined by power_phase_type.

Definition at line 315 of file recordmessage_p.h.

motorPower

quint16 RecordMessagePrivate::motorPower

The RecordMessage FIT message's motorPower field.

lev motor power

Definition at line 353 of file recordmessage_p.h.

nextStopDepth

quint32 RecordMessagePrivate::nextStopDepth

The RecordMessage FIT message's nextStopDepth field.

0 if above water

Definition at line 389 of file recordmessage_p.h.

resistance

quint8 RecordMessagePrivate::resistance

The RecordMessage FIT message's resistance field.

Relative. 0 is none 254 is Max.

Definition at line 101 of file recordmessage_p.h.

rightPco

qint8 RecordMessagePrivate::rightPco

The RecordMessage FIT message's rightPco field.

Right platform center offset

Definition at line 301 of file recordmessage_p.h.

rightPowerPhase

quint8 RecordMessagePrivate::rightPowerPhase

The RecordMessage FIT message's rightPowerPhase field.

Right power phase angles. Data value indexes defined by power_phase_type.

Definition at line 322 of file recordmessage_p.h.

rightPowerPhasePeak

quint8 RecordMessagePrivate::rightPowerPhasePeak

The RecordMessage FIT message's rightPowerPhasePeak field.

Right power phase peak angles. Data value indexes defined by power_phase_type.

Definition at line 329 of file recordmessage_p.h.

saturatedHemoglobinPercent

quint16 RecordMessagePrivate::saturatedHemoglobinPercent

The RecordMessage FIT message's saturatedHemoglobinPercent field.

Percentage of hemoglobin saturated with oxygen

Definition at line 268 of file recordmessage_p.h.

saturatedHemoglobinPercentMax

quint16 RecordMessagePrivate::saturatedHemoglobinPercentMax

The RecordMessage FIT message's saturatedHemoglobinPercentMax field.

Max percentage of hemoglobin saturated with oxygen

Definition at line 282 of file recordmessage_p.h.

saturatedHemoglobinPercentMin

quint16 RecordMessagePrivate::saturatedHemoglobinPercentMin

The RecordMessage FIT message's saturatedHemoglobinPercentMin field.

Min percentage of hemoglobin saturated with oxygen

Definition at line 275 of file recordmessage_p.h.

speed1s

quint8 RecordMessagePrivate::speed1s

The RecordMessage FIT message's speed1s field.

Speed at 1s intervals. Timestamp field indicates time of last array element.

Definition at line 123 of file recordmessage_p.h.

totalHemoglobinConc

quint16 RecordMessagePrivate::totalHemoglobinConc

The RecordMessage FIT message's totalHemoglobinConc field.

Total saturated and unsaturated hemoglobin

Definition at line 247 of file recordmessage_p.h.

totalHemoglobinConcMax

quint16 RecordMessagePrivate::totalHemoglobinConcMax

The RecordMessage FIT message's totalHemoglobinConcMax field.

Max saturated and unsaturated hemoglobin

Definition at line 261 of file recordmessage_p.h.

totalHemoglobinConcMin

quint16 RecordMessagePrivate::totalHemoglobinConcMin

The RecordMessage FIT message's totalHemoglobinConcMin field.

Min saturated and unsaturated hemoglobin

Definition at line 254 of file recordmessage_p.h.

---

The documentation for this class was generated from the following files:

• recordmessage_p.h
• recordmessage.cpp