/// <summary>Creates a new instance of the <see cref="T:NMasters.Silverlight.Net.Http.Content.StringContent" /> class.</summary>
/// <param name="content">The content used to initialize the <see cref="T:NMasters.Silverlight.Net.Http.Content.StringContent" />.</param>
/// <param name="encoding">The encoding to use for the content.</param>
/// <param name="mediaType">The media type to use for the content.</param>
public StringContent(string content, Encoding encoding, string mediaType)
: base(GetContentByteArray(content, encoding))
{
MediaTypeHeaderValue value2 = new MediaTypeHeaderValue((mediaType == null) ? "text/plain" : mediaType) {
CharSet = (encoding == null) ? HttpContent.DefaultStringEncoding.WebName : encoding.WebName
};
base.Headers.ContentType = value2;
}
/// <summary>
/// Initializes a new instance of a <see cref="MediaTypeMapping"/> with the
/// given <paramref name="mediaType"/> value.
/// </summary>
/// <param name="mediaType">
/// The <see cref="string"/> that is associated with <see cref="HttpRequestMessage"/> or
/// <see cref="HttpResponseMessage"/> instances that have the given characteristics of the
/// <see cref="MediaTypeMapping"/>.
/// </param>
protected MediaTypeMapping(string mediaType)
{
if (String.IsNullOrWhiteSpace(mediaType))
{
throw Error.ArgumentNull("mediaType");
}
MediaType = new MediaTypeHeaderValue(mediaType);
}
/// <summary>
/// Initializes a new instance of a <see cref="MediaTypeMapping"/> with the
/// given <paramref name="mediaType"/> value.
/// </summary>
/// <param name="mediaType">
/// The <see cref="MediaTypeHeaderValue"/> that is associated with <see cref="HttpRequestMessage"/> or
/// <see cref="HttpResponseMessage"/> instances that have the given characteristics of the
/// <see cref="MediaTypeMapping"/>.
/// </param>
protected MediaTypeMapping(MediaTypeHeaderValue mediaType)
{
if (mediaType == null)
{
throw Error.ArgumentNull("mediaType");
}
MediaType = mediaType;
}
/// <summary>Initializes a new instance of the <see cref="T:NMasters.Silverlight.Net.Http.Headers.MediaTypeHeaderValue" /> class.</summary>
protected MediaTypeHeaderValue(MediaTypeHeaderValue source)
{
this.mediaType = source.mediaType;
if (source.parameters != null)
{
foreach (NameValueHeaderValue value2 in source.parameters)
{
this.Parameters.Add((NameValueHeaderValue)((ICloneable)value2).Clone());
}
}
}
public ParsedMediaTypeHeaderValue(MediaTypeHeaderValue mediaType)
{
Contract.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
string[] splitMediaType = mediaType.MediaType.Split(MediaTypeSubtypeDelimiter);
Contract.Assert(splitMediaType.Length == 2, "The constructor of the MediaTypeHeaderValue would have failed if there wasn't a type and subtype.");
_type = splitMediaType[0];
_subType = splitMediaType[1];
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
{
Contract.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeHeaderValueRange.None;
return false;
}
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
MediaTypeHeaderValueRange.None;
if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
{
return false;
}
}
else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
{
return false;
}
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
foreach (NameValueHeaderValue parameter1 in mediaType1.Parameters)
{
if (!mediaType2.Parameters.Any(parameter2 => parameter1.Equals(parameter2)))
{
return false;
}
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectContent"/> class.
/// </summary>
/// <param name="type">The type of object this instance will contain.</param>
/// <param name="value">The value of the object this instance will contain.</param>
/// <param name="formatter">The formatter to use when serializing the value.</param>
/// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
/// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
public ObjectContent(Type type, object value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (formatter == null)
{
throw Error.ArgumentNull("formatter");
}
if (!formatter.CanWriteType(type))
{
throw Error.InvalidOperation(FSR.ObjectContent_FormatterCannotWriteType, formatter.GetType().FullName, type.Name);
}
_formatter = formatter;
ObjectType = type;
VerifyAndSetObject(value);
_formatter.SetDefaultContentHeaders(type, Headers, mediaType);
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2)
{
MediaTypeHeaderValueRange mediaType2Range;
return IsSubsetOf(mediaType1, mediaType2, out mediaType2Range);
}
internal static int GetMediaTypeLength(string input, int startIndex, Func<MediaTypeHeaderValue> mediaTypeCreator, out MediaTypeHeaderValue parsedValue)
{
parsedValue = null;
if (string.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return 0;
}
string mediaType = null;
int num = GetMediaTypeExpressionLength(input, startIndex, out mediaType);
if (num == 0)
{
return 0;
}
int num2 = startIndex + num;
num2 += HttpRuleParser.GetWhitespaceLength(input, num2);
MediaTypeHeaderValue value2 = null;
if ((num2 < input.Length) && (input[num2] == ';'))
{
value2 = mediaTypeCreator.Invoke();
value2.mediaType = mediaType;
num2++;
int num3 = NameValueHeaderValue.GetNameValueListLength(input, num2, ';', value2.Parameters);
if (num3 == 0)
{
return 0;
}
parsedValue = value2;
return ((num2 + num3) - startIndex);
}
value2 = mediaTypeCreator.Invoke();
value2.mediaType = mediaType;
parsedValue = value2;
return (num2 - startIndex);
}
/// <summary>Creates a new object that is a copy of the current <see cref="T:NMasters.Silverlight.Net.Http.Headers.MediaTypeHeaderValue" /> instance.</summary>
/// <returns>Returns <see cref="T:System.Object" />.A copy of the current instance.</returns>
public MediaTypeHeaderValue Clone()
{
var result = new MediaTypeHeaderValue(this.mediaType);
foreach (var parameter in this.Parameters)
{
result.Parameters.Add(new NameValueHeaderValue(parameter.Name, parameter.Value));
}
return result;
}
/// <summary>Determines whether a string is valid <see cref="T:NMasters.Silverlight.Net.Http.Headers.MediaTypeHeaderValue" /> information.</summary>
/// <returns>Returns <see cref="T:System.Boolean" />.true if <paramref name="input" /> is valid <see cref="T:NMasters.Silverlight.Net.Http.Headers.MediaTypeHeaderValue" /> information; otherwise, false.</returns>
/// <param name="input">The string to validate.</param>
/// <param name="parsedValue">The <see cref="T:NMasters.Silverlight.Net.Http.Headers.MediaTypeHeaderValue" /> version of the string.</param>
public static bool TryParse(string input, out MediaTypeHeaderValue parsedValue)
{
object obj2;
int index = 0;
parsedValue = null;
if (MediaTypeHeaderParser.SingleValueParser.TryParseValue(input, null, ref index, out obj2))
{
parsedValue = (MediaTypeHeaderValue) obj2;
return true;
}
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="RequestHeaderMapping"/> class.
/// </summary>
/// <param name="headerName">Name of the header to match.</param>
/// <param name="headerValue">The header value to match.</param>
/// <param name="valueComparison">The <see cref="StringComparison"/> to use when matching <paramref name="headerValue"/>.</param>
/// <param name="isValueSubstring">if set to <c>true</c> then <paramref name="headerValue"/> is
/// considered a match if it matches a substring of the actual header value.</param>
/// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to use if <paramref name="headerName"/> and <paramref name="headerValue"/>
/// is considered a match.</param>
public RequestHeaderMapping(string headerName, string headerValue, StringComparison valueComparison, bool isValueSubstring, MediaTypeHeaderValue mediaType)
: base(mediaType)
{
Initialize(headerName, headerValue, valueComparison, isValueSubstring);
}
