TryParseByFormat()

static bool System.Globalization.TimeSpanParse.TryParseByFormat ( ReadOnlySpan< char > input, ReadOnlySpan< char > format, TimeSpanStyles styles, ref TimeSpanResult result )

inlinestaticprivate

Definition at line 1239 of file TimeSpanParse.cs.

    {
        bool flag = false;
        bool flag2 = false;
        bool flag3 = false;
        bool flag4 = false;
        bool flag5 = false;
        int result2 = 0;
        int result3 = 0;
        int result4 = 0;
        int result5 = 0;
        int zeroes = 0;
        int result6 = 0;
        int i = 0;
        TimeSpanTokenizer tokenizer = new TimeSpanTokenizer(input, -1);
        int returnValue;
        for (; i < format.Length; i += returnValue)
        {
            char c = format[i];
            switch (c)
            {
            case 'h':
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 2 || flag2 || !ParseExactDigits(ref tokenizer, returnValue, out result3))
                {
                    return result.SetInvalidStringFailure();
                }
                flag2 = true;
                break;
            case 'm':
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 2 || flag3 || !ParseExactDigits(ref tokenizer, returnValue, out result4))
                {
                    return result.SetInvalidStringFailure();
                }
                flag3 = true;
                break;
            case 's':
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 2 || flag4 || !ParseExactDigits(ref tokenizer, returnValue, out result5))
                {
                    return result.SetInvalidStringFailure();
                }
                flag4 = true;
                break;
            case 'f':
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 7 || flag5 || !ParseExactDigits(ref tokenizer, returnValue, returnValue, out zeroes, out result6))
                {
                    return result.SetInvalidStringFailure();
                }
                flag5 = true;
                break;
            case 'F':
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 7 || flag5)
                {
                    return result.SetInvalidStringFailure();
                }
                ParseExactDigits(ref tokenizer, returnValue, returnValue, out zeroes, out result6);
                flag5 = true;
                break;
            case 'd':
            {
                returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
                if (returnValue > 8 || flag || !ParseExactDigits(ref tokenizer, (returnValue < 2) ? 1 : returnValue, (returnValue < 2) ? 8 : returnValue, out var _, out result2))
                {
                    return result.SetInvalidStringFailure();
                }
                flag = true;
                break;
            }
            case '"':
            case '\'':
            {
                StringBuilder stringBuilder = StringBuilderCache.Acquire();
                if (!DateTimeParse.TryParseQuoteString(format, i, stringBuilder, out returnValue))
                {
                    StringBuilderCache.Release(stringBuilder);
                    return result.SetBadQuoteFailure(c);
                }
                if (!ParseExactLiteral(ref tokenizer, stringBuilder))
                {
                    StringBuilderCache.Release(stringBuilder);
                    return result.SetInvalidStringFailure();
                }
                StringBuilderCache.Release(stringBuilder);
                break;
            }
            case '%':
            {
                int num = DateTimeFormat.ParseNextChar(format, i);
                if (num >= 0 && num != 37)
                {
                    returnValue = 1;
                    break;
                }
                return result.SetInvalidStringFailure();
            }
            case '\\':
            {
                int num = DateTimeFormat.ParseNextChar(format, i);
                if (num >= 0 && tokenizer.NextChar == (ushort)num)
                {
                    returnValue = 2;
                    break;
                }
                return result.SetInvalidStringFailure();
            }
            default:
                return result.SetInvalidStringFailure();
            }
        }
        if (!tokenizer.EOL)
        {
            return result.SetBadTimeSpanFailure();
        }
        bool flag6 = (styles & TimeSpanStyles.AssumeNegative) == 0;
        if (TryTimeToTicks(flag6, new TimeSpanToken(result2), new TimeSpanToken(result3), new TimeSpanToken(result4), new TimeSpanToken(result5), new TimeSpanToken(result6, zeroes), out var result7))
        {
            if (!flag6)
            {
                result7 = -result7;
            }
            result.parsedTimeSpan = new TimeSpan(result7);
            return true;
        }
        return result.SetOverflowFailure();
    }

References System.Text.StringBuilderCache.Acquire(), System.Globalization.TimeSpanParse.TimeSpanTokenizer.EOL, System.format, System.input, System.Globalization.TimeSpanParse.ParseExactDigits(), System.Globalization.TimeSpanParse.ParseExactLiteral(), System.DateTimeFormat.ParseNextChar(), System.DateTimeFormat.ParseRepeatPattern(), System.Text.StringBuilderCache.Release(), System.DateTimeParse.TryParseQuoteString(), and System.Globalization.TimeSpanParse.TryTimeToTicks().

Referenced by System.Globalization.TimeSpanParse.TryParseExactTimeSpan().