CommandLine.Parser Class Reference

Provides methods to parse command line arguments. More...

Inheritance diagram for CommandLine.Parser:

Public Member Functions
	Parser ()
	Initializes a new instance of the CommandLine.Parser class.
	Parser (Action< ParserSettings > configuration)
	Initializes a new instance of the Parser class, configurable with ParserSettings using a delegate.
	Parser (Func< ParserSettings > factory)
void	Dispose ()
	Frees resources owned by the instance.
ParserResult< T >	ParseArguments< T > (IEnumerable< string > args)
	Parses a string array of command line arguments constructing values in an instance of type T . Grammar rules are defined decorating public properties with appropriate attributes.
ParserResult< T >	ParseArguments< T > (Func< T > factory, IEnumerable< string > args)
	Parses a string array of command line arguments constructing values in an instance of type T . Grammar rules are defined decorating public properties with appropriate attributes.
ParserResult< object >	ParseArguments (IEnumerable< string > args, params Type[] types)
	Parses a string array of command line arguments for verb commands scenario, constructing the proper instance from the array of types supplied by types . Grammar rules are defined decorating public properties with appropriate attributes. The CommandLine.VerbAttribute must be applied to types in the array.

Package Functions
	Parser (ParserSettings settings)

Properties
static Parser	Default [get]
	Gets the singleton instance created with basic defaults.
ParserSettings	Settings [get]
	Gets the instance that implements CommandLine.ParserSettings in use.

Private Member Functions
	~Parser ()
	Finalizes an instance of the CommandLine.Parser class.
void	Dispose (bool disposing)

Static Private Member Functions
static Result< IEnumerable< Token >, Error >	Tokenize (IEnumerable< string > arguments, IEnumerable< OptionSpecification > optionSpecs, ParserSettings settings)
static ParserResult< T >	MakeParserResult< T > (ParserResult< T > parserResult, ParserSettings settings)
static ParserResult< T >	DisplayHelp< T > (ParserResult< T > parserResult, TextWriter helpWriter, int maxDisplayWidth)
static IEnumerable< ErrorType >	HandleUnknownArguments (bool ignoreUnknownArguments)

Private Attributes
bool	disposed

Static Private Attributes
static readonly Lazy< Parser >	DefaultParser

Detailed Description

Provides methods to parse command line arguments.

Definition at line 20 of file Parser.cs.

Constructor & Destructor Documentation

Parser() [1/4]

CommandLine.Parser.Parser

(

)

Initializes a new instance of the CommandLine.Parser class.

Definition at line 30 of file Parser.cs.

        {
            Settings = new ParserSettings { Consumed = true };
        }

Parser() [2/4]

CommandLine.Parser.Parser

(

Action< ParserSettings >

configuration

)

Initializes a new instance of the Parser class, configurable with ParserSettings using a delegate.

Parameters

configuration

The Action<ParserSettings> delegate used to configure aspects and behaviors of the parser.

Definition at line 43 of file Parser.cs.

        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }
 
            Settings = new ParserSettings();
            configuration(Settings);
            Settings.Consumed = true;
        }

Parser() [3/4]

CommandLine.Parser.Parser

(

Func< ParserSettings >

factory

)

Definition at line 55 of file Parser.cs.

        {
            if (factory == null)
            {
                throw new ArgumentNullException(nameof(factory));
            }
 
            Settings = factory();
            Settings.Consumed = true;
        }

Parser() [4/4]

CommandLine.Parser.Parser ( ParserSettings  settings )

package

Definition at line 66 of file Parser.cs.

        {
            Settings = settings;
            Settings.Consumed = true;
        }

~Parser()

CommandLine.Parser.~Parser ( )

private

Finalizes an instance of the CommandLine.Parser class.

Definition at line 99 of file Parser.cs.

        {
            Dispose(false);
        }

Member Function Documentation

DisplayHelp< T >()

static ParserResult< T > CommandLine.Parser.DisplayHelp< T > ( ParserResult< T >  parserResult, TextWriter  helpWriter, int  maxDisplayWidth  )

staticprivate

Definition at line 273 of file Parser.cs.

        {
            parserResult.WithNotParsed(errors =>
                                           Maybe.Merge(errors.ToMaybe(), helpWriter.ToMaybe())
                                                .Do((_, writer) =>
                                                        writer.Write(HelpText.AutoBuild(parserResult, maxDisplayWidth))
                                                   )
                                      );
 
            return parserResult;
        }

Dispose() [1/2]

void CommandLine.Parser.Dispose

(

)

Frees resources owned by the instance.

Definition at line 87 of file Parser.cs.

        {
            Dispose(true);
 
            GC.SuppressFinalize(this);
        }

Dispose() [2/2]

void CommandLine.Parser.Dispose ( bool  disposing )

private

Definition at line 295 of file Parser.cs.

        {
            if (disposed)
            {
                return;
            }
 
            if (disposing)
            {
                if (Settings != null)
                {
                    Settings.Dispose();
                }
 
                disposed = true;
            }
        }

HandleUnknownArguments()

static IEnumerable< ErrorType > CommandLine.Parser.HandleUnknownArguments ( bool  ignoreUnknownArguments )

staticprivate

Definition at line 287 of file Parser.cs.

        {
            return ignoreUnknownArguments
                       ? Enumerable.Empty<ErrorType>()
                                   .Concat(ErrorType.UnknownOptionError)
                       : Enumerable.Empty<ErrorType>();
        }

MakeParserResult< T >()

static ParserResult< T > CommandLine.Parser.MakeParserResult< T > ( ParserResult< T >  parserResult, ParserSettings  settings  )

staticprivate

Definition at line 265 of file Parser.cs.

        {
            return DisplayHelp(parserResult,
                               settings.HelpWriter,
                               settings.MaximumDisplayWidth
                              );
        }

ParseArguments()

ParserResult< object > CommandLine.Parser.ParseArguments	(	IEnumerable< string >	args,
		params Type[]	types
	)

Parses a string array of command line arguments for verb commands scenario, constructing the proper instance from the array of types supplied by types . Grammar rules are defined decorating public properties with appropriate attributes. The CommandLine.VerbAttribute must be applied to types in the array.

Parameters

args	A System.String array of command line arguments, normally supplied by application entry point.
types	A System.Type array used to supply verb alternatives.

Returns

A CommandLine.ParserResult<T> containing the appropriate instance with parsed values as a System.Object and a sequence of CommandLine.Error.

Exceptions

System.ArgumentNullException	Thrown if one or more arguments are null.
System.ArgumentOutOfRangeException	Thrown if types array is empty.

All types must expose a parameterless constructor. It's strongly recommended to use a generic overload.

Definition at line 216 of file Parser.cs.

        {
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            if (types == null)
            {
                throw new ArgumentNullException("types");
            }
 
            if (types.Length == 0)
            {
                throw new ArgumentOutOfRangeException("types");
            }
 
            return MakeParserResult(InstanceChooser.Choose((arguments, optionSpecs) =>
                                                               Tokenize(arguments, optionSpecs, Settings),
                                                           types,
                                                           args,
                                                           Settings.NameComparer,
                                                           Settings.CaseInsensitiveEnumValues,
                                                           Settings.ParsingCulture,
                                                           Settings.AutoHelp,
                                                           Settings.AutoVersion,
                                                           Settings.AllowMultiInstance,
                                                           HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                          ),
                                    Settings
                                   );
        }

ParseArguments< T >() [1/2]

ParserResult< T > CommandLine.Parser.ParseArguments< T >	(	Func< T >	factory,
		IEnumerable< string >	args
	)

Parses a string array of command line arguments constructing values in an instance of type T . Grammar rules are defined decorating public properties with appropriate attributes.

Template Parameters

T	Type of the target instance built with parsed value.

Parameters

factory	A System.Func<T> delegate used to initialize the target instance.
args	A System.String array of command line arguments, normally supplied by application entry point.

Returns

A CommandLine.ParserResult<T> containing an instance of type T with parsed values and a sequence of CommandLine.Error.

Exceptions

System.ArgumentNullException

Thrown if one or more arguments are null.

Definition at line 164 of file Parser.cs.

        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }
 
            if (!typeof(T).IsMutable())
            {
                throw new ArgumentException("factory");
            }
 
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            return MakeParserResult(InstanceBuilder.Build(Maybe.Just(factory),
                                                          (arguments, optionSpecs) =>
                                                              Tokenize(arguments, optionSpecs, Settings),
                                                          args,
                                                          Settings.NameComparer,
                                                          Settings.CaseInsensitiveEnumValues,
                                                          Settings.ParsingCulture,
                                                          Settings.AutoHelp,
                                                          Settings.AutoVersion,
                                                          Settings.AllowMultiInstance,
                                                          HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                         ),
                                    Settings
                                   );
        }

ParseArguments< T >() [2/2]

ParserResult< T > CommandLine.Parser.ParseArguments< T >

(

IEnumerable< string >

args

)

Parses a string array of command line arguments constructing values in an instance of type T . Grammar rules are defined decorating public properties with appropriate attributes.

Template Parameters

T	Type of the target instance built with parsed value.

Parameters

args	A System.String array of command line arguments, normally supplied by application entry point.

Returns

A CommandLine.ParserResult<T> containing an instance of type T with parsed values and a sequence of CommandLine.Error.

Exceptions

System.ArgumentNullException

Thrown if one or more arguments are null.

Definition at line 120 of file Parser.cs.

        {
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            Maybe<Func<T>> factory = typeof(T).IsMutable()
                                         ? Maybe.Just<Func<T>>(Activator.CreateInstance<T>)
                                         : Maybe.Nothing<Func<T>>();
 
            return MakeParserResult(InstanceBuilder.Build(factory,
                                                          (arguments, optionSpecs) =>
                                                              Tokenize(arguments, optionSpecs, Settings),
                                                          args,
                                                          Settings.NameComparer,
                                                          Settings.CaseInsensitiveEnumValues,
                                                          Settings.ParsingCulture,
                                                          Settings.AutoHelp,
                                                          Settings.AutoVersion,
                                                          Settings.AllowMultiInstance,
                                                          HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                         ),
                                    Settings
                                   );
        }

Tokenize()

static Result< IEnumerable< Token >, Error > CommandLine.Parser.Tokenize ( IEnumerable< string >  arguments, IEnumerable< OptionSpecification >  optionSpecs, ParserSettings  settings  )

staticprivate

Definition at line 249 of file Parser.cs.

        {
            return settings.GetoptMode
                       ? GetoptTokenizer.ConfigureTokenizer(settings.NameComparer,
                                                            settings.IgnoreUnknownArguments,
                                                            settings.EnableDashDash,
                                                            settings.PosixlyCorrect
                                                           )(arguments, optionSpecs)
                       : Tokenizer.ConfigureTokenizer(settings.NameComparer,
                                                      settings.IgnoreUnknownArguments,
                                                      settings.EnableDashDash
                                                     )(arguments, optionSpecs);
        }

Member Data Documentation

DefaultParser

readonly Lazy<Parser> CommandLine.Parser.DefaultParser

staticprivate

Initial value:

=
            new Lazy<Parser>(() => new Parser(new ParserSettings { HelpWriter = Console.Error }))

Definition at line 22 of file Parser.cs.

disposed

bool CommandLine.Parser.disposed

private

Definition at line 25 of file Parser.cs.

Property Documentation

Default

Parser CommandLine.Parser.Default

staticget

Gets the singleton instance created with basic defaults.

Definition at line 75 of file Parser.cs.

Settings

ParserSettings CommandLine.Parser.Settings

get

Gets the instance that implements CommandLine.ParserSettings in use.

Definition at line 80 of file Parser.cs.

{ get; }

---

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

• deps/commandlineparser/src/CommandLine/Parser.cs