Inheritance diagram for Ntp.Common.IO.OptionSet:

Collaboration diagram for Ntp.Common.IO.OptionSet:

Classes
class	ActionOption

class	ActionOption

class	ActionOption

class	ArgumentEnumerator

class	Category

Public Member Functions
	OptionSet ()

	OptionSet (MessageLocalizerConverter localizer)

OptionSet	Add (string header)

new OptionSet	Add (Option option)

OptionSet	Add (string prototype, Action< string > action)

OptionSet	Add (string prototype, string description, Action< string > action)

OptionSet	Add (string prototype, string description, Action< string > action, bool hidden)

OptionSet	Add (string prototype, OptionAction< string, string > action)

OptionSet	Add (string prototype, string description, OptionAction< string, string > action)

OptionSet	Add (string prototype, string description, OptionAction< string, string > action, bool hidden)

OptionSet	Add (ArgumentSource source)

OptionSet	Add< T > (string prototype, Action< T > action)

OptionSet	Add< T > (string prototype, string description, Action< T > action)

OptionSet	Add< TKey, TValue > (string prototype, OptionAction< TKey, TValue > action)

OptionSet	Add< TKey, TValue > (string prototype, string description, OptionAction< TKey, TValue > action)

List< string >	Parse (IEnumerable< string > arguments)

void	WriteOptionDescriptions (TextWriter o)

Protected Member Functions
virtual OptionContext	CreateOptionContext ()

override string	GetKeyForItem (Option item)

Option	GetOptionForName (string option)

bool	GetOptionParts (string argument, out string flag, out string name, out string sep, out string value)

override void	InsertItem (int index, Option item)

virtual bool	Parse (string argument, OptionContext c)

override void	RemoveItem (int index)

override void	SetItem (int index, Option item)

Properties
ReadOnlyCollection< ArgumentSource >	ArgumentSources `[get]`

MessageLocalizerConverter	MessageLocalizer `[get]`

Private Member Functions
void	AddImpl (Option option)

bool	AddSource (ArgumentEnumerator ae, string argument)

bool	ParseBool (string option, string n, OptionContext c)

bool	ParseBundledValue (string f, string n, OptionContext c)

void	ParseValue (string option, OptionContext c)

void	WriteDescription (TextWriter o, string value, string prefix, int firstWidth, int remWidth)

bool	WriteOptionPrototype (TextWriter o, Option p, ref int written)

Static Private Member Functions
static string	GetArgumentName (int index, int maxIndex, string description)

static string	GetDescription (string description)

static IEnumerable< string >	GetLines (string description, int firstWidth, int remWidth)

static int	GetNextOptionIndex (string[] names, int i)

static void	Invoke (OptionContext c, string name, string value, Option option)

static void	Unprocessed (ICollection< string > extra, Option def, OptionContext c, string argument)

static void	Write (TextWriter o, ref int n, string s)

Private Attributes
const int	DescriptionFirstWidth = 80 - OptionWidth

const int	DescriptionRemWidth = 80 - OptionWidth - 2

const int	OptionWidth = 29

readonly List< ArgumentSource >	sources = new List<ArgumentSource>()

readonly Regex	valueOption

Detailed Description

Definition at line 785 of file Options.cs.

Constructor & Destructor Documentation

Ntp.Common.IO.OptionSet.OptionSet ( )

inline

Definition at line 787 of file Options.cs.

             : this(f => f)
         {
         }

Ntp.Common.IO.OptionSet.OptionSet ( MessageLocalizerConverter localizer )

inline

Definition at line 792 of file Options.cs.

         {
             MessageLocalizer = localizer;
             ArgumentSources = new ReadOnlyCollection<ArgumentSource>(sources);
         }

Member Function Documentation

OptionSet Ntp.Common.IO.OptionSet.Add ( string header )

inline

Definition at line 811 of file Options.cs.

Referenced by Ntp.Common.IO.OptionSet.Add().

         {
             if (header == null)
                 throw new ArgumentNullException(nameof(header));
             Add(new Category(header));
             return this;
         }

Here is the caller graph for this function:

new OptionSet Ntp.Common.IO.OptionSet.Add ( Option option )

inline

Definition at line 820 of file Options.cs.

References Ntp.Common.IO.OptionSet.Add().

         {
             base.Add(option);
             return this;
         }

Here is the call graph for this function:

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		Action< string >	action
	)

inline

Definition at line 826 of file Options.cs.

         {
             return Add(prototype, null, action);
         }

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		string	description,
		Action< string >	action
	)

inline

Definition at line 831 of file Options.cs.

         {
             return Add(prototype, description, action, false);
         }

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		string	description,
		Action< string >	action,
		bool	hidden
	)

inline

Definition at line 836 of file Options.cs.

         {
             if (action == null)
                 throw new ArgumentNullException(nameof(action));
             Option p = new ActionOption(prototype, description, 1,
                 delegate(OptionValueCollection v) { action(v[0]); }, hidden);
             base.Add(p);
             return this;
         }

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		OptionAction< string, string >	action
	)

inline

Definition at line 846 of file Options.cs.

         {
             return Add(prototype, null, action);
         }

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		string	description,
		OptionAction< string, string >	action
	)

inline

Definition at line 851 of file Options.cs.

         {
             return Add(prototype, description, action, false);
         }

OptionSet Ntp.Common.IO.OptionSet.Add	(	string	prototype,
		string	description,
		OptionAction< string, string >	action,
		bool	hidden
	)

inline

Definition at line 856 of file Options.cs.

         {
             if (action == null)
                 throw new ArgumentNullException(nameof(action));
             Option p = new ActionOption(prototype, description, 2,
                 delegate(OptionValueCollection v) { action(v[0], v[1]); }, hidden);
             base.Add(p);
             return this;
         }

OptionSet Ntp.Common.IO.OptionSet.Add ( ArgumentSource source )

inline

Definition at line 886 of file Options.cs.

         {
             if (source == null)
                 throw new ArgumentNullException(nameof(source));
             sources.Add(source);
             return this;
         }

OptionSet Ntp.Common.IO.OptionSet.Add< T >	(	string	prototype,
		Action< T >	action
	)

inline

Definition at line 866 of file Options.cs.

         {
             return Add(prototype, null, action);
         }

OptionSet Ntp.Common.IO.OptionSet.Add< T >	(	string	prototype,
		string	description,
		Action< T >	action
	)

inline

Definition at line 871 of file Options.cs.

         {
             return Add(new ActionOption<T>(prototype, description, action));
         }

OptionSet Ntp.Common.IO.OptionSet.Add< TKey, TValue >	(	string	prototype,
		OptionAction< TKey, TValue >	action
	)

inline

Definition at line 876 of file Options.cs.

         {
             return Add(prototype, null, action);
         }

OptionSet Ntp.Common.IO.OptionSet.Add< TKey, TValue >	(	string	prototype,
		string	description,
		OptionAction< TKey, TValue >	action
	)

inline

Definition at line 881 of file Options.cs.

         {
             return Add(new ActionOption<TKey, TValue>(prototype, description, action));
         }

void Ntp.Common.IO.OptionSet.AddImpl ( Option option )

inlineprivate

Definition at line 1101 of file Options.cs.

References Ntp.Common.IO.Option.Names.

         {
             if (option == null)
                 throw new ArgumentNullException(nameof(option));
             var added = new List<string>(option.Names.Length);
             try
             {
                 // KeyedCollection.InsertItem/SetItem handle the 0th name.
                 for (var i = 1; i < option.Names.Length; ++i)
                 {
                     Dictionary.Add(option.Names[i], option);
                     added.Add(option.Names[i]);
                 }
             }
             catch (Exception)
             {
                 foreach (var name in added)
                     Dictionary.Remove(name);
                 throw;
             }
         }

bool Ntp.Common.IO.OptionSet.AddSource	(	ArgumentEnumerator	ae,
		string	argument
	)

inlineprivate

Definition at line 1123 of file Options.cs.

         {
             foreach (var source in sources)
             {
                 IEnumerable<string> replacement;
                 if (!source.GetArguments(argument, out replacement))
                     continue;
                 ae.Add(replacement);
                 return true;
             }
             return false;
         }

virtual OptionContext Ntp.Common.IO.OptionSet.CreateOptionContext ( )

inlineprotectedvirtual

Definition at line 989 of file Options.cs.

         {
             return new OptionContext(this);
         }

static string Ntp.Common.IO.OptionSet.GetArgumentName	(	int	index,
		int	maxIndex,
		string	description
	)

inlinestaticprivate

Definition at line 1136 of file Options.cs.

         {
             if (description == null)
                 return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
 
             var nameStart = maxIndex == 1 ? new[] {"{0:", "{"} : new[] {"{" + index + ":"};
 
             foreach (var t in nameStart)
             {
                 int start, j = 0;
                 do
                 {
                     start = description.IndexOf(t, j, StringComparison.Ordinal);
                 } while (start >= 0 && j != 0 && description[j++ - 1] == '{');
                 if (start == -1)
                     continue;
                 var end = description.IndexOf("}", start, StringComparison.Ordinal);
                 if (end == -1)
                     continue;
                 return description.Substring(start + t.Length, end - start - t.Length);
             }
 
             return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
         }

static string Ntp.Common.IO.OptionSet.GetDescription ( string description )

inlinestaticprivate

Definition at line 1161 of file Options.cs.

         {
             if (description == null)
                 return string.Empty;
             var sb = new StringBuilder(description.Length);
             var start = -1;
             for (var i = 0; i < description.Length; ++i)
             {
                 switch (description[i])
                 {
                     case '{':
                         if (i == start)
                         {
                             sb.Append('{');
                             start = -1;
                         }
                         else if (start < 0)
                             start = i + 1;
                         break;
                     case '}':
                         if (start < 0)
                         {
                             if (i + 1 == description.Length || description[i + 1] != '}')
                                 throw new InvalidOperationException("Invalid option description: " + description);
                             ++i;
                             sb.Append("}");
                         }
                         else
                         {
                             sb.Append(description.Substring(start, i - start));
                             start = -1;
                         }
                         break;
                     case ':':
                         if (start < 0)
                             goto default;
                         start = i + 1;
                         break;
                     default:
                         if (start < 0)
                             sb.Append(description[i]);
                         break;
                 }
             }
             return sb.ToString();
         }

override string Ntp.Common.IO.OptionSet.GetKeyForItem ( Option item )

inlineprotected

Definition at line 995 of file Options.cs.

References Ntp.Common.IO.Option.Names.

         {
             if (item == null)
                 throw new ArgumentNullException(nameof(item));
             if (item.Names != null && item.Names.Length > 0)
                 return item.Names[0];
             // This should never happen, as it's invalid for Option to be
             // constructed w/o any names.
             throw new InvalidOperationException("Option has no names!");
         }

static IEnumerable<string> Ntp.Common.IO.OptionSet.GetLines	(	string	description,
		int	firstWidth,
		int	remWidth
	)

inlinestaticprivate

Definition at line 1208 of file Options.cs.

References Ntp.Common.IO.StringCoda.WrappedLines().

         {
             return StringCoda.WrappedLines(description, firstWidth, remWidth);
         }

Here is the call graph for this function:

static int Ntp.Common.IO.OptionSet.GetNextOptionIndex	(	string[]	names,
		int	i
	)

inlinestaticprivate

Definition at line 1213 of file Options.cs.

         {
             while (i < names.Length && names[i] == "<>")
             {
                 ++i;
             }
             return i;
         }

Option Ntp.Common.IO.OptionSet.GetOptionForName ( string option )

inlineprotected

Definition at line 1007 of file Options.cs.

         {
             if (option == null)
                 throw new ArgumentNullException(nameof(option));
             try
             {
                 return base[option];
             }
             catch (KeyNotFoundException)
             {
                 return null;
             }
         }

bool Ntp.Common.IO.OptionSet.GetOptionParts	(	string	argument,
		out string	flag,
		out string	name,
		out string	sep,
		out string	value
	)

inlineprotected

Definition at line 1021 of file Options.cs.

         {
             if (argument == null)
                 throw new ArgumentNullException(nameof(argument));
 
             flag = name = sep = value = null;
             var m = valueOption.Match(argument);
             if (!m.Success)
             {
                 return false;
             }
             flag = m.Groups["flag"].Value;
             name = m.Groups["name"].Value;
             if (m.Groups["sep"].Success && m.Groups["value"].Success)
             {
                 sep = m.Groups["sep"].Value;
                 value = m.Groups["value"].Value;
             }
             return true;
         }

override void Ntp.Common.IO.OptionSet.InsertItem	(	int	index,
		Option	item
	)

inlineprotected

Definition at line 1043 of file Options.cs.

         {
             base.InsertItem(index, item);
             AddImpl(item);
         }

static void Ntp.Common.IO.OptionSet.Invoke	(	OptionContext	c,
		string	name,
		string	value,
		Option	option
	)

inlinestaticprivate

Definition at line 1222 of file Options.cs.

References Ntp.Common.IO.OptionValueCollection.Add(), Ntp.Common.IO.Option.Invoke(), Ntp.Common.IO.OptionContext.Option, Ntp.Common.IO.OptionContext.OptionName, and Ntp.Common.IO.OptionContext.OptionValues.

         {
             c.OptionName = name;
             c.Option = option;
             c.OptionValues.Add(value);
             option.Invoke(c);
         }

Here is the call graph for this function:

List<string> Ntp.Common.IO.OptionSet.Parse ( IEnumerable< string > arguments )

inline

Definition at line 894 of file Options.cs.

         {
             if (arguments == null)
                 throw new ArgumentNullException(nameof(arguments));
 
             var c = CreateOptionContext();
             c.OptionIndex = -1;
             var process = true;
             var unprocessed = new List<string>();
             var def = Contains("<>") ? this["<>"] : null;
             var ae = new ArgumentEnumerator(arguments);
 
             foreach (var argument in ae)
             {
                 ++c.OptionIndex;
                 if (argument == "--")
                 {
                     process = false;
                     continue;
                 }
                 if (!process)
                 {
                     Unprocessed(unprocessed, def, c, argument);
                     continue;
                 }
                 if (AddSource(ae, argument))
                     continue;
                 if (!Parse(argument, c))
                     Unprocessed(unprocessed, def, c, argument);
             }
 
             c.Option?.Invoke(c);
             return unprocessed;
         }

virtual bool Ntp.Common.IO.OptionSet.Parse	(	string	argument,
		OptionContext	c
	)

inlineprotectedvirtual

Definition at line 1049 of file Options.cs.

References Ntp.Common.IO.OptionValueCollection.Add(), Ntp.Common.IO.Option.Invoke(), Ntp.Common.IO.OptionContext.Option, Ntp.Common.IO.OptionContext.OptionName, Ntp.Common.IO.OptionContext.OptionValues, and s().

         {
             if (c.Option != null)
             {
                 ParseValue(argument, c);
                 return true;
             }
 
             string f, n, s, v;
             if (!GetOptionParts(argument, out f, out n, out s, out v))
                 return false;
 
             if (Contains(n))
             {
                 var p = this[n];
                 c.OptionName = f + n;
                 c.Option = p;
                 switch (p.OptionValueType)
                 {
                     case OptionValueType.None:
                         c.OptionValues.Add(n);
                         c.Option.Invoke(c);
                         break;
                     case OptionValueType.Optional:
                     case OptionValueType.Required:
                         ParseValue(v, c);
                         break;
                 }
                 return true;
             }
 
             // no match; is it a bool option?
             return ParseBool(argument, n, c) || ParseBundledValue(f, $"{n}{s}{v}", c);
         }

Here is the call graph for this function:

bool Ntp.Common.IO.OptionSet.ParseBool	(	string	option,
		string	n,
		OptionContext	c
	)

inlineprivate

Definition at line 1230 of file Options.cs.

References Ntp.Common.IO.OptionValueCollection.Add(), Ntp.Common.IO.OptionContext.Option, Ntp.Common.IO.OptionContext.OptionName, and Ntp.Common.IO.OptionContext.OptionValues.

         {
             string rn;
             if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') &&
                 Contains(rn = n.Substring(0, n.Length - 1)))
             {
                 var p = this[rn];
                 var v = n[n.Length - 1] == '+' ? option : null;
                 c.OptionName = option;
                 c.Option = p;
                 c.OptionValues.Add(v);
                 p.Invoke(c);
                 return true;
             }
             return false;
         }

Here is the call graph for this function:

bool Ntp.Common.IO.OptionSet.ParseBundledValue	(	string	f,
		string	n,
		OptionContext	c
	)

inlineprivate

Definition at line 1247 of file Options.cs.

References Ntp.Common.IO.OptionContext.Option, and Ntp.Common.IO.OptionContext.OptionName.

         {
             if (f != "-")
                 return false;
             for (var i = 0; i < n.Length; ++i)
             {
                 var opt = f + n[i];
                 var rn = n[i].ToString();
                 if (!Contains(rn))
                 {
                     if (i == 0)
                         return false;
                     throw new OptionException(string.Format(MessageLocalizer(
                         "Cannot use unregistered option '{0}' in bundle '{1}'."), rn, f + n), null);
                 }
                 var p = this[rn];
                 switch (p.OptionValueType)
                 {
                     case OptionValueType.None:
                         Invoke(c, opt, n, p);
                         break;
                     case OptionValueType.Optional:
                     case OptionValueType.Required:
                     {
                         var v = n.Substring(i + 1);
                         c.Option = p;
                         c.OptionName = opt;
                         ParseValue(v.Length != 0 ? v : null, c);
                         return true;
                     }
                     default:
                         throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType);
                 }
             }
             return true;
         }

void Ntp.Common.IO.OptionSet.ParseValue	(	string	option,
		OptionContext	c
	)

inlineprivate

Definition at line 1284 of file Options.cs.

         {
             if (option != null)
                 foreach (var o in c.Option.ValueSeparators != null
                     ? option.Split(c.Option.ValueSeparators, c.Option.MaxValueCount - c.OptionValues.Count,
                         StringSplitOptions.None)
                     : new[] {option})
                 {
                     c.OptionValues.Add(o);
                 }
             if (c.OptionValues.Count == c.Option.MaxValueCount ||
                 c.Option.OptionValueType == OptionValueType.Optional)
                 c.Option.Invoke(c);
             else if (c.OptionValues.Count > c.Option.MaxValueCount)
             {
                 throw new OptionException(MessageLocalizer(
                     $"Error: Found {c.OptionValues.Count} option values when expecting {c.Option.MaxValueCount}."),
                     c.OptionName);
             }
         }

override void Ntp.Common.IO.OptionSet.RemoveItem ( int index )

inlineprotected

Definition at line 1084 of file Options.cs.

         {
             var p = Items[index];
             base.RemoveItem(index);
             // KeyedCollection.RemoveItem() handles the 0th item
             for (var i = 1; i < p.Names.Length; ++i)
             {
                 Dictionary.Remove(p.Names[i]);
             }
         }

override void Ntp.Common.IO.OptionSet.SetItem	(	int	index,
		Option	item
	)

inlineprotected

Definition at line 1095 of file Options.cs.

         {
             base.SetItem(index, item);
             AddImpl(item);
         }

static void Ntp.Common.IO.OptionSet.Unprocessed	(	ICollection< string >	extra,
		Option	def,
		OptionContext	c,
		string	argument
	)

inlinestaticprivate

Definition at line 1305 of file Options.cs.

References Ntp.Common.IO.OptionValueCollection.Add(), Ntp.Common.IO.Option.Invoke(), Ntp.Common.IO.OptionContext.Option, and Ntp.Common.IO.OptionContext.OptionValues.

         {
             if (def == null)
             {
                 extra.Add(argument);
                 return;
             }
             c.OptionValues.Add(argument);
             c.Option = def;
             c.Option.Invoke(c);
         }

Here is the call graph for this function:

static void Ntp.Common.IO.OptionSet.Write	(	TextWriter	o,
		ref int	n,
		string	s
	)

inlinestaticprivate

Definition at line 1317 of file Options.cs.

         {
             n += s.Length;
             o.Write(s);
         }

void Ntp.Common.IO.OptionSet.WriteDescription	(	TextWriter	o,
		string	value,
		string	prefix,
		int	firstWidth,
		int	remWidth
	)

inlineprivate

Definition at line 1323 of file Options.cs.

         {
             var indent = false;
             foreach (var line in GetLines(MessageLocalizer(GetDescription(value)), firstWidth, remWidth))
             {
                 if (indent)
                     o.Write(prefix);
                 o.WriteLine(line);
                 indent = true;
             }
         }

void Ntp.Common.IO.OptionSet.WriteOptionDescriptions ( TextWriter o )

inline

Definition at line 929 of file Options.cs.

References s().

         {
             foreach (var p in this)
             {
                 var written = 0;
 
                 if (p.Hidden)
                     continue;
 
                 var c = p as Category;
                 if (c != null)
                 {
                     WriteDescription(o, p.Description, "", 80, 80);
                     continue;
                 }
 
                 if (!WriteOptionPrototype(o, p, ref written))
                     continue;
 
                 if (written < OptionWidth)
                     o.Write(new string(' ', OptionWidth - written));
                 else
                 {
                     o.WriteLine();
                     o.Write(new string(' ', OptionWidth));
                 }
 
                 WriteDescription(o, p.Description, new string(' ', OptionWidth + 2),
                     DescriptionFirstWidth, DescriptionRemWidth);
             }
 
             foreach (var s in sources)
             {
                 var names = s.GetNames();
                 if (names == null || names.Length == 0)
                     continue;
 
                 var written = 0;
 
                 Write(o, ref written, "  ");
                 Write(o, ref written, names[0]);
                 for (var i = 1; i < names.Length; ++i)
                 {
                     Write(o, ref written, ", ");
                     Write(o, ref written, names[i]);
                 }
 
                 if (written < OptionWidth)
                     o.Write(new string(' ', OptionWidth - written));
                 else
                 {
                     o.WriteLine();
                     o.Write(new string(' ', OptionWidth));
                 }
 
                 WriteDescription(o, s.Description, new string(' ', OptionWidth + 2),
                     DescriptionFirstWidth, DescriptionRemWidth);
             }
         }

Here is the call graph for this function:

bool Ntp.Common.IO.OptionSet.WriteOptionPrototype	(	TextWriter	o,
		Option	p,
		ref int	written
	)

inlineprivate

Definition at line 1335 of file Options.cs.

References c, Ntp.Common.IO.Option.Description, Ntp.Common.IO.Option.MaxValueCount, Ntp.Common.IO.Option.Names, Ntp.Common.IO.Option.OptionValueType, and Ntp.Common.IO.Option.ValueSeparators.

         {
             var names = p.Names;
 
             var i = GetNextOptionIndex(names, 0);
             if (i == names.Length)
                 return false;
 
             if (names[i].Length == 1)
             {
                 Write(o, ref written, "  -");
                 Write(o, ref written, names[0]);
             }
             else
             {
                 Write(o, ref written, "      --");
                 Write(o, ref written, names[0]);
             }
 
             for (i = GetNextOptionIndex(names, i + 1);
                 i < names.Length;
                 i = GetNextOptionIndex(names, i + 1))
             {
                 Write(o, ref written, ", ");
                 Write(o, ref written, names[i].Length == 1 ? "-" : "--");
                 Write(o, ref written, names[i]);
             }
 
             if (p.OptionValueType == OptionValueType.Optional ||
                 p.OptionValueType == OptionValueType.Required)
             {
                 if (p.OptionValueType == OptionValueType.Optional)
                 {
                     Write(o, ref written, MessageLocalizer("["));
                 }
                 Write(o, ref written, MessageLocalizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description)));
                 var sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0
                     ? p.ValueSeparators[0]
                     : " ";
                 for (var c = 1; c < p.MaxValueCount; ++c)
                 {
                     Write(o, ref written, MessageLocalizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description)));
                 }
                 if (p.OptionValueType == OptionValueType.Optional)
                 {
                     Write(o, ref written, MessageLocalizer("]"));
                 }
             }
             return true;
         }

Member Data Documentation

const int Ntp.Common.IO.OptionSet.DescriptionFirstWidth = 80 - OptionWidth

private

Definition at line 799 of file Options.cs.

const int Ntp.Common.IO.OptionSet.DescriptionRemWidth = 80 - OptionWidth - 2

private

Definition at line 800 of file Options.cs.

const int Ntp.Common.IO.OptionSet.OptionWidth = 29

private

Definition at line 798 of file Options.cs.

readonly List<ArgumentSource> Ntp.Common.IO.OptionSet.sources = new List<ArgumentSource>()

private

Definition at line 802 of file Options.cs.

readonly Regex Ntp.Common.IO.OptionSet.valueOption

private

Initial value:

= new Regex(

@"^(?<flag>--|-|/)(?<name>[^:=]+)((?<sep>[:=])(?<value>.*))?$")

Definition at line 804 of file Options.cs.

Property Documentation

ReadOnlyCollection<ArgumentSource> Ntp.Common.IO.OptionSet.ArgumentSources

get

Definition at line 809 of file Options.cs.

MessageLocalizerConverter Ntp.Common.IO.OptionSet.MessageLocalizer

get

Definition at line 807 of file Options.cs.

Referenced by Ntp.Common.IO.Option.Parse< T >().

The documentation for this class was generated from the following file:

Ntp.Common/IO/Options.cs

Classes

Public Member Functions

Protected Member Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation