Inheritance diagram for SessionMessagePrivate:

Collaboration diagram for SessionMessagePrivate:

Public Member Functions
	SessionMessagePrivate (SessionMessage *const q)

virtual	~SessionMessagePrivate ()

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 SessionMessage FIT message's messageIndex field. More...

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

Event	event
	The SessionMessage FIT message's event field. More...

EventType	eventType
	The SessionMessage FIT message's eventType field. More...

DateTime	startTime
	The SessionMessage FIT message's startTime field.

qint32	startPositionLat
	The SessionMessage FIT message's startPositionLat field.

qint32	startPositionLong
	The SessionMessage FIT message's startPositionLong field.

Sport	sport
	The SessionMessage FIT message's sport field.

SubSport	subSport
	The SessionMessage FIT message's subSport field.

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

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

quint32	totalDistance
	The SessionMessage FIT message's totalDistance field.

quint32	totalCycles
	The SessionMessage FIT message's totalCycles field.

quint16	totalCalories
	The SessionMessage FIT message's totalCalories field.

quint16	totalFatCalories
	The SessionMessage FIT message's totalFatCalories field.

quint16	avgSpeed
	The SessionMessage FIT message's avgSpeed field. More...

quint16	maxSpeed
	The SessionMessage FIT message's maxSpeed field.

quint8	avgHeartRate
	The SessionMessage FIT message's avgHeartRate field. More...

quint8	maxHeartRate
	The SessionMessage FIT message's maxHeartRate field.

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

quint8	maxCadence
	The SessionMessage FIT message's maxCadence field.

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

quint16	maxPower
	The SessionMessage FIT message's maxPower field.

quint16	totalAscent
	The SessionMessage FIT message's totalAscent field.

quint16	totalDescent
	The SessionMessage FIT message's totalDescent field.

quint8	totalTrainingEffect
	The SessionMessage FIT message's totalTrainingEffect field.

quint16	firstLapIndex
	The SessionMessage FIT message's firstLapIndex field.

quint16	numLaps
	The SessionMessage FIT message's numLaps field.

quint8	eventGroup
	The SessionMessage FIT message's eventGroup field.

SessionTrigger	trigger
	The SessionMessage FIT message's trigger field.

qint32	necLat
	The SessionMessage FIT message's necLat field. More...

qint32	necLong
	The SessionMessage FIT message's necLong field. More...

qint32	swcLat
	The SessionMessage FIT message's swcLat field. More...

qint32	swcLong
	The SessionMessage FIT message's swcLong field. More...

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

quint16	normalizedPower
	The SessionMessage FIT message's normalizedPower field.

quint16	trainingStressScore
	The SessionMessage FIT message's trainingStressScore field.

quint16	intensityFactor
	The SessionMessage FIT message's intensityFactor field.

LeftRightBalance100	leftRightBalance
	The SessionMessage FIT message's leftRightBalance field.

quint32	avgStrokeCount
	The SessionMessage FIT message's avgStrokeCount field.

quint16	avgStrokeDistance
	The SessionMessage FIT message's avgStrokeDistance field.

SwimStroke	swimStroke
	The SessionMessage FIT message's swimStroke field.

quint16	poolLength
	The SessionMessage FIT message's poolLength field.

quint16	thresholdPower
	The SessionMessage FIT message's thresholdPower field.

DisplayMeasure	poolLengthUnit
	The SessionMessage FIT message's poolLengthUnit field.

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

quint32	totalWork
	The SessionMessage FIT message's totalWork field.

quint16	avgAltitude
	The SessionMessage FIT message's avgAltitude field.

quint16	maxAltitude
	The SessionMessage FIT message's maxAltitude field.

quint8	gpsAccuracy
	The SessionMessage FIT message's gpsAccuracy field.

qint16	avgGrade
	The SessionMessage FIT message's avgGrade field.

qint16	avgPosGrade
	The SessionMessage FIT message's avgPosGrade field.

qint16	avgNegGrade
	The SessionMessage FIT message's avgNegGrade field.

qint16	maxPosGrade
	The SessionMessage FIT message's maxPosGrade field.

qint16	maxNegGrade
	The SessionMessage FIT message's maxNegGrade field.

qint8	avgTemperature
	The SessionMessage FIT message's avgTemperature field.

qint8	maxTemperature
	The SessionMessage FIT message's maxTemperature field.

quint32	totalMovingTime
	The SessionMessage FIT message's totalMovingTime field.

qint16	avgPosVerticalSpeed
	The SessionMessage FIT message's avgPosVerticalSpeed field.

qint16	avgNegVerticalSpeed
	The SessionMessage FIT message's avgNegVerticalSpeed field.

qint16	maxPosVerticalSpeed
	The SessionMessage FIT message's maxPosVerticalSpeed field.

qint16	maxNegVerticalSpeed
	The SessionMessage FIT message's maxNegVerticalSpeed field.

quint8	minHeartRate
	The SessionMessage FIT message's minHeartRate field.

quint32	timeInHrZone
	The SessionMessage FIT message's timeInHrZone field.

quint32	timeInSpeedZone
	The SessionMessage FIT message's timeInSpeedZone field.

quint32	timeInCadenceZone
	The SessionMessage FIT message's timeInCadenceZone field.

quint32	timeInPowerZone
	The SessionMessage FIT message's timeInPowerZone field.

quint32	avgLapTime
	The SessionMessage FIT message's avgLapTime field.

quint16	bestLapIndex
	The SessionMessage FIT message's bestLapIndex field.

quint16	minAltitude
	The SessionMessage FIT message's minAltitude field.

quint16	playerScore
	The SessionMessage FIT message's playerScore field.

quint16	opponentScore
	The SessionMessage FIT message's opponentScore field.

QString	opponentName
	The SessionMessage FIT message's opponentName field.

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

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

quint16	maxBallSpeed
	The SessionMessage FIT message's maxBallSpeed field.

quint16	avgBallSpeed
	The SessionMessage FIT message's avgBallSpeed field.

quint16	avgVerticalOscillation
	The SessionMessage FIT message's avgVerticalOscillation field.

quint16	avgStanceTimePercent
	The SessionMessage FIT message's avgStanceTimePercent field.

quint16	avgStanceTime
	The SessionMessage FIT message's avgStanceTime field.

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

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

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

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

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

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

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

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

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

quint8	avgLeftTorqueEffectiveness
	The SessionMessage FIT message's avgLeftTorqueEffectiveness field.

quint8	avgRightTorqueEffectiveness
	The SessionMessage FIT message's avgRightTorqueEffectiveness field.

quint8	avgLeftPedalSmoothness
	The SessionMessage FIT message's avgLeftPedalSmoothness field.

quint8	avgRightPedalSmoothness
	The SessionMessage FIT message's avgRightPedalSmoothness field.

quint8	avgCombinedPedalSmoothness
	The SessionMessage FIT message's avgCombinedPedalSmoothness field.

quint8	sportIndex
	The SessionMessage FIT message's sportIndex field.

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

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

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

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

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

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

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

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

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

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

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

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

quint32	enhancedAvgSpeed
	The SessionMessage FIT message's enhancedAvgSpeed field. More...

quint32	enhancedMaxSpeed
	The SessionMessage FIT message's enhancedMaxSpeed field.

quint32	enhancedAvgAltitude
	The SessionMessage FIT message's enhancedAvgAltitude field.

quint32	enhancedMinAltitude
	The SessionMessage FIT message's enhancedMinAltitude field.

quint32	enhancedMaxAltitude
	The SessionMessage FIT message's enhancedMaxAltitude field.

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

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

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

quint16	avgVerticalRatio
	The SessionMessage FIT message's avgVerticalRatio field.

quint16	avgStanceTimeBalance
	The SessionMessage FIT message's avgStanceTimeBalance field.

quint16	avgStepLength
	The SessionMessage FIT message's avgStepLength field.

quint8	totalAnaerobicTrainingEffect
	The SessionMessage FIT message's totalAnaerobicTrainingEffect field.

quint16	avgVam
	The SessionMessage FIT message's avgVam field.

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

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

quint16	jumpCount
	The SessionMessage FIT message's jumpCount field.

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

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

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

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

quint16	avgCoreTemperature
	The SessionMessage FIT message's avgCoreTemperature field.

quint16	minCoreTemperature
	The SessionMessage FIT message's minCoreTemperature field.

quint16	maxCoreTemperature
	The SessionMessage 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 SessionMessagePrivate class provides private implementation for the SessionMessage.

See also: SessionMessage

Definition at line 38 of file sessionmessage_p.h.

Constructor & Destructor Documentation

◆ SessionMessagePrivate()

SessionMessagePrivate::SessionMessagePrivate ( SessionMessage *const q )

explicit

Constructs a SessionMessagePrivate object with public implementation q.

Parameters

q	Pointer to public implementaton.

Definition at line 2923 of file sessionmessage.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)
   , sport(static_cast<Sport>(-1))
   , subSport(static_cast<SubSport>(-1))
   , 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)
   , totalTrainingEffect(0xFF)
   , firstLapIndex(0xFFFF)
   , numLaps(0xFFFF)
   , eventGroup(0xFF)
   , trigger(static_cast<SessionTrigger>(-1))
   , necLat(0x7FFFFFFF)
   , necLong(0x7FFFFFFF)
   , swcLat(0x7FFFFFFF)
   , swcLong(0x7FFFFFFF)
   , numLengths(0xFFFF)
   , normalizedPower(0xFFFF)
   , trainingStressScore(0xFFFF)
   , intensityFactor(0xFFFF)
   , leftRightBalance(static_cast<LeftRightBalance100>(-1))
   , avgStrokeCount(0xFFFFFFFF)
   , avgStrokeDistance(0xFFFF)
   , swimStroke(static_cast<SwimStroke>(-1))
   , poolLength(0xFFFF)
   , thresholdPower(0xFFFF)
   , poolLengthUnit(static_cast<DisplayMeasure>(-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)
   , minHeartRate(0xFF)
   , timeInHrZone(0xFFFFFFFF)
   , timeInSpeedZone(0xFFFFFFFF)
   , timeInCadenceZone(0xFFFFFFFF)
   , timeInPowerZone(0xFFFFFFFF)
   , avgLapTime(0xFFFFFFFF)
   , bestLapIndex(0xFFFF)
   , minAltitude(0xFFFF)
   , playerScore(0xFFFF)
   , opponentScore(0xFFFF)
   , strokeCount(0xFFFF)
   , zoneCount(0xFFFF)
   , maxBallSpeed(0xFFFF)
   , avgBallSpeed(0xFFFF)
   , avgVerticalOscillation(0xFFFF)
   , avgStanceTimePercent(0xFFFF)
   , avgStanceTime(0xFFFF)
   , avgFractionalCadence(0xFF)
   , maxFractionalCadence(0xFF)
   , totalFractionalCycles(0xFF)
   , avgTotalHemoglobinConc(0xFFFF)
   , minTotalHemoglobinConc(0xFFFF)
   , maxTotalHemoglobinConc(0xFFFF)
   , avgSaturatedHemoglobinPercent(0xFFFF)
   , minSaturatedHemoglobinPercent(0xFFFF)
   , maxSaturatedHemoglobinPercent(0xFFFF)
   , avgLeftTorqueEffectiveness(0xFF)
   , avgRightTorqueEffectiveness(0xFF)
   , avgLeftPedalSmoothness(0xFF)
   , avgRightPedalSmoothness(0xFF)
   , avgCombinedPedalSmoothness(0xFF)
   , sportIndex(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)
   , totalAnaerobicTrainingEffect(0xFF)
   , 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::Session;
 }

References AbstractDataMessagePrivate::globalMessageNumber.

◆ ~SessionMessagePrivate()

SessionMessagePrivate::~SessionMessagePrivate ( )

virtual

Destroys the SessionMessagePrivate object.

Definition at line 3063 of file sessionmessage.cpp.

 {
  
 }

Member Function Documentation

◆ setField()

bool SessionMessagePrivate::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 3068 of file sessionmessage.cpp.

 {
     switch (fieldId) {
     case 254: // See Profile.xlsx::Messages:session.messageIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.messageIndex")) return false;
         this->messageIndex = static_cast<MessageIndex>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 253: // See Profile.xlsx::Messages:session.timestamp
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timestamp")) return false;
         this->timestamp = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 0: // See Profile.xlsx::Messages:session.event
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.event")) return false;
         this->event = static_cast<Event>(data.at(0));
         break;
     case 1: // See Profile.xlsx::Messages:session.eventType
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.eventType")) return false;
         this->eventType = static_cast<EventType>(data.at(0));
         break;
     case 2: // See Profile.xlsx::Messages:session.startTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.startTime")) return false;
         this->startTime = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 3: // See Profile.xlsx::Messages:session.startPositionLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.startPositionLat")) return false;
         this->startPositionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 4: // See Profile.xlsx::Messages:session.startPositionLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.startPositionLong")) return false;
         this->startPositionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 5: // See Profile.xlsx::Messages:session.sport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.sport")) return false;
         this->sport = static_cast<Sport>(data.at(0));
         break;
     case 6: // See Profile.xlsx::Messages:session.subSport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.subSport")) return false;
         this->subSport = static_cast<SubSport>(data.at(0));
         break;
     case 7: // See Profile.xlsx::Messages:session.totalElapsedTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalElapsedTime")) return false;
         this->totalElapsedTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 8: // See Profile.xlsx::Messages:session.totalTimerTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalTimerTime")) return false;
         this->totalTimerTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 9: // See Profile.xlsx::Messages:session.totalDistance
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalDistance")) return false;
         this->totalDistance = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 10: // See Profile.xlsx::Messages:session.totalCycles
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalCycles")) return false;
         this->totalCycles = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 11: // See Profile.xlsx::Messages:session.totalCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.totalCalories")) return false;
         this->totalCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 13: // See Profile.xlsx::Messages:session.totalFatCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.totalFatCalories")) return false;
         this->totalFatCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 14: // See Profile.xlsx::Messages:session.avgSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgSpeed")) return false;
         this->avgSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 15: // See Profile.xlsx::Messages:session.maxSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxSpeed")) return false;
         this->maxSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 16: // See Profile.xlsx::Messages:session.avgHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgHeartRate")) return false;
         this->avgHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 17: // See Profile.xlsx::Messages:session.maxHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.maxHeartRate")) return false;
         this->maxHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 18: // See Profile.xlsx::Messages:session.avgCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgCadence")) return false;
         this->avgCadence = static_cast<quint8>(data.at(0));
         break;
     case 19: // See Profile.xlsx::Messages:session.maxCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.maxCadence")) return false;
         this->maxCadence = static_cast<quint8>(data.at(0));
         break;
     case 20: // See Profile.xlsx::Messages:session.avgPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgPower")) return false;
         this->avgPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 21: // See Profile.xlsx::Messages:session.maxPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxPower")) return false;
         this->maxPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 22: // See Profile.xlsx::Messages:session.totalAscent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.totalAscent")) return false;
         this->totalAscent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 23: // See Profile.xlsx::Messages:session.totalDescent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.totalDescent")) return false;
         this->totalDescent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 24: // See Profile.xlsx::Messages:session.totalTrainingEffect
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.totalTrainingEffect")) return false;
         this->totalTrainingEffect = static_cast<quint8>(data.at(0));
         break;
     case 25: // See Profile.xlsx::Messages:session.firstLapIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.firstLapIndex")) return false;
         this->firstLapIndex = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 26: // See Profile.xlsx::Messages:session.numLaps
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.numLaps")) return false;
         this->numLaps = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 27: // See Profile.xlsx::Messages:session.eventGroup
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.eventGroup")) return false;
         this->eventGroup = static_cast<quint8>(data.at(0));
         break;
     case 28: // See Profile.xlsx::Messages:session.trigger
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.trigger")) return false;
         this->trigger = static_cast<SessionTrigger>(data.at(0));
         break;
     case 29: // See Profile.xlsx::Messages:session.necLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.necLat")) return false;
         this->necLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 30: // See Profile.xlsx::Messages:session.necLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.necLong")) return false;
         this->necLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 31: // See Profile.xlsx::Messages:session.swcLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.swcLat")) return false;
         this->swcLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 32: // See Profile.xlsx::Messages:session.swcLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "session.swcLong")) return false;
         this->swcLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 33: // See Profile.xlsx::Messages:session.numLengths
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.numLengths")) return false;
         this->numLengths = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 34: // See Profile.xlsx::Messages:session.normalizedPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.normalizedPower")) return false;
         this->normalizedPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 35: // See Profile.xlsx::Messages:session.trainingStressScore
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.trainingStressScore")) return false;
         this->trainingStressScore = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 36: // See Profile.xlsx::Messages:session.intensityFactor
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.intensityFactor")) return false;
         this->intensityFactor = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 37: // See Profile.xlsx::Messages:session.leftRightBalance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.leftRightBalance")) return false;
         this->leftRightBalance = static_cast<LeftRightBalance100>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 41: // See Profile.xlsx::Messages:session.avgStrokeCount
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.avgStrokeCount")) return false;
         this->avgStrokeCount = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 42: // See Profile.xlsx::Messages:session.avgStrokeDistance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgStrokeDistance")) return false;
         this->avgStrokeDistance = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 43: // See Profile.xlsx::Messages:session.swimStroke
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.swimStroke")) return false;
         this->swimStroke = static_cast<SwimStroke>(data.at(0));
         break;
     case 44: // See Profile.xlsx::Messages:session.poolLength
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.poolLength")) return false;
         this->poolLength = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 45: // See Profile.xlsx::Messages:session.thresholdPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.thresholdPower")) return false;
         this->thresholdPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 46: // See Profile.xlsx::Messages:session.poolLengthUnit
         if (!verify(data, baseType, 1, FitBaseType::Enum, "session.poolLengthUnit")) return false;
         this->poolLengthUnit = static_cast<DisplayMeasure>(data.at(0));
         break;
     case 47: // See Profile.xlsx::Messages:session.numActiveLengths
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.numActiveLengths")) return false;
         this->numActiveLengths = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 48: // See Profile.xlsx::Messages:session.totalWork
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalWork")) return false;
         this->totalWork = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 49: // See Profile.xlsx::Messages:session.avgAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgAltitude")) return false;
         this->avgAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 50: // See Profile.xlsx::Messages:session.maxAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxAltitude")) return false;
         this->maxAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 51: // See Profile.xlsx::Messages:session.gpsAccuracy
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.gpsAccuracy")) return false;
         this->gpsAccuracy = static_cast<quint8>(data.at(0));
         break;
     case 52: // See Profile.xlsx::Messages:session.avgGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.avgGrade")) return false;
         this->avgGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 53: // See Profile.xlsx::Messages:session.avgPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.avgPosGrade")) return false;
         this->avgPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 54: // See Profile.xlsx::Messages:session.avgNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.avgNegGrade")) return false;
         this->avgNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 55: // See Profile.xlsx::Messages:session.maxPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.maxPosGrade")) return false;
         this->maxPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 56: // See Profile.xlsx::Messages:session.maxNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.maxNegGrade")) return false;
         this->maxNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 57: // See Profile.xlsx::Messages:session.avgTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "session.avgTemperature")) return false;
         this->avgTemperature = static_cast<qint8>(data.at(0));
         break;
     case 58: // See Profile.xlsx::Messages:session.maxTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "session.maxTemperature")) return false;
         this->maxTemperature = static_cast<qint8>(data.at(0));
         break;
     case 59: // See Profile.xlsx::Messages:session.totalMovingTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.totalMovingTime")) return false;
         this->totalMovingTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 60: // See Profile.xlsx::Messages:session.avgPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.avgPosVerticalSpeed")) return false;
         this->avgPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 61: // See Profile.xlsx::Messages:session.avgNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.avgNegVerticalSpeed")) return false;
         this->avgNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 62: // See Profile.xlsx::Messages:session.maxPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.maxPosVerticalSpeed")) return false;
         this->maxPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 63: // See Profile.xlsx::Messages:session.maxNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "session.maxNegVerticalSpeed")) return false;
         this->maxNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 64: // See Profile.xlsx::Messages:session.minHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.minHeartRate")) return false;
         this->minHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 65: // See Profile.xlsx::Messages:session.timeInHrZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timeInHrZone")) return false;
         this->timeInHrZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 66: // See Profile.xlsx::Messages:session.timeInSpeedZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timeInSpeedZone")) return false;
         this->timeInSpeedZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 67: // See Profile.xlsx::Messages:session.timeInCadenceZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timeInCadenceZone")) return false;
         this->timeInCadenceZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 68: // See Profile.xlsx::Messages:session.timeInPowerZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timeInPowerZone")) return false;
         this->timeInPowerZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 69: // See Profile.xlsx::Messages:session.avgLapTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.avgLapTime")) return false;
         this->avgLapTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 70: // See Profile.xlsx::Messages:session.bestLapIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.bestLapIndex")) return false;
         this->bestLapIndex = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 71: // See Profile.xlsx::Messages:session.minAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.minAltitude")) return false;
         this->minAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 82: // See Profile.xlsx::Messages:session.playerScore
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.playerScore")) return false;
         this->playerScore = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 83: // See Profile.xlsx::Messages:session.opponentScore
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.opponentScore")) return false;
         this->opponentScore = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 84: // See Profile.xlsx::Messages:session.opponentName
         if (!verify(data, baseType, 1, FitBaseType::String, "session.opponentName")) return false;
         this->opponentName = QString::fromUtf8(data);
         break;
     case 85: // See Profile.xlsx::Messages:session.strokeCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.strokeCount")) return false;
         this->strokeCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 86: // See Profile.xlsx::Messages:session.zoneCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.zoneCount")) return false;
         this->zoneCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 87: // See Profile.xlsx::Messages:session.maxBallSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxBallSpeed")) return false;
         this->maxBallSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 88: // See Profile.xlsx::Messages:session.avgBallSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgBallSpeed")) return false;
         this->avgBallSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 89: // See Profile.xlsx::Messages:session.avgVerticalOscillation
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgVerticalOscillation")) return false;
         this->avgVerticalOscillation = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 90: // See Profile.xlsx::Messages:session.avgStanceTimePercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgStanceTimePercent")) return false;
         this->avgStanceTimePercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 91: // See Profile.xlsx::Messages:session.avgStanceTime
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgStanceTime")) return false;
         this->avgStanceTime = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 92: // See Profile.xlsx::Messages:session.avgFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgFractionalCadence")) return false;
         this->avgFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 93: // See Profile.xlsx::Messages:session.maxFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.maxFractionalCadence")) return false;
         this->maxFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 94: // See Profile.xlsx::Messages:session.totalFractionalCycles
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.totalFractionalCycles")) return false;
         this->totalFractionalCycles = static_cast<quint8>(data.at(0));
         break;
     case 95: // See Profile.xlsx::Messages:session.avgTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgTotalHemoglobinConc")) return false;
         this->avgTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 96: // See Profile.xlsx::Messages:session.minTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.minTotalHemoglobinConc")) return false;
         this->minTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 97: // See Profile.xlsx::Messages:session.maxTotalHemoglobinConc
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxTotalHemoglobinConc")) return false;
         this->maxTotalHemoglobinConc = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 98: // See Profile.xlsx::Messages:session.avgSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgSaturatedHemoglobinPercent")) return false;
         this->avgSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 99: // See Profile.xlsx::Messages:session.minSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.minSaturatedHemoglobinPercent")) return false;
         this->minSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 100: // See Profile.xlsx::Messages:session.maxSaturatedHemoglobinPercent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxSaturatedHemoglobinPercent")) return false;
         this->maxSaturatedHemoglobinPercent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 101: // See Profile.xlsx::Messages:session.avgLeftTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgLeftTorqueEffectiveness")) return false;
         this->avgLeftTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 102: // See Profile.xlsx::Messages:session.avgRightTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgRightTorqueEffectiveness")) return false;
         this->avgRightTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 103: // See Profile.xlsx::Messages:session.avgLeftPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgLeftPedalSmoothness")) return false;
         this->avgLeftPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 104: // See Profile.xlsx::Messages:session.avgRightPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgRightPedalSmoothness")) return false;
         this->avgRightPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 105: // See Profile.xlsx::Messages:session.avgCombinedPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgCombinedPedalSmoothness")) return false;
         this->avgCombinedPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 111: // See Profile.xlsx::Messages:session.sportIndex
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.sportIndex")) return false;
         this->sportIndex = static_cast<quint8>(data.at(0));
         break;
     case 112: // See Profile.xlsx::Messages:session.timeStanding
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.timeStanding")) return false;
         this->timeStanding = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 113: // See Profile.xlsx::Messages:session.standCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.standCount")) return false;
         this->standCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 114: // See Profile.xlsx::Messages:session.avgLeftPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "session.avgLeftPco")) return false;
         this->avgLeftPco = static_cast<qint8>(data.at(0));
         break;
     case 115: // See Profile.xlsx::Messages:session.avgRightPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "session.avgRightPco")) return false;
         this->avgRightPco = static_cast<qint8>(data.at(0));
         break;
     case 116: // See Profile.xlsx::Messages:session.avgLeftPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgLeftPowerPhase")) return false;
         this->avgLeftPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 117: // See Profile.xlsx::Messages:session.avgLeftPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgLeftPowerPhasePeak")) return false;
         this->avgLeftPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 118: // See Profile.xlsx::Messages:session.avgRightPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgRightPowerPhase")) return false;
         this->avgRightPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 119: // See Profile.xlsx::Messages:session.avgRightPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgRightPowerPhasePeak")) return false;
         this->avgRightPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 120: // See Profile.xlsx::Messages:session.avgPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgPowerPosition")) return false;
         this->avgPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 121: // See Profile.xlsx::Messages:session.maxPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxPowerPosition")) return false;
         this->maxPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 122: // See Profile.xlsx::Messages:session.avgCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.avgCadencePosition")) return false;
         this->avgCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 123: // See Profile.xlsx::Messages:session.maxCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.maxCadencePosition")) return false;
         this->maxCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 124: // See Profile.xlsx::Messages:session.enhancedAvgSpeed
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.enhancedAvgSpeed")) return false;
         this->enhancedAvgSpeed = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 125: // See Profile.xlsx::Messages:session.enhancedMaxSpeed
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.enhancedMaxSpeed")) return false;
         this->enhancedMaxSpeed = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 126: // See Profile.xlsx::Messages:session.enhancedAvgAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.enhancedAvgAltitude")) return false;
         this->enhancedAvgAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 127: // See Profile.xlsx::Messages:session.enhancedMinAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.enhancedMinAltitude")) return false;
         this->enhancedMinAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 128: // See Profile.xlsx::Messages:session.enhancedMaxAltitude
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "session.enhancedMaxAltitude")) return false;
         this->enhancedMaxAltitude = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 129: // See Profile.xlsx::Messages:session.avgLevMotorPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgLevMotorPower")) return false;
         this->avgLevMotorPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 130: // See Profile.xlsx::Messages:session.maxLevMotorPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxLevMotorPower")) return false;
         this->maxLevMotorPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 131: // See Profile.xlsx::Messages:session.levBatteryConsumption
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.levBatteryConsumption")) return false;
         this->levBatteryConsumption = static_cast<quint8>(data.at(0));
         break;
     case 132: // See Profile.xlsx::Messages:session.avgVerticalRatio
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgVerticalRatio")) return false;
         this->avgVerticalRatio = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 133: // See Profile.xlsx::Messages:session.avgStanceTimeBalance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgStanceTimeBalance")) return false;
         this->avgStanceTimeBalance = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 134: // See Profile.xlsx::Messages:session.avgStepLength
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgStepLength")) return false;
         this->avgStepLength = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 137: // See Profile.xlsx::Messages:session.totalAnaerobicTrainingEffect
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.totalAnaerobicTrainingEffect")) return false;
         this->totalAnaerobicTrainingEffect = static_cast<quint8>(data.at(0));
         break;
     case 139: // See Profile.xlsx::Messages:session.avgVam
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgVam")) return false;
         this->avgVam = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 181: // See Profile.xlsx::Messages:session.totalGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "session.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 182: // See Profile.xlsx::Messages:session.totalFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "session.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 183: // See Profile.xlsx::Messages:session.jumpCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.jumpCount")) return false;
         this->jumpCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 186: // See Profile.xlsx::Messages:session.avgGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "session.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 187: // See Profile.xlsx::Messages:session.avgFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "session.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 199: // See Profile.xlsx::Messages:session.totalFractionalAscent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.totalFractionalAscent")) return false;
         this->totalFractionalAscent = static_cast<quint8>(data.at(0));
         break;
     case 200: // See Profile.xlsx::Messages:session.totalFractionalDescent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "session.totalFractionalDescent")) return false;
         this->totalFractionalDescent = static_cast<quint8>(data.at(0));
         break;
     case 208: // See Profile.xlsx::Messages:session.avgCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.avgCoreTemperature")) return false;
         this->avgCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 209: // See Profile.xlsx::Messages:session.minCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.minCoreTemperature")) return false;
         this->minCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 210: // See Profile.xlsx::Messages:session.maxCoreTemperature
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "session.maxCoreTemperature")) return false;
         this->maxCoreTemperature = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     default:
         qWarning() << "ignoring unknown session 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 SessionMessagePrivate::avgCadence

The SessionMessage FIT message's avgCadence field.

total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time

Definition at line 158 of file sessionmessage_p.h.

◆ avgCadencePosition

quint8 SessionMessagePrivate::avgCadencePosition

The SessionMessage FIT message's avgCadencePosition field.

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

Definition at line 647 of file sessionmessage_p.h.

◆ avgFlow

float SessionMessagePrivate::avgFlow

The SessionMessage 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 764 of file sessionmessage_p.h.

◆ avgFractionalCadence

quint8 SessionMessagePrivate::avgFractionalCadence

The SessionMessage FIT message's avgFractionalCadence field.

fractional part of the avg_cadence

Definition at line 484 of file sessionmessage_p.h.

◆ avgGrit

float SessionMessagePrivate::avgGrit

The SessionMessage 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 756 of file sessionmessage_p.h.

◆ avgHeartRate

quint8 SessionMessagePrivate::avgHeartRate

The SessionMessage FIT message's avgHeartRate field.

average heart rate (excludes pause time)

Definition at line 145 of file sessionmessage_p.h.

◆ avgLeftPco

qint8 SessionMessagePrivate::avgLeftPco

The SessionMessage FIT message's avgLeftPco field.

Average platform center offset Left

Definition at line 591 of file sessionmessage_p.h.

◆ avgLeftPowerPhase

quint8 SessionMessagePrivate::avgLeftPowerPhase

The SessionMessage FIT message's avgLeftPowerPhase field.

Average left power phase angles. Indexes defined by power_phase_type.

Definition at line 605 of file sessionmessage_p.h.

◆ avgLeftPowerPhasePeak

quint8 SessionMessagePrivate::avgLeftPowerPhasePeak

The SessionMessage FIT message's avgLeftPowerPhasePeak field.

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

Definition at line 612 of file sessionmessage_p.h.

◆ avgLevMotorPower

quint16 SessionMessagePrivate::avgLevMotorPower

The SessionMessage FIT message's avgLevMotorPower field.

lev average motor power during session

Definition at line 688 of file sessionmessage_p.h.

◆ avgPower

quint16 SessionMessagePrivate::avgPower

The SessionMessage FIT message's avgPower field.

total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time

Definition at line 171 of file sessionmessage_p.h.

◆ avgPowerPosition

quint16 SessionMessagePrivate::avgPowerPosition

The SessionMessage FIT message's avgPowerPosition field.

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

Definition at line 633 of file sessionmessage_p.h.

◆ avgRightPco

qint8 SessionMessagePrivate::avgRightPco

The SessionMessage FIT message's avgRightPco field.

Average platform center offset Right

Definition at line 598 of file sessionmessage_p.h.

◆ avgRightPowerPhase

quint8 SessionMessagePrivate::avgRightPowerPhase

The SessionMessage FIT message's avgRightPowerPhase field.

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

Definition at line 619 of file sessionmessage_p.h.

◆ avgRightPowerPhasePeak

quint8 SessionMessagePrivate::avgRightPowerPhasePeak

The SessionMessage FIT message's avgRightPowerPhasePeak field.

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

Definition at line 626 of file sessionmessage_p.h.

◆ avgSaturatedHemoglobinPercent

quint16 SessionMessagePrivate::avgSaturatedHemoglobinPercent

The SessionMessage FIT message's avgSaturatedHemoglobinPercent field.

Avg percentage of hemoglobin saturated with oxygen

Definition at line 526 of file sessionmessage_p.h.

◆ avgSpeed

quint16 SessionMessagePrivate::avgSpeed

The SessionMessage FIT message's avgSpeed field.

total_distance / total_timer_time

Definition at line 133 of file sessionmessage_p.h.

◆ avgTotalHemoglobinConc

quint16 SessionMessagePrivate::avgTotalHemoglobinConc

The SessionMessage FIT message's avgTotalHemoglobinConc field.

Avg saturated and unsaturated hemoglobin

Definition at line 505 of file sessionmessage_p.h.

◆ enhancedAvgSpeed

quint32 SessionMessagePrivate::enhancedAvgSpeed

The SessionMessage FIT message's enhancedAvgSpeed field.

total_distance / total_timer_time

Definition at line 661 of file sessionmessage_p.h.

◆ event

Event SessionMessagePrivate::event

The SessionMessage FIT message's event field.

session

Definition at line 60 of file sessionmessage_p.h.

◆ eventType

EventType SessionMessagePrivate::eventType

The SessionMessage FIT message's eventType field.

stop

Definition at line 67 of file sessionmessage_p.h.

◆ levBatteryConsumption

quint8 SessionMessagePrivate::levBatteryConsumption

The SessionMessage FIT message's levBatteryConsumption field.

lev battery consumption during session

Definition at line 702 of file sessionmessage_p.h.

◆ maxCadencePosition

quint8 SessionMessagePrivate::maxCadencePosition

The SessionMessage FIT message's maxCadencePosition field.

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

Definition at line 654 of file sessionmessage_p.h.

◆ maxFractionalCadence

quint8 SessionMessagePrivate::maxFractionalCadence

The SessionMessage FIT message's maxFractionalCadence field.

fractional part of the max_cadence

Definition at line 491 of file sessionmessage_p.h.

◆ maxLevMotorPower

quint16 SessionMessagePrivate::maxLevMotorPower

The SessionMessage FIT message's maxLevMotorPower field.

lev maximum motor power during session

Definition at line 695 of file sessionmessage_p.h.

◆ maxPowerPosition

quint16 SessionMessagePrivate::maxPowerPosition

The SessionMessage FIT message's maxPowerPosition field.

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

Definition at line 640 of file sessionmessage_p.h.

◆ maxSaturatedHemoglobinPercent

quint16 SessionMessagePrivate::maxSaturatedHemoglobinPercent

The SessionMessage FIT message's maxSaturatedHemoglobinPercent field.

Max percentage of hemoglobin saturated with oxygen

Definition at line 540 of file sessionmessage_p.h.

◆ maxTotalHemoglobinConc

quint16 SessionMessagePrivate::maxTotalHemoglobinConc

The SessionMessage FIT message's maxTotalHemoglobinConc field.

Max saturated and unsaturated hemoglobin

Definition at line 519 of file sessionmessage_p.h.

◆ messageIndex

MessageIndex SessionMessagePrivate::messageIndex

The SessionMessage FIT message's messageIndex field.

Selected bit is set for the current session.

Definition at line 46 of file sessionmessage_p.h.

◆ minSaturatedHemoglobinPercent

quint16 SessionMessagePrivate::minSaturatedHemoglobinPercent

The SessionMessage FIT message's minSaturatedHemoglobinPercent field.

Min percentage of hemoglobin saturated with oxygen

Definition at line 533 of file sessionmessage_p.h.

◆ minTotalHemoglobinConc

quint16 SessionMessagePrivate::minTotalHemoglobinConc

The SessionMessage FIT message's minTotalHemoglobinConc field.

Min saturated and unsaturated hemoglobin

Definition at line 512 of file sessionmessage_p.h.

◆ necLat

qint32 SessionMessagePrivate::necLat

The SessionMessage FIT message's necLat field.

North east corner latitude

Definition at line 218 of file sessionmessage_p.h.

◆ necLong

qint32 SessionMessagePrivate::necLong

The SessionMessage FIT message's necLong field.

North east corner longitude

Definition at line 225 of file sessionmessage_p.h.

◆ numActiveLengths

quint16 SessionMessagePrivate::numActiveLengths

The SessionMessage FIT message's numActiveLengths field.

of active lengths of swim pool

Definition at line 303 of file sessionmessage_p.h.

◆ numLengths

quint16 SessionMessagePrivate::numLengths

The SessionMessage FIT message's numLengths field.

of lengths of swim pool

Definition at line 246 of file sessionmessage_p.h.

◆ standCount

quint16 SessionMessagePrivate::standCount

The SessionMessage FIT message's standCount field.

Number of transitions to the standing state

Definition at line 584 of file sessionmessage_p.h.

◆ strokeCount

quint16 SessionMessagePrivate::strokeCount

The SessionMessage FIT message's strokeCount field.

stroke_type enum used as the index

Definition at line 445 of file sessionmessage_p.h.

◆ swcLat

qint32 SessionMessagePrivate::swcLat

The SessionMessage FIT message's swcLat field.

South west corner latitude

Definition at line 232 of file sessionmessage_p.h.

◆ swcLong

qint32 SessionMessagePrivate::swcLong

The SessionMessage FIT message's swcLong field.

South west corner longitude

Definition at line 239 of file sessionmessage_p.h.

◆ timestamp

DateTime SessionMessagePrivate::timestamp

The SessionMessage FIT message's timestamp field.

Sesson end time.

Definition at line 53 of file sessionmessage_p.h.

◆ timeStanding

quint32 SessionMessagePrivate::timeStanding

The SessionMessage FIT message's timeStanding field.

Total time spend in the standing position

Definition at line 577 of file sessionmessage_p.h.

◆ totalElapsedTime

quint32 SessionMessagePrivate::totalElapsedTime

The SessionMessage FIT message's totalElapsedTime field.

Time (includes pauses)

Definition at line 99 of file sessionmessage_p.h.

◆ totalFlow

float SessionMessagePrivate::totalFlow

The SessionMessage 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 743 of file sessionmessage_p.h.

◆ totalFractionalAscent

quint8 SessionMessagePrivate::totalFractionalAscent

The SessionMessage FIT message's totalFractionalAscent field.

fractional part of total_ascent

Definition at line 771 of file sessionmessage_p.h.

◆ totalFractionalCycles

quint8 SessionMessagePrivate::totalFractionalCycles

The SessionMessage FIT message's totalFractionalCycles field.

fractional part of the total_cycles

Definition at line 498 of file sessionmessage_p.h.

◆ totalFractionalDescent

quint8 SessionMessagePrivate::totalFractionalDescent

The SessionMessage FIT message's totalFractionalDescent field.

fractional part of total_descent

Definition at line 778 of file sessionmessage_p.h.

◆ totalGrit

float SessionMessagePrivate::totalGrit

The SessionMessage FIT message's totalGrit field.