Inheritance diagram for SegmentLapMessagePrivate:

Collaboration diagram for SegmentLapMessagePrivate:

Public Member Functions
	SegmentLapMessagePrivate (SegmentLapMessage *const q)

virtual	~SegmentLapMessagePrivate ()

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

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

Event	event
	The SegmentLapMessage FIT message's event field.

EventType	eventType
	The SegmentLapMessage FIT message's eventType field.

DateTime	startTime
	The SegmentLapMessage FIT message's startTime field.

qint32	startPositionLat
	The SegmentLapMessage FIT message's startPositionLat field.

qint32	startPositionLong
	The SegmentLapMessage FIT message's startPositionLong field.

qint32	endPositionLat
	The SegmentLapMessage FIT message's endPositionLat field.

qint32	endPositionLong
	The SegmentLapMessage FIT message's endPositionLong field.

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

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

quint32	totalDistance
	The SegmentLapMessage FIT message's totalDistance field.

quint32	totalCycles
	The SegmentLapMessage FIT message's totalCycles field.

quint16	totalCalories
	The SegmentLapMessage FIT message's totalCalories field.

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

quint16	avgSpeed
	The SegmentLapMessage FIT message's avgSpeed field.

quint16	maxSpeed
	The SegmentLapMessage FIT message's maxSpeed field.

quint8	avgHeartRate
	The SegmentLapMessage FIT message's avgHeartRate field.

quint8	maxHeartRate
	The SegmentLapMessage FIT message's maxHeartRate field.

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

quint8	maxCadence
	The SegmentLapMessage FIT message's maxCadence field.

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

quint16	maxPower
	The SegmentLapMessage FIT message's maxPower field.

quint16	totalAscent
	The SegmentLapMessage FIT message's totalAscent field.

quint16	totalDescent
	The SegmentLapMessage FIT message's totalDescent field.

Sport	sport
	The SegmentLapMessage FIT message's sport field.

quint8	eventGroup
	The SegmentLapMessage FIT message's eventGroup field.

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

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

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

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

QString	name
	The SegmentLapMessage FIT message's name field.

quint16	normalizedPower
	The SegmentLapMessage FIT message's normalizedPower field.

LeftRightBalance100	leftRightBalance
	The SegmentLapMessage FIT message's leftRightBalance field.

SubSport	subSport
	The SegmentLapMessage FIT message's subSport field.

quint32	totalWork
	The SegmentLapMessage FIT message's totalWork field.

quint16	avgAltitude
	The SegmentLapMessage FIT message's avgAltitude field.

quint16	maxAltitude
	The SegmentLapMessage FIT message's maxAltitude field.

quint8	gpsAccuracy
	The SegmentLapMessage FIT message's gpsAccuracy field.

qint16	avgGrade
	The SegmentLapMessage FIT message's avgGrade field.

qint16	avgPosGrade
	The SegmentLapMessage FIT message's avgPosGrade field.

qint16	avgNegGrade
	The SegmentLapMessage FIT message's avgNegGrade field.

qint16	maxPosGrade
	The SegmentLapMessage FIT message's maxPosGrade field.

qint16	maxNegGrade
	The SegmentLapMessage FIT message's maxNegGrade field.

qint8	avgTemperature
	The SegmentLapMessage FIT message's avgTemperature field.

qint8	maxTemperature
	The SegmentLapMessage FIT message's maxTemperature field.

quint32	totalMovingTime
	The SegmentLapMessage FIT message's totalMovingTime field.

qint16	avgPosVerticalSpeed
	The SegmentLapMessage FIT message's avgPosVerticalSpeed field.

qint16	avgNegVerticalSpeed
	The SegmentLapMessage FIT message's avgNegVerticalSpeed field.

qint16	maxPosVerticalSpeed
	The SegmentLapMessage FIT message's maxPosVerticalSpeed field.

qint16	maxNegVerticalSpeed
	The SegmentLapMessage FIT message's maxNegVerticalSpeed field.

quint32	timeInHrZone
	The SegmentLapMessage FIT message's timeInHrZone field.

quint32	timeInSpeedZone
	The SegmentLapMessage FIT message's timeInSpeedZone field.

quint32	timeInCadenceZone
	The SegmentLapMessage FIT message's timeInCadenceZone field.

quint32	timeInPowerZone
	The SegmentLapMessage FIT message's timeInPowerZone field.

quint16	repetitionNum
	The SegmentLapMessage FIT message's repetitionNum field.

quint16	minAltitude
	The SegmentLapMessage FIT message's minAltitude field.

quint8	minHeartRate
	The SegmentLapMessage FIT message's minHeartRate field.

quint32	activeTime
	The SegmentLapMessage FIT message's activeTime field.

MessageIndex	wktStepIndex
	The SegmentLapMessage FIT message's wktStepIndex field.

SportEvent	sportEvent
	The SegmentLapMessage FIT message's sportEvent field.

quint8	avgLeftTorqueEffectiveness
	The SegmentLapMessage FIT message's avgLeftTorqueEffectiveness field.

quint8	avgRightTorqueEffectiveness
	The SegmentLapMessage FIT message's avgRightTorqueEffectiveness field.

quint8	avgLeftPedalSmoothness
	The SegmentLapMessage FIT message's avgLeftPedalSmoothness field.

quint8	avgRightPedalSmoothness
	The SegmentLapMessage FIT message's avgRightPedalSmoothness field.

quint8	avgCombinedPedalSmoothness
	The SegmentLapMessage FIT message's avgCombinedPedalSmoothness field.

SegmentLapStatus	status
	The SegmentLapMessage FIT message's status field.

QString	uuid
	The SegmentLapMessage FIT message's uuid field.

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

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

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

quint16	frontGearShiftCount
	The SegmentLapMessage FIT message's frontGearShiftCount field.

quint16	rearGearShiftCount
	The SegmentLapMessage FIT message's rearGearShiftCount field.

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

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

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

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

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

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

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

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

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

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

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

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

Manufacturer	manufacturer
	The SegmentLapMessage FIT message's manufacturer field. More...

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

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

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

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

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

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

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 SegmentLapMessagePrivate class provides private implementation for the SegmentLapMessage.

See also: SegmentLapMessage

Definition at line 38 of file segmentlapmessage_p.h.

Constructor & Destructor Documentation

◆ SegmentLapMessagePrivate()

SegmentLapMessagePrivate::SegmentLapMessagePrivate ( SegmentLapMessage *const q )

explicit

Constructs a SegmentLapMessagePrivate object with public implementation q.

Parameters

q	Pointer to public implementaton.

Definition at line 2091 of file segmentlapmessage.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)
   , sport(static_cast<Sport>(-1))
   , eventGroup(0xFF)
   , necLat(0x7FFFFFFF)
   , necLong(0x7FFFFFFF)
   , swcLat(0x7FFFFFFF)
   , swcLong(0x7FFFFFFF)
   , normalizedPower(0xFFFF)
   , leftRightBalance(static_cast<LeftRightBalance100>(-1))
   , subSport(static_cast<SubSport>(-1))
   , 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)
   , activeTime(0xFFFFFFFF)
   , wktStepIndex(static_cast<MessageIndex>(-1))
   , sportEvent(static_cast<SportEvent>(-1))
   , avgLeftTorqueEffectiveness(0xFF)
   , avgRightTorqueEffectiveness(0xFF)
   , avgLeftPedalSmoothness(0xFF)
   , avgRightPedalSmoothness(0xFF)
   , avgCombinedPedalSmoothness(0xFF)
   , status(static_cast<SegmentLapStatus>(-1))
   , avgFractionalCadence(0xFF)
   , maxFractionalCadence(0xFF)
   , totalFractionalCycles(0xFF)
   , frontGearShiftCount(0xFFFF)
   , rearGearShiftCount(0xFFFF)
   , timeStanding(0xFFFFFFFF)
   , standCount(0xFFFF)
   , avgLeftPco(0x7F)
   , avgRightPco(0x7F)
   , avgLeftPowerPhase(0xFF)
   , avgLeftPowerPhasePeak(0xFF)
   , avgRightPowerPhase(0xFF)
   , avgRightPowerPhasePeak(0xFF)
   , avgPowerPosition(0xFFFF)
   , maxPowerPosition(0xFFFF)
   , avgCadencePosition(0xFF)
   , maxCadencePosition(0xFF)
   , manufacturer(static_cast<Manufacturer>(-1))
   , totalGrit(static_cast<float>(-1))
   , totalFlow(static_cast<float>(-1))
   , avgGrit(static_cast<float>(-1))
   , avgFlow(static_cast<float>(-1))
   , totalFractionalAscent(0xFF)
   , totalFractionalDescent(0xFF)
 {
     globalMessageNumber = MesgNum::SegmentLap;
 }

References AbstractDataMessagePrivate::globalMessageNumber.

◆ ~SegmentLapMessagePrivate()

SegmentLapMessagePrivate::~SegmentLapMessagePrivate ( )

virtual

Destroys the SegmentLapMessagePrivate object.

Definition at line 2192 of file segmentlapmessage.cpp.

 {
  
 }

Member Function Documentation

◆ setField()

bool SegmentLapMessagePrivate::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 2197 of file segmentlapmessage.cpp.

 {
     switch (fieldId) {
     case 254: // See Profile.xlsx::Messages:segment_lap.messageIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.messageIndex")) return false;
         this->messageIndex = static_cast<MessageIndex>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 253: // See Profile.xlsx::Messages:segment_lap.timestamp
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timestamp")) return false;
         this->timestamp = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 0: // See Profile.xlsx::Messages:segment_lap.event
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.event")) return false;
         this->event = static_cast<Event>(data.at(0));
         break;
     case 1: // See Profile.xlsx::Messages:segment_lap.eventType
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.eventType")) return false;
         this->eventType = static_cast<EventType>(data.at(0));
         break;
     case 2: // See Profile.xlsx::Messages:segment_lap.startTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.startTime")) return false;
         this->startTime = static_cast<DateTime>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 3: // See Profile.xlsx::Messages:segment_lap.startPositionLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.startPositionLat")) return false;
         this->startPositionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 4: // See Profile.xlsx::Messages:segment_lap.startPositionLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.startPositionLong")) return false;
         this->startPositionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 5: // See Profile.xlsx::Messages:segment_lap.endPositionLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.endPositionLat")) return false;
         this->endPositionLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 6: // See Profile.xlsx::Messages:segment_lap.endPositionLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.endPositionLong")) return false;
         this->endPositionLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 7: // See Profile.xlsx::Messages:segment_lap.totalElapsedTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalElapsedTime")) return false;
         this->totalElapsedTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 8: // See Profile.xlsx::Messages:segment_lap.totalTimerTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalTimerTime")) return false;
         this->totalTimerTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 9: // See Profile.xlsx::Messages:segment_lap.totalDistance
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalDistance")) return false;
         this->totalDistance = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 10: // See Profile.xlsx::Messages:segment_lap.totalCycles
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalCycles")) return false;
         this->totalCycles = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 11: // See Profile.xlsx::Messages:segment_lap.totalCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.totalCalories")) return false;
         this->totalCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 12: // See Profile.xlsx::Messages:segment_lap.totalFatCalories
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.totalFatCalories")) return false;
         this->totalFatCalories = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 13: // See Profile.xlsx::Messages:segment_lap.avgSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.avgSpeed")) return false;
         this->avgSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 14: // See Profile.xlsx::Messages:segment_lap.maxSpeed
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.maxSpeed")) return false;
         this->maxSpeed = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 15: // See Profile.xlsx::Messages:segment_lap.avgHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgHeartRate")) return false;
         this->avgHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 16: // See Profile.xlsx::Messages:segment_lap.maxHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.maxHeartRate")) return false;
         this->maxHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 17: // See Profile.xlsx::Messages:segment_lap.avgCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgCadence")) return false;
         this->avgCadence = static_cast<quint8>(data.at(0));
         break;
     case 18: // See Profile.xlsx::Messages:segment_lap.maxCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.maxCadence")) return false;
         this->maxCadence = static_cast<quint8>(data.at(0));
         break;
     case 19: // See Profile.xlsx::Messages:segment_lap.avgPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.avgPower")) return false;
         this->avgPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 20: // See Profile.xlsx::Messages:segment_lap.maxPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.maxPower")) return false;
         this->maxPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 21: // See Profile.xlsx::Messages:segment_lap.totalAscent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.totalAscent")) return false;
         this->totalAscent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 22: // See Profile.xlsx::Messages:segment_lap.totalDescent
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.totalDescent")) return false;
         this->totalDescent = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 23: // See Profile.xlsx::Messages:segment_lap.sport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.sport")) return false;
         this->sport = static_cast<Sport>(data.at(0));
         break;
     case 24: // See Profile.xlsx::Messages:segment_lap.eventGroup
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.eventGroup")) return false;
         this->eventGroup = static_cast<quint8>(data.at(0));
         break;
     case 25: // See Profile.xlsx::Messages:segment_lap.necLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.necLat")) return false;
         this->necLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 26: // See Profile.xlsx::Messages:segment_lap.necLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.necLong")) return false;
         this->necLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 27: // See Profile.xlsx::Messages:segment_lap.swcLat
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.swcLat")) return false;
         this->swcLat = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 28: // See Profile.xlsx::Messages:segment_lap.swcLong
         if (!verify(data, baseType, 4, FitBaseType::Sint32, "segment_lap.swcLong")) return false;
         this->swcLong = static_cast<qint32>(bigEndian ? qFromBigEndian< qint32>(data) : qFromLittleEndian< qint32>(data));
         break;
     case 29: // See Profile.xlsx::Messages:segment_lap.name
         if (!verify(data, baseType, 1, FitBaseType::String, "segment_lap.name")) return false;
         this->name = QString::fromUtf8(data);
         break;
     case 30: // See Profile.xlsx::Messages:segment_lap.normalizedPower
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.normalizedPower")) return false;
         this->normalizedPower = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 31: // See Profile.xlsx::Messages:segment_lap.leftRightBalance
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.leftRightBalance")) return false;
         this->leftRightBalance = static_cast<LeftRightBalance100>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 32: // See Profile.xlsx::Messages:segment_lap.subSport
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.subSport")) return false;
         this->subSport = static_cast<SubSport>(data.at(0));
         break;
     case 33: // See Profile.xlsx::Messages:segment_lap.totalWork
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalWork")) return false;
         this->totalWork = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 34: // See Profile.xlsx::Messages:segment_lap.avgAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.avgAltitude")) return false;
         this->avgAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 35: // See Profile.xlsx::Messages:segment_lap.maxAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.maxAltitude")) return false;
         this->maxAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 36: // See Profile.xlsx::Messages:segment_lap.gpsAccuracy
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.gpsAccuracy")) return false;
         this->gpsAccuracy = static_cast<quint8>(data.at(0));
         break;
     case 37: // See Profile.xlsx::Messages:segment_lap.avgGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.avgGrade")) return false;
         this->avgGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 38: // See Profile.xlsx::Messages:segment_lap.avgPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.avgPosGrade")) return false;
         this->avgPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 39: // See Profile.xlsx::Messages:segment_lap.avgNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.avgNegGrade")) return false;
         this->avgNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 40: // See Profile.xlsx::Messages:segment_lap.maxPosGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.maxPosGrade")) return false;
         this->maxPosGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 41: // See Profile.xlsx::Messages:segment_lap.maxNegGrade
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.maxNegGrade")) return false;
         this->maxNegGrade = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 42: // See Profile.xlsx::Messages:segment_lap.avgTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "segment_lap.avgTemperature")) return false;
         this->avgTemperature = static_cast<qint8>(data.at(0));
         break;
     case 43: // See Profile.xlsx::Messages:segment_lap.maxTemperature
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "segment_lap.maxTemperature")) return false;
         this->maxTemperature = static_cast<qint8>(data.at(0));
         break;
     case 44: // See Profile.xlsx::Messages:segment_lap.totalMovingTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.totalMovingTime")) return false;
         this->totalMovingTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 45: // See Profile.xlsx::Messages:segment_lap.avgPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.avgPosVerticalSpeed")) return false;
         this->avgPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 46: // See Profile.xlsx::Messages:segment_lap.avgNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.avgNegVerticalSpeed")) return false;
         this->avgNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 47: // See Profile.xlsx::Messages:segment_lap.maxPosVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.maxPosVerticalSpeed")) return false;
         this->maxPosVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 48: // See Profile.xlsx::Messages:segment_lap.maxNegVerticalSpeed
         if (!verify(data, baseType, 2, FitBaseType::Sint16, "segment_lap.maxNegVerticalSpeed")) return false;
         this->maxNegVerticalSpeed = static_cast<qint16>(bigEndian ? qFromBigEndian< qint16>(data) : qFromLittleEndian< qint16>(data));
         break;
     case 49: // See Profile.xlsx::Messages:segment_lap.timeInHrZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timeInHrZone")) return false;
         this->timeInHrZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 50: // See Profile.xlsx::Messages:segment_lap.timeInSpeedZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timeInSpeedZone")) return false;
         this->timeInSpeedZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 51: // See Profile.xlsx::Messages:segment_lap.timeInCadenceZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timeInCadenceZone")) return false;
         this->timeInCadenceZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 52: // See Profile.xlsx::Messages:segment_lap.timeInPowerZone
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timeInPowerZone")) return false;
         this->timeInPowerZone = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 53: // See Profile.xlsx::Messages:segment_lap.repetitionNum
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.repetitionNum")) return false;
         this->repetitionNum = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 54: // See Profile.xlsx::Messages:segment_lap.minAltitude
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.minAltitude")) return false;
         this->minAltitude = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 55: // See Profile.xlsx::Messages:segment_lap.minHeartRate
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.minHeartRate")) return false;
         this->minHeartRate = static_cast<quint8>(data.at(0));
         break;
     case 56: // See Profile.xlsx::Messages:segment_lap.activeTime
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.activeTime")) return false;
         this->activeTime = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 57: // See Profile.xlsx::Messages:segment_lap.wktStepIndex
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.wktStepIndex")) return false;
         this->wktStepIndex = static_cast<MessageIndex>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 58: // See Profile.xlsx::Messages:segment_lap.sportEvent
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.sportEvent")) return false;
         this->sportEvent = static_cast<SportEvent>(data.at(0));
         break;
     case 59: // See Profile.xlsx::Messages:segment_lap.avgLeftTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgLeftTorqueEffectiveness")) return false;
         this->avgLeftTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 60: // See Profile.xlsx::Messages:segment_lap.avgRightTorqueEffectiveness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgRightTorqueEffectiveness")) return false;
         this->avgRightTorqueEffectiveness = static_cast<quint8>(data.at(0));
         break;
     case 61: // See Profile.xlsx::Messages:segment_lap.avgLeftPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgLeftPedalSmoothness")) return false;
         this->avgLeftPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 62: // See Profile.xlsx::Messages:segment_lap.avgRightPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgRightPedalSmoothness")) return false;
         this->avgRightPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 63: // See Profile.xlsx::Messages:segment_lap.avgCombinedPedalSmoothness
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgCombinedPedalSmoothness")) return false;
         this->avgCombinedPedalSmoothness = static_cast<quint8>(data.at(0));
         break;
     case 64: // See Profile.xlsx::Messages:segment_lap.status
         if (!verify(data, baseType, 1, FitBaseType::Enum, "segment_lap.status")) return false;
         this->status = static_cast<SegmentLapStatus>(data.at(0));
         break;
     case 65: // See Profile.xlsx::Messages:segment_lap.uuid
         if (!verify(data, baseType, 1, FitBaseType::String, "segment_lap.uuid")) return false;
         this->uuid = QString::fromUtf8(data);
         break;
     case 66: // See Profile.xlsx::Messages:segment_lap.avgFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgFractionalCadence")) return false;
         this->avgFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 67: // See Profile.xlsx::Messages:segment_lap.maxFractionalCadence
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.maxFractionalCadence")) return false;
         this->maxFractionalCadence = static_cast<quint8>(data.at(0));
         break;
     case 68: // See Profile.xlsx::Messages:segment_lap.totalFractionalCycles
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.totalFractionalCycles")) return false;
         this->totalFractionalCycles = static_cast<quint8>(data.at(0));
         break;
     case 69: // See Profile.xlsx::Messages:segment_lap.frontGearShiftCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.frontGearShiftCount")) return false;
         this->frontGearShiftCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 70: // See Profile.xlsx::Messages:segment_lap.rearGearShiftCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.rearGearShiftCount")) return false;
         this->rearGearShiftCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 71: // See Profile.xlsx::Messages:segment_lap.timeStanding
         if (!verify(data, baseType, 4, FitBaseType::Uint32, "segment_lap.timeStanding")) return false;
         this->timeStanding = static_cast<quint32>(bigEndian ? qFromBigEndian<quint32>(data) : qFromLittleEndian<quint32>(data));
         break;
     case 72: // See Profile.xlsx::Messages:segment_lap.standCount
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.standCount")) return false;
         this->standCount = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 73: // See Profile.xlsx::Messages:segment_lap.avgLeftPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "segment_lap.avgLeftPco")) return false;
         this->avgLeftPco = static_cast<qint8>(data.at(0));
         break;
     case 74: // See Profile.xlsx::Messages:segment_lap.avgRightPco
         if (!verify(data, baseType, 1, FitBaseType::Sint8, "segment_lap.avgRightPco")) return false;
         this->avgRightPco = static_cast<qint8>(data.at(0));
         break;
     case 75: // See Profile.xlsx::Messages:segment_lap.avgLeftPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgLeftPowerPhase")) return false;
         this->avgLeftPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 76: // See Profile.xlsx::Messages:segment_lap.avgLeftPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgLeftPowerPhasePeak")) return false;
         this->avgLeftPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 77: // See Profile.xlsx::Messages:segment_lap.avgRightPowerPhase
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgRightPowerPhase")) return false;
         this->avgRightPowerPhase = static_cast<quint8>(data.at(0));
         break;
     case 78: // See Profile.xlsx::Messages:segment_lap.avgRightPowerPhasePeak
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgRightPowerPhasePeak")) return false;
         this->avgRightPowerPhasePeak = static_cast<quint8>(data.at(0));
         break;
     case 79: // See Profile.xlsx::Messages:segment_lap.avgPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.avgPowerPosition")) return false;
         this->avgPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 80: // See Profile.xlsx::Messages:segment_lap.maxPowerPosition
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.maxPowerPosition")) return false;
         this->maxPowerPosition = static_cast<quint16>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 81: // See Profile.xlsx::Messages:segment_lap.avgCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.avgCadencePosition")) return false;
         this->avgCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 82: // See Profile.xlsx::Messages:segment_lap.maxCadencePosition
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.maxCadencePosition")) return false;
         this->maxCadencePosition = static_cast<quint8>(data.at(0));
         break;
     case 83: // See Profile.xlsx::Messages:segment_lap.manufacturer
         if (!verify(data, baseType, 2, FitBaseType::Uint16, "segment_lap.manufacturer")) return false;
         this->manufacturer = static_cast<Manufacturer>(bigEndian ? qFromBigEndian<quint16>(data) : qFromLittleEndian<quint16>(data));
         break;
     case 84: // See Profile.xlsx::Messages:segment_lap.totalGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "segment_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 85: // See Profile.xlsx::Messages:segment_lap.totalFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "segment_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 86: // See Profile.xlsx::Messages:segment_lap.avgGrit
         if (!verify(data, baseType, 4, FitBaseType::Float32, "segment_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 87: // See Profile.xlsx::Messages:segment_lap.avgFlow
         if (!verify(data, baseType, 4, FitBaseType::Float32, "segment_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 89: // See Profile.xlsx::Messages:segment_lap.totalFractionalAscent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.totalFractionalAscent")) return false;
         this->totalFractionalAscent = static_cast<quint8>(data.at(0));
         break;
     case 90: // See Profile.xlsx::Messages:segment_lap.totalFractionalDescent
         if (!verify(data, baseType, 1, FitBaseType::Uint8, "segment_lap.totalFractionalDescent")) return false;
         this->totalFractionalDescent = static_cast<quint8>(data.at(0));
         break;
     default:
         qWarning() << "ignoring unknown segment_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 SegmentLapMessagePrivate::avgCadence

The SegmentLapMessage 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 segmentlapmessage_p.h.

◆ avgCadencePosition

quint8 SegmentLapMessagePrivate::avgCadencePosition

The SegmentLapMessage FIT message's avgCadencePosition field.

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

Definition at line 509 of file segmentlapmessage_p.h.

◆ avgFlow

float SegmentLapMessagePrivate::avgFlow

The SegmentLapMessage 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 555 of file segmentlapmessage_p.h.

◆ avgFractionalCadence

quint8 SegmentLapMessagePrivate::avgFractionalCadence

The SegmentLapMessage FIT message's avgFractionalCadence field.

fractional part of the avg_cadence

Definition at line 408 of file segmentlapmessage_p.h.

◆ avgGrit

float SegmentLapMessagePrivate::avgGrit

The SegmentLapMessage 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 547 of file segmentlapmessage_p.h.

◆ avgLeftPco

qint8 SegmentLapMessagePrivate::avgLeftPco

The SegmentLapMessage FIT message's avgLeftPco field.

Average left platform center offset

Definition at line 453 of file segmentlapmessage_p.h.

◆ avgLeftPowerPhase

quint8 SegmentLapMessagePrivate::avgLeftPowerPhase

The SegmentLapMessage FIT message's avgLeftPowerPhase field.

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

Definition at line 467 of file segmentlapmessage_p.h.

◆ avgLeftPowerPhasePeak

quint8 SegmentLapMessagePrivate::avgLeftPowerPhasePeak

The SegmentLapMessage FIT message's avgLeftPowerPhasePeak field.

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

Definition at line 474 of file segmentlapmessage_p.h.

◆ avgPower

quint16 SegmentLapMessagePrivate::avgPower

The SegmentLapMessage 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 segmentlapmessage_p.h.

◆ avgPowerPosition

quint16 SegmentLapMessagePrivate::avgPowerPosition

The SegmentLapMessage FIT message's avgPowerPosition field.

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

Definition at line 495 of file segmentlapmessage_p.h.

◆ avgRightPco

qint8 SegmentLapMessagePrivate::avgRightPco

The SegmentLapMessage FIT message's avgRightPco field.

Average right platform center offset

Definition at line 460 of file segmentlapmessage_p.h.

◆ avgRightPowerPhase

quint8 SegmentLapMessagePrivate::avgRightPowerPhase

The SegmentLapMessage FIT message's avgRightPowerPhase field.

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

Definition at line 481 of file segmentlapmessage_p.h.

◆ avgRightPowerPhasePeak

quint8 SegmentLapMessagePrivate::avgRightPowerPhasePeak

The SegmentLapMessage FIT message's avgRightPowerPhasePeak field.

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

Definition at line 488 of file segmentlapmessage_p.h.

◆ manufacturer

Manufacturer SegmentLapMessagePrivate::manufacturer

The SegmentLapMessage FIT message's manufacturer field.

Manufacturer that produced the segment

Definition at line 523 of file segmentlapmessage_p.h.

◆ maxCadencePosition

quint8 SegmentLapMessagePrivate::maxCadencePosition

The SegmentLapMessage FIT message's maxCadencePosition field.

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

Definition at line 516 of file segmentlapmessage_p.h.

◆ maxFractionalCadence

quint8 SegmentLapMessagePrivate::maxFractionalCadence

The SegmentLapMessage FIT message's maxFractionalCadence field.

fractional part of the max_cadence

Definition at line 415 of file segmentlapmessage_p.h.

◆ maxPowerPosition

quint16 SegmentLapMessagePrivate::maxPowerPosition

The SegmentLapMessage FIT message's maxPowerPosition field.

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

Definition at line 502 of file segmentlapmessage_p.h.

◆ necLat

qint32 SegmentLapMessagePrivate::necLat

The SegmentLapMessage FIT message's necLat field.

North east corner latitude.

Definition at line 195 of file segmentlapmessage_p.h.

◆ necLong

qint32 SegmentLapMessagePrivate::necLong

The SegmentLapMessage FIT message's necLong field.

North east corner longitude.

Definition at line 202 of file segmentlapmessage_p.h.

◆ standCount

quint16 SegmentLapMessagePrivate::standCount

The SegmentLapMessage FIT message's standCount field.

Number of transitions to the standing state

Definition at line 446 of file segmentlapmessage_p.h.

◆ swcLat

qint32 SegmentLapMessagePrivate::swcLat

The SegmentLapMessage FIT message's swcLat field.

South west corner latitude.

Definition at line 209 of file segmentlapmessage_p.h.

◆ swcLong

qint32 SegmentLapMessagePrivate::swcLong

The SegmentLapMessage FIT message's swcLong field.

South west corner latitude.

Definition at line 216 of file segmentlapmessage_p.h.

◆ timestamp

DateTime SegmentLapMessagePrivate::timestamp

The SegmentLapMessage FIT message's timestamp field.

Lap end time.

Definition at line 51 of file segmentlapmessage_p.h.

◆ timeStanding

quint32 SegmentLapMessagePrivate::timeStanding

The SegmentLapMessage FIT message's timeStanding field.

Total time spent in the standing position

Definition at line 439 of file segmentlapmessage_p.h.

◆ totalElapsedTime

quint32 SegmentLapMessagePrivate::totalElapsedTime

The SegmentLapMessage FIT message's totalElapsedTime field.

Time (includes pauses)

Definition at line 93 of file segmentlapmessage_p.h.

◆ totalFatCalories

quint16 SegmentLapMessagePrivate::totalFatCalories

The SegmentLapMessage FIT message's totalFatCalories field.

If New Leaf

Definition at line 122 of file segmentlapmessage_p.h.

◆ totalFlow

float SegmentLapMessagePrivate::totalFlow

The SegmentLapMessage 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 539 of file segmentlapmessage_p.h.

◆ totalFractionalAscent

quint8 SegmentLapMessagePrivate::totalFractionalAscent

The SegmentLapMessage FIT message's totalFractionalAscent field.

fractional part of total_ascent

Definition at line 562 of file segmentlapmessage_p.h.

◆ totalFractionalCycles

quint8 SegmentLapMessagePrivate::totalFractionalCycles

The SegmentLapMessage FIT message's totalFractionalCycles field.

fractional part of the total_cycles

Definition at line 422 of file segmentlapmessage_p.h.

◆ totalFractionalDescent

quint8 SegmentLapMessagePrivate::totalFractionalDescent

The SegmentLapMessage FIT message's totalFractionalDescent field.

fractional part of total_descent

Definition at line 569 of file segmentlapmessage_p.h.

◆ totalGrit

float SegmentLapMessagePrivate::totalGrit

The SegmentLapMessage FIT message's totalGrit field.