private static bool TryReadCode(string input, ref int current, out int code)
{
code = 0;
int codeLength = HttpRuleParser.GetNumberLength(input, current, false);
// code must be a 3 digit value. We accept less digits, but we don't accept more.
if ((codeLength == 0) || (codeLength > 3))
{
return(false);
}
if (!HeaderUtilities.TryParseInt32(input, current, codeLength, out code))
{
Debug.Fail("Unable to parse value even though it was parsed as <=3 digits string. Input: '" +
input + "', Current: " + current + ", CodeLength: " + codeLength);
return(false);
}
current = current + codeLength;
int whitespaceLength = HttpRuleParser.GetWhitespaceLength(input, current);
current = current + whitespaceLength;
// Make sure the number is followed by at least one whitespace and that we have characters left to parse.
if ((whitespaceLength == 0) || (current == input.Length))
{
return(false);
}
return(true);
}
private static bool TrySetTimeSpan(NameValueHeaderValue nameValue, ref TimeSpan?timeSpan)
{
Debug.Assert(nameValue != null);
if (nameValue.Value == null)
{
return(false);
}
int seconds;
if (!HeaderUtilities.TryParseInt32(nameValue.Value, out seconds))
{
return(false);
}
timeSpan = new TimeSpan(0, 0, seconds);
return(true);
}
protected override int GetParsedValueLength(string value, int startIndex, object?storeValue,
out object?parsedValue)
{
parsedValue = null;
int numberLength = HttpRuleParser.GetNumberLength(value, startIndex, false);
if ((numberLength == 0) || (numberLength > HttpRuleParser.MaxInt32Digits))
{
return(0);
}
int result = 0;
if (!HeaderUtilities.TryParseInt32(value, startIndex, numberLength, out result))
{
return(0);
}
parsedValue = new TimeSpan(0, 0, result);
return(numberLength);
}
internal static int GetRetryConditionLength(string?input, int startIndex, out object?parsedValue)
{
Debug.Assert(startIndex >= 0);
parsedValue = null;
if (string.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return(0);
}
int current = startIndex;
// Caller must remove leading whitespace.
DateTimeOffset date = DateTimeOffset.MinValue;
int deltaSeconds = -1; // use -1 to indicate that the value was not set. 'delta' values are always >=0
// We either have a timespan or a date/time value. Determine which one we have by looking at the first char.
// If it is a number, we have a timespan, otherwise we assume we have a date.
char firstChar = input[current];
if ((firstChar >= '0') && (firstChar <= '9'))
{
int deltaStartIndex = current;
int deltaLength = HttpRuleParser.GetNumberLength(input, current, false);
// The value must be in the range 0..2^31
if ((deltaLength == 0) || (deltaLength > HttpRuleParser.MaxInt32Digits))
{
return(0);
}
current = current + deltaLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
// RetryConditionHeaderValue only allows 1 value. There must be no delimiter/other chars after 'delta'
if (current != input.Length)
{
return(0);
}
if (!HeaderUtilities.TryParseInt32(input, deltaStartIndex, deltaLength, out deltaSeconds))
{
return(0); // int.TryParse() may return 'false' if the value has 10 digits and is > Int32.MaxValue.
}
}
else
{
if (!HttpDateParser.TryParse(input.AsSpan(current), out date))
{
return(0);
}
// If we got a valid date, then the parser consumed the whole string (incl. trailing whitespace).
current = input.Length;
}
RetryConditionHeaderValue result = new RetryConditionHeaderValue();
if (deltaSeconds == -1) // we didn't change delta, so we must have found a date.
{
result._date = date;
}
else
{
result._delta = new TimeSpan(0, 0, deltaSeconds);
}
parsedValue = result;
return(current - startIndex);
}
internal static bool TryParseInt32(string value, out int result)
{
return(HeaderUtilities.TryParseInt32(value, 0, value.Length, out result));
}