private async Task ParseCommandAsync(CommandLineCommandBase cmd, ParseResult <TOption> result, CancellationToken cancellationToken)
        {
            var found = ArgumentManager.TryGetValue(cmd, out var model);

            if (!found)
            {
                result.MergeResult(new CommandNotFoundParserResult(cmd));

                if (cmd.IsRequired)
                {
                    throw new CommandNotFoundException(cmd);
                }

                return;
            }
            else if (found && HelpRequested(result, cmd, model))
            {
                return;
            }

            var cmdParseResult = await cmd.ParseAsync(cancellationToken);

            result.MergeResult(cmdParseResult);

            if (cmdParseResult.HasErrors)
            {
                throw new CommandParseException(cmd, cmdParseResult.Errors);
            }
        }
        private void ParseOption(CommandLineOptionBase option, ParseResult <TOption> result)
        {
            bool found = ArgumentManager.TryGetValue(option, out ArgumentModel model);

            if (found && HelpRequested(result, option, model))
            {
                return;
            }
            else if (!found && option.CheckOptionNotFound())
            {
                throw new OptionNotFoundException(option);
            }
            else if (option.ShouldUseDefault(found, model))
            {
                option.UseDefault();

                return;
            }
            else if (found && !option.CanParse(model))
            {
                throw new OptionParseException(option, model);
            }
            else if (!found)
            {
                return;
            }

            option.Parse(model);
        }
 private void CheckForGlobalHelpOption(ParseResult <TOption> result)
 {
     if (ArgumentManager.TryGetValue(this, out var model))
     {
         HelpRequested(result, this, model);
     }
 }