Changeset 2020


Ignore:
Timestamp:
5/3/2010 1:01:55 PM (5 years ago)
Author:
lowjoel
Message:

Rearchitect the API for the ErasureTarget? class to be simpler.

Location:
trunk/eraser
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser/Eraser.Manager/Eraser.Manager.csproj

    r1902 r2020  
    6767    <Compile Include="DirectExecutor.cs" /> 
    6868    <Compile Include="EntropySource.cs" /> 
     69    <Compile Include="ErasureTarget.cs" /> 
    6970    <Compile Include="Exception.cs" /> 
    7071    <Compile Include="Executor.cs" /> 
  • trunk/eraser/Eraser.Manager/ErasureTarget.cs

    r2018 r2020  
    4646            Guid methodGuid = (Guid)info.GetValue("Method", typeof(Guid)); 
    4747            if (methodGuid == Guid.Empty) 
    48                 method = ErasureMethodRegistrar.Default; 
     48                Method = ErasureMethodRegistrar.Default; 
    4949            else 
    50                 method = ManagerLibrary.Instance.ErasureMethodRegistrar[methodGuid]; 
     50                Method = ManagerLibrary.Instance.ErasureMethodRegistrar[methodGuid]; 
    5151        } 
    5252 
     
    5454        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) 
    5555        { 
    56             info.AddValue("Method", method.Guid); 
     56            info.AddValue("Method", Method.Guid); 
    5757        } 
    5858        #endregion 
     
    6363        protected ErasureTarget() 
    6464        { 
    65         } 
    66  
    67         /// <summary> 
    68         /// The method used for erasing the file. If the variable is equal to 
    69         /// ErasureMethodManager.Default then the default is queried for the 
    70         /// task type. Check the <see cref="MethodDefined"/> property to see if 
    71         /// this variable was set on deliberately or if the result of the get 
    72         /// call is from the inferred default. 
    73         /// </summary> 
    74         public virtual ErasureMethod Method 
    75         { 
    76             get 
    77             { 
    78                 return method; 
    79             } 
    80             set 
    81             { 
    82                 method = value; 
    83                 MethodDefined = method != ErasureMethodRegistrar.Default; 
    84             } 
    85         } 
    86  
    87         /// <summary> 
    88         /// Checks whether a method has been selected for this target. This is 
    89         /// because the Method property will return non-default erasure methods 
    90         /// only. 
    91         /// </summary> 
    92         public bool MethodDefined { get; private set; } 
     65            Method = ErasureMethodRegistrar.Default; 
     66        } 
     67 
     68        /// <summary> 
     69        /// The method used for erasing the file. 
     70        /// </summary> 
     71        public ErasureMethod Method 
     72        { 
     73            get; 
     74            set; 
     75        } 
     76 
     77        /// <summary> 
     78        /// Gets the effective erasure method for the current target (i.e., returns 
     79        /// the correct erasure method for cases where the <see cref="Method"/> 
     80        /// property is <see cref="ErasureMethodRegistrar.Default"/> 
     81        /// </summary> 
     82        /// <returns>The Erasure method which the target should be erased with. 
     83        /// This function will never return <see cref="ErasureMethodRegistrar.Default"/></returns> 
     84        public virtual ErasureMethod EffectiveMethod 
     85        { 
     86            get 
     87            { 
     88                if (Method != ErasureMethodRegistrar.Default) 
     89                    return Method; 
     90 
     91                throw new InvalidOperationException("The effective method of the erasure " + 
     92                    "target cannot be ErasureMethodRegistrar.Default"); 
     93            } 
     94        } 
    9395 
    9496        /// <summary> 
     
    104106            get; 
    105107        } 
    106  
    107         /// <summary> 
    108         /// Retrieves the amount of data that needs to be written in order to 
    109         /// complete the erasure. 
    110         /// </summary> 
    111         public abstract long TotalData 
    112         { 
    113             get; 
    114         } 
    115  
    116         /// <summary> 
    117         /// Erasure method to use for the target. 
    118         /// </summary> 
    119         private ErasureMethod method; 
    120108 
    121109        /// <summary> 
     
    156144            : base() 
    157145        { 
    158             Method = ErasureMethodRegistrar.Default; 
    159146        } 
    160147 
     
    219206        public string Path { get; set; } 
    220207 
    221         public sealed override ErasureMethod Method 
    222         { 
    223             get 
    224             { 
    225                 if (base.MethodDefined) 
    226                     return base.Method; 
     208        public sealed override ErasureMethod EffectiveMethod 
     209        { 
     210            get 
     211            { 
     212                if (Method == ErasureMethodRegistrar.Default) 
     213                    return base.EffectiveMethod; 
     214 
    227215                return ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    228216                    ManagerLibrary.Settings.DefaultFileErasureMethod]; 
    229             } 
    230             set 
    231             { 
    232                 base.Method = value; 
    233217            } 
    234218        } 
     
    243227                        (string.IsNullOrEmpty(directoryName) ? Path : directoryName) 
    244228                    : fileName; 
    245             } 
    246         } 
    247  
    248         public override long TotalData 
    249         { 
    250             get 
    251             { 
    252                 long totalSize = 0; 
    253                 List<string> paths = GetPaths(out totalSize); 
    254                 return Method.CalculateEraseDataSize(paths, totalSize); 
    255229            } 
    256230        } 
     
    286260            : base() 
    287261        { 
    288             Method = ErasureMethodRegistrar.Default; 
    289         } 
    290  
    291         public override sealed ErasureMethod Method 
    292         { 
    293             get 
    294             { 
    295                 if (base.MethodDefined) 
    296                     return base.Method; 
     262        } 
     263 
     264        public sealed override ErasureMethod EffectiveMethod 
     265        { 
     266            get 
     267            { 
     268                if (Method == ErasureMethodRegistrar.Default) 
     269                    return base.EffectiveMethod; 
     270 
    297271                return ManagerLibrary.Instance.ErasureMethodRegistrar[ 
    298272                    ManagerLibrary.Settings.DefaultUnusedSpaceErasureMethod]; 
    299273            } 
    300             set 
    301             { 
    302                 base.Method = value; 
    303             } 
    304274        } 
    305275 
     
    307277        { 
    308278            get { return S._("Unused disk space ({0})", Drive); } 
    309         } 
    310  
    311         public override long TotalData 
    312         { 
    313             get 
    314             { 
    315                 VolumeInfo info = VolumeInfo.FromMountPoint(Drive); 
    316                 return Method.CalculateEraseDataSize(null, info.AvailableFreeSpace); 
    317             } 
    318279        } 
    319280 
  • trunk/eraser/Eraser/TaskDataSelectionForm.cs

    r1998 r2020  
    138138            { 
    139139                //Set the erasure method. 
    140                 if (value.MethodDefined) 
    141                 { 
    142                     foreach (object item in method.Items) 
    143                         if (((ErasureMethod)item).Guid == value.Method.Guid) 
    144                             method.SelectedItem = item; 
    145                 } 
    146                 else 
    147                     method.SelectedIndex = 0; 
     140                foreach (object item in method.Items) 
     141                    if (((ErasureMethod)item).Guid == value.Method.Guid) 
     142                        method.SelectedItem = item; 
    148143 
    149144                //Then the data to be erased. 
  • trunk/eraser/Eraser/TaskPropertiesForm.cs

    r1967 r2020  
    141141            { 
    142142                ListViewItem item = data.Items.Add(target.UIText); 
    143                 item.SubItems.Add(target.MethodDefined ? target.Method.Name : S._("(default)")); 
     143                item.SubItems.Add(target.Method == ErasureMethodRegistrar.Default ? 
     144                    S._("(default)") : target.Method.Name); 
    144145                item.Tag = target; 
    145146            } 
     
    215216                    ErasureTarget target = form.Target; 
    216217                    ListViewItem item = data.Items.Add(target.UIText); 
    217                     item.SubItems.Add(target.MethodDefined ? target.Method.Name : S._("(default)")); 
     218                    item.SubItems.Add(target.Method == ErasureMethodRegistrar.Default ? 
     219                        S._("(default)") : target.Method.Name); 
    218220                    item.Tag = target; 
    219221 
     
    244246                    item.Tag = target; 
    245247                    item.Text = target.UIText; 
    246                     item.SubItems[1].Text = target.MethodDefined ? target.Method.Name : S._("(default)"); 
     248                    item.SubItems[1].Text = target.Method == ErasureMethodRegistrar.Default ? 
     249                        S._("(default)") : target.Method.Name; 
    247250                } 
    248251            } 
Note: See TracChangeset for help on using the changeset viewer.