public bool IsValid(Argument arg, string value, out string errorMsg)
{
var ok = true;
errorMsg = null;
if(Values != null) {
var values = PermitMultipleValues ? value.SplitCSV() : new string[] { value };
foreach(var val in values) {
ok = ok && (CaseSensitive ? Values.Contains(val) :
Values.Contains(val, StringComparer.OrdinalIgnoreCase));
}
}
if(!ok) {
errorMsg = String.Format("Value must be {0} of: {1}{2}",
PermitMultipleValues ? "any" : "one",
String.Join(", ", Values.ToArray()),
PermitMultipleValues ? " (Use a comma to separate multiple values)" : "");
}
return ok;
}
private static ArgumentHelpStrings GetHelpStrings(Argument arg)
{
return new ArgumentHelpStrings(arg.SyntaxHelp, arg.FullHelpText);
}
/// <summary>
/// Adds an Argument definition to the list of arguments this command-line
/// supports.
/// </summary>
public Argument AddArgument(Argument arg)
{
Arguments.Add(arg.Key, arg);
if(arg is PositionalArgument) {
_positionalArgumentOrder.Add(arg.Key);
}
return arg;
}
/// <summary>
/// Creates a new command line argument parser.
/// </summary>
/// <param name="argumentSpecification"> The type of object to parse. </param>
/// <param name="reporter"> The destination for parse errors. </param>
public Parser(Type argumentSpecification, ReportError reporter)
{
this.reporter = reporter;
arguments = new ArrayList();
argumentMap = new Hashtable();
foreach (FieldInfo field in argumentSpecification.GetFields())
{
if (!field.IsStatic && !field.IsInitOnly && !field.IsLiteral)
{
ArgumentAttribute attribute = GetAttribute(field);
if (attribute is DefaultArgumentAttribute)
{
Debug.Assert(defaultArgument == null);
defaultArgument = new Argument(attribute, field, reporter);
}
else
{
arguments.Add(new Argument(attribute, field, reporter));
}
}
}
// add explicit names to map
foreach (Argument argument in arguments)
{
Debug.Assert(!argumentMap.ContainsKey(argument.LongName));
argumentMap[argument.LongName] = argument;
if (argument.ExplicitShortName)
{
if (argument.ShortName != null && argument.ShortName.Length > 0)
{
Debug.Assert(!argumentMap.ContainsKey(argument.ShortName));
argumentMap[argument.ShortName] = argument;
}
else
{
argument.ClearShortName();
}
}
}
// add implicit names which don't collide to map
foreach (Argument argument in arguments)
{
if (!argument.ExplicitShortName)
{
if (argument.ShortName != null && argument.ShortName.Length > 0 &&
!argumentMap.ContainsKey(argument.ShortName))
{
argumentMap[argument.ShortName] = argument;
}
else
{
argument.ClearShortName();
}
}
}
}
/// Processes a single argument value, ensuring it passes validation,
/// calling any OnParse handlers etc.
protected string ProcessArgumentValue(Dictionary<string, object> result, Argument arg, object val, string set)
{
// Validate value, if argument specifies validation
string errorMsg;
var valArg = arg as ValueArgument;
var sVal = val as string;
if(set != null) {
// Argument must be a member of the same set, or a member of no set
_log.DebugFormat("Checking argument {0} is valid for argument set {1}", arg.Key, set);
if(arg.Set != null && arg.Set != set) {
throw new ParseException(string.Format("Cannot mix arguments from sets {0} and {1}",
arg.Set, set));
}
}
else if(arg.Set != null) {
set = arg.Set;
_log.DebugFormat("Argument set is {0}", set);
}
if(valArg != null) {
if(valArg.Validate != null && sVal != null) {
_log.DebugFormat("Validating argument {0}", valArg.Key);
foreach(ValueArgument.ValidateHandler validate in valArg.Validate.GetInvocationList()) {
if(!validate(arg, sVal, out errorMsg)) {
throw new ParseException(string.Format("The value '{0}' for argument {1} is not valid. {2}.",
sVal, arg.Key, errorMsg));
}
}
_log.TraceFormat("Argument {0} validated", valArg.Key);
}
_log.TraceFormat("Setting {0} to '{1}'", arg.Key, valArg.IsSensitive ? "******" : val);
}
else {
_log.TraceFormat("Setting flag {0} to true", arg.Key);
}
result.Add(arg.Key, val);
// Call OnParse event, if handler specified
if(arg.OnParse != null) {
arg.OnParse(arg, val as string);
}
return set;
}
/// Outputs a single argument definition
protected void OutputArg(Argument arg, TextWriter console)
{
if(arg is FlagArgument) {
console.Write(" --{0,-14} {1}", arg.Key, arg.Description);
}
else {
console.Write(" {0,-16} {1}", arg.Key, arg.Description);
}
var valArg = arg as ValueArgument;
if(valArg != null) {
if(valArg.DefaultValue != null) {
console.Write(" (Default: {0})", valArg.DefaultValue);
}
else if(valArg.IsRequired) {
console.Write(" (Required)");
}
}
console.WriteLine();
}
/// <summary>
/// Convenience method for defining a new positional argument.
/// </summary>
public PositionalArgument AddPositionalArgument(string key, string desc,
Argument.OnParseHandler onParse)
{
var arg = new PositionalArgument { Key = key, Description = desc };
arg.OnParse += onParse;
return (PositionalArgument)Definition.AddArgument(arg);
}
/// <summary>
/// Creates a new command line argument parser.
/// </summary>
/// <param name="argumentSpecification"> The type of object to parse. </param>
/// <param name="reporter"> The destination for parse errors. </param>
public Parser(Type argumentSpecification, ErrorReporter reporter)
{
this.reporter = reporter;
this.arguments = new ArrayList();
this.argumentMap = new Hashtable();
foreach (PropertyInfo prop in argumentSpecification.GetProperties())
{
ArgumentAttribute attribute = GetAttribute(prop);
if (attribute is DefaultArgumentAttribute)
{
Debug.Assert(this.defaultArgument == null);
this.defaultArgument = new Argument(attribute, prop, reporter);
}
else
{
this.arguments.Add(new Argument(attribute, prop, reporter));
}
}
// add explicit names to map
foreach (Argument argument in this.arguments)
{
Debug.Assert(!argumentMap.ContainsKey(argument.LongName));
this.argumentMap[argument.LongName] = argument;
if (argument.ExplicitShortName)
{
if (argument.ShortName != null && argument.ShortName.Length > 0)
{
Debug.Assert(!argumentMap.ContainsKey(argument.ShortName));
this.argumentMap[argument.ShortName] = argument;
}
else
{
argument.ClearShortName();
}
}
}
// add implicit names which don't collide to map
foreach (Argument argument in this.arguments)
{
if (!argument.ExplicitShortName)
{
if (argument.ShortName != null && argument.ShortName.Length > 0 && !argumentMap.ContainsKey(argument.ShortName))
this.argumentMap[argument.ShortName] = argument;
else
argument.ClearShortName();
}
}
}
public bool IsValid(Argument arg, string value, out string errorMsg)
{
errorMsg = null;
if(Expression == null) {
return true;
}
else {
errorMsg = String.Format("Value must satisfy the regular expression: /{0}/", Expression);
return Expression.IsMatch(value);
}
}
public bool IsValid(Argument arg, string value, out string errorMsg)
{
int iVal = int.Parse(value);
errorMsg = null;
if(Min != null && Max != null) {
errorMsg = String.Format("Value must be in the range {0} to {1} inclusive", Min, Max);
}
else if(Min != null) {
errorMsg = String.Format("Value must be greater than or equal to {0}", Min);
}
else if(Max != null) {
errorMsg = String.Format("Value must be less than or equal to {0}", Max);
}
return (Min == null || iVal >= Min) && (Max == null || iVal <= Max);
}
private static ArgumentHelpText GetHelpText(Argument arg)
{
return new ArgumentHelpText(arg.SyntaxHelp, arg.FullHelpText);
}
