protected override int GetParsedValueLength(string value, int startIndex, object?storeValue, out object?parsedValue) { CacheControlHeaderValue?temp = null; bool isInvalidValue = true; if (storeValue is List <object> list) { foreach (object item in list) { if (item is not HttpHeaders.InvalidValue) { isInvalidValue = false; temp = item as CacheControlHeaderValue; break; } } } else { if (storeValue is not HttpHeaders.InvalidValue) { isInvalidValue = false; temp = storeValue as CacheControlHeaderValue; } } Debug.Assert(isInvalidValue || storeValue == null || temp != null, "'storeValue' is not of type CacheControlHeaderValue"); int resultLength = CacheControlHeaderValue.GetCacheControlLength(value, startIndex, temp, out temp); parsedValue = temp; return(resultLength); }
internal static int GetCacheControlLength(string?input, int startIndex, CacheControlHeaderValue?storeValue, out CacheControlHeaderValue?parsedValue) { Debug.Assert(startIndex >= 0); parsedValue = null; if (string.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return(0); } // Cache-Control header consists of a list of name/value pairs, where the value is optional. So use an // instance of NameValueHeaderParser to parse the string. int current = startIndex; object?nameValue; List <NameValueHeaderValue> nameValueList = new List <NameValueHeaderValue>(); while (current < input.Length) { if (!s_nameValueListParser.TryParseValue(input, null, ref current, out nameValue)) { return(0); } nameValueList.Add((NameValueHeaderValue)nameValue); } // If we get here, we were able to successfully parse the string as list of name/value pairs. Now analyze // the name/value pairs. // Cache-Control is a header supporting lists of values. However, expose the header as an instance of // CacheControlHeaderValue. So if we already have an instance of CacheControlHeaderValue, add the values // from this string to the existing instances. CacheControlHeaderValue?result = storeValue; if (result == null) { result = new CacheControlHeaderValue(); } if (!TrySetCacheControlValues(result, nameValueList)) { return(0); } // If we had an existing store value and we just updated that instance, return 'null' to indicate that // we don't have a new instance of CacheControlHeaderValue, but just updated an existing one. This is the // case if we have multiple 'Cache-Control' headers set in a request/response message. if (storeValue == null) { parsedValue = result; } // If we get here we successfully parsed the whole string. return(input.Length - startIndex); }
/// <summary> /// Attempts to parse the specified <paramref name="input"/> as a <see cref="CacheControlHeaderValue"/>. /// </summary> /// <param name="input">The value to parse.</param> /// <param name="parsedValue">The parsed value.</param> /// <returns><see langword="true"/> if input is a valid <see cref="CacheControlHeaderValue"/>, otherwise <see langword="false"/>.</returns> public static bool TryParse(StringSegment input, [NotNullWhen(true)] out CacheControlHeaderValue?parsedValue) { var index = 0; // Cache-Control is unusual because there are no required values so the parser will succeed for an empty string, but still return null. if (Parser.TryParseValue(input, ref index, out parsedValue) && parsedValue != null) { return(true); } parsedValue = null; return(false); }
protected override int GetParsedValueLength(string value, int startIndex, object?storeValue, out object?parsedValue) { CacheControlHeaderValue?temp = storeValue as CacheControlHeaderValue; Debug.Assert(storeValue == null || temp != null, "'storeValue' is not of type CacheControlHeaderValue"); int resultLength = CacheControlHeaderValue.GetCacheControlLength(value, startIndex, temp, out temp); parsedValue = temp; return(resultLength); }
public static bool TryParse(string?input, out CacheControlHeaderValue?parsedValue) { int index = 0; parsedValue = null; if (CacheControlHeaderParser.Parser.TryParseValue(input, null, ref index, out object?output)) { parsedValue = (CacheControlHeaderValue?)output; return(true); } return(false); }
private static int GetCacheControlLength(StringSegment input, int startIndex, out CacheControlHeaderValue?parsedValue) { Contract.Requires(startIndex >= 0); parsedValue = null; if (StringSegment.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return(0); } // Cache-Control header consists of a list of name/value pairs, where the value is optional. So use an // instance of NameValueHeaderParser to parse the string. var current = startIndex; var nameValueList = new List <NameValueHeaderValue>(); while (current < input.Length) { if (!NameValueHeaderValue.MultipleValueParser.TryParseValue(input, ref current, out var nameValue)) { return(0); } if (nameValue != null) { nameValueList.Add(nameValue); } } // If we get here, we were able to successfully parse the string as list of name/value pairs. Now analyze // the name/value pairs. // Cache-Control is a header supporting lists of values. However, expose the header as an instance of // CacheControlHeaderValue. var result = new CacheControlHeaderValue(); if (!TrySetCacheControlValues(result, nameValueList)) { return(0); } parsedValue = result; // If we get here we successfully parsed the whole string. return(input.Length - startIndex); }
public override bool Equals(object?obj) { CacheControlHeaderValue?other = obj as CacheControlHeaderValue; if (other == null) { return(false); } if ((_noCache != other._noCache) || (_noStore != other._noStore) || (_maxAge != other._maxAge) || (_sharedMaxAge != other._sharedMaxAge) || (_maxStale != other._maxStale) || (_maxStaleLimit != other._maxStaleLimit) || (_minFresh != other._minFresh) || (_noTransform != other._noTransform) || (_onlyIfCached != other._onlyIfCached) || (_publicField != other._publicField) || (_privateField != other._privateField) || (_mustRevalidate != other._mustRevalidate) || (_proxyRevalidate != other._proxyRevalidate)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_noCacheHeaders, other._noCacheHeaders, StringComparer.OrdinalIgnoreCase)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_privateHeaders, other._privateHeaders, StringComparer.OrdinalIgnoreCase)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_extensions, other._extensions)) { return(false); } return(true); }