Example #1
0
 private void PopulateArgValues(TokenMatchResult target, IEnumerable <TokenMatchResult> sources)
 {
     foreach (var source in sources)
     {
         target.ArgumentValues.AddAll(source.ArgumentValues);
     }
 }
Example #2
0
        public TokenMatchResult Matches(string[] inputTokens, int startIdx)
        {
            //Not in bounds of input tokens array
            if (startIdx >= inputTokens.Length || startIdx < 0)
            {
                return(TokenMatchResult.None);
            }

            int    partialMatchLength;
            string match = Name.GetLongestMatch(inputTokens[startIdx], out partialMatchLength);

            if (match.Length != partialMatchLength)
            {
                //Only partial match on the option name
                return(new TokenMatchResult(this, inputTokens[startIdx], match, MatchOutcome.Partial, partialMatchLength, 0));
            }

            int charsMatched = inputTokens[startIdx].Length;

            List <TokenMatchResult> argMatchResults = new List <TokenMatchResult>();

            int argIdx = 0;

            //start at startIdx+1 because we already checked the option name at startIdx.
            //So start looking for arguments at startIdx+1
            for (int i = startIdx + 1; i < inputTokens.Length && argIdx < Arguments.Length; i++)
            {
                TokenMatchResult matchResult = Arguments[argIdx].Matches(inputTokens, i);
                argMatchResults.Add(matchResult);
                if (matchResult.MatchOutcome != MatchOutcome.Full)
                {
                    string partialMatchText = TokenUtils.GetMatchText(inputTokens, startIdx, i);
                    var    partialResult    = new TokenMatchResult(this, partialMatchText, partialMatchText, MatchOutcome.Partial, charsMatched + matchResult.CharsMatched, 1 + argIdx);
                    PopulateArgValues(partialResult, argMatchResults);
                    return(partialResult);
                }

                i += matchResult.TokensMatched - 1;
                argIdx++;
            }

            //Add one for the option name
            int              numTokens = 1 + argIdx;
            string           matchText = TokenUtils.GetMatchText(inputTokens, startIdx, numTokens);
            TokenMatchResult result;

            if (numTokens == FullMatchLength)
            {
                //Full match
                result = new TokenMatchResult(this, matchText, matchText, MatchOutcome.Full, charsMatched, numTokens);
            }
            else
            {
                //Partial match
                result = new TokenMatchResult(this, matchText, matchText, MatchOutcome.Partial, charsMatched, numTokens);
            }
            PopulateArgValues(result, argMatchResults);
            return(result);
        }
        public override TokenMatchResult Matches(string[] inputTokens, int startIdx)
        {
            for (int len = 1; len <= inputTokens.Length - startIdx; len++)
            {
                string combinedStr = TokenUtils.GetMatchText(inputTokens, startIdx, len);
                if (Range <T> .TryParse(combinedStr, ValueParser, out Range <T> range))
                {
                    var result = new TokenMatchResult(this, combinedStr, combinedStr, MatchOutcome.Full, combinedStr.Length, len);
                    result.SetArgValue(this, range);
                    return(result);
                }
            }

            return(TokenMatchResult.None);
        }