public void Deserialize_V1(Stream stream, DataVersion version) { Byte[] intBuffer = new Byte[sizeof(UInt32)]; BaseCadenceTarget.IConcreteCadenceTarget.CadenceTargetType type; stream.Read(intBuffer, 0, sizeof(UInt32)); type = (BaseCadenceTarget.IConcreteCadenceTarget.CadenceTargetType)BitConverter.ToUInt32(intBuffer, 0); switch (type) { case BaseCadenceTarget.IConcreteCadenceTarget.CadenceTargetType.ZoneST: { m_ConcreteTarget = new CadenceZoneSTTarget(stream, version, this); break; } case BaseCadenceTarget.IConcreteCadenceTarget.CadenceTargetType.Range: { m_ConcreteTarget = new CadenceRangeTarget(stream, version, this); break; } default: { Debug.Assert(false); break; } } }
public new void Deserialize_V0(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(IRepeatDuration), stream, version); m_RepetitionCount.Deserialize(stream, version); }
public void Deserialize_V1(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(BasePowerTarget.IConcretePowerTarget), stream, version); IZoneCategory zones = Options.Instance.PowerZoneCategory; // RefId GarminFitnessString categoryRefID = new GarminFitnessString(); categoryRefID.Deserialize(stream, version); // Zone index GarminFitnessInt32Range zoneIndex = new GarminFitnessInt32Range(0); zoneIndex.Deserialize(stream, version); if (categoryRefID == zones.ReferenceId && zoneIndex < zones.Zones.Count) { Zone = zones.Zones[zoneIndex]; } else { Debug.Assert(zones.Zones.Count > 0); Zone = zones.Zones[0]; // We can't find saved zone, force dirty IsDirty = true; } }
public void Deserialize_V0(Stream stream, DataVersion version) { byte[] dateBuffer = new byte[sizeof(long)]; stream.Read(dateBuffer, 0, sizeof(long)); Value = new DateTime(BitConverter.ToInt64(dateBuffer, 0)); }
public void Deserialize_V0(Stream stream, DataVersion version) { byte[] guidBuffer = new byte[16]; stream.Read(guidBuffer, 0, 16); Value = new Guid(guidBuffer); }
public new void Deserialize_V0(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(BaseHeartRateTarget.IConcreteHeartRateTarget), stream, version); m_Zone.Deserialize(stream, version); }
protected void Deserialize(Type forcedType, Stream stream, DataVersion version) { MethodInfo deserializeMethod = GetLatestDeserializeMethod(forcedType, version); Debug.Assert(deserializeMethod != null); deserializeMethod.Invoke(this, new object[] { stream, version }); }
private MethodInfo GetLatestDeserializeMethod(Type forcedType, DataVersion version) { int bestVersionNumber = -1; MethodInfo deserializeMethod = null; MethodInfo[] methods = forcedType.GetMethods(); for (int i = 0; i < methods.Length; ++i) { MethodInfo currentMethod = methods[i]; if (currentMethod.Name.StartsWith(Constants.DeserializeMethodNamePrefix) && currentMethod.DeclaringType.FullName == forcedType.FullName) { Byte currentMethodVersionNumber = 0; try { currentMethodVersionNumber = Byte.Parse(currentMethod.Name.Substring(Constants.DeserializeMethodNamePrefix.Length)); } catch { // Too big version for Byte????? Debug.Assert(false); } if (currentMethodVersionNumber > bestVersionNumber && currentMethodVersionNumber <= version.VersionNumber) { deserializeMethod = currentMethod; bestVersionNumber = currentMethodVersionNumber; } } } return deserializeMethod; }
public new void Deserialize_V0(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(IDuration), stream, version); m_CaloriesToSpend.Deserialize(stream, version); }
public void Deserialize_V0(Stream stream, DataVersion version) { byte[] boolBuffer = new byte[sizeof(bool)]; stream.Read(boolBuffer, 0, sizeof(bool)); Value = BitConverter.ToBoolean(boolBuffer, 0); }
public void Deserialize_V0(Stream stream, DataVersion version) { Byte[] buffer = new Byte[1]; stream.Read(buffer, 0, 1); Value = (SByte)buffer[0]; }
public void Deserialize(Stream stream, DataVersion version) { MethodInfo deserializeMethod = GetLatestDeserializeMethod(this.GetType(), version); if (deserializeMethod != null) { deserializeMethod.Invoke(this, new object[] { stream, version }); } }
public Workout(Stream stream, DataVersion version) { CreateStepsList(); Deserialize(stream, version); WorkoutChanged += new WorkoutChangedEventHandler(OnWorkoutChanged); UpdateSplitsCache(); }
public WorkoutLinkStep(Stream stream, DataVersion version, Workout parent) : base(StepType.Link, parent) { Deserialize(stream, version); // Make sure we found the linked workout, it is possible we are copy-pasting // an unavailable one, in which case this step is temporary and will be disposed if (LinkedWorkout != null) { Initialize(); } }
public void Deserialize_V0(Stream stream, DataVersion version) { byte[] intBuffer = new byte[sizeof(Int32)]; byte[] stringBuffer; Int32 stringLength; stream.Read(intBuffer, 0, sizeof(Int32)); stringLength = BitConverter.ToInt32(intBuffer, 0); stringBuffer = new byte[stringLength]; stream.Read(stringBuffer, 0, stringLength); Value = Encoding.UTF8.GetString(stringBuffer); }
public static ITarget Create(ITarget.TargetType type, Stream stream, DataVersion version, RegularStep parent) { ITarget newTarget; switch (type) { case ITarget.TargetType.Null: { newTarget = new NullTarget(stream, version, parent); break; } case ITarget.TargetType.Speed: { newTarget = new BaseSpeedTarget(stream, version, parent); break; } case ITarget.TargetType.HeartRate: { newTarget = new BaseHeartRateTarget(stream, version, parent); break; } case ITarget.TargetType.Cadence: { newTarget = new BaseCadenceTarget(stream, version, parent); break; } case ITarget.TargetType.Power: { newTarget = new BasePowerTarget(stream, version, parent); break; } default: { Debug.Assert(false); newTarget = null; break; } } parent.Target = newTarget; return newTarget; }
public void Deserialize_V0(Stream stream, DataVersion version) { // This is the code that was in ITarget in data V0. Since we changed our // inheritance structure between V0 and V1, we must also change where the // loading is done. It happens ITarget didn't deserialize anything in V0, // so this is empty }
public PowerZoneSTTarget(Stream stream, DataVersion version, BasePowerTarget baseTarget) : this(baseTarget) { Deserialize(stream, version); }
public void Deserialize_V1(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(BasePowerTarget.IConcretePowerTarget), stream, version); m_MinPowerWatts.Deserialize(stream, version); m_MaxPowerWatts.Deserialize(stream, version); }
public void Deserialize_V0(Stream stream, DataVersion version) { }
protected ITarget(Stream stream, DataVersion version, IStep parent) { Deserialize(stream, version); }
public DistanceDuration(Stream stream, DataVersion version, IStep parent) : this(parent) { Deserialize(stream, version); }
public new void Deserialize_V0(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(IDuration), stream, version); byte[] doubleBuffer = new byte[sizeof(double)]; byte[] intBuffer = new byte[sizeof(Int32)]; stream.Read(doubleBuffer, 0, sizeof(double)); stream.Read(intBuffer, 0, sizeof(Int32)); SetDistanceInUnits(BitConverter.ToDouble(doubleBuffer, 0), (Length.Units)BitConverter.ToInt32(intBuffer, 0)); }
public RepeatUntilHeartRateAboveDuration(Stream stream, DataVersion version, RepeatStep parent) : this(parent) { Deserialize(stream, version); }
public void Deserialize_V10(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(IDuration), stream, version); m_Distance.Deserialize(stream, version); }
public new void Deserialize_V0(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(IRepeatDuration), stream, version); m_IsPercentageMaxHR.Deserialize(stream, version); InternalMaxHeartRate.Deserialize(stream, version); }
public void Deserialize_V18(Stream stream, DataVersion version) { // Call base deserialization Deserialize(typeof(BasePowerTarget.IConcretePowerTarget), stream, version); // Inverted the data order in V10 so we can use the Internal... functions m_IsPercentFTP.Deserialize(stream, version); InternalMinPower.Deserialize(stream, version); InternalMaxPower.Deserialize(stream, version); }
public new void Deserialize_V0(Stream stream, DataVersion version) { // In V0, we only have GTC zone type m_ConcreteTarget = new CadenceRangeTarget(stream, version, this); }
public BaseCadenceTarget(Stream stream, DataVersion version, IStep parent) : this(parent) { Deserialize(stream, version); }
public RepeatUntilDistanceDuration(Stream stream, DataVersion version, RepeatStep parent) : this(parent) { Deserialize(stream, version); }