Ignore:
Timestamp:
01/13/10 04:29:25 (5 years ago)
Author:
lowjoel
Message:

Merged the SpeedMeter? branch to trunk. Fixes #90: Generic speed meter

Location:
trunk/eraser6
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser6

  • trunk/eraser6/Eraser.Manager/Task.cs

    r1498 r1515  
    161161        public bool Canceled 
    162162        { 
    163             get 
    164             { 
    165                 return canceled; 
    166             } 
    167  
    168             internal set 
    169             { 
    170                 canceled = value; 
    171             } 
     163            get; 
     164            internal set; 
    172165        } 
    173166 
     
    206199        public Logger Log { get; private set; } 
    207200 
     201        /// <summary> 
     202        /// The progress manager object which manages the progress of this task. 
     203        /// </summary> 
     204        public SteppedProgressManager Progress 
     205        { 
     206            get 
     207            { 
     208                if (!Executing) 
     209                    throw new InvalidOperationException("The progress of an erasure can only " + 
     210                        "be queried when the task is being executed."); 
     211 
     212                return progress; 
     213            } 
     214            private set 
     215            { 
     216                progress = value; 
     217            } 
     218        } 
     219 
    208220        private Schedule schedule; 
    209  
    210         /// <see cref="Canceled"/> 
    211         private volatile bool canceled; 
     221        private SteppedProgressManager progress; 
    212222 
    213223        #region Events 
     
    225235        /// The event object holding all event handlers. 
    226236        /// </summary> 
    227         public EventHandler<TaskProgressEventArgs> ProgressChanged { get; set; } 
     237        public EventHandler<ProgressChangedEventArgs> ProgressChanged { get; set; } 
    228238 
    229239        /// <summary> 
     
    250260                TaskStarted(this, e); 
    251261            Executing = true; 
    252         } 
    253  
    254         /// <summary> 
    255         /// Broadcasts a ProgressChanged event. 
    256         /// </summary> 
     262            Progress = new SteppedProgressManager(); 
     263        } 
     264 
     265        /// <summary> 
     266        /// Broadcasts a ProgressChanged event. The sender will be the erasure target 
     267        /// which broadcast this event; e.UserState will contain extra information 
     268        /// about the progress which is stored as a TaskProgressChangedEventArgs 
     269        /// object. 
     270        /// </summary> 
     271        /// <param name="sender">The <see cref="ErasureTarget"/> which is reporting 
     272        /// progress.</param> 
    257273        /// <param name="e">The new progress value.</param> 
    258         internal void OnProgressChanged(TaskProgressEventArgs e) 
    259         { 
     274        /// <exception cref="ArgumentException">e.UserState must be of the type 
     275        /// <see cref="TaskProgressEventargs"/></exception> 
     276        /// <exception cref="ArgumentNullException">Both sender and e cannot be null.</exception> 
     277        internal void OnProgressChanged(ErasureTarget sender, ProgressChangedEventArgs e) 
     278        { 
     279            if (sender == null) 
     280                throw new ArgumentNullException("sender"); 
     281            if (e == null) 
     282                throw new ArgumentNullException("sender"); 
     283            if (e.UserState.GetType() != typeof(TaskProgressChangedEventArgs)) 
     284                throw new ArgumentException("The Task.OnProgressChanged event expects a " + 
     285                    "TaskProgressEventArgs argument for the ProgressChangedEventArgs' UserState " + 
     286                    "object.", "e"); 
     287 
    260288            if (ProgressChanged != null) 
    261                 ProgressChanged(this, e); 
     289                ProgressChanged(sender, e); 
    262290        } 
    263291 
     
    271299                TaskFinished(this, e); 
    272300            Executing = false; 
     301            Progress = null; 
    273302        } 
    274303        #endregion 
     
    358387        /// </summary> 
    359388        private ErasureMethod method; 
     389 
     390        /// <summary> 
     391        /// The progress of this target. 
     392        /// </summary> 
     393        public ProgressManagerBase Progress 
     394        { 
     395            get; 
     396            internal set; 
     397        } 
    360398    } 
    361399 
     
    9891027 
    9901028    /// <summary> 
    991     /// A Event argument object containing the progress of the task. 
     1029    /// Stores extra information in the <see cref="ProgressChangedEventArgs"/> 
     1030    /// structure that is not conveyed in the ProgressManagerBase classes. 
    9921031    /// </summary> 
    993     public class TaskProgressEventArgs : TaskEventArgs 
     1032    public class TaskProgressChangedEventArgs 
    9941033    { 
    9951034        /// <summary> 
    9961035        /// Constructor. 
    9971036        /// </summary> 
    998         /// <param name="task">The task being run.</param> 
    999         public TaskProgressEventArgs(Task task) 
    1000             : base(task) 
    1001         { 
    1002             CurrentItemPass = 1; 
    1003         } 
    1004  
    1005         /// <summary> 
    1006         /// A number from 0 to 1 detailing the overall progress of the task. 
    1007         /// </summary> 
    1008         public float OverallProgress 
    1009         { 
    1010             get { return overallProgress; } 
    1011         } 
    1012  
    1013         /// <summary> 
    1014         /// The amount of time left for the operation to complete, in seconds. 
    1015         /// </summary> 
    1016         public TimeSpan TimeLeft { get; internal set; } 
    1017  
    1018         /// <summary> 
    1019         /// The current erasure target - the current item being erased. 
    1020         /// </summary> 
    1021         public ErasureTarget CurrentTarget { get; internal set; } 
    1022  
    1023         /// <summary> 
    1024         /// The current index of the target. 
    1025         /// </summary> 
    1026         public int CurrentTargetIndex { get; internal set; } 
     1037        /// <param name="itemName">The item whose erasure progress is being erased.</param> 
     1038        /// <param name="itemPass">The current pass number for this item.</param> 
     1039        /// <param name="itemTotalPasses">The total number of passes to complete erasure 
     1040        /// of this item.</param> 
     1041        public TaskProgressChangedEventArgs(string itemName, int itemPass, 
     1042            int itemTotalPasses) 
     1043        { 
     1044            ItemName = itemName; 
     1045            ItemPass = itemPass; 
     1046            ItemTotalPasses = itemTotalPasses; 
     1047        } 
     1048 
     1049        /// <summary> 
     1050        /// The file name of the item being erased. 
     1051        /// </summary> 
     1052        public string ItemName { get; private set; } 
     1053 
     1054        /// <summary> 
     1055        /// The pass number of a multi-pass erasure method. 
     1056        /// </summary> 
     1057        public int ItemPass { get; private set; } 
    10271058 
    10281059        /// <summary> 
     
    10301061        /// completed. 
    10311062        /// </summary> 
    1032         public int CurrentTargetTotalPasses { get; internal set; } 
    1033  
    1034         /// <summary> 
    1035         /// The stage of the erasure the executor is at. 
    1036         /// </summary> 
    1037         public string CurrentTargetStatus { get; internal set; } 
    1038  
    1039         /// <summary> 
    1040         /// A number from 0 to 1 detailing the overall progress of the item. 
    1041         /// Negative numbers indicate indeterminate progress. 
    1042         /// </summary> 
    1043         public float CurrentItemProgress { get; internal set; } 
    1044  
    1045         /// <summary> 
    1046         /// The file name of the item being erased. 
    1047         /// </summary> 
    1048         public string CurrentItemName { get; internal set; } 
    1049  
    1050         /// <summary> 
    1051         /// The pass number of a multi-pass erasure method. 
    1052         /// </summary> 
    1053         public int CurrentItemPass { get; internal set; } 
    1054  
    1055         /// <summary> 
    1056         /// The progress made by the current target. 
    1057         /// </summary> 
    1058         internal float CurrentTargetProgress 
    1059         { 
    1060             set 
    1061             { 
    1062                 overallProgress = Math.Min( 
    1063                     (value + (float)(CurrentTargetIndex - 1)) / Task.Targets.Count, 
    1064                     1.0f); 
    1065             } 
    1066         } 
    1067  
    1068         private float overallProgress; 
     1063        public int ItemTotalPasses { get; private set; } 
    10691064    } 
    10701065} 
Note: See TracChangeset for help on using the changeset viewer.