Inheritance diagram for LapMessagePrivate:

Collaboration diagram for LapMessagePrivate:

Public Member Functions
	LapMessagePrivate (LapMessage *const q)

virtual	~LapMessagePrivate ()

Public Member Functions inherited from AbstractDataMessagePrivate
	AbstractDataMessagePrivate (AbstractDataMessage *const q)

virtual	~AbstractDataMessagePrivate ()

bool	setFields (const DataDefinition *const defn, const QByteArray &record)

Public Attributes
MessageIndex	messageIndex
	The LapMessage FIT message's messageIndex field.

DateTime	timestamp
	The LapMessage FIT message's timestamp field. More...

Event	event
	The LapMessage FIT message's event field.

EventType	eventType
	The LapMessage FIT message's eventType field.

DateTime	startTime
	The LapMessage FIT message's startTime field.

qint32	startPositionLat
	The LapMessage FIT message's startPositionLat field.

qint32	startPositionLong
	The LapMessage FIT message's startPositionLong field.

qint32	endPositionLat
	The LapMessage FIT message's endPositionLat field.

qint32	endPositionLong
	The LapMessage FIT message's endPositionLong field.

quint32	totalElapsedTime
	The LapMessage FIT message's totalElapsedTime field. More...

quint32	totalTimerTime
	The LapMessage FIT message's totalTimerTime field. More...

quint32	totalDistance
	The LapMessage FIT message's totalDistance field.

quint32	totalCycles
	The LapMessage FIT message's totalCycles field.

quint16	totalCalories
	The LapMessage FIT message's totalCalories field.

quint16	totalFatCalories
	The LapMessage FIT message's totalFatCalories field. More...

quint16	avgSpeed
	The LapMessage FIT message's avgSpeed field.

quint16	maxSpeed
	The LapMessage FIT message's maxSpeed field.

quint8	avgHeartRate
	The LapMessage FIT message's avgHeartRate field.

quint8	maxHeartRate
	The LapMessage FIT message's maxHeartRate field.

quint8	avgCadence
	The LapMessage FIT message's avgCadence field. More...

quint8	maxCadence
	The LapMessage FIT message's maxCadence field.

quint16	avgPower
	The LapMessage FIT message's avgPower field. More...

quint16	maxPower
	The LapMessage FIT message's maxPower field.

quint16	totalAscent
	The LapMessage FIT message's totalAscent field.

quint16	totalDescent
	The LapMessage FIT message's totalDescent field.

Intensity	intensity
	The LapMessage FIT message's intensity field.

LapTrigger	lapTrigger
	The LapMessage FIT message's lapTrigger field.

Sport	sport
	The LapMessage FIT message's sport field.

quint8	eventGroup
	The LapMessage FIT message's eventGroup field.

quint16	numLengths
	The LapMessage FIT message's numLengths field. More...

quint16	normalizedPower
	The LapMessage FIT message's normalizedPower field.

LeftRightBalance100	leftRightBalance
	The LapMessage FIT message's leftRightBalance field.

quint16	firstLengthIndex
	The LapMessage FIT message's firstLengthIndex field.

quint16	avgStrokeDistance
	The LapMessage FIT message's avgStrokeDistance field.

SwimStroke	swimStroke
	The LapMessage FIT message's swimStroke field.

SubSport	subSport
	The LapMessage FIT message's subSport field.

quint16	numActiveLengths
	The LapMessage FIT message's numActiveLengths field. More...

quint32	totalWork
	The LapMessage FIT message's totalWork field.

quint16	avgAltitude
	The LapMessage FIT message's avgAltitude field.

quint16	maxAltitude
	The LapMessage FIT message's maxAltitude field.

quint8	gpsAccuracy
	The LapMessage FIT message's gpsAccuracy field.

qint16	avgGrade
	The LapMessage FIT message's avgGrade field.

qint16	avgPosGrade
	The LapMessage FIT message's avgPosGrade field.

qint16	avgNegGrade
	The LapMessage FIT message's avgNegGrade field.

qint16	maxPosGrade
	The LapMessage FIT message's maxPosGrade field.

qint16	maxNegGrade
	The LapMessage FIT message's maxNegGrade field.

qint8	avgTemperature
	The LapMessage FIT message's avgTemperature field.

qint8	maxTemperature
	The LapMessage FIT message's maxTemperature field.

quint32	totalMovingTime
	The LapMessage FIT message's totalMovingTime field.

qint16	avgPosVerticalSpeed
	The LapMessage FIT message's avgPosVerticalSpeed field.

qint16	avgNegVerticalSpeed
	The LapMessage FIT message's avgNegVerticalSpeed field.

qint16	maxPosVerticalSpeed
	The LapMessage FIT message's maxPosVerticalSpeed field.

qint16	maxNegVerticalSpeed
	The LapMessage FIT message's maxNegVerticalSpeed field.

quint32	timeInHrZone
	The LapMessage FIT message's timeInHrZone field.

quint32	timeInSpeedZone
	The LapMessage FIT message's timeInSpeedZone field.

quint32	timeInCadenceZone
	The LapMessage FIT message's timeInCadenceZone field.

quint32	timeInPowerZone
	The LapMessage FIT message's timeInPowerZone field.

quint16	repetitionNum
	The LapMessage FIT message's repetitionNum field.

quint16	minAltitude
	The LapMessage FIT message's minAltitude field.

quint8	minHeartRate
	The LapMessage FIT message's minHeartRate field.

MessageIndex	wktStepIndex
	The LapMessage FIT message's wktStepIndex field.

quint16	opponentScore
	The LapMessage FIT message's opponentScore field.

quint16	strokeCount
	The LapMessage FIT message's strokeCount field. More...

quint16	zoneCount
	The LapMessage FIT message's zoneCount field. More...

quint16	avgVerticalOscillation
	The LapMessage FIT message's avgVerticalOscillation field.

quint16	avgStanceTimePercent
	The LapMessage FIT message's avgStanceTimePercent field.

quint16	avgStanceTime
	The LapMessage FIT message's avgStanceTime field.

quint8	avgFractionalCadence
	The LapMessage FIT message's avgFractionalCadence field. More...

quint8	maxFractionalCadence
	The LapMessage FIT message's maxFractionalCadence field. More...

quint8	totalFractionalCycles
	The LapMessage FIT message's totalFractionalCycles field. More...

quint16	playerScore
	The LapMessage FIT message's playerScore field.

quint16	avgTotalHemoglobinConc
	The LapMessage FIT message's avgTotalHemoglobinConc field. More...

quint16	minTotalHemoglobinConc
	The LapMessage FIT message's minTotalHemoglobinConc field. More...

quint16	maxTotalHemoglobinConc
	The LapMessage FIT message's maxTotalHemoglobinConc field. More...

quint16	avgSaturatedHemoglobinPercent
	The LapMessage FIT message's avgSaturatedHemoglobinPercent field. More...

quint16	minSaturatedHemoglobinPercent
	The LapMessage FIT message's minSaturatedHemoglobinPercent field. More...

quint16	maxSaturatedHemoglobinPercent
	The LapMessage FIT message's maxSaturatedHemoglobinPercent field. More...

quint8	avgLeftTorqueEffectiveness
	The LapMessage FIT message's avgLeftTorqueEffectiveness field.

quint8	avgRightTorqueEffectiveness
	The LapMessage FIT message's avgRightTorqueEffectiveness field.

quint8	avgLeftPedalSmoothness
	The LapMessage FIT message's avgLeftPedalSmoothness field.

quint8	avgRightPedalSmoothness
	The LapMessage FIT message's avgRightPedalSmoothness field.

quint8	avgCombinedPedalSmoothness
	The LapMessage FIT message's avgCombinedPedalSmoothness field.

quint32	timeStanding
	The LapMessage FIT message's timeStanding field. More...

quint16	standCount
	The LapMessage FIT message's standCount field. More...

qint8	avgLeftPco
	The LapMessage FIT message's avgLeftPco field. More...

qint8	avgRightPco
	The LapMessage FIT message's avgRightPco field. More...

quint8	avgLeftPowerPhase
	The LapMessage FIT message's avgLeftPowerPhase field. More...

quint8	avgLeftPowerPhasePeak
	The LapMessage FIT message's avgLeftPowerPhasePeak field. More...

quint8	avgRightPowerPhase
	The LapMessage FIT message's avgRightPowerPhase field. More...

quint8	avgRightPowerPhasePeak
	The LapMessage FIT message's avgRightPowerPhasePeak field. More...

quint16	avgPowerPosition
	The LapMessage FIT message's avgPowerPosition field. More...

quint16	maxPowerPosition
	The LapMessage FIT message's maxPowerPosition field. More...

quint8	avgCadencePosition
	The LapMessage FIT message's avgCadencePosition field. More...

quint8	maxCadencePosition
	The LapMessage FIT message's maxCadencePosition field. More...

quint32	enhancedAvgSpeed
	The LapMessage FIT message's enhancedAvgSpeed field.

quint32	enhancedMaxSpeed
	The LapMessage FIT message's enhancedMaxSpeed field.

quint32	enhancedAvgAltitude
	The LapMessage FIT message's enhancedAvgAltitude field.

quint32	enhancedMinAltitude
	The LapMessage FIT message's enhancedMinAltitude field.

quint32	enhancedMaxAltitude
	The LapMessage FIT message's enhancedMaxAltitude field.

quint16	avgLevMotorPower
	The LapMessage FIT message's avgLevMotorPower field. More...

quint16	maxLevMotorPower
	The LapMessage FIT message's maxLevMotorPower field. More...

quint8	levBatteryConsumption
	The LapMessage FIT message's levBatteryConsumption field. More...

quint16	avgVerticalRatio
	The LapMessage FIT message's avgVerticalRatio field.

quint16	avgStanceTimeBalance
	The LapMessage FIT message's avgStanceTimeBalance field.

quint16	avgStepLength
	The LapMessage FIT message's avgStepLength field.

quint16	avgVam
	The LapMessage FIT message's avgVam field.

float	totalGrit
	The LapMessage FIT message's totalGrit field. More...

float	totalFlow
	The LapMessage FIT message's totalFlow field. More...

quint16	jumpCount
	The LapMessage FIT message's jumpCount field.

float	avgGrit
	The LapMessage FIT message's avgGrit field. More...

float	avgFlow
	The LapMessage FIT message's avgFlow field. More...

quint8	totalFractionalAscent
	The LapMessage FIT message's totalFractionalAscent field. More...

quint8	totalFractionalDescent
	The LapMessage FIT message's totalFractionalDescent field. More...

quint16	avgCoreTemperature
	The LapMessage FIT message's avgCoreTemperature field.

quint16	minCoreTemperature
	The LapMessage FIT message's minCoreTemperature field.

quint16	maxCoreTemperature
	The LapMessage FIT message's maxCoreTemperature 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 LapMessagePrivate class provides private implementation for the LapMessage.

See also: LapMessage

Definition at line 38 of file lapmessage_p.h.

Constructor & Destructor Documentation

◆ LapMessagePrivate()

LapMessagePrivate::LapMessagePrivate ( LapMessage *const q )

explicit

Constructs a LapMessagePrivate object with public implementation q.

Parameters

q	Pointer to public implementaton.

Definition at line 2611 of file lapmessage.cpp.

   : AbstractDataMessagePrivate(q)
   , messageIndex(static_cast<MessageIndex>(-1))
   , timestamp(static_cast<DateTime>(-1))
   , event(static_cast<Event>(-1))
   , eventType(static_cast<EventType>(-1))
   , startTime(static_cast<DateTime>(-1))
   , startPositionLat(0x7FFFFFFF)
   , startPositionLong(0x7FFFFFFF)
   , endPositionLat(0x7FFFFFFF)
   , endPositionLong(0x7FFFFFFF)
   , totalElapsedTime(0xFFFFFFFF)
   , totalTimerTime(0xFFFFFFFF)
   , totalDistance(0xFFFFFFFF)
   , totalCycles(0xFFFFFFFF)
   , totalCalories(0xFFFF)
   , totalFatCalories(0xFFFF)
   , avgSpeed(0xFFFF)
   , maxSpeed(0xFFFF)
   , avgHeartRate(0xFF)
   , maxHeartRate(0xFF)
   , avgCadence(0xFF)
   , maxCadence(0xFF)
   , avgPower(0xFFFF)
   , maxPower(0xFFFF)
   , totalAscent(0xFFFF)
   , totalDescent(0xFFFF)
   , intensity(static_cast<Intensity>(-1))
   , lapTrigger(static_cast<LapTrigger>(-1))
   , sport(static_cast<Sport>(-1))
   , eventGroup(0xFF)
   , numLengths(0xFFFF)
   , normalizedPower(0xFFFF)
   , leftRightBalance(static_cast<LeftRightBalance100>(-1))
   , firstLengthIndex(0xFFFF)
   , avgStrokeDistance(0xFFFF)
   , swimStroke(static_cast<SwimStroke>(-1))
   , subSport(static_cast<SubSport>(-1))
   , numActiveLengths(0xFFFF)
   , totalWork(0xFFFFFFFF)
   , avgAltitude(0xFFFF)
   , maxAltitude(0xFFFF)
   , gpsAccuracy(0xFF)
   , avgGrade(0x7FFF)
   , avgPosGrade(0x7FFF)
   , avgNegGrade(0x7FFF)
   , maxPosGrade(0x7FFF)
   , maxNegGrade(0x7FFF)
   , avgTemperature(0x7F)
   , maxTemperature(0x7F)
   , totalMovingTime(0xFFFFFFFF)
   , avgPosVerticalSpeed(0x7FFF)
   , avgNegVerticalSpeed(0x7FFF)
   , maxPosVerticalSpeed(0x7FFF)
   , maxNegVerticalSpeed(0x7FFF)
   , timeInHrZone(0xFFFFFFFF)
   , timeInSpeedZone(0xFFFFFFFF)
   , timeInCadenceZone(0xFFFFFFFF)
   , timeInPowerZone(0xFFFFFFFF)
   , repetitionNum(0xFFFF)
   , minAltitude(0xFFFF)
   , minHeartRate(0xFF)
   , wktStepIndex(static_cast<MessageIndex>(-1))
   , opponentScore(0xFFFF)
   , strokeCount(0xFFFF)
   , zoneCount(0xFFFF)
   , avgVerticalOscillation(0xFFFF)
   , avgStanceTimePercent(0xFFFF)
   , avgStanceTime(0xFFFF)
   , avgFractionalCadence(0xFF)
   , maxFractionalCadence(0xFF)
   , totalFractionalCycles(0xFF)
   , playerScore(0xFFFF)
   , avgTotalHemoglobinConc(0xFFFF)
   , minTotalHemoglobinConc(0xFFFF)
   , maxTotalHemoglobinConc(0xFFFF)
   , avgSaturatedHemoglobinPercent(0xFFFF)
   , minSaturatedHemoglobinPercent(0xFFFF)
   , maxSaturatedHemoglobinPercent(0xFFFF)
   , avgLeftTorqueEffectiveness(0xFF)
   , avgRightTorqueEffectiveness(0xFF)
   , avgLeftPedalSmoothness(0xFF)
   , avgRightPedalSmoothness(0xFF)
   , avgCombinedPedalSmoothness(0xFF)
   , timeStanding(0xFFFFFFFF)
   , standCount(0xFFFF)
   , avgLeftPco(0x7F)
   , avgRightPco(0x7F)
   , avgLeftPowerPhase(0xFF)
   , avgLeftPowerPhasePeak(0xFF)
   , avgRightPowerPhase(0xFF)
   , avgRightPowerPhasePeak(0xFF)
   , avgPowerPosition(0xFFFF)
   , maxPowerPosition(0xFFFF)
   , avgCadencePosition(0xFF)
   , maxCadencePosition(0xFF)
   , enhancedAvgSpeed(0xFFFFFFFF)
   , enhancedMaxSpeed(0xFFFFFFFF)
   , enhancedAvgAltitude(0xFFFFFFFF)
   , enhancedMinAltitude(0xFFFFFFFF)
   , enhancedMaxAltitude(0xFFFFFFFF)
   , avgLevMotorPower(0xFFFF)
   , maxLevMotorPower(0xFFFF)
   , levBatteryConsumption(0xFF)
   , avgVerticalRatio(0xFFFF)
   , avgStanceTimeBalance(0xFFFF)
   , avgStepLength(0xFFFF)
   , avgVam(0xFFFF)
   , totalGrit(static_cast<float>(-1))
   , totalFlow(static_cast<float>(-1))
   , jumpCount(0xFFFF)
   , avgGrit(static_cast<float>(-1))
   , avgFlow(static_cast<float>(-1))
   , totalFractionalAscent(0xFF)
   , totalFractionalDescent(0xFF)
   , avgCoreTemperature(0xFFFF)
   , minCoreTemperature(0xFFFF)
   , maxCoreTemperature(0xFFFF)
 {
     globalMessageNumber = MesgNum::Lap;
 }

References AbstractDataMessagePrivate::globalMessageNumber.

◆ ~LapMessagePrivate()

LapMessagePrivate::~LapMessagePrivate ( )

virtual

Destroys the LapMessagePrivate object.

Definition at line 2738 of file lapmessage.cpp.

 {
  
 }

Member Function Documentation

◆ setField()

bool LapMessagePrivate::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 2743 of file lapmessage.cpp.

 {
     switch (fieldId) {
     case 254: // See Profile.xlsx::Messages:lap.messageIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.messageIndex")) return false;
         this->messageIndex = static_cast<MessageIndex>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 253: // See Profile.xlsx::Messages:lap.timestamp
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timestamp")) return false;
         this->timestamp = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 0: // See Profile.xlsx::Messages:lap.event
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.event")) return false;
         this->event = static_cast<Event>(data.at(0));
         break;
     case 1: // See Profile.xlsx::Messages:lap.eventType
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.eventType")) return false;
         this->eventType = static_cast<EventType>(data.at(0));
         break;
     case 2: // See Profile.xlsx::Messages:lap.startTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.startTime")) return false;
         this->startTime = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 3: // See Profile.xlsx::Messages:lap.startPositionLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "lap.startPositionLat")) return false;
         this->startPositionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 4: // See Profile.xlsx::Messages:lap.startPositionLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "lap.startPositionLong")) return false;
         this->startPositionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 5: // See Profile.xlsx::Messages:lap.endPositionLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "lap.endPositionLat")) return false;
         this->endPositionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 6: // See Profile.xlsx::Messages:lap.endPositionLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "lap.endPositionLong")) return false;
         this->endPositionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 7: // See Profile.xlsx::Messages:lap.totalElapsedTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalElapsedTime")) return false;
         this->totalElapsedTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 8: // See Profile.xlsx::Messages:lap.totalTimerTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalTimerTime")) return false;
         this->totalTimerTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 9: // See Profile.xlsx::Messages:lap.totalDistance
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalDistance")) return false;
         this->totalDistance = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 10: // See Profile.xlsx::Messages:lap.totalCycles
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalCycles")) return false;
         this->totalCycles = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 11: // See Profile.xlsx::Messages:lap.totalCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.totalCalories")) return false;
         this->totalCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 12: // See Profile.xlsx::Messages:lap.totalFatCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.totalFatCalories")) return false;
         this->totalFatCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 13: // See Profile.xlsx::Messages:lap.avgSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgSpeed")) return false;
         this->avgSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 14: // See Profile.xlsx::Messages:lap.maxSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxSpeed")) return false;
         this->maxSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 15: // See Profile.xlsx::Messages:lap.avgHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgHeartRate")) return false;
         this->avgHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 16: // See Profile.xlsx::Messages:lap.maxHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.maxHeartRate")) return false;
         this->maxHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 17: // See Profile.xlsx::Messages:lap.avgCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgCadence")) return false;
         this->avgCadence = static_cast<quint8>(data.at(0));
         break;
     case 18: // See Profile.xlsx::Messages:lap.maxCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.maxCadence")) return false;
         this->maxCadence = static_cast<quint8>(data.at(0));
         break;
     case 19: // See Profile.xlsx::Messages:lap.avgPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgPower")) return false;
         this->avgPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 20: // See Profile.xlsx::Messages:lap.maxPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxPower")) return false;
         this->maxPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 21: // See Profile.xlsx::Messages:lap.totalAscent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.totalAscent")) return false;
         this->totalAscent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 22: // See Profile.xlsx::Messages:lap.totalDescent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.totalDescent")) return false;
         this->totalDescent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 23: // See Profile.xlsx::Messages:lap.intensity
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.intensity")) return false;
         this->intensity = static_cast<Intensity>(data.at(0));
         break;
     case 24: // See Profile.xlsx::Messages:lap.lapTrigger
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.lapTrigger")) return false;
         this->lapTrigger = static_cast<LapTrigger>(data.at(0));
         break;
     case 25: // See Profile.xlsx::Messages:lap.sport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.sport")) return false;
         this->sport = static_cast<Sport>(data.at(0));
         break;
     case 26: // See Profile.xlsx::Messages:lap.eventGroup
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.eventGroup")) return false;
         this->eventGroup = static_cast<quint8>(data.at(0));
         break;
     case 32: // See Profile.xlsx::Messages:lap.numLengths
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.numLengths")) return false;
         this->numLengths = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 33: // See Profile.xlsx::Messages:lap.normalizedPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.normalizedPower")) return false;
         this->normalizedPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 34: // See Profile.xlsx::Messages:lap.leftRightBalance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.leftRightBalance")) return false;
         this->leftRightBalance = static_cast<LeftRightBalance100>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 35: // See Profile.xlsx::Messages:lap.firstLengthIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.firstLengthIndex")) return false;
         this->firstLengthIndex = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 37: // See Profile.xlsx::Messages:lap.avgStrokeDistance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgStrokeDistance")) return false;
         this->avgStrokeDistance = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 38: // See Profile.xlsx::Messages:lap.swimStroke
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.swimStroke")) return false;
         this->swimStroke = static_cast<SwimStroke>(data.at(0));
         break;
     case 39: // See Profile.xlsx::Messages:lap.subSport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "lap.subSport")) return false;
         this->subSport = static_cast<SubSport>(data.at(0));
         break;
     case 40: // See Profile.xlsx::Messages:lap.numActiveLengths
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.numActiveLengths")) return false;
         this->numActiveLengths = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 41: // See Profile.xlsx::Messages:lap.totalWork
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalWork")) return false;
         this->totalWork = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 42: // See Profile.xlsx::Messages:lap.avgAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgAltitude")) return false;
         this->avgAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 43: // See Profile.xlsx::Messages:lap.maxAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxAltitude")) return false;
         this->maxAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 44: // See Profile.xlsx::Messages:lap.gpsAccuracy
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.gpsAccuracy")) return false;
         this->gpsAccuracy = static_cast<quint8>(data.at(0));
         break;
     case 45: // See Profile.xlsx::Messages:lap.avgGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.avgGrade")) return false;
         this->avgGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 46: // See Profile.xlsx::Messages:lap.avgPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.avgPosGrade")) return false;
         this->avgPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 47: // See Profile.xlsx::Messages:lap.avgNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.avgNegGrade")) return false;
         this->avgNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 48: // See Profile.xlsx::Messages:lap.maxPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.maxPosGrade")) return false;
         this->maxPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 49: // See Profile.xlsx::Messages:lap.maxNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.maxNegGrade")) return false;
         this->maxNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 50: // See Profile.xlsx::Messages:lap.avgTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "lap.avgTemperature")) return false;
         this->avgTemperature = static_cast<qint8>(data.at(0));
         break;
     case 51: // See Profile.xlsx::Messages:lap.maxTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "lap.maxTemperature")) return false;
         this->maxTemperature = static_cast<qint8>(data.at(0));
         break;
     case 52: // See Profile.xlsx::Messages:lap.totalMovingTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.totalMovingTime")) return false;
         this->totalMovingTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 53: // See Profile.xlsx::Messages:lap.avgPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.avgPosVerticalSpeed")) return false;
         this->avgPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 54: // See Profile.xlsx::Messages:lap.avgNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.avgNegVerticalSpeed")) return false;
         this->avgNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 55: // See Profile.xlsx::Messages:lap.maxPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.maxPosVerticalSpeed")) return false;
         this->maxPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 56: // See Profile.xlsx::Messages:lap.maxNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "lap.maxNegVerticalSpeed")) return false;
         this->maxNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 57: // See Profile.xlsx::Messages:lap.timeInHrZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timeInHrZone")) return false;
         this->timeInHrZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 58: // See Profile.xlsx::Messages:lap.timeInSpeedZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timeInSpeedZone")) return false;
         this->timeInSpeedZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 59: // See Profile.xlsx::Messages:lap.timeInCadenceZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timeInCadenceZone")) return false;
         this->timeInCadenceZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 60: // See Profile.xlsx::Messages:lap.timeInPowerZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timeInPowerZone")) return false;
         this->timeInPowerZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 61: // See Profile.xlsx::Messages:lap.repetitionNum
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.repetitionNum")) return false;
         this->repetitionNum = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 62: // See Profile.xlsx::Messages:lap.minAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.minAltitude")) return false;
         this->minAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 63: // See Profile.xlsx::Messages:lap.minHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.minHeartRate")) return false;
         this->minHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 71: // See Profile.xlsx::Messages:lap.wktStepIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.wktStepIndex")) return false;
         this->wktStepIndex = static_cast<MessageIndex>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 74: // See Profile.xlsx::Messages:lap.opponentScore
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.opponentScore")) return false;
         this->opponentScore = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 75: // See Profile.xlsx::Messages:lap.strokeCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.strokeCount")) return false;
         this->strokeCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 76: // See Profile.xlsx::Messages:lap.zoneCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.zoneCount")) return false;
         this->zoneCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 77: // See Profile.xlsx::Messages:lap.avgVerticalOscillation
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgVerticalOscillation")) return false;
         this->avgVerticalOscillation = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 78: // See Profile.xlsx::Messages:lap.avgStanceTimePercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgStanceTimePercent")) return false;
         this->avgStanceTimePercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 79: // See Profile.xlsx::Messages:lap.avgStanceTime
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgStanceTime")) return false;
         this->avgStanceTime = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 80: // See Profile.xlsx::Messages:lap.avgFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgFractionalCadence")) return false;
         this->avgFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 81: // See Profile.xlsx::Messages:lap.maxFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.maxFractionalCadence")) return false;
         this->maxFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 82: // See Profile.xlsx::Messages:lap.totalFractionalCycles
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.totalFractionalCycles")) return false;
         this->totalFractionalCycles = static_cast<quint8>(data.at(0));
         break;
     case 83: // See Profile.xlsx::Messages:lap.playerScore
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.playerScore")) return false;
         this->playerScore = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 84: // See Profile.xlsx::Messages:lap.avgTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgTotalHemoglobinConc")) return false;
         this->avgTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 85: // See Profile.xlsx::Messages:lap.minTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.minTotalHemoglobinConc")) return false;
         this->minTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 86: // See Profile.xlsx::Messages:lap.maxTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxTotalHemoglobinConc")) return false;
         this->maxTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 87: // See Profile.xlsx::Messages:lap.avgSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgSaturatedHemoglobinPercent")) return false;
         this->avgSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 88: // See Profile.xlsx::Messages:lap.minSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.minSaturatedHemoglobinPercent")) return false;
         this->minSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 89: // See Profile.xlsx::Messages:lap.maxSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxSaturatedHemoglobinPercent")) return false;
         this->maxSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 91: // See Profile.xlsx::Messages:lap.avgLeftTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgLeftTorqueEffectiveness")) return false;
         this->avgLeftTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 92: // See Profile.xlsx::Messages:lap.avgRightTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgRightTorqueEffectiveness")) return false;
         this->avgRightTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 93: // See Profile.xlsx::Messages:lap.avgLeftPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgLeftPedalSmoothness")) return false;
         this->avgLeftPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 94: // See Profile.xlsx::Messages:lap.avgRightPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgRightPedalSmoothness")) return false;
         this->avgRightPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 95: // See Profile.xlsx::Messages:lap.avgCombinedPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgCombinedPedalSmoothness")) return false;
         this->avgCombinedPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 98: // See Profile.xlsx::Messages:lap.timeStanding
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.timeStanding")) return false;
         this->timeStanding = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 99: // See Profile.xlsx::Messages:lap.standCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.standCount")) return false;
         this->standCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 100: // See Profile.xlsx::Messages:lap.avgLeftPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "lap.avgLeftPco")) return false;
         this->avgLeftPco = static_cast<qint8>(data.at(0));
         break;
     case 101: // See Profile.xlsx::Messages:lap.avgRightPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "lap.avgRightPco")) return false;
         this->avgRightPco = static_cast<qint8>(data.at(0));
         break;
     case 102: // See Profile.xlsx::Messages:lap.avgLeftPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgLeftPowerPhase")) return false;
         this->avgLeftPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 103: // See Profile.xlsx::Messages:lap.avgLeftPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgLeftPowerPhasePeak")) return false;
         this->avgLeftPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 104: // See Profile.xlsx::Messages:lap.avgRightPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgRightPowerPhase")) return false;
         this->avgRightPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 105: // See Profile.xlsx::Messages:lap.avgRightPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgRightPowerPhasePeak")) return false;
         this->avgRightPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 106: // See Profile.xlsx::Messages:lap.avgPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgPowerPosition")) return false;
         this->avgPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 107: // See Profile.xlsx::Messages:lap.maxPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxPowerPosition")) return false;
         this->maxPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 108: // See Profile.xlsx::Messages:lap.avgCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.avgCadencePosition")) return false;
         this->avgCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 109: // See Profile.xlsx::Messages:lap.maxCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.maxCadencePosition")) return false;
         this->maxCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 110: // See Profile.xlsx::Messages:lap.enhancedAvgSpeed
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.enhancedAvgSpeed")) return false;
         this->enhancedAvgSpeed = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 111: // See Profile.xlsx::Messages:lap.enhancedMaxSpeed
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.enhancedMaxSpeed")) return false;
         this->enhancedMaxSpeed = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 112: // See Profile.xlsx::Messages:lap.enhancedAvgAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.enhancedAvgAltitude")) return false;
         this->enhancedAvgAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 113: // See Profile.xlsx::Messages:lap.enhancedMinAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.enhancedMinAltitude")) return false;
         this->enhancedMinAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 114: // See Profile.xlsx::Messages:lap.enhancedMaxAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "lap.enhancedMaxAltitude")) return false;
         this->enhancedMaxAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 115: // See Profile.xlsx::Messages:lap.avgLevMotorPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgLevMotorPower")) return false;
         this->avgLevMotorPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 116: // See Profile.xlsx::Messages:lap.maxLevMotorPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxLevMotorPower")) return false;
         this->maxLevMotorPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 117: // See Profile.xlsx::Messages:lap.levBatteryConsumption
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.levBatteryConsumption")) return false;
         this->levBatteryConsumption = static_cast<quint8>(data.at(0));
         break;
     case 118: // See Profile.xlsx::Messages:lap.avgVerticalRatio
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgVerticalRatio")) return false;
         this->avgVerticalRatio = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 119: // See Profile.xlsx::Messages:lap.avgStanceTimeBalance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgStanceTimeBalance")) return false;
         this->avgStanceTimeBalance = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 120: // See Profile.xlsx::Messages:lap.avgStepLength
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgStepLength")) return false;
         this->avgStepLength = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 121: // See Profile.xlsx::Messages:lap.avgVam
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgVam")) return false;
         this->avgVam = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 149: // See Profile.xlsx::Messages:lap.totalGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "lap.totalGrit")) 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->totalGrit) == 4, "src and dst not the same size");
             memcpy(&this->totalGrit, &localEndian, data.size());
         }
         #else
         this->totalGrit = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
         #endif
         break;
     case 150: // See Profile.xlsx::Messages:lap.totalFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "lap.totalFlow")) 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->totalFlow) == 4, "src and dst not the same size");
             memcpy(&this->totalFlow, &localEndian, data.size());
         }
         #else
         this->totalFlow = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
         #endif
         break;
     case 151: // See Profile.xlsx::Messages:lap.jumpCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.jumpCount")) return false;
         this->jumpCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 153: // See Profile.xlsx::Messages:lap.avgGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "lap.avgGrit")) 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->avgGrit) == 4, "src and dst not the same size");
             memcpy(&this->avgGrit, &localEndian, data.size());
         }
         #else
         this->avgGrit = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
         #endif
         break;
     case 154: // See Profile.xlsx::Messages:lap.avgFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "lap.avgFlow")) 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->avgFlow) == 4, "src and dst not the same size");
             memcpy(&this->avgFlow, &localEndian, data.size());
         }
         #else
         this->avgFlow = static_cast<float>(bigEndian ? qFromBigEndian<float>(data) : qFromLittleEndian<float>(data));
         #endif
         break;
     case 156: // See Profile.xlsx::Messages:lap.totalFractionalAscent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.totalFractionalAscent")) return false;
         this->totalFractionalAscent = static_cast<quint8>(data.at(0));
         break;
     case 157: // See Profile.xlsx::Messages:lap.totalFractionalDescent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "lap.totalFractionalDescent")) return false;
         this->totalFractionalDescent = static_cast<quint8>(data.at(0));
         break;
     case 158: // See Profile.xlsx::Messages:lap.avgCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.avgCoreTemperature")) return false;
         this->avgCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 159: // See Profile.xlsx::Messages:lap.minCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.minCoreTemperature")) return false;
         this->minCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 160: // See Profile.xlsx::Messages:lap.maxCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "lap.maxCoreTemperature")) return false;
         this->maxCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     default:
         qWarning() << "ignoring unknown lap 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

◆ avgCadence

quint8 LapMessagePrivate::avgCadence

The LapMessage FIT message's avgCadence field.

total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time

Definition at line 150 of file lapmessage_p.h.

◆ avgCadencePosition

quint8 LapMessagePrivate::avgCadencePosition

The LapMessage FIT message's avgCadencePosition field.

Average cadence by position. Data value indexes defined by rider_position_type.

Definition at line 566 of file lapmessage_p.h.

◆ avgFlow

float LapMessagePrivate::avgFlow

The LapMessage FIT message's avgFlow 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 676 of file lapmessage_p.h.

◆ avgFractionalCadence

quint8 LapMessagePrivate::avgFractionalCadence

The LapMessage FIT message's avgFractionalCadence field.

fractional part of the avg_cadence

Definition at line 403 of file lapmessage_p.h.

◆ avgGrit

float LapMessagePrivate::avgGrit

The LapMessage FIT message's avgGrit 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 668 of file lapmessage_p.h.

◆ avgLeftPco

qint8 LapMessagePrivate::avgLeftPco

The LapMessage FIT message's avgLeftPco field.

Average left platform center offset

Definition at line 510 of file lapmessage_p.h.

◆ avgLeftPowerPhase

quint8 LapMessagePrivate::avgLeftPowerPhase

The LapMessage FIT message's avgLeftPowerPhase field.

Average left power phase angles. Data value indexes defined by power_phase_type.

Definition at line 524 of file lapmessage_p.h.

◆ avgLeftPowerPhasePeak

quint8 LapMessagePrivate::avgLeftPowerPhasePeak

The LapMessage FIT message's avgLeftPowerPhasePeak field.

Average left power phase peak angles. Data value indexes defined by power_phase_type.

Definition at line 531 of file lapmessage_p.h.

◆ avgLevMotorPower

quint16 LapMessagePrivate::avgLevMotorPower

The LapMessage FIT message's avgLevMotorPower field.

lev average motor power during lap

Definition at line 605 of file lapmessage_p.h.

◆ avgPower

quint16 LapMessagePrivate::avgPower

The LapMessage FIT message's avgPower field.

total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time

Definition at line 163 of file lapmessage_p.h.

◆ avgPowerPosition

quint16 LapMessagePrivate::avgPowerPosition

The LapMessage FIT message's avgPowerPosition field.

Average power by position. Data value indexes defined by rider_position_type.

Definition at line 552 of file lapmessage_p.h.

◆ avgRightPco

qint8 LapMessagePrivate::avgRightPco

The LapMessage FIT message's avgRightPco field.

Average right platform center offset

Definition at line 517 of file lapmessage_p.h.

◆ avgRightPowerPhase

quint8 LapMessagePrivate::avgRightPowerPhase

The LapMessage FIT message's avgRightPowerPhase field.

Average right power phase angles. Data value indexes defined by power_phase_type.

Definition at line 538 of file lapmessage_p.h.

◆ avgRightPowerPhasePeak

quint8 LapMessagePrivate::avgRightPowerPhasePeak

The LapMessage FIT message's avgRightPowerPhasePeak field.

Average right power phase peak angles. Data value indexes defined by power_phase_type.

Definition at line 545 of file lapmessage_p.h.

◆ avgSaturatedHemoglobinPercent

quint16 LapMessagePrivate::avgSaturatedHemoglobinPercent

The LapMessage FIT message's avgSaturatedHemoglobinPercent field.

Avg percentage of hemoglobin saturated with oxygen

Definition at line 450 of file lapmessage_p.h.

◆ avgTotalHemoglobinConc

quint16 LapMessagePrivate::avgTotalHemoglobinConc

The LapMessage FIT message's avgTotalHemoglobinConc field.

Avg saturated and unsaturated hemoglobin

Definition at line 429 of file lapmessage_p.h.

◆ levBatteryConsumption

quint8 LapMessagePrivate::levBatteryConsumption

The LapMessage FIT message's levBatteryConsumption field.

lev battery consumption during lap

Definition at line 619 of file lapmessage_p.h.

◆ maxCadencePosition

quint8 LapMessagePrivate::maxCadencePosition

The LapMessage FIT message's maxCadencePosition field.

Maximum cadence by position. Data value indexes defined by rider_position_type.

Definition at line 573 of file lapmessage_p.h.

◆ maxFractionalCadence

quint8 LapMessagePrivate::maxFractionalCadence

The LapMessage FIT message's maxFractionalCadence field.

fractional part of the max_cadence

Definition at line 410 of file lapmessage_p.h.

◆ maxLevMotorPower

quint16 LapMessagePrivate::maxLevMotorPower

The LapMessage FIT message's maxLevMotorPower field.

lev maximum motor power during lap

Definition at line 612 of file lapmessage_p.h.

◆ maxPowerPosition

quint16 LapMessagePrivate::maxPowerPosition

The LapMessage FIT message's maxPowerPosition field.

Maximum power by position. Data value indexes defined by rider_position_type.

Definition at line 559 of file lapmessage_p.h.

◆ maxSaturatedHemoglobinPercent

quint16 LapMessagePrivate::maxSaturatedHemoglobinPercent

The LapMessage FIT message's maxSaturatedHemoglobinPercent field.

Max percentage of hemoglobin saturated with oxygen

Definition at line 464 of file lapmessage_p.h.

◆ maxTotalHemoglobinConc

quint16 LapMessagePrivate::maxTotalHemoglobinConc

The LapMessage FIT message's maxTotalHemoglobinConc field.

Max saturated and unsaturated hemoglobin

Definition at line 443 of file lapmessage_p.h.

◆ minSaturatedHemoglobinPercent

quint16 LapMessagePrivate::minSaturatedHemoglobinPercent

The LapMessage FIT message's minSaturatedHemoglobinPercent field.

Min percentage of hemoglobin saturated with oxygen

Definition at line 457 of file lapmessage_p.h.

◆ minTotalHemoglobinConc

quint16 LapMessagePrivate::minTotalHemoglobinConc

The LapMessage FIT message's minTotalHemoglobinConc field.

Min saturated and unsaturated hemoglobin

Definition at line 436 of file lapmessage_p.h.

◆ numActiveLengths

quint16 LapMessagePrivate::numActiveLengths

The LapMessage FIT message's numActiveLengths field.

of active lengths of swim pool

Definition at line 242 of file lapmessage_p.h.

◆ numLengths

quint16 LapMessagePrivate::numLengths

The LapMessage FIT message's numLengths field.

of lengths of swim pool

Definition at line 205 of file lapmessage_p.h.

◆ standCount

quint16 LapMessagePrivate::standCount

The LapMessage FIT message's standCount field.

Number of transitions to the standing state

Definition at line 503 of file lapmessage_p.h.

◆ strokeCount

quint16 LapMessagePrivate::strokeCount

The LapMessage FIT message's strokeCount field.

stroke_type enum used as the index

Definition at line 374 of file lapmessage_p.h.

◆ timestamp

DateTime LapMessagePrivate::timestamp

The LapMessage FIT message's timestamp field.

Lap end time.

Definition at line 51 of file lapmessage_p.h.

◆ timeStanding

quint32 LapMessagePrivate::timeStanding

The LapMessage FIT message's timeStanding field.

Total time spent in the standing position

Definition at line 496 of file lapmessage_p.h.

◆ totalElapsedTime

quint32 LapMessagePrivate::totalElapsedTime

The LapMessage FIT message's totalElapsedTime field.

Time (includes pauses)

Definition at line 93 of file lapmessage_p.h.

◆ totalFatCalories

quint16 LapMessagePrivate::totalFatCalories

The LapMessage FIT message's totalFatCalories field.

If New Leaf

Definition at line 122 of file lapmessage_p.h.

◆ totalFlow

float LapMessagePrivate::totalFlow

The LapMessage FIT message's totalFlow 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 655 of file lapmessage_p.h.

◆ totalFractionalAscent

quint8 LapMessagePrivate::totalFractionalAscent

The LapMessage FIT message's totalFractionalAscent field.

fractional part of total_ascent

Definition at line 683 of file lapmessage_p.h.

◆ totalFractionalCycles

quint8 LapMessagePrivate::totalFractionalCycles

The LapMessage FIT message's totalFractionalCycles field.

fractional part of the total_cycles

Definition at line 417 of file lapmessage_p.h.

◆ totalFractionalDescent

quint8 LapMessagePrivate::totalFractionalDescent

The LapMessage FIT message's totalFractionalDescent field.

fractional part of total_descent

Definition at line 690 of file lapmessage_p.h.

◆ totalGrit

float LapMessagePrivate::totalGrit

The LapMessage FIT message's totalGrit field.