Changeset 248


Ignore:
Timestamp:
03/11/08 15:07:28 (7 years ago)
Author:
lowjoel
Message:

Implement the PassBasedErasureMethod? class. The majority of erasure methods do a full file overwrite using a predefined set of passes. The PassBasedErasureMethod? implements majority of the functionality, save the passes to run. This helps keep the code compact and concise. We all hate copy and pastes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Manager/Method.cs

    r237 r248  
    165165            } 
    166166 
    167             PassFunction Function; 
    168             object OpaqueValue; 
     167            public PassFunction Function; 
     168            public object OpaqueValue; 
     169        } 
     170    } 
     171 
     172    /// <summary> 
     173    /// Pass-based erasure method. This subclass of erasure methods follow a fixed 
     174    /// pattern for every pass, although the order of passes can be randomized. 
     175    /// This is to simplify definitions of classes in plugins. 
     176    /// </summary> 
     177    public abstract class PassBasedErasureMethod : ErasureMethod 
     178    { 
     179        public override int Passes 
     180        { 
     181            get { return PassesSet.Length; } 
     182        } 
     183 
     184        /// <summary> 
     185        /// Whether the passes should be randomized before running them in random 
     186        /// order. 
     187        /// </summary> 
     188        protected abstract bool RandomizePasses 
     189        { 
     190            get; 
     191        } 
     192 
     193        /// <summary> 
     194        /// The set of Pass objects describing the passes in this erasure method. 
     195        /// </summary> 
     196        protected abstract Pass[] PassesSet 
     197        { 
     198            get; 
     199        } 
     200 
     201        public override void Erase(Stream strm, PRNG prng, OnProgress callback) 
     202        { 
     203            //Randomize the order of the passes 
     204            Pass[] randomizedPasses = PassesSet; 
     205            if (RandomizePasses) 
     206                randomizedPasses = ShufflePasses(randomizedPasses); 
     207 
     208            //Remember the starting position of the stream. 
     209            long strmStart = strm.Position; 
     210            long strmLength = strm.Length - strmStart; 
     211 
     212            //Allocate memory for a buffer holding data for the pass. 
     213            byte[] buffer = new byte[Math.Min(DiskOperationUnit, strmLength)]; 
     214 
     215            //Run every pass! 
     216            for (int pass = 0; pass < Passes; ++pass) 
     217            { 
     218                //Do a progress callback first. 
     219                callback(pass / (float)Passes, pass + 1); 
     220 
     221                //Start from the beginning again 
     222                strm.Seek(strmStart, SeekOrigin.Begin); 
     223 
     224                //Write the buffer to disk. 
     225                long toWrite = strmLength; 
     226                int dataStopped = buffer.Length; 
     227                while (toWrite > 0) 
     228                { 
     229                    //Calculate how much of the buffer to write to disk. 
     230                    int amount = (int)Math.Min(toWrite, buffer.Length - dataStopped); 
     231 
     232                    //If we have no data left, get more! 
     233                    if (amount == 0) 
     234                    { 
     235                        randomizedPasses[pass].Execute(ref buffer, prng); 
     236                        dataStopped = 0; 
     237                        continue; 
     238                    } 
     239 
     240                    //Write the data. 
     241                    strm.Write(buffer, dataStopped, amount); 
     242                    strm.Flush(); 
     243                    toWrite -= amount; 
     244 
     245                    //Do a progress callback. 
     246                    callback(((float)pass + ((strmLength - toWrite) / (float)strmLength)) / (float)Passes, pass + 1); 
     247                } 
     248            } 
    169249        } 
    170250    } 
Note: See TracChangeset for help on using the changeset viewer.