//[Fact]
//public void RetrieveNotExistentShortOption()
//{
// var shortOi = _optionMap["y"];
// shortOi.Should().BeNull();
//}
//[Fact]
//public void RetrieveNotExistentLongOption()
//{
// var longOi = _optionMap["nomorebugshere"];
// longOi.Should().BeNull();
//}
private static OptionMap CreateMap(ref OptionMap map, IDictionary<string, OptionInfo> optionCache)
{
if (map == null)
{
map = new OptionMap (3, new CommandLineParserSettings (true));
}
var attribute1 = new OptionAttribute('p', "pretend");
var attribute2 = new OptionAttribute("newuse");
var attribute3 = new OptionAttribute('D', null);
var option1 = attribute1.CreateOptionInfo();
var option2 = attribute2.CreateOptionInfo();
var option3 = attribute3.CreateOptionInfo();
map[attribute1.UniqueName] = option1;
map[attribute2.UniqueName] = option2;
map[attribute3.UniqueName] = option3;
if (optionCache != null)
{
optionCache[attribute1.UniqueName] = option1;
optionCache[attribute1.UniqueName] = option2;
optionCache[attribute2.UniqueName]= option3;
}
return map;
}
//[Fact]
//public void RetrieveNotExistentShortOption()
//{
// var shortOi = _optionMap["y"];
// shortOi.Should().BeNull();
//}
//[Fact]
//public void RetrieveNotExistentLongOption()
//{
// var longOi = _optionMap["nomorebugshere"];
// longOi.Should().BeNull();
//}
private static OptionMap CreateMap(ref OptionMap map, IDictionary <string, OptionInfo> optionCache)
{
if (map == null)
{
map = new OptionMap(3, new ParserSettings(true));
}
var attribute1 = new OptionAttribute('p', "pretend");
var attribute2 = new OptionAttribute("newuse");
var attribute3 = new OptionAttribute('D', null);
var option1 = attribute1.CreateOptionInfo();
var option2 = attribute2.CreateOptionInfo();
var option3 = attribute3.CreateOptionInfo();
map[attribute1.UniqueName] = option1;
map[attribute2.UniqueName] = option2;
map[attribute3.UniqueName] = option3;
if (optionCache != null)
{
optionCache[attribute1.UniqueName] = option1;
optionCache[attribute1.UniqueName] = option2;
optionCache[attribute2.UniqueName] = option3;
}
return(map);
}
private bool TryParseHelpVerb(string[] args, object options, Pair <MethodInfo, HelpVerbOptionAttribute> helpInfo,
OptionMap optionMap)
{
TextWriter helpWriter = _settings.HelpWriter;
if (helpInfo != null && helpWriter != null)
{
if (string.Compare(args[0], helpInfo.Right.LongName, GetStringComparison(_settings)) == 0)
{
// User explicitly requested help
string verb = args.FirstOrDefault();
if (verb != null)
{
OptionInfo verbOption = optionMap[verb];
if (verbOption != null)
{
if (verbOption.GetValue(options) is null)
{
// We need to create an instance also to render help
verbOption.CreateInstance(options);
}
}
}
DisplayHelpVerbText(options, helpInfo, verb);
return(true);
}
}
return(false);
}
public override sealed ParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
IArgumentEnumerator group = new OneCharStringEnumerator(argumentEnumerator.Current.Substring(1));
while (group.MoveNext())
{
var option = map[group.Current];
if (option == null)
return ParserState.Failure;
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (argumentEnumerator.IsLast && group.IsLast)
return ParserState.Failure;
if (!group.IsLast)
{
if (!option.IsArray)
return ArgumentParser.BooleanToParserState(option.SetValue(group.GetRemainingFromNext(), options));
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, group.GetRemainingFromNext());
return ArgumentParser.BooleanToParserState(option.SetValue(items, options), true);
}
}
if (!argumentEnumerator.IsLast && !ArgumentParser.IsInputValue(argumentEnumerator.Next))
return ParserState.Failure;
else
{
if (!option.IsArray)
return ArgumentParser.BooleanToParserState(option.SetValue(argumentEnumerator.Next, options), true);
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
return ArgumentParser.BooleanToParserState(option.SetValue(items, options));
}
}
}
else
{
if (!group.IsLast && map[group.Next] == null)
return ParserState.Failure;
if (!option.SetValue(true, options))
return ParserState.Failure;
}
}
return ParserState.Success;
}
public void CreateInstance()
{
_omBuilder = new OptionMapBuilder(3);
_omBuilder.AppendOption("p", "pretend");
_omBuilder.AppendOption(null, "newuse");
_omBuilder.AppendOption("D", null);
_optionMap = _omBuilder.OptionMap;
}
public void CreateInstance()
{
_omBuilder = new OptionMapBuilder(3);
_omBuilder.AppendOption('p', "pretend");
_omBuilder.AppendOption("newuse");
_omBuilder.AppendOption('D', null);
_optionMap = _omBuilder.OptionMap;
}
private bool DoParseArgumentsVerbs(string[] args, object options, ref object verbInstance)
{
IList <Pair <PropertyInfo, VerbOptionAttribute> > verbs =
ReflectionHelper.RetrievePropertyList <VerbOptionAttribute>(options);
Pair <MethodInfo, HelpVerbOptionAttribute> helpInfo =
ReflectionHelper.RetrieveMethod <HelpVerbOptionAttribute>(options);
if (args.Length == 0)
{
if (helpInfo != null && _settings.HelpWriter != null)
{
DisplayHelpVerbText(options, helpInfo, null);
}
return(false);
}
OptionMap optionMap = OptionMap.Create(options, verbs, _settings);
if (TryParseHelpVerb(args, options, helpInfo, optionMap))
{
return(false);
}
OptionInfo verbOption = optionMap[args.First()];
// User invoked a bad verb name
if (verbOption is null)
{
if (helpInfo != null)
{
DisplayHelpVerbText(options, helpInfo, null);
}
return(false);
}
verbInstance = verbOption.GetValue(options);
if (verbInstance is null)
{
// Developer has not provided a default value and did not assign an instance
verbInstance = verbOption.CreateInstance(options);
}
bool verbResult = DoParseArgumentsCore(args.Skip(1).ToArray(), verbInstance);
if (!verbResult && helpInfo != null)
{
// Particular verb parsing failed, we try to print its help
DisplayHelpVerbText(options, helpInfo, args.First());
}
return(verbResult);
}
public sealed override ParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var parts = argumentEnumerator.Current.Substring(2).Split(new char[] { '=' }, 2);
var option = map[parts[0]];
if (option == null)
return ParserState.Failure;
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (parts.Length == 1 && (argumentEnumerator.IsLast || !ArgumentParser.IsInputValue(argumentEnumerator.Next)))
return ParserState.Failure;
if (parts.Length == 2)
{
if (!option.IsArray)
return ArgumentParser.BooleanToParserState(option.SetValue(parts[1], options));
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, parts[1]);
return ArgumentParser.BooleanToParserState(option.SetValue(items, options));
}
}
else
{
if (!option.IsArray)
return ArgumentParser.BooleanToParserState(option.SetValue(argumentEnumerator.Next, options), true);
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
return ArgumentParser.BooleanToParserState(option.SetValue(items, options), true);
}
}
}
else
{
if (parts.Length == 2)
return ParserState.Failure;
return ArgumentParser.BooleanToParserState(option.SetValue(true, options));
}
}
private bool DoParseArgumentsCore(string[] args, object options)
{
var hadError = false;
var optionMap = OptionMap.Create(options, _settings);
optionMap.SetDefaults();
var valueMapper = new ValueMapper(options, _settings.ParsingCulture);
var arguments = new StringArrayEnumerator(args);
while (arguments.MoveNext())
{
var argument = arguments.Current;
if (string.IsNullOrEmpty(argument))
{
continue;
}
var parser = ArgumentParser.Create(argument, _settings.IgnoreUnknownArguments);
if (parser != null)
{
var result = parser.Parse(arguments, optionMap, options);
if ((result & PresentParserState.Failure) == PresentParserState.Failure)
{
SetParserStateIfNeeded(options, parser.PostParsingState);
hadError = true;
continue;
}
if ((result & PresentParserState.MoveOnNextElement) == PresentParserState.MoveOnNextElement)
{
arguments.MoveNext();
}
}
else if (valueMapper.CanReceiveValues)
{
if (!valueMapper.MapValueItem(argument))
{
hadError = true;
}
}
}
hadError |= !optionMap.EnforceRules();
return(!hadError);
}
public static OptionMap CreateMap(Type type)
{
FieldInfo[] fields = type.GetFields();
OptionMap map = new OptionMap(fields.Length);
foreach (FieldInfo field in fields)
{
if (!field.IsStatic && !field.IsInitOnly && !field.IsLiteral)
{
CmdLineOptionAttribute attribute = CmdLineOptionAttribute.FromField(field);
if (attribute != null)
{
map[attribute.UniqueName] = new OptionInfo(attribute, field);
}
}
}
return(map);
}
private bool TryParseHelpVerb(string[] args, object options, Pair<MethodInfo, HelpVerbOptionAttribute> helpInfo, OptionMap optionMap)
{
var helpWriter = _settings.HelpWriter;
if (helpInfo != null && helpWriter != null)
{
if (string.Compare(args[0], helpInfo.Right.LongName, GetStringComparison(_settings)) == 0)
{
// User explicitly requested help
var verb = args.ElementAtOrDefault(1);
if (verb != null)
{
var verbOption = optionMap[verb];
if (verbOption != null)
{
if (verbOption.GetValue(options) == null)
{
// We need to create an instance also to render help
verbOption.CreateInstance(options);
}
}
}
DisplayHelpVerbText(options, helpInfo, verb);
return true;
}
}
return false;
}
public void ShutdownOptionMap()
{
optionMap = null;
}
public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var optionGroup = new OneCharStringEnumerator(argumentEnumerator.Current.Substring(1));
while (optionGroup.MoveNext())
{
var option = map[optionGroup.Current];
if (option == null)
{
return _ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure;
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (argumentEnumerator.IsLast && optionGroup.IsLast)
{
return PresentParserState.Failure;
}
bool valueSetting;
if (!optionGroup.IsLast)
{
if (!option.IsArray)
{
valueSetting = option.SetValue(optionGroup.GetRemainingFromNext(), options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, optionGroup.GetRemainingFromNext());
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting, true);
}
if (!argumentEnumerator.IsLast && !ArgumentParser.IsInputValue(argumentEnumerator.Next))
{
return PresentParserState.Failure;
}
if (!option.IsArray)
{
valueSetting = option.SetValue(argumentEnumerator.Next, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting, true);
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var moreItems = ArgumentParser.GetNextInputValues(argumentEnumerator);
valueSetting = option.SetValue(moreItems, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
if (!optionGroup.IsLast && map[optionGroup.Next] == null)
{
return PresentParserState.Failure;
}
if (!argumentEnumerator.IsLast)
{
string value = argumentEnumerator.Next;
bool result;
if (bool.TryParse(value, out result))
{
if (!option.SetValue(value, options))
{
return PresentParserState.Failure;
}
argumentEnumerator.MoveNext();
}
else if (!option.SetValue(true, options))
{
return PresentParserState.Failure;
}
}
else
{
if (!option.SetValue(true, options))
{
return PresentParserState.Failure;
}
}
}
return PresentParserState.Success;
}
public sealed override ParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
IArgumentEnumerator group = new OneCharStringEnumerator(argumentEnumerator.Current.Substring(1));
while (group.MoveNext())
{
var option = map[group.Current];
if (option == null)
{
return(ParserState.Failure);
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (argumentEnumerator.IsLast && group.IsLast)
{
return(ParserState.Failure);
}
if (!group.IsLast)
{
if (!option.IsArray)
{
return(ArgumentParser.BooleanToParserState(option.SetValue(group.GetRemainingFromNext(), options)));
}
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, group.GetRemainingFromNext());
return(ArgumentParser.BooleanToParserState(option.SetValue(items, options), true));
}
}
if (!argumentEnumerator.IsLast && !ArgumentParser.IsInputValue(argumentEnumerator.Next))
{
return(ParserState.Failure);
}
else
{
if (!option.IsArray)
{
return(ArgumentParser.BooleanToParserState(option.SetValue(argumentEnumerator.Next, options), true));
}
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
return(ArgumentParser.BooleanToParserState(option.SetValue(items, options)));
}
}
}
else
{
if (!group.IsLast && map[group.Next] == null)
{
return(ParserState.Failure);
}
if (!option.SetValue(true, options))
{
return(ParserState.Failure);
}
}
}
return(ParserState.Success);
}
public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var parts = argumentEnumerator.Current.Substring(2).Split(new[] { '=' }, 2);
var option = map[parts[0]];
if (option == null)
{
return _ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure;
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
bool valueSetting;
if (!option.IsBoolean)
{
if (parts.Length == 1 && (argumentEnumerator.IsLast || !ArgumentParser.IsInputValue(argumentEnumerator.Next)))
{
return PresentParserState.Failure;
}
if (parts.Length == 2)
{
if (!option.IsArray)
{
valueSetting = option.SetValue(parts[1], options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, parts[1]);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
else
{
if (!option.IsArray)
{
valueSetting = option.SetValue(argumentEnumerator.Next, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting, true);
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
}
if (parts.Length == 2)
{
return PresentParserState.Failure;
}
valueSetting = option.SetValue(true, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return ArgumentParser.BooleanToParserState(valueSetting);
}
public static OptionMap Create(object target, IParserSettings settings)
{
var list = ReflectionUtil.RetrievePropertyList<BaseOptionAttribute>(target);
if (list == null)
{
return null;
}
var map = new OptionMap(list.Count, settings);
foreach (var pair in list)
{
if (pair.Left != null && pair.Right != null)
{
string uniqueName;
if (pair.Right.AutoLongName)
{
uniqueName = pair.Left.Name.ToLowerInvariant();
pair.Right.LongName = uniqueName;
}
else
{
uniqueName = pair.Right.UniqueName;
}
map[uniqueName] = new OptionInfo(pair.Right, pair.Left, settings.ParsingCulture);
}
}
map.RawOptions = target;
return map;
}
public Parser(Type type)
{
m_optionMap = OptionInfo.CreateMap(type);
}
public OptionMapBuilder(int capacity)
{
_optionMap = new OptionMap(capacity, new CommandLineParserSettings(true));
_options = new List<OptionInfo>(capacity);
_names = new List<string>(capacity);
}
public void ShutdownInstance()
{
_optionMap = null;
}
public sealed override ParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var parts = argumentEnumerator.Current.Substring(2).Split(new char[] { '=' }, 2);
var option = map[parts[0]];
if (option == null)
{
return(ParserState.Failure);
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (parts.Length == 1 && (argumentEnumerator.IsLast || !ArgumentParser.IsInputValue(argumentEnumerator.Next)))
{
return(ParserState.Failure);
}
if (parts.Length == 2)
{
if (!option.IsArray)
{
return(ArgumentParser.BooleanToParserState(option.SetValue(parts[1], options)));
}
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, parts[1]);
return(ArgumentParser.BooleanToParserState(option.SetValue(items, options)));
}
}
else
{
if (!option.IsArray)
{
return(ArgumentParser.BooleanToParserState(option.SetValue(argumentEnumerator.Next, options), true));
}
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
return(ArgumentParser.BooleanToParserState(option.SetValue(items, options), true));
}
}
}
else
{
if (parts.Length == 2)
{
return(ParserState.Failure);
}
return(ArgumentParser.BooleanToParserState(option.SetValue(true, options)));
}
}
public override sealed ParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var parts = argumentEnumerator.Current.Substring(switchLength).Split(new char[] { '=' }, 2);
var option = map[parts[0]];
var valueSetting = false;
if (option == null)
return ParserState.Failure;
option.IsDefined = true;
EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (parts.Length == 1 && (argumentEnumerator.IsLast || !IsInputValue(argumentEnumerator.Next)))
return ParserState.Failure;
if (parts.Length == 2)
{
if (!option.IsArray)
{
valueSetting = option.SetValue(parts[1], options);
if (!valueSetting)
this.DefineOptionThatViolatesFormat(option);
return BooleanToParserState(valueSetting);
}
else
{
EnsureOptionAttributeIsArrayCompatible(option);
var items = GetNextInputValues(argumentEnumerator);
items.Insert(0, parts[1]);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
this.DefineOptionThatViolatesFormat(option);
return BooleanToParserState(valueSetting);
}
}
else
{
if (!option.IsArray)
{
valueSetting = option.SetValue(argumentEnumerator.Next, options);
if (!valueSetting)
this.DefineOptionThatViolatesFormat(option);
return ArgumentParser.BooleanToParserState(valueSetting, true);
}
else
{
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
this.DefineOptionThatViolatesFormat(option);
return ArgumentParser.BooleanToParserState(valueSetting, true);
}
}
}
else
{
if (parts.Length == 2)
return ParserState.Failure;
valueSetting = option.SetValue(true, options);
if (!valueSetting)
this.DefineOptionThatViolatesFormat(option);
return ArgumentParser.BooleanToParserState(valueSetting);
}
}
public void ShutdownInstance()
{
_optionMap = null;
}
public void CreateInstance()
{
optionMap = new OptionMap(3);
}
public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var parts = argumentEnumerator.Current.Substring(2).Split(new[] { '=' }, 2);
var option = map[parts[0]];
if (option == null)
{
return(_ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure);
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
bool valueSetting;
if (!option.IsBoolean)
{
if (parts.Length == 1 && (argumentEnumerator.IsLast || !ArgumentParser.IsInputValue(argumentEnumerator.Next)))
{
return(PresentParserState.Failure);
}
if (parts.Length == 2)
{
if (!option.IsArray)
{
valueSetting = option.SetValue(parts[1], options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, parts[1]);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
else
{
if (!option.IsArray)
{
valueSetting = option.SetValue(argumentEnumerator.Next, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting, true));
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
}
if (parts.Length == 2)
{
return(PresentParserState.Failure);
}
valueSetting = option.SetValue(true, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
public OptionMapBuilder(int capacity)
{
_optionMap = new OptionMap(capacity, new ParserSettings(true));
_options = new List <OptionInfo>(capacity);
_names = new List <string>(capacity);
}
public override PresentParserState Parse(IArgumentEnumerator argumentEnumerator, OptionMap map, object options)
{
var optionGroup = new OneCharStringEnumerator(argumentEnumerator.Current.Substring(1));
while (optionGroup.MoveNext())
{
var option = map[optionGroup.Current];
if (option == null)
{
return(_ignoreUnkwnownArguments ? PresentParserState.MoveOnNextElement : PresentParserState.Failure);
}
option.IsDefined = true;
ArgumentParser.EnsureOptionArrayAttributeIsNotBoundToScalar(option);
if (!option.IsBoolean)
{
if (argumentEnumerator.IsLast && optionGroup.IsLast)
{
return(PresentParserState.Failure);
}
bool valueSetting;
if (!optionGroup.IsLast)
{
if (!option.IsArray)
{
valueSetting = option.SetValue(optionGroup.GetRemainingFromNext(), options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var items = ArgumentParser.GetNextInputValues(argumentEnumerator);
items.Insert(0, optionGroup.GetRemainingFromNext());
valueSetting = option.SetValue(items, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting, true));
}
if (!argumentEnumerator.IsLast && !ArgumentParser.IsInputValue(argumentEnumerator.Next))
{
return(PresentParserState.Failure);
}
if (!option.IsArray)
{
valueSetting = option.SetValue(argumentEnumerator.Next, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting, true));
}
ArgumentParser.EnsureOptionAttributeIsArrayCompatible(option);
var moreItems = ArgumentParser.GetNextInputValues(argumentEnumerator);
valueSetting = option.SetValue(moreItems, options);
if (!valueSetting)
{
DefineOptionThatViolatesFormat(option);
}
return(ArgumentParser.BooleanToParserState(valueSetting));
}
if (!optionGroup.IsLast && map[optionGroup.Next] == null)
{
return(PresentParserState.Failure);
}
if (!option.SetValue(true, options))
{
return(PresentParserState.Failure);
}
}
return(PresentParserState.Success);
}
public static OptionMap Create(
object target,
IList<Pair<PropertyInfo, VerbOptionAttribute>> verbs,
IParserSettings settings)
{
var map = new OptionMap(verbs.Count, settings);
foreach (var verb in verbs)
{
var optionInfo = new OptionInfo(verb.Right, verb.Left, settings.ParsingCulture)
{
HasParameterLessCtor = verb.Left.PropertyType.GetConstructor(Type.EmptyTypes) != null
};
if (!optionInfo.HasParameterLessCtor && verb.Left.GetValue(target, null) == null)
{
throw new ParserException("Type {0} must have a parameterless constructor or" +
" be already initialized to be used as a verb command.".FormatInvariant(verb.Left.PropertyType));
}
map[verb.Right.UniqueName] = optionInfo;
}
map.RawOptions = target;
return map;
}
void MyOnLoad(object sender, EventArgs e)
{
//TestBoundries();
if (Environment.CommandLine.Contains("hide"))
{
this.Visible = false;
//this.ShowInTaskbar = false;
}
if (Environment.CommandLine.Contains("HIDE"))
{
this.Visible = false;
this.ShowInTaskbar = false;
}
if (!Environment.CommandLine.Contains("config"))
{
#if test
button2.Enabled = false;
button3.Enabled = false;
button4.Enabled = false;
button5.Enabled = false;
button6.Enabled = false;
buttonOptionEdit.Enabled = false;
#endif
}
// might take this option out of the starter... and just Start...
#if asdfasdfasdf
if (Options.Default["System:" + Environment.MachineName]["Bingo Game Core"]["External Game Data"]["Enable Reciever", "0"].Bool)
{
//String_Utilities.BuildSessionRangeCondition( null, DateTime.Now, 0 );
BingoGameCore4.Networking.EltaninReceiver.BingodayChanged
+= new BingoGameCore4.Networking.ExternalReceiver.OnBingodayChange(ExternalReceiver_BingodayChanged);
BingoGameCore4.Networking.EltaninReceiver.SessionChanged
+= new BingoGameCore4.Networking.ExternalReceiver.OnSessionChange(ExternalReceiver_SessionChanged);
BingoGameCore4.Networking.EltaninReceiver.GameChanged
+= new BingoGameCore4.Networking.ExternalReceiver.OnGameChange(ExternalReceiver_GameChanged);
BingoGameCore4.Networking.ExternalReceiver.Start();
}
#endif
schedule_dsn = new DsnConnection(StaticDsnConnection.dsn.DataSource);
schedule = new OpenSkieScheduler3.ScheduleDataSet(schedule_dsn);
schedule.Fill();
BingoGameCore4.RateRank.Setup(schedule_dsn);
BingoGameCore4.RateRank.game_points = new BingoGameCore4.Database.RankPointsExtended(schedule);
input_db = new DsnConnection(Options.File("RateRank.ini")[Options.ProgramName + "/config"]["Input Database DSN", "MySQL"].Value);
Text = Text + "[" + input_db.DataSource + "]";
OptionMap options = Options.Database(input_db)[Options.ProgramName];
StateWriter.WritePackRateDetails = options["Write called_game_player_pack_stats (per card info)", "1"].Bool;
if (options["config"]["Enable Game Check Timer", "0"].Bool)
{
timer_gameEventDataSet = new BingoGameEvent.GameEventDataSet(input_db);
check_winner = new System.Windows.Forms.Timer();
check_winner.Interval = options["config"]["Game Check Timer Length", "5000"].Integer;
check_winner.Tick += new EventHandler(check_winner_Tick);
check_winner.Start();
}
monthCalendar1.ActiveMonth.Year = DateTime.Now.Year;
monthCalendar1.ActiveMonth.Month = DateTime.Now.Month;
monthCalendar1.MonthChanged += new Pabo.Calendar.MonthChangedEventHandler(monthCalendar1_MonthChanged);
monthCalendar1.DaySelected += new Pabo.Calendar.DaySelectedEventHandler(monthCalendar1_DaySelected);
listBoxSessions.SelectedIndexChanged += new EventHandler(listBoxSessions_SelectedIndexChanged);
dataGridView1.SelectionChanged += new EventHandler(dataGridView1_SelectionChanged);
dataGridView1.MouseCaptureChanged += new EventHandler(dataGridView1_MouseCaptureChanged);
}
