Changeset 1813 for trunk/eraser6


Ignore:
Timestamp:
2/11/2010 5:50:39 AM (5 years ago)
Author:
lowjoel
Message:

Replaced the Speed property of the ProgressManager? classes to a float so that it is unit agnostic, bearing the unit percentage points per second instead, so it is generalised to all progress manager classes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser6/Eraser.Util/ProgressManager.cs

    r1802 r1813  
    2222using System; 
    2323using System.Collections.Generic; 
     24using System.Linq; 
    2425using System.Text; 
    2526 
     
    6162 
    6263        /// <summary> 
    63         /// Computes the speed of the erase, in units of completion per second, 
     64        /// Computes the speed of the erase, in percentage of completion per second, 
    6465        /// based on the information collected in the previous 15 seconds. 
    6566        /// </summary> 
    66         public abstract int Speed 
     67        public abstract float Speed 
    6768        { 
    6869            get; 
     
    156157        } 
    157158 
    158         public override int Speed 
    159         { 
    160             get 
    161             { 
    162                 if (DateTime.Now == StartTime) 
    163                     return 0; 
    164  
    165                 if ((DateTime.Now - lastSpeedCalc).Seconds < 5 && lastSpeed != 0) 
     159        public override float Speed 
     160        { 
     161            get 
     162            { 
     163                if ((DateTime.Now - lastSpeedCalc).Seconds <= 1 && lastSpeed != 0) 
    166164                    return lastSpeed; 
    167165 
     
    172170 
    173171                //Then compute the speed of the calculation 
    174                 lastSpeed = (int)((Completed - lastCompleted) / timeElapsed); 
     172                lastSpeed = (float)((Completed - lastCompleted) / timeElapsed / total); 
    175173                lastSpeedCalc = DateTime.Now; 
    176174                lastCompleted = Completed; 
     
    183181            get 
    184182            { 
    185                 if (Speed == 0) 
     183                float speed = Speed; 
     184                if (speed == 0.0) 
    186185                    return TimeSpan.Zero; 
    187                 return new TimeSpan(0, 0, (int)((Total - Completed) / Speed)); 
     186 
     187                return TimeSpan.FromSeconds((1.0f - Progress) / speed); 
    188188            } 
    189189        } 
     
    203203        /// The last calculated speed of the operation. 
    204204        /// </summary> 
    205         private int lastSpeed; 
     205        private float lastSpeed; 
    206206 
    207207        /// <summary> 
     
    412412            get 
    413413            { 
    414                 float result = 0.0f; 
    415                 lock (ListLock) 
    416                     foreach (SteppedProgressManagerStep step in Steps) 
    417                         result += step.Progress.Progress * step.Weight; 
    418  
    419                 return result; 
    420             } 
    421         } 
    422  
    423         public override int Speed 
     414                lock (ListLock) 
     415                    return Steps.Sum(step => step.Progress.Progress * step.Weight); 
     416            } 
     417        } 
     418 
     419        public override float Speed 
    424420        { 
    425421            get 
     
    436432            get 
    437433            { 
    438                 long ticksElapsed = (DateTime.Now - StartTime).Ticks; 
    439                 float progressRemaining = 1.0f - Progress; 
    440                 return new TimeSpan((long) 
    441                     (progressRemaining * (ticksElapsed / (double)Progress))); 
     434                float speed = Speed; 
     435                if (speed == 0.0) 
     436                    return TimeSpan.Zero; 
     437 
     438                return TimeSpan.FromSeconds((1.0f - Progress) / speed); 
    442439            } 
    443440        } 
     
    687684            get 
    688685            { 
    689                 float result = 0.0f; 
    690686                lock (TaskLock) 
    691                     foreach (ProgressManagerBase subTask in Tasks) 
    692                         result += subTask.Progress * (1.0f / Tasks.Count); 
    693  
    694                 return result; 
    695             } 
    696         } 
    697  
    698         public override int Speed 
    699         { 
    700             get 
    701             { 
    702                 int maxSpeed = 0; 
     687                    return Tasks.Sum(task => task.Progress * (1.0f / Tasks.Count)); 
     688            } 
     689        } 
     690 
     691        public override float Speed 
     692        { 
     693            get 
     694            { 
    703695                lock (TaskLock) 
    704                     foreach (ProgressManagerBase subTask in Tasks) 
    705                         maxSpeed = Math.Max(subTask.Speed, maxSpeed); 
    706  
    707                 return maxSpeed; 
     696                    return Tasks.Max(task => task.Speed); 
    708697            } 
    709698        } 
     
    713702            get 
    714703            { 
    715                 TimeSpan maxTime = TimeSpan.MinValue; 
    716704                lock (TaskLock) 
    717                     foreach (ProgressManagerBase subTask in Tasks) 
    718                         if (maxTime < subTask.TimeLeft) 
    719                             maxTime = subTask.TimeLeft; 
    720  
    721                 return maxTime; 
     705                    return Tasks.Max(task => task.TimeLeft); 
    722706            } 
    723707        } 
Note: See TracChangeset for help on using the changeset viewer.