Public Member Functions
	HelpText ()
	Initializes a new instance of the CommandLine.Text.HelpText class.

	HelpText (SentenceBuilder sentenceBuilder)
	Initializes a new instance of the CommandLine.Text.HelpText class specifying the sentence builder.

	HelpText (string heading)
	Initializes a new instance of the CommandLine.Text.HelpText class specifying heading string.

	HelpText (SentenceBuilder sentenceBuilder, string heading)
	Initializes a new instance of the CommandLine.Text.HelpText class specifying the sentence builder and heading string.

	HelpText (string heading, string copyright)
	Initializes a new instance of the CommandLine.Text.HelpText class specifying heading and copyright strings.

	HelpText (SentenceBuilder sentenceBuilder, string heading, string copyright)
	Initializes a new instance of the CommandLine.Text.HelpText class specifying heading and copyright strings.

HelpText	AddPreOptionsLine (string value)
	Adds a text line after copyright and before options usage strings.

HelpText	AddPostOptionsLine (string value)
	Adds a text line at the bottom, after options usage string.

HelpText	AddPreOptionsLines (IEnumerable< string > lines)
	Adds text lines after copyright and before options usage strings.

HelpText	AddPostOptionsLines (IEnumerable< string > lines)
	Adds text lines at the bottom, after options usage string.

HelpText	AddPreOptionsText (string text)
	Adds a text block of lines after copyright and before options usage strings.

HelpText	AddPostOptionsText (string text)
	Adds a text block of lines at the bottom, after options usage string.

HelpText	AddOptions< T > (ParserResult< T > result)
	Adds a text block with options usage string.

HelpText	AddVerbs (params Type[] types)
	Adds a text block with verbs usage string.

HelpText	AddOptions< T > (int maximumLength, ParserResult< T > result)
	Adds a text block with options usage string.

HelpText	AddVerbs (int maximumLength, params Type[] types)
	Adds a text block with verbs usage string.

override string	ToString ()
	Returns the help screen as a System.String.

Static Public Member Functions
static HelpText	AutoBuild< T > (ParserResult< T > parserResult, Func< HelpText, HelpText > onError, Func< Example, Example > onExample, bool verbsIndex=false, int maxDisplayWidth=DefaultMaximumLength)
	Creates a new instance of the CommandLine.Text.HelpText class using common defaults.

static HelpText	AutoBuild< T > (ParserResult< T > parserResult, int maxDisplayWidth=DefaultMaximumLength)
	Creates a default instance of the CommandLine.Text.HelpText class, automatically handling verbs or options scenario.

static HelpText	AutoBuild< T > (ParserResult< T > parserResult, Func< HelpText, HelpText > onError, int maxDisplayWidth=DefaultMaximumLength)
	Creates a custom instance of the CommandLine.Text.HelpText class, automatically handling verbs or options scenario.

static HelpText	DefaultParsingErrorsHandler< T > (ParserResult< T > parserResult, HelpText current)
	Supplies a default parsing error handler implementation.

static implicit	operator string (HelpText info)
	Converts the help instance to a System.String.

static string	RenderParsingErrorsText< T > (ParserResult< T > parserResult, Func< Error, string > formatError, Func< IEnumerable< MutuallyExclusiveSetError >, string > formatMutuallyExclusiveSetErrors, int indent)
	Builds a string that contains a parsing error message.

static IEnumerable< string >	RenderParsingErrorsTextAsLines< T > (ParserResult< T > parserResult, Func< Error, string > formatError, Func< IEnumerable< MutuallyExclusiveSetError >, string > formatMutuallyExclusiveSetErrors, int indent)
	Builds a sequence of string that contains a parsing error message.

static string	RenderUsageText< T > (ParserResult< T > parserResult)
	Builds a string with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

static string	RenderUsageText< T > (ParserResult< T > parserResult, Func< Example, Example > mapperFunc)
	Builds a string with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

static IEnumerable< string >	RenderUsageTextAsLines< T > (ParserResult< T > parserResult, Func< Example, Example > mapperFunc)
	Builds a string sequence with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

Static Public Attributes
static Comparison< ComparableOption >	RequiredThenAlphaComparison

Static Package Functions
static void	AddLine (StringBuilder builder, string value, int maximumLength)

Properties
string	Heading `[get, set]`
	Gets or sets the heading string. You can directly assign a CommandLine.Text.HeadingInfo instance.

string	Copyright `[get, set]`
	Gets or sets the copyright string. You can directly assign a CommandLine.Text.CopyrightInfo instance.

int	MaximumDisplayWidth `[get, set]`
	Gets or sets the maximum width of the display. This determines word wrap when displaying the text.

bool	AddDashesToOption `[get, set]`
	Gets or sets a value indicating whether the format of options should contain dashes. It modifies behavior of AddOptions<T>(ParserResult<T>) method.

bool	AdditionalNewLineAfterOption `[get, set]`
	Gets or sets a value indicating whether to add an additional line after the description of the specification.

bool	AddNewLineBetweenHelpSections `[get, set]`
	Gets or sets a value indicating whether to add newlines between help sections.

bool	AddEnumValuesToHelpText `[get, set]`
	Gets or sets a value indicating whether to add the values of an enum after the description of the specification.

bool	AutoHelp `[get, set]`
	Gets or sets a value indicating whether implicit option or verb 'help' should be supported.

bool	AutoVersion `[get, set]`
	Gets or sets a value indicating whether implicit option or verb 'version' should be supported.

SentenceBuilder	SentenceBuilder `[get]`
	Gets the SentenceBuilder instance specified in constructor.

Comparison< ComparableOption >	OptionComparison = null `[get, set]`

Private Member Functions
IEnumerable< Specification >	GetSpecificationsFromType (Type type)

IEnumerable< Specification >	AdaptVerbsToSpecifications (IEnumerable< Type > types)

HelpText	AddOptionsImpl (IEnumerable< Specification > specifications, string requiredWord, string optionGroupWord, int maximumLength)

OptionSpecification	MakeHelpEntry ()

OptionSpecification	MakeVersionEntry ()

HelpText	AddPreOptionsLine (string value, int maximumLength)

HelpText	AddOption (string requiredWord, string optionGroupWord, int maxLength, Specification specification, int widthOfHelpText)

string	AddOptionName (int maxLength, OptionSpecification specification)

string	AddValueName (int maxLength, ValueSpecification specification)

HelpText	AddLine (StringBuilder builder, string value)

int	GetMaxLength (IEnumerable< Specification > specifications)

int	GetMaxOptionLength (OptionSpecification spec)

int	GetMaxValueLength (ValueSpecification spec)

ComparableOption	ToComparableOption (Specification spec, int index)

Static Private Member Functions
static Maybe< Tuple< UsageAttribute, IEnumerable< Example > > >	GetUsageFromType (Type type)

static string	FormatDefaultValue< T > (T value)

Private Attributes
readonly StringBuilder	postOptionsHelp

readonly StringBuilder	preOptionsHelp

string	copyright

string	heading

StringBuilder	optionsHelp

Static Private Attributes
const int	BuilderCapacity = 128

const int	DefaultMaximumLength = 80

const int	OptionToHelpTextSeparatorWidth = 4
	The number of spaces between an option and its associated help text.

const int	OptionPrefixWidth = 2
	The width of the option prefix (either "--" or " ".

const int	TotalOptionPadding = OptionToHelpTextSeparatorWidth + OptionPrefixWidth
	The total amount of extra space that needs to accounted for when indenting Option help text.

Detailed Description

Definition at line 32 of file HelpText.cs.

Constructor & Destructor Documentation

◆ HelpText() [1/6]

CommandLine.Text.HelpText.HelpText ( )

Initializes a new instance of the CommandLine.Text.HelpText class.

Definition at line 61 of file HelpText.cs.

62 : this(SentenceBuilder.Create(), string.Empty, string.Empty) { }

CommandLine.Text.HelpText.SentenceBuilder

SentenceBuilder SentenceBuilder

Gets the SentenceBuilder instance specified in constructor.

Definition HelpText.cs:227

CommandLine.Text.SentenceBuilder.Create

static SentenceBuilder Create()

Create instance of CommandLine.Text.SentenceBuilder,.

Definition SentenceBuilder.cs:79

◆ HelpText() [2/6]

CommandLine.Text.HelpText.HelpText ( SentenceBuilder sentenceBuilder )

Initializes a new instance of the CommandLine.Text.HelpText class specifying the sentence builder.

Parameters

sentenceBuilder A SentenceBuilder instance.

Definition at line 71 of file HelpText.cs.

72 : this(sentenceBuilder, string.Empty, string.Empty) { }

◆ HelpText() [3/6]

CommandLine.Text.HelpText.HelpText ( string heading )

Initializes a new instance of the CommandLine.Text.HelpText class specifying heading string.

Parameters

heading An heading string or an instance of CommandLine.Text.HeadingInfo.

Exceptions

System.ArgumentException Thrown when parameter heading is null or empty string.

Definition at line 80 of file HelpText.cs.

81 : this(SentenceBuilder.Create(), heading, string.Empty) { }

CommandLine.Text.HelpText.heading

string heading

Definition HelpText.cs:55

◆ HelpText() [4/6]

CommandLine.Text.HelpText.HelpText	(	SentenceBuilder	sentenceBuilder,
		string	heading
	)

Initializes a new instance of the CommandLine.Text.HelpText class specifying the sentence builder and heading string.

Parameters

sentenceBuilder	A SentenceBuilder instance.
heading	A string with heading or an instance of CommandLine.Text.HeadingInfo.

Definition at line 89 of file HelpText.cs.

90 : this(sentenceBuilder, heading, string.Empty) { }

◆ HelpText() [5/6]

CommandLine.Text.HelpText.HelpText	(	string	heading,
		string	copyright
	)

Initializes a new instance of the CommandLine.Text.HelpText class specifying heading and copyright strings.

Parameters

heading	A string with heading or an instance of CommandLine.Text.HeadingInfo.
copyright	A string with copyright or an instance of CommandLine.Text.CopyrightInfo.

Exceptions

System.ArgumentNullException Thrown when one or more parameters are null or empty strings.

Definition at line 99 of file HelpText.cs.

100 : this(SentenceBuilder.Create(), heading, copyright) { }

CommandLine.Text.HelpText.copyright

string copyright

Definition HelpText.cs:54

◆ HelpText() [6/6]

CommandLine.Text.HelpText.HelpText	(	SentenceBuilder	sentenceBuilder,
		string	heading,
		string	copyright
	)

Initializes a new instance of the CommandLine.Text.HelpText class specifying heading and copyright strings.

Parameters

sentenceBuilder	A SentenceBuilder instance.
heading	A string with heading or an instance of CommandLine.Text.HeadingInfo.
copyright	A string with copyright or an instance of CommandLine.Text.CopyrightInfo.

Exceptions

System.ArgumentNullException Thrown when one or more parameters are null or empty strings.

Definition at line 110 of file HelpText.cs.

        {
            if (sentenceBuilder == null)
            {
                throw new ArgumentNullException("sentenceBuilder");
            }
 
            if (heading == null)
            {
                throw new ArgumentNullException("heading");
            }
 
            if (copyright == null)
            {
                throw new ArgumentNullException("copyright");
            }
 
            preOptionsHelp = new StringBuilder(BuilderCapacity);
            postOptionsHelp = new StringBuilder(BuilderCapacity);
 
            try
            {
                MaximumDisplayWidth = Console.WindowWidth;
 
                if (MaximumDisplayWidth < 1)
                {
                    MaximumDisplayWidth = DefaultMaximumLength;
                }
            }
            catch (IOException)
            {
                MaximumDisplayWidth = DefaultMaximumLength;
            }
 
            SentenceBuilder = sentenceBuilder;
            this.heading = heading;
            this.copyright = copyright;
            AutoHelp = true;
            AutoVersion = true;
        }

Member Function Documentation

◆ AdaptVerbsToSpecifications()

IEnumerable< Specification > CommandLine.Text.HelpText.AdaptVerbsToSpecifications ( IEnumerable< Type > types )

private

Definition at line 949 of file HelpText.cs.

        {
            IEnumerable<OptionSpecification> optionSpecs = from verbTuple in Verb.SelectFromTypes(types)
                                                           select
                                                               OptionSpecification.NewSwitch(string.Empty,
                                                                    verbTuple.Item1.Name.Concat(verbTuple.Item1.Aliases)
                                                                             .ToDelimitedString(", "),
                                                                    false,
                                                                    verbTuple.Item1.IsDefault
                                                                        ? "(Default Verb) " + verbTuple.Item1.HelpText
                                                                        : verbTuple.Item1.HelpText, //Default verb
                                                                    string.Empty,
                                                                    verbTuple.Item1.Hidden
                                                                   );
 
            if (AutoHelp)
            {
                optionSpecs = optionSpecs.Concat(new[] { MakeHelpEntry() });
            }
 
            if (AutoVersion)
            {
                optionSpecs = optionSpecs.Concat(new[] { MakeVersionEntry() });
            }
 
            return optionSpecs;
        }

◆ AddLine() [1/2]

HelpText CommandLine.Text.HelpText.AddLine	(	StringBuilder	builder,
		string	value
	)

private

Definition at line 1161 of file HelpText.cs.

        {
            AddLine(builder, value, MaximumDisplayWidth);
 
            return this;
        }

◆ AddLine() [2/2]

static void CommandLine.Text.HelpText.AddLine	(	StringBuilder	builder,
		string	value,
		int	maximumLength
	)

staticpackage

Definition at line 879 of file HelpText.cs.

        {
            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }
 
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            if (maximumLength < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(value));
            }
 
            value = value.TrimEnd();
 
            builder.AppendWhen(builder.Length > 0, Environment.NewLine);
            builder.Append(TextWrapper.WrapAndIndentText(value, 0, maximumLength));
        }

◆ AddOption()

HelpText CommandLine.Text.HelpText.AddOption	(	string	requiredWord,
		string	optionGroupWord,
		int	maxLength,
		Specification	specification,
		int	widthOfHelpText
	)

private

Definition at line 1046 of file HelpText.cs.

        {
            OptionSpecification GetOptionGroupSpecification()
            {
                if (specification.Tag == SpecificationType.Option &&
                    specification is OptionSpecification optionSpecification &&
                    optionSpecification.Group.Length > 0
                   )
 
                {
                    return optionSpecification;
                }
 
                return null;
            }
 
            if (specification.Hidden)
            {
                return this;
            }
 
            optionsHelp.Append("  ");
 
            StringBuilder name = new StringBuilder(maxLength)
                .BimapIf(specification.Tag == SpecificationType.Option,
                         it => it.Append(AddOptionName(maxLength, (OptionSpecification)specification)),
                         it => it.Append(AddValueName(maxLength, (ValueSpecification)specification))
                        );
 
            optionsHelp
                .Append(name.Length < maxLength
                            ? name.ToString()
                                  .PadRight(maxLength)
                            : name.ToString()
                       )
                .Append(OptionToHelpTextSeparatorWidth.Spaces());
 
            string optionHelpText = specification.HelpText;
 
            if (AddEnumValuesToHelpText && specification.EnumValues.Any())
            {
                optionHelpText += " Valid values: " + string.Join(", ", specification.EnumValues);
            }
 
            specification.DefaultValue.Do(defaultValue =>
                                              optionHelpText =
                                                  "(Default: {0}) ".FormatInvariant(FormatDefaultValue(defaultValue)) +
                                                  optionHelpText
                                         );
 
            OptionSpecification optionGroupSpecification = GetOptionGroupSpecification();
 
            if (specification.Required && optionGroupSpecification == null)
            {
                optionHelpText = "{0} ".FormatInvariant(requiredWord) + optionHelpText;
            }
 
            if (optionGroupSpecification != null)
            {
                optionHelpText = "({0}: {1}) ".FormatInvariant(optionGroupWord, optionGroupSpecification.Group) +
                                 optionHelpText;
            }
 
            //note that we need to indent trim the start of the string because it's going to be 
            //appended to an existing line that is as long as the indent-level
            string indented = TextWrapper
                              .WrapAndIndentText(optionHelpText, maxLength + TotalOptionPadding, widthOfHelpText)
                              .TrimStart();
 
            optionsHelp
                .Append(indented)
                .Append(Environment.NewLine)
                .AppendWhen(AdditionalNewLineAfterOption, Environment.NewLine);
 
            return this;
        }

◆ AddOptionName()

string CommandLine.Text.HelpText.AddOptionName	(	int	maxLength,
		OptionSpecification	specification
	)

private

Definition at line 1127 of file HelpText.cs.

        {
            return
                new StringBuilder(maxLength)
                    .MapIf(specification.ShortName.Length > 0,
                           it => it
                                 .AppendWhen(AddDashesToOption, '-')
                                 .AppendFormat("{0}", specification.ShortName)
                                 .AppendFormatWhen(specification.MetaValue.Length > 0, " {0}", specification.MetaValue)
                                 .AppendWhen(specification.LongName.Length > 0, ", ")
                          )
                    .MapIf(specification.LongName.Length > 0,
                           it => it
                                 .AppendWhen(AddDashesToOption, "--")
                                 .AppendFormat("{0}", specification.LongName)
                                 .AppendFormatWhen(specification.MetaValue.Length > 0, "={0}", specification.MetaValue)
                          )
                    .ToString();
        }

◆ AddOptions< T >() [1/2]

HelpText CommandLine.Text.HelpText.AddOptions< T >	(	int	maximumLength,
		ParserResult< T >	result
	)

Adds a text block with options usage string.

Parameters

maximumLength	The maximum length of the help screen.
result	A parsing computation result.

Exceptions

System.ArgumentNullException Thrown when parameter result is null.

Definition at line 614 of file HelpText.cs.

        {
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }
 
            return AddOptionsImpl(GetSpecificationsFromType(result.TypeInfo.Current),
                                  SentenceBuilder.RequiredWord(),
                                  SentenceBuilder.OptionGroupWord(),
                                  maximumLength
                                 );
        }

◆ AddOptions< T >() [2/2]

HelpText CommandLine.Text.HelpText.AddOptions< T > ( ParserResult< T > result )

Adds a text block with options usage string.

Parameters

result A parsing computation result.

Exceptions

System.ArgumentNullException Thrown when parameter result is null.

Definition at line 569 of file HelpText.cs.

        {
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }
 
            return AddOptionsImpl(GetSpecificationsFromType(result.TypeInfo.Current),
                                  SentenceBuilder.RequiredWord(),
                                  SentenceBuilder.OptionGroupWord(),
                                  MaximumDisplayWidth
                                 );
        }

◆ AddOptionsImpl()

HelpText CommandLine.Text.HelpText.AddOptionsImpl	(	IEnumerable< Specification >	specifications,
		string	requiredWord,
		string	optionGroupWord,
		int	maximumLength
	)

private

Definition at line 977 of file HelpText.cs.

        {
            int maxLength = GetMaxLength(specifications);
 
            optionsHelp = new StringBuilder(BuilderCapacity);
 
            int remainingSpace = maximumLength - (maxLength + TotalOptionPadding);
 
            if (OptionComparison != null)
            {
                int i = -1;
 
                List<ComparableOption> comparables = specifications.ToList()
                                                                   .Select(s =>
                                                                           {
                                                                               i++;
 
                                                                               return ToComparableOption(s, i);
                                                                           }
                                                                          )
                                                                   .ToList();
                comparables.Sort(OptionComparison);
 
                foreach (ComparableOption comparable in comparables)
                {
                    Specification spec = specifications.ElementAt(comparable.Index);
                    AddOption(requiredWord, optionGroupWord, maxLength, spec, remainingSpace);
                }
            }
            else
            {
                specifications.ForEach(option =>
                                           AddOption(requiredWord, optionGroupWord, maxLength, option, remainingSpace)
                                      );
            }
 
            return this;
        }

◆ AddPostOptionsLine()

HelpText CommandLine.Text.HelpText.AddPostOptionsLine ( string value )

Adds a text line at the bottom, after options usage string.

Parameters

value A System.String instance.

Returns: Updated CommandLine.Text.HelpText instance.

Exceptions

System.ArgumentNullException Thrown when parameter value is null or empty string.

Definition at line 505 of file HelpText.cs.

        {
            return AddLine(postOptionsHelp, value);
        }

◆ AddPostOptionsLines()

HelpText CommandLine.Text.HelpText.AddPostOptionsLines ( IEnumerable< string > lines )

Adds text lines at the bottom, after options usage string.

Parameters

lines A System.String sequence of line to add.

Returns: Updated CommandLine.Text.HelpText instance.

Definition at line 527 of file HelpText.cs.

        {
            lines.ForEach(line => AddPostOptionsLine(line));
 
            return this;
        }

◆ AddPostOptionsText()

HelpText CommandLine.Text.HelpText.AddPostOptionsText ( string text )

Adds a text block of lines at the bottom, after options usage string.

Parameters

text	A System.String text block.

Returns: Updated CommandLine.Text.HelpText instance.

Definition at line 554 of file HelpText.cs.

        {
            string[] lines = text.Split(new[] { Environment.NewLine },
                                        StringSplitOptions.None
                                       );
            lines.ForEach(line => AddPostOptionsLine(line));
 
            return this;
        }

◆ AddPreOptionsLine() [1/2]

HelpText CommandLine.Text.HelpText.AddPreOptionsLine ( string value )

Adds a text line after copyright and before options usage strings.

Parameters

value A System.String instance.

Returns: Updated CommandLine.Text.HelpText instance.

Exceptions

System.ArgumentNullException Thrown when parameter value is null or empty string.

Definition at line 494 of file HelpText.cs.

        {
            return AddPreOptionsLine(value, MaximumDisplayWidth);
        }

◆ AddPreOptionsLine() [2/2]

HelpText CommandLine.Text.HelpText.AddPreOptionsLine	(	string	value,
		int	maximumLength
	)

private

Definition at line 1039 of file HelpText.cs.

        {
            AddLine(preOptionsHelp, value, maximumLength);
 
            return this;
        }

◆ AddPreOptionsLines()

HelpText CommandLine.Text.HelpText.AddPreOptionsLines ( IEnumerable< string > lines )

Adds text lines after copyright and before options usage strings.

Parameters

lines A System.String sequence of line to add.

Returns: Updated CommandLine.Text.HelpText instance.

Definition at line 515 of file HelpText.cs.

        {
            lines.ForEach(line => AddPreOptionsLine(line));
 
            return this;
        }

◆ AddPreOptionsText()

HelpText CommandLine.Text.HelpText.AddPreOptionsText ( string text )

Adds a text block of lines after copyright and before options usage strings.

Parameters

text	A System.String text block.

Returns: Updated CommandLine.Text.HelpText instance.

Definition at line 539 of file HelpText.cs.

        {
            string[] lines = text.Split(new[] { Environment.NewLine },
                                        StringSplitOptions.None
                                       );
            lines.ForEach(line => AddPreOptionsLine(line));
 
            return this;
        }

◆ AddValueName()

string CommandLine.Text.HelpText.AddValueName	(	int	maxLength,
		ValueSpecification	specification
	)

private

Definition at line 1147 of file HelpText.cs.

        {
            return new StringBuilder(maxLength)
                   .BimapIf(specification.MetaName.Length > 0,
                            it => it.AppendFormat("{0} (pos. {1})", specification.MetaName, specification.Index),
                            it => it.AppendFormat("value pos. {0}", specification.Index)
                           )
                   .AppendFormatWhen(specification.MetaValue.Length > 0,
                                     " {0}",
                                     specification.MetaValue
                                    )
                   .ToString();
        }

◆ AddVerbs() [1/2]

HelpText CommandLine.Text.HelpText.AddVerbs	(	int	maximumLength,
		params Type[]	types
	)

Adds a text block with verbs usage string.

Parameters

maximumLength	The maximum length of the help screen.
types	The array of System.Type with verb commands.

Exceptions

System.ArgumentNullException	Thrown when parameter types is null.
System.ArgumentOutOfRangeException	Thrown if types array is empty.

Definition at line 635 of file HelpText.cs.

        {
            if (types == null)
            {
                throw new ArgumentNullException("types");
            }
 
            if (types.Length == 0)
            {
                throw new ArgumentOutOfRangeException("types");
            }
 
            return AddOptionsImpl(AdaptVerbsToSpecifications(types),
                                  SentenceBuilder.RequiredWord(),
                                  SentenceBuilder.OptionGroupWord(),
                                  maximumLength
                                 );
        }

◆ AddVerbs() [2/2]

HelpText CommandLine.Text.HelpText.AddVerbs ( params Type[] types )

Adds a text block with verbs usage string.

Parameters

types The array of System.Type with verb commands.

Exceptions

System.ArgumentNullException	Thrown when parameter types is null.
System.ArgumentOutOfRangeException	Thrown if types array is empty.

Definition at line 589 of file HelpText.cs.

        {
            if (types == null)
            {
                throw new ArgumentNullException("types");
            }
 
            if (types.Length == 0)
            {
                throw new ArgumentOutOfRangeException("types");
            }
 
            return AddOptionsImpl(AdaptVerbsToSpecifications(types),
                                  SentenceBuilder.RequiredWord(),
                                  SentenceBuilder.OptionGroupWord(),
                                  MaximumDisplayWidth
                                 );
        }

◆ AutoBuild< T >() [1/3]

static HelpText CommandLine.Text.HelpText.AutoBuild< T >	(	ParserResult< T >	parserResult,
		Func< HelpText, HelpText >	onError,
		Func< Example, Example >	onExample,
		bool	verbsIndex = `false`,
		int	maxDisplayWidth = `DefaultMaximumLength`
	)

static

Creates a new instance of the CommandLine.Text.HelpText class using common defaults.

Returns: An instance of CommandLine.Text.HelpText class.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
onError	A delegate used to customize the text block of reporting parsing errors text block.
onExample	A delegate used to customize CommandLine.Text.Example model used to render text block of usage examples.
verbsIndex	If true the output style is consistent with verb commands (no dashes), otherwise it outputs options.
maxDisplayWidth	The maximum width of the display.

The parameter verbsIndex is not ontly a metter of formatting, it controls whether to handle verbs or options.

Definition at line 253 of file HelpText.cs.

        {
            HelpText auto = new HelpText
            {
                Heading = HeadingInfo.Empty,
                Copyright = CopyrightInfo.Empty,
                AdditionalNewLineAfterOption = true,
                AddDashesToOption = !verbsIndex,
                MaximumDisplayWidth = maxDisplayWidth,
            };
 
            try
            {
                auto.Heading = HeadingInfo.Default;
                auto.Copyright = CopyrightInfo.Default;
            }
            catch (Exception)
            {
                auto = onError(auto);
            }
 
            IEnumerable<Error> errors = Enumerable.Empty<Error>();
 
            if (onError != null && parserResult.Tag == ParserResultType.NotParsed)
            {
                errors = ((NotParsed<T>)parserResult).Errors;
 
                if (errors.IsHelp() ||
                    errors.OnlyMeaningfulOnes()
                          .Any())
                {
                    auto = onError(auto);
                }
            }
 
            ReflectionHelper.GetAttribute<AssemblyLicenseAttribute>()
                            .Do(license => license.AddToHelpText(auto, true));
 
            Maybe<AssemblyUsageAttribute> usageAttr = ReflectionHelper.GetAttribute<AssemblyUsageAttribute>();
 
            Maybe<IEnumerable<string>> usageLines = RenderUsageTextAsLines(parserResult, onExample)
                .ToMaybe();
 
            if (usageAttr.IsJust() || usageLines.IsJust())
            {
                string heading = auto.SentenceBuilder.UsageHeadingText();
 
                if (heading.Length > 0)
                {
                    if (auto.AddNewLineBetweenHelpSections)
                    {
                        heading = Environment.NewLine + heading;
                    }
 
                    auto.AddPreOptionsLine(heading);
                }
            }
 
            usageAttr.Do(usage => usage.AddToHelpText(auto, true));
 
            usageLines.Do(lines => auto.AddPreOptionsLines(lines));
 
            if ((verbsIndex && parserResult.TypeInfo.Choices.Any()) ||
                errors.Any(e => e.Tag == ErrorType.NoVerbSelectedError))
            {
                auto.AddDashesToOption = false;
                auto.AddVerbs(parserResult.TypeInfo.Choices.ToArray());
            }
            else
            {
                auto.AddOptions(parserResult);
            }
 
            return auto;
        }

◆ AutoBuild< T >() [2/3]

static HelpText CommandLine.Text.HelpText.AutoBuild< T >	(	ParserResult< T >	parserResult,
		Func< HelpText, HelpText >	onError,
		int	maxDisplayWidth = `DefaultMaximumLength`
	)

static

Creates a custom instance of the CommandLine.Text.HelpText class, automatically handling verbs or options scenario.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
onError	A delegate used to customize the text block of reporting parsing errors text block.
maxDisplayWidth	The maximum width of the display.

Returns: An instance of CommandLine.Text.HelpText class.

This feature is meant to be invoked automatically by the parser, setting the HelpWriter property of CommandLine.ParserSettings.

Definition at line 371 of file HelpText.cs.

        {
            if (parserResult.Tag != ParserResultType.NotParsed)
            {
                throw new ArgumentException("Excepting NotParsed<T> type.", "parserResult");
            }
 
            IEnumerable<Error> errors = ((NotParsed<T>)parserResult).Errors;
 
            if (errors.Any(e => e.Tag == ErrorType.VersionRequestedError))
            {
                return new HelpText($"{HeadingInfo.Default}{Environment.NewLine}")
                {
                    MaximumDisplayWidth = maxDisplayWidth,
                }.AddPreOptionsLine(Environment.NewLine);
            }
 
            if (!errors.Any(e => e.Tag == ErrorType.HelpVerbRequestedError))
            {
                return AutoBuild(parserResult,
                                 current =>
                                 {
                                     onError?.Invoke(current);
 
                                     return DefaultParsingErrorsHandler(parserResult, current);
                                 },
                                 e => e,
                                 maxDisplayWidth: maxDisplayWidth
                                );
            }
 
            HelpVerbRequestedError err = errors.OfType<HelpVerbRequestedError>()
                                               .Single();
 
            NotParsed<object> pr = new NotParsed<object>(TypeInfo.Create(err.Type),
                                                         new Error[] { err }
                                                        );
 
            return err.Matched
                       ? AutoBuild(pr,
                                   current =>
                                   {
                                       onError?.Invoke(current);
 
                                       return DefaultParsingErrorsHandler(pr, current);
                                   },
                                   e => e,
                                   maxDisplayWidth: maxDisplayWidth
                                  )
                       : AutoBuild(parserResult,
                                   current =>
                                   {
                                       onError?.Invoke(current);
 
                                       return DefaultParsingErrorsHandler(parserResult, current);
                                   },
                                   e => e,
                                   true,
                                   maxDisplayWidth
                                  );
        }

◆ AutoBuild< T >() [3/3]

static HelpText CommandLine.Text.HelpText.AutoBuild< T >	(	ParserResult< T >	parserResult,
		int	maxDisplayWidth = `DefaultMaximumLength`
	)

static

Creates a default instance of the CommandLine.Text.HelpText class, automatically handling verbs or options scenario.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
maxDisplayWidth	The maximum width of the display.

Returns: An instance of CommandLine.Text.HelpText class.

This feature is meant to be invoked automatically by the parser, setting the HelpWriter property of CommandLine.ParserSettings.

Definition at line 349 of file HelpText.cs.

        {
            return AutoBuild(parserResult, h => h, maxDisplayWidth);
        }

◆ DefaultParsingErrorsHandler< T >()

static HelpText CommandLine.Text.HelpText.DefaultParsingErrorsHandler< T >	(	ParserResult< T >	parserResult,
		HelpText	current
	)

static

Supplies a default parsing error handler implementation.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
current	The CommandLine.Text.HelpText instance.

Definition at line 443 of file HelpText.cs.

        {
            if (parserResult == null)
            {
                throw new ArgumentNullException("parserResult");
            }
 
            if (current == null)
            {
                throw new ArgumentNullException("current");
            }
 
            if (((NotParsed<T>)parserResult).Errors.OnlyMeaningfulOnes()
                                            .Empty())
            {
                return current;
            }
 
            IEnumerable<string> errors = RenderParsingErrorsTextAsLines(parserResult,
                                                                        current.SentenceBuilder.FormatError,
                                                                        current.SentenceBuilder
                                                                               .FormatMutuallyExclusiveSetErrors,
                                                                        2
                                                                       ); // indent with two spaces
 
            if (errors.Empty())
            {
                return current;
            }
 
            return current
                   .AddPreOptionsLine(string.Concat(Environment.NewLine, current.SentenceBuilder.ErrorsHeadingText()))
                   .AddPreOptionsLines(errors);
        }

◆ FormatDefaultValue< T >()

static string CommandLine.Text.HelpText.FormatDefaultValue< T > ( T value )

staticprivate

Definition at line 1266 of file HelpText.cs.

        {
            if (value is bool)
            {
                return value.ToStringLocal()
                            .ToLowerInvariant();
            }
 
            if (value is string)
            {
                return value.ToStringLocal();
            }
 
            IEnumerable asEnumerable = value as IEnumerable;
 
            if (asEnumerable == null)
            {
                return value.ToStringLocal();
            }
 
            StringBuilder builder = new StringBuilder();
 
            foreach (object item in asEnumerable)
            {
                builder
                    .Append(item.ToStringLocal())
                    .Append(" ");
            }
 
            return builder.Length > 0
                       ? builder.ToString(0, builder.Length - 1)
                       : string.Empty;
        }

◆ GetMaxLength()

int CommandLine.Text.HelpText.GetMaxLength ( IEnumerable< Specification > specifications )

private

Definition at line 1168 of file HelpText.cs.

        {
            return specifications.Aggregate(0,
                                            (length, spec) =>
                                            {
                                                if (spec.Hidden)
                                                {
                                                    return length;
                                                }
 
                                                int specLength = spec.Tag == SpecificationType.Option
                                                                     ? GetMaxOptionLength((OptionSpecification)spec)
                                                                     : GetMaxValueLength((ValueSpecification)spec);
 
                                                return Math.Max(length, specLength);
                                            }
                                           );
        }

◆ GetMaxOptionLength()

int CommandLine.Text.HelpText.GetMaxOptionLength ( OptionSpecification spec )

private

Definition at line 1188 of file HelpText.cs.

        {
            int specLength = 0;
 
            bool hasShort = spec.ShortName.Length > 0;
            bool hasLong = spec.LongName.Length > 0;
 
            int metaLength = 0;
 
            if (spec.MetaValue.Length > 0)
            {
                metaLength = spec.MetaValue.Length + 1;
            }
 
            if (hasShort)
            {
                ++specLength;
 
                if (AddDashesToOption)
                {
                    ++specLength;
                }
 
                specLength += metaLength;
            }
 
            if (hasLong)
            {
                specLength += spec.LongName.Length;
 
                if (AddDashesToOption)
                {
                    specLength += OptionPrefixWidth;
                }
 
                specLength += metaLength;
            }
 
            if (hasShort && hasLong)
            {
                specLength += OptionPrefixWidth;
            }
 
            return specLength;
        }

◆ GetMaxValueLength()

int CommandLine.Text.HelpText.GetMaxValueLength ( ValueSpecification spec )

private

Definition at line 1234 of file HelpText.cs.

        {
            int specLength = 0;
 
            bool hasMeta = spec.MetaName.Length > 0;
 
            int metaLength = 0;
 
            if (spec.MetaValue.Length > 0)
            {
                metaLength = spec.MetaValue.Length + 1;
            }
 
            if (hasMeta)
            {
                specLength += spec.MetaName.Length +
                              spec.Index.ToStringInvariant()
                                  .Length +
                              8; //METANAME (pos. N)
            }
            else
            {
                specLength += spec.Index.ToStringInvariant()
                                  .Length +
                              11; // "value pos. N"
            }
 
            specLength += metaLength;
 
            return specLength;
        }

◆ GetSpecificationsFromType()

IEnumerable< Specification > CommandLine.Text.HelpText.GetSpecificationsFromType ( Type type )

private

Definition at line 902 of file HelpText.cs.

        {
            IEnumerable<Specification> specs = type.GetSpecifications(Specification.FromProperty);
 
            IEnumerable<OptionSpecification> optionSpecs = specs
                .OfType<OptionSpecification>();
 
            if (AutoHelp)
            {
                optionSpecs = optionSpecs.Concat(new[] { MakeHelpEntry() });
            }
 
            if (AutoVersion)
            {
                optionSpecs = optionSpecs.Concat(new[] { MakeVersionEntry() });
            }
 
            IOrderedEnumerable<ValueSpecification> valueSpecs = specs
                                                                .OfType<ValueSpecification>()
                                                                .OrderBy(v => v.Index);
 
            return Enumerable.Empty<Specification>()
                             .Concat(optionSpecs)
                             .Concat(valueSpecs);
        }

◆ GetUsageFromType()

static Maybe< Tuple< UsageAttribute, IEnumerable< Example > > > CommandLine.Text.HelpText.GetUsageFromType ( Type type )

staticprivate

Definition at line 928 of file HelpText.cs.

        {
            return type.GetUsageData()
                       .Map(tuple =>
                            {
                                PropertyInfo prop = tuple.Item1;
                                UsageAttribute attr = tuple.Item2;
 
                                IEnumerable<Example> examples = (IEnumerable<Example>)prop
                                    .GetValue(null,
                                              BindingFlags.Public | BindingFlags.Static | BindingFlags.GetProperty,
                                              null,
                                              null,
                                              null
                                             );
 
                                return Tuple.Create(attr, examples);
                            }
                           );
        }

◆ MakeHelpEntry()

OptionSpecification CommandLine.Text.HelpText.MakeHelpEntry ( )

private

Definition at line 1019 of file HelpText.cs.

        {
            return OptionSpecification.NewSwitch(string.Empty,
                                                 "help",
                                                 false,
                                                 SentenceBuilder.HelpCommandText(AddDashesToOption),
                                                 string.Empty
                                                );
        }

◆ MakeVersionEntry()

OptionSpecification CommandLine.Text.HelpText.MakeVersionEntry ( )

private

Definition at line 1029 of file HelpText.cs.

        {
            return OptionSpecification.NewSwitch(string.Empty,
                                                 "version",
                                                 false,
                                                 SentenceBuilder.VersionCommandText(AddDashesToOption),
                                                 string.Empty
                                                );
        }

◆ operator string()

static implicit CommandLine.Text.HelpText.operator string ( HelpText info )

static

Converts the help instance to a System.String.

Parameters

info	This CommandLine.Text.HelpText instance.

Returns: The System.String that contains the help screen.

Definition at line 483 of file HelpText.cs.

        {
            return info.ToString();
        }

◆ RenderParsingErrorsText< T >()

static string CommandLine.Text.HelpText.RenderParsingErrorsText< T >	(	ParserResult< T >	parserResult,
		Func< Error, string >	formatError,
		Func< IEnumerable< MutuallyExclusiveSetError >, string >	formatMutuallyExclusiveSetErrors,
		int	indent
	)

static

Builds a string that contains a parsing error message.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
formatError	The error formatting delegate.
formatMutuallyExclusiveSetErrors	The specialized CommandLine.MutuallyExclusiveSetError sequence formatting delegate.
indent	Number of spaces used to indent text.

Returns: The System.String that contains the parsing error message.

Definition at line 668 of file HelpText.cs.

        {
            return string.Join(Environment.NewLine,
                               RenderParsingErrorsTextAsLines(parserResult,
                                                              formatError,
                                                              formatMutuallyExclusiveSetErrors,
                                                              indent
                                                             )
                              );
        }

◆ RenderParsingErrorsTextAsLines< T >()

static IEnumerable< string > CommandLine.Text.HelpText.RenderParsingErrorsTextAsLines< T >	(	ParserResult< T >	parserResult,
		Func< Error, string >	formatError,
		Func< IEnumerable< MutuallyExclusiveSetError >, string >	formatMutuallyExclusiveSetErrors,
		int	indent
	)

static

Builds a sequence of string that contains a parsing error message.

Parameters

parserResult	The CommandLine.ParserResult<T> containing the instance that collected command line arguments parsed with CommandLine.Parser class.
formatError	The error formatting delegate.
formatMutuallyExclusiveSetErrors	The specialized CommandLine.MutuallyExclusiveSetError sequence formatting delegate.
indent	Number of spaces used to indent text.

Returns: A sequence of System.String that contains the parsing error message.

Definition at line 697 of file HelpText.cs.

        {
            if (parserResult == null)
            {
                throw new ArgumentNullException("parserResult");
            }
 
            IEnumerable<Error> meaningfulErrors =
                ((NotParsed<T>)parserResult).Errors.OnlyMeaningfulOnes();
 
            if (meaningfulErrors.Empty())
            {
                yield break;
            }
 
            foreach (Error error in meaningfulErrors
                         .Where(e => e.Tag != ErrorType.MutuallyExclusiveSetError))
            {
                StringBuilder line = new StringBuilder(indent.Spaces())
                    .Append(formatError(error));
 
                yield return line.ToString();
            }
 
            string mutuallyErrs =
                formatMutuallyExclusiveSetErrors(meaningfulErrors.OfType<MutuallyExclusiveSetError>());
 
            if (mutuallyErrs.Length > 0)
            {
                string[] lines = mutuallyErrs
                    .Split(new[] { Environment.NewLine },
                           StringSplitOptions.None
                          );
 
                foreach (string line in lines)
                {
                    yield return line;
                }
            }
        }

◆ RenderUsageText< T >() [1/2]

static string CommandLine.Text.HelpText.RenderUsageText< T > ( ParserResult< T > parserResult )

static

Builds a string with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

Template Parameters

T	Type of parsing computation result.

Parameters

parserResult A parsing computation result.

Returns: Resulting formatted text.

Definition at line 750 of file HelpText.cs.

        {
            return RenderUsageText(parserResult, example => example);
        }

◆ RenderUsageText< T >() [2/2]

static string CommandLine.Text.HelpText.RenderUsageText< T >	(	ParserResult< T >	parserResult,
		Func< Example, Example >	mapperFunc
	)

static

Builds a string with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

Template Parameters

T	Type of parsing computation result.

Parameters

parserResult	A parsing computation result.
mapperFunc	A mapping lambda normally used to translate text in other languages.

Returns: Resulting formatted text.

Definition at line 763 of file HelpText.cs.

        {
            return string.Join(Environment.NewLine, RenderUsageTextAsLines(parserResult, mapperFunc));
        }

◆ RenderUsageTextAsLines< T >()

static IEnumerable< string > CommandLine.Text.HelpText.RenderUsageTextAsLines< T >	(	ParserResult< T >	parserResult,
		Func< Example, Example >	mapperFunc
	)

static

Builds a string sequence with usage text block created using CommandLine.Text.UsageAttribute data and metadata.

Template Parameters

T	Type of parsing computation result.

Parameters

parserResult	A parsing computation result.
mapperFunc	A mapping lambda normally used to translate text in other languages.

Returns: Resulting formatted text.

Definition at line 776 of file HelpText.cs.

        {
            if (parserResult == null)
            {
                throw new ArgumentNullException("parserResult");
            }
 
            Maybe<Tuple<UsageAttribute, IEnumerable<Example>>> usage = GetUsageFromType(parserResult.TypeInfo.Current);
 
            if (usage.MatchNothing())
            {
                yield break;
            }
 
            Tuple<UsageAttribute, IEnumerable<Example>> usageTuple = usage.FromJustOrFail();
            IEnumerable<Example> examples = usageTuple.Item2;
            string appAlias = usageTuple.Item1.ApplicationAlias ?? ReflectionHelper.GetAssemblyName();
 
            foreach (Example e in examples)
            {
                Example example = mapperFunc(e);
 
                StringBuilder exampleText = new StringBuilder(example.HelpText)
                    .Append(':');
 
                yield return exampleText.ToString();
                IEnumerable<UnParserSettings> styles = example.GetFormatStylesOrDefault();
 
                foreach (UnParserSettings s in styles)
                {
                    StringBuilder commandLine = new StringBuilder(OptionPrefixWidth.Spaces())
                                                .Append(appAlias)
                                                .Append(' ')
                                                .Append(Parser.Default.FormatCommandLine(example.Sample,
                                                             config =>
                                                             {
                                                                 config.PreferShortName = s.PreferShortName;
                                                                 config.GroupSwitches = s.GroupSwitches;
                                                                 config.UseEqualToken = s.UseEqualToken;
                                                                 config.SkipDefault = s.SkipDefault;
                                                             }
                                                            )
                                                       );
 
                    yield return commandLine.ToString();
                }
            }
        }

◆ ToComparableOption()

ComparableOption CommandLine.Text.HelpText.ToComparableOption	(	Specification	spec,
		int	index
	)

private

Definition at line 1302 of file HelpText.cs.

        {
            OptionSpecification option = spec as OptionSpecification;
            ValueSpecification value = spec as ValueSpecification;
            bool required = option?.Required ?? false;
 
            return new ComparableOption
            {
                Required = required,
                IsOption = option != null,
                IsValue = value != null,
                LongName = option?.LongName ?? value?.MetaName,
                ShortName = option?.ShortName,
                Index = index,
            };
        }

◆ ToString()

override string CommandLine.Text.HelpText.ToString ( )

Returns the help screen as a System.String.

Returns: The System.String that contains the help screen.

Definition at line 830 of file HelpText.cs.

        {
            const int ExtraLength = 10;
 
            int sbLength = heading.SafeLength() +
                           copyright.SafeLength() +
                           preOptionsHelp.SafeLength() +
                           optionsHelp.SafeLength() +
                           postOptionsHelp.SafeLength() +
                           ExtraLength;
            StringBuilder result = new StringBuilder(sbLength);
 
            result.Append(heading)
                  .AppendWhen(!string.IsNullOrEmpty(copyright),
                              Environment.NewLine,
                              copyright
                             )
                  .AppendWhen(preOptionsHelp.SafeLength() > 0,
                              NewLineIfNeededBefore(preOptionsHelp),
                              Environment.NewLine,
                              preOptionsHelp.ToString()
                             )
                  .AppendWhen(optionsHelp.SafeLength() > 0,
                              Environment.NewLine,
                              Environment.NewLine,
                              optionsHelp.SafeToString()
                             )
                  .AppendWhen(postOptionsHelp.SafeLength() > 0,
                              NewLineIfNeededBefore(postOptionsHelp),
                              Environment.NewLine,
                              postOptionsHelp.ToString()
                             );
 
            string NewLineIfNeededBefore(StringBuilder sb)
            {
                if (AddNewLineBetweenHelpSections &&
                    result.Length > 0 &&
                    !result.SafeEndsWith(Environment.NewLine) &&
                    !sb.SafeStartsWith(Environment.NewLine))
                {
                    return Environment.NewLine;
                }
 
                return null;
            }
 
            return result.ToString();
        }

Member Data Documentation

◆ BuilderCapacity

const int CommandLine.Text.HelpText.BuilderCapacity = 128

staticprivate

Definition at line 34 of file HelpText.cs.

◆ copyright

string CommandLine.Text.HelpText.copyright

private

Definition at line 54 of file HelpText.cs.

◆ DefaultMaximumLength

const int CommandLine.Text.HelpText.DefaultMaximumLength = 80

staticprivate

Definition at line 35 of file HelpText.cs.

◆ heading

string CommandLine.Text.HelpText.heading

private

Definition at line 55 of file HelpText.cs.

◆ OptionPrefixWidth

const int CommandLine.Text.HelpText.OptionPrefixWidth = 2

staticprivate

The width of the option prefix (either "--" or " ".

Definition at line 45 of file HelpText.cs.

◆ optionsHelp

StringBuilder CommandLine.Text.HelpText.optionsHelp

private

Definition at line 56 of file HelpText.cs.

◆ OptionToHelpTextSeparatorWidth

const int CommandLine.Text.HelpText.OptionToHelpTextSeparatorWidth = 4

staticprivate

The number of spaces between an option and its associated help text.

Definition at line 40 of file HelpText.cs.

◆ postOptionsHelp

readonly StringBuilder CommandLine.Text.HelpText.postOptionsHelp

private

Definition at line 52 of file HelpText.cs.

◆ preOptionsHelp

readonly StringBuilder CommandLine.Text.HelpText.preOptionsHelp

private

Definition at line 53 of file HelpText.cs.

◆ RequiredThenAlphaComparison

Comparison<ComparableOption> CommandLine.Text.HelpText.RequiredThenAlphaComparison

static

Initial value:

= (attr1, attr2) =>
        {
            if (attr1.IsOption && attr2.IsOption)
            {
                if (attr1.Required && !attr2.Required)
                {
                    return -1;
                }
 
                if (!attr1.Required && attr2.Required)
                {
                    return 1;
                }
 
                return string.Compare(attr1.LongName, attr2.LongName, StringComparison.Ordinal);
            }
 
            if (attr1.IsOption && attr2.IsValue)
            {
                return -1;
            }
 
            return 1;
        }

Definition at line 1322 of file HelpText.cs.

        {
            if (attr1.IsOption && attr2.IsOption)
            {
                if (attr1.Required && !attr2.Required)
                {
                    return -1;
                }
 
                if (!attr1.Required && attr2.Required)
                {
                    return 1;
                }
 
                return string.Compare(attr1.LongName, attr2.LongName, StringComparison.Ordinal);
            }
 
            if (attr1.IsOption && attr2.IsValue)
            {
                return -1;
            }
 
            return 1;
        };

◆ TotalOptionPadding

const int CommandLine.Text.HelpText.TotalOptionPadding = OptionToHelpTextSeparatorWidth + OptionPrefixWidth

staticprivate

The total amount of extra space that needs to accounted for when indenting Option help text.

Definition at line 50 of file HelpText.cs.

Property Documentation

◆ AddDashesToOption

bool CommandLine.Text.HelpText.AddDashesToOption

getset

Gets or sets a value indicating whether the format of options should contain dashes. It modifies behavior of AddOptions<T>(ParserResult<T>) method.

Definition at line 197 of file HelpText.cs.

197{ get; set; }

◆ AddEnumValuesToHelpText

bool CommandLine.Text.HelpText.AddEnumValuesToHelpText

getset

Gets or sets a value indicating whether to add the values of an enum after the description of the specification.

Definition at line 212 of file HelpText.cs.

212{ get; set; }

◆ AdditionalNewLineAfterOption

bool CommandLine.Text.HelpText.AdditionalNewLineAfterOption

getset

Gets or sets a value indicating whether to add an additional line after the description of the specification.

Definition at line 202 of file HelpText.cs.

202{ get; set; }

◆ AddNewLineBetweenHelpSections

bool CommandLine.Text.HelpText.AddNewLineBetweenHelpSections

getset

Gets or sets a value indicating whether to add newlines between help sections.

Definition at line 207 of file HelpText.cs.

207{ get; set; }

◆ AutoHelp

bool CommandLine.Text.HelpText.AutoHelp

getset

Gets or sets a value indicating whether implicit option or verb 'help' should be supported.

Definition at line 217 of file HelpText.cs.

217{ get; set; }

◆ AutoVersion

bool CommandLine.Text.HelpText.AutoVersion

getset

Gets or sets a value indicating whether implicit option or verb 'version' should be supported.

Definition at line 222 of file HelpText.cs.

222{ get; set; }

◆ Copyright

string CommandLine.Text.HelpText.Copyright

getset

Gets or sets the copyright string. You can directly assign a CommandLine.Text.CopyrightInfo instance.

Definition at line 173 of file HelpText.cs.

        {
            get => copyright;
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
 
                copyright = value;
            }
        }

◆ Heading

string CommandLine.Text.HelpText.Heading

getset

Gets or sets the heading string. You can directly assign a CommandLine.Text.HeadingInfo instance.

Definition at line 155 of file HelpText.cs.

        {
            get => heading;
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
 
                heading = value;
            }
        }

◆ MaximumDisplayWidth

int CommandLine.Text.HelpText.MaximumDisplayWidth

getset

Gets or sets the maximum width of the display. This determines word wrap when displaying the text.

The maximum width of the display.

Definition at line 191 of file HelpText.cs.

191{ get; set; }

◆ OptionComparison

Comparison<ComparableOption> CommandLine.Text.HelpText.OptionComparison = null

getset

Definition at line 1320 of file HelpText.cs.

1320{ get; set; } = null;

◆ SentenceBuilder

SentenceBuilder CommandLine.Text.HelpText.SentenceBuilder

get

Gets the SentenceBuilder instance specified in constructor.

Definition at line 227 of file HelpText.cs.

227{ get; }

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

deps/commandlineparser/src/CommandLine/Text/HelpText.cs

Public Member Functions

Static Public Member Functions

Static Public Attributes

Static Package Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HelpText() [1/6]

◆ HelpText() [2/6]

◆ HelpText() [3/6]

◆ HelpText() [4/6]

◆ HelpText() [5/6]

◆ HelpText() [6/6]

Member Function Documentation

◆ AdaptVerbsToSpecifications()

◆ AddLine() [1/2]

◆ AddLine() [2/2]

◆ AddOption()

◆ AddOptionName()

◆ AddOptions< T >() [1/2]

◆ AddOptions< T >() [2/2]

◆ AddOptionsImpl()

◆ AddPostOptionsLine()

◆ AddPostOptionsLines()

◆ AddPostOptionsText()

◆ AddPreOptionsLine() [1/2]

◆ AddPreOptionsLine() [2/2]

◆ AddPreOptionsLines()

◆ AddPreOptionsText()

◆ AddValueName()

◆ AddVerbs() [1/2]

◆ AddVerbs() [2/2]

◆ AutoBuild< T >() [1/3]

◆ AutoBuild< T >() [2/3]

◆ AutoBuild< T >() [3/3]

◆ DefaultParsingErrorsHandler< T >()

◆ FormatDefaultValue< T >()

◆ GetMaxLength()

◆ GetMaxOptionLength()

◆ GetMaxValueLength()

◆ GetSpecificationsFromType()

◆ GetUsageFromType()

◆ MakeHelpEntry()

◆ MakeVersionEntry()

◆ operator string()

◆ RenderParsingErrorsText< T >()

◆ RenderParsingErrorsTextAsLines< T >()

◆ RenderUsageText< T >() [1/2]

◆ RenderUsageText< T >() [2/2]

◆ RenderUsageTextAsLines< T >()

◆ ToComparableOption()

◆ ToString()

Member Data Documentation

◆ BuilderCapacity

◆ copyright

◆ DefaultMaximumLength

◆ heading

◆ OptionPrefixWidth

◆ optionsHelp

◆ OptionToHelpTextSeparatorWidth

◆ postOptionsHelp

◆ preOptionsHelp

◆ RequiredThenAlphaComparison

◆ TotalOptionPadding

Property Documentation

◆ AddDashesToOption

◆ AddEnumValuesToHelpText

◆ AdditionalNewLineAfterOption

◆ AddNewLineBetweenHelpSections

◆ AutoHelp

◆ AutoVersion

◆ Copyright

◆ Heading

◆ MaximumDisplayWidth

◆ OptionComparison

◆ SentenceBuilder