Changeset 1155


Ignore:
Timestamp:
7/3/2009 7:29:06 AM (5 years ago)
Author:
lowjoel
Message:

-Sent the CommandLine? class for a slight rewrite - the properties are now automatic properties, and the command line is no longer passed to the constructor as that would result in a virtual call in the base class constructor; instead a Parse function is used.
-Instead of mapping actions to handlers, use the Types instead
-Convert the CommandLine? class to be a Singleton-like class, where the CommandLine?.Get function will return a CommandLine? object representing the action requested
-Instead of letting the user specify files without a --, - or , we now need the user to specify --file=

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser6/Eraser/Program.cs

    r1153 r1155  
    618618        /// Manages a command line. 
    619619        /// </summary> 
    620         public class CommandLine 
    621         { 
     620        public abstract class CommandLine 
     621        { 
     622            /// <summary> 
     623            /// Gets the CommandLine-derived object for the given command line. 
     624            /// </summary> 
     625            /// <param name="cmdParams">The raw arguments passed to the program.</param> 
     626            /// <returns>A processed CommandLine Object.</returns> 
     627            public static CommandLine Get(string[] cmdParams) 
     628            { 
     629                //Get the action. 
     630                if (cmdParams.Length < 1) 
     631                    throw new ArgumentException("An action must be specified."); 
     632                string action = cmdParams[0]; 
     633 
     634                CommandLine result = null; 
     635                switch (action) 
     636                { 
     637                    case "help": 
     638                        result = new HelpCommandLine(); 
     639                        break; 
     640                    case "querymethods": 
     641                        result = new QueryMethodsCommandLine(); 
     642                        break; 
     643                    case "importtasklist": 
     644                        result = new ImportTaskListCommandLine(); 
     645                        break; 
     646                    case "addtask": 
     647                        result = new AddTaskCommandLine(); 
     648                        break; 
     649                } 
     650 
     651                if (result != null) 
     652                { 
     653                    result.Parse(cmdParams); 
     654                    return result; 
     655                } 
     656                else 
     657                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, 
     658                        "Unknown action: {0}", action)); 
     659            } 
     660 
    622661            /// <summary> 
    623662            /// Constructor. 
    624663            /// </summary> 
     664            protected CommandLine() 
     665            { 
     666            } 
     667 
     668            /// <summary> 
     669            /// Parses the given command line arguments to the respective properties of 
     670            /// the class. 
     671            /// </summary> 
    625672            /// <param name="cmdParams">The raw arguments passed to the program.</param> 
    626             public CommandLine(string[] cmdParams) 
    627             { 
    628                 //Get the action. 
    629                 if (cmdParams.Length < 1) 
    630                     throw new ArgumentException("An action must be specified."); 
    631                 Action = cmdParams[0]; 
    632  
     673            /// <returns></returns> 
     674            public bool Parse(string[] cmdParams) 
     675            { 
    633676                //Iterate over each argument, resolving them ourselves and letting 
    634677                //subclasses resolve them if we don't know how to. 
     
    640683                        throw new ArgumentException("Unknown argument: " + cmdParams[i]); 
    641684                } 
     685 
     686                return true; 
    642687            } 
    643688 
     
    648693            /// <param name="param">The parameter to resolve.</param> 
    649694            /// <returns>Return true if the parameter was resolved and accepted.</returns> 
    650             virtual protected bool ResolveParameter(string param) 
     695            protected virtual bool ResolveParameter(string param) 
    651696            { 
    652697                return false; 
     
    780825 
    781826            /// <summary> 
    782             /// The action that the command line specifies. 
    783             /// </summary> 
    784             public string Action 
    785             { 
    786                 get 
    787                 { 
    788                     return action; 
    789                 } 
    790                 private set 
    791                 { 
    792                     action = value; 
    793                 } 
    794             } 
    795  
    796             /// <summary> 
    797827            /// True if no console window should be created. 
    798828            /// </summary> 
    799             public bool Quiet 
    800             { 
    801                 get 
    802                 { 
    803                     return quiet; 
    804                 } 
    805                 private set 
    806                 { 
    807                     quiet = value; 
    808                 } 
    809             } 
    810  
    811             private string action; 
    812             private bool quiet; 
     829            public bool Quiet { get; private set; } 
     830        } 
     831 
     832        /// <summary> 
     833        /// Manages a help query command line. 
     834        /// </summary> 
     835        class HelpCommandLine : CommandLine 
     836        { 
     837            public HelpCommandLine() 
     838            { 
     839            } 
     840        } 
     841 
     842        class QueryMethodsCommandLine : CommandLine 
     843        { 
     844            public QueryMethodsCommandLine() 
     845            { 
     846            } 
    813847        } 
    814848 
     
    821855            /// Constructor. 
    822856            /// </summary> 
    823             /// <param name="cmdParams">The raw command line arguments passed to the program.</param> 
    824             public AddTaskCommandLine(string[] cmdParams) 
    825                 : base(cmdParams) 
    826             { 
     857            public AddTaskCommandLine() 
     858            { 
     859                Schedule = Schedule.RunNow; 
     860                Targets = new List<ErasureTarget>(); 
    827861            } 
    828862 
     
    838872                    List<KeyValuePair<string, string>> subParams = 
    839873                        GetSubParameters(param.Substring(equalPos + 1)); 
    840                     erasureMethod = new Guid(subParams[0].Key); 
     874                    ErasureMethod = new Guid(subParams[0].Key); 
    841875                } 
    842876                else if (IsParam(param, "schedule", "s")) 
     
    851885                    { 
    852886                        case "now": 
    853                             schedule = Schedule.RunNow; 
     887                            Schedule = Schedule.RunNow; 
    854888                            break; 
    855889                        case "restart": 
    856                             schedule = Schedule.RunOnRestart; 
     890                            Schedule = Schedule.RunOnRestart; 
    857891                            break; 
    858892                        default: 
     
    862896                else if (IsParam(param, "recycled", "r")) 
    863897                { 
    864                     targets.Add(new RecycleBinTarget()); 
     898                    Targets.Add(new RecycleBinTarget()); 
    865899                } 
    866900                else if (IsParam(param, "unused", "u")) 
     
    884918                        else 
    885919                            throw new ArgumentException("Unknown subparameter: " + kvp.Key); 
    886                     targets.Add(target); 
     920                    Targets.Add(target); 
    887921                } 
    888922                else if (IsParam(param, "dir", "d") || IsParam(param, "directory", null)) 
     
    921955 
    922956                    //Add the target to the list of targets 
    923                     targets.Add(target); 
    924                 } 
    925                 else 
     957                    Targets.Add(target); 
     958                } 
     959                else if (IsParam(param, "file", "f")) 
    926960                { 
    927961                    //It's just a file! 
    928962                    FileTarget target = new FileTarget(); 
    929963                    target.Path = Path.GetFullPath(param); 
    930                     targets.Add(target); 
    931                 } 
     964                    Targets.Add(target); 
     965                } 
     966                else 
     967                    return false; 
    932968 
    933969                return true; 
     
    937973            /// The erasure method which the user specified on the command line. 
    938974            /// </summary> 
    939             public Guid ErasureMethod 
    940             { 
    941                 get 
    942                 { 
    943                     return erasureMethod; 
    944                 } 
    945             } 
     975            public Guid ErasureMethod { get; private set; } 
    946976 
    947977            /// <summary> 
    948978            /// The schedule for the current set of targets. 
    949979            /// </summary> 
    950             public Schedule Schedule 
    951             { 
    952                 get 
    953                 { 
    954                     return schedule; 
    955                 } 
    956             } 
     980            public Schedule Schedule { get; private set; } 
    957981 
    958982            /// <summary> 
    959983            /// The list of targets which was specified on the command line. 
    960984            /// </summary> 
    961             public List<ErasureTarget> Targets 
    962             { 
    963                 get 
    964                 { 
    965                     return new List<ErasureTarget>(targets.ToArray()); 
    966                 } 
    967             } 
    968  
    969             private Guid erasureMethod; 
    970             private Schedule schedule = Schedule.RunNow; 
    971             private List<ErasureTarget> targets = new List<ErasureTarget>(); 
     985            public List<ErasureTarget> Targets { get; private set; } 
    972986        } 
    973987 
     
    981995            /// Constructor. 
    982996            /// </summary> 
    983             /// <param name="cmdParams">The raw command line arguments passed to the program.</param> 
    984             public ImportTaskListCommandLine(string[] cmdParams) 
    985                 : base(cmdParams) 
     997            public ImportTaskListCommandLine() 
    986998            { 
    987999            } 
     
    10171029            try 
    10181030            { 
    1019                 //Parse the command line arguments. 
    1020                 if (cmdParams.Length < 1) 
    1021                     throw new ArgumentException("An action must be specified."); 
    1022  
    1023                 switch (cmdParams[0]) 
    1024                 { 
    1025                     case "addtask": 
    1026                         Arguments = new AddTaskCommandLine(cmdParams); 
    1027                         break; 
    1028                     case "importtasklist": 
    1029                         Arguments = new ImportTaskListCommandLine(cmdParams); 
    1030                         break; 
    1031                     case "querymethods": 
    1032                     case "help": 
    1033                     default: 
    1034                         Arguments = new CommandLine(cmdParams); 
    1035                         break; 
    1036                 } 
     1031                Arguments = CommandLine.Get(cmdParams); 
    10371032 
    10381033                //If the user did not specify the quiet command line, then create the console. 
     
    10411036 
    10421037                //Map actions to their handlers 
    1043                 actionHandlers.Add("addtask", AddTask); 
    1044                 actionHandlers.Add("importtasklist", ImportTaskList); 
    1045                 actionHandlers.Add("querymethods", QueryMethods); 
    1046                 actionHandlers.Add("help", Help); 
     1038                actionHandlers.Add(typeof(AddTaskCommandLine), AddTask); 
     1039                actionHandlers.Add(typeof(ImportTaskListCommandLine), ImportTaskList); 
     1040                actionHandlers.Add(typeof(QueryMethodsCommandLine), QueryMethods); 
     1041                actionHandlers.Add(typeof(HelpCommandLine), Help); 
    10471042            } 
    10481043            finally 
     
    10591054        { 
    10601055            //Call the function handling the current command line. 
    1061             actionHandlers[Arguments.Action](); 
     1056            actionHandlers[Arguments.GetType()](); 
    10621057        } 
    10631058 
     
    10961091parameters for addtask: 
    10971092    eraser addtask [--method=<methodGUID>] [--schedule=(now|restart)] (--recycled " + 
    1098 @"| --unused=<volume> | --dir=<directory> | [file1 [file2 [...]]]) 
     1093@"| --unused=<volume> | --dir=<directory> | --file=<file>)[...] 
    10991094 
    11001095    --method, -m            The Erasure method to use. 
     
    11191114            delete          Deletes the folder at the end of the erasure if 
    11201115                            specified. 
    1121     file1 ... fileN         The list of files to erase. 
     1116    --file, -f              Erases the specified file 
    11221117 
    11231118parameters for querymethods: 
     
    11341129        /// The command line arguments passed to the program. 
    11351130        /// </summary> 
    1136         public CommandLine Arguments 
    1137         { 
    1138             get 
    1139             { 
    1140                 return arguments; 
    1141             } 
    1142             private set 
    1143             { 
    1144                 arguments = value; 
    1145             } 
    1146         } 
     1131        public CommandLine Arguments { get; private set; } 
    11471132 
    11481133        /// <summary> 
     
    11941179                ErasureMethodManager.Default : 
    11951180                ErasureMethodManager.GetInstance(taskArgs.ErasureMethod); 
     1181 
    11961182            foreach (ErasureTarget target in taskArgs.Targets) 
    11971183            { 
     
    12891275        #endregion 
    12901276 
    1291         /// <see cref="Arguments"/> 
    1292         private CommandLine arguments; 
    1293  
    12941277        /// <summary> 
    12951278        /// The prototype of an action handler in the class which executes an 
     
    13011284        /// Matches an action handler to a function in the class. 
    13021285        /// </summary> 
    1303         private Dictionary<string, ActionHandler> actionHandlers = 
    1304             new Dictionary<string, ActionHandler>(); 
     1286        private Dictionary<Type, ActionHandler> actionHandlers = 
     1287            new Dictionary<Type, ActionHandler>(); 
    13051288    } 
    13061289 
Note: See TracChangeset for help on using the changeset viewer.