public StepTracking Clone()
{
StepTracking clone = new StepTracking();
base.Copy(clone);
clone.count = new AtomicLong(count.Get());
clone.total = total;
return(clone);
}
/// <summary>Returns a counter associated with the specified phase and step.</summary>
/// <remarks>
/// Returns a counter associated with the specified phase and step. Typical
/// usage is to increment a counter within a tight loop. Callers may use this
/// method to obtain a counter once and then increment that instance repeatedly
/// within a loop. This prevents redundant lookup operations and object
/// creation within the tight loop. Incrementing the counter is an atomic
/// operation, so there is no risk of lost updates even if multiple threads
/// increment the same counter.
/// </remarks>
/// <param name="phase">Phase to get</param>
/// <param name="step">Step to get</param>
/// <returns>Counter associated with phase and step</returns>
public virtual StartupProgress.Counter GetCounter(Phase phase, Step step)
{
if (!IsComplete())
{
StepTracking tracking = LazyInitStep(phase, step);
return(new _Counter_154(tracking));
}
else
{
return(new _Counter_161());
}
}
public _Counter_154(StepTracking tracking)
{
this.tracking = tracking;
}
/// <summary>Returns the counter value for the specified phase and step.</summary>
/// <param name="phase">Phase to get</param>
/// <param name="step">Step to get</param>
/// <returns>long counter value for phase and step</returns>
public virtual long GetCount(Phase phase, Step step)
{
StepTracking tracking = GetStepTracking(phase, step);
return(tracking != null?tracking.count.Get() : 0);
}
/// <summary>Returns the total for the specified phase and step.</summary>
/// <param name="phase">Phase to get</param>
/// <param name="step">Step to get</param>
/// <returns>long total</returns>
public virtual long GetTotal(Phase phase, Step step)
{
StepTracking tracking = GetStepTracking(phase, step);
return(tracking != null && tracking.total != long.MinValue ? tracking.total : 0);
}
