/// <summary>
/// Creates an instance of the output context for this format.
/// </summary>
/// <param name="message">The message to use.</param>
/// <param name="mediaType">The specific media type being written.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>The newly created output context.</returns>
internal override ODataOutputContext CreateOutputContext(
ODataMessage message,
MediaType mediaType,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
ExceptionUtils.CheckArgumentNotNull(message, "message");
ExceptionUtils.CheckArgumentNotNull(messageWriterSettings, "messageWriterSettings");
Stream messageStream = message.GetStream();
return(new ODataMetadataOutputContext(
this,
messageStream,
encoding,
messageWriterSettings,
writingResponse,
/*synchronous*/ true,
model,
urlResolver));
}
/// <summary>
/// Create a metadata input context.
/// </summary>
/// <param name="format">The format for this input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Stream messageStream = message.GetStream();
return(new ODataMetadataInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver));
}
/// <summary>
/// Creates an instance of the input context for this format.
/// </summary>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="contentType">The content type of the message to read.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="payloadKindDetectionFormatState">Format specific state stored during payload kind detection
/// using the <see cref="ODataPayloadKindDetectionInfo.SetPayloadKindDetectionFormatState"/>.</param>
/// <returns>The newly created input context.</returns>
internal override ODataInputContext CreateInputContext(
ODataPayloadKind readerPayloadKind,
ODataMessage message,
MediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
object payloadKindDetectionFormatState)
{
DebugUtils.CheckNoExternalCallers();
ExceptionUtils.CheckArgumentNotNull(message, "message");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
Stream messageStream = message.GetStream();
return(new ODataMetadataInputContext(
this,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
/*synchronous*/ true,
model,
urlResolver));
}
/// <summary>
/// Creates an instance of the output context for this format.
/// </summary>
/// <param name="message">The message to use.</param>
/// <param name="mediaType">The specific media type being written.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which represents the pending create operation.</returns>
internal abstract Task <ODataOutputContext> CreateOutputContextAsync(
ODataMessage message,
MediaType mediaType,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver);
internal static ODataVersion GetDataServiceVersion(ODataMessage message, ODataVersion defaultVersion)
{
string header = message.GetHeader("DataServiceVersion");
if (!string.IsNullOrEmpty(header))
{
return ODataUtils.StringToODataVersion(header);
}
return defaultVersion;
}
/// <summary>
/// Sets the 'DataServiceVersion' HTTP header on the message based on the protocol version specified in the settings.
/// </summary>
/// <param name="message">The message to set the data service version header on.</param>
/// <param name="settings">The <see cref="ODataMessageWriterSettings"/> determining the protocol version to use.</param>
internal static void SetDataServiceVersion(ODataMessage message, ODataMessageWriterSettings settings)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(settings != null, "settings != null");
Debug.Assert(settings.Version.HasValue, "settings.Version.HasValue");
string dataServiceVersionString = ODataUtils.ODataVersionToString(settings.Version.Value) + ";";
message.SetHeader(ODataConstants.DataServiceVersionHeader, dataServiceVersionString);
}
/// <summary>
/// Asynchronously creates an instance of the input context for this format.
/// </summary>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="contentType">The content type of the message to read.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="payloadKindDetectionFormatState">Format specific state stored during payload kind detection
/// using the <see cref="ODataPayloadKindDetectionInfo.SetPayloadKindDetectionFormatState"/>.</param>
/// <returns>Task which when completed returned the newly created input context.</returns>
internal abstract Task <ODataInputContext> CreateInputContextAsync(
ODataPayloadKind readerPayloadKind,
ODataMessage message,
MediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
object payloadKindDetectionFormatState);
/// <summary>
/// Sets the 'DataServiceVersion' HTTP header on the message based on the protocol version specified in the settings.
/// </summary>
/// <param name="message">The message to set the data service version header on.</param>
/// <param name="settings">The <see cref="ODataMessageWriterSettings"/> determining the protocol version to use.</param>
internal static void SetDataServiceVersion(ODataMessage message, ODataMessageWriterSettings settings)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(settings != null, "settings != null");
Debug.Assert(settings.Version.HasValue, "settings.Version.HasValue");
string dataServiceVersionString = ODataUtils.ODataVersionToString(settings.Version.Value) + ";";
message.SetHeader(ODataConstants.DataServiceVersionHeader, dataServiceVersionString);
}
/// <summary>
/// Reads the DataServiceVersion header from the <paramref name="message"/> and parses it.
/// If no DataServiceVersion header is found it sets the default version to be used for reading.
/// </summary>
/// <param name="message">The message to get the data service version header from.</param>
/// <param name="defaultVersion">The default version to use if the header was not specified.</param>
/// <returns>
/// The <see cref="ODataVersion"/> retrieved from the DataServiceVersion header of the message.
/// The default version if none is specified in the header.
/// </returns>
internal static ODataVersion GetDataServiceVersion(ODataMessage message, ODataVersion defaultVersion)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
string originalHeaderValue = message.GetHeader(ODataConstants.DataServiceVersionHeader);
string headerValue = originalHeaderValue;
return(string.IsNullOrEmpty(headerValue)
? defaultVersion
: ODataUtils.StringToODataVersion(headerValue));
}
/// <summary>
/// Reads the DataServiceVersion header from the <paramref name="message"/> and parses it.
/// If no DataServiceVersion header is found it sets the default version to be used for reading.
/// </summary>
/// <param name="message">The message to get the data service version header from.</param>
/// <param name="defaultVersion">The default version to use if the header was not specified.</param>
/// <returns>
/// The <see cref="ODataVersion"/> retrieved from the DataServiceVersion header of the message.
/// The default version if none is specified in the header.
/// </returns>
internal static ODataVersion GetDataServiceVersion(ODataMessage message, ODataVersion defaultVersion)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
string originalHeaderValue = message.GetHeader(ODataConstants.DataServiceVersionHeader);
string headerValue = originalHeaderValue;
return string.IsNullOrEmpty(headerValue)
? defaultVersion
: ODataUtils.StringToODataVersion(headerValue);
}
public ODataMessageReader(IODataResponseMessage responseMessage, ODataMessageReaderSettings settings, IEdmModel model)
{
this.readerPayloadKind = ODataPayloadKind.Unsupported;
ExceptionUtils.CheckArgumentNotNull <IODataResponseMessage>(responseMessage, "responseMessage");
this.settings = (settings == null) ? new ODataMessageReaderSettings() : new ODataMessageReaderSettings(settings);
ReaderValidationUtils.ValidateMessageReaderSettings(this.settings, true);
this.readingResponse = true;
this.message = new ODataResponseMessage(responseMessage, false, this.settings.DisableMessageStreamDisposal, this.settings.MessageQuotas.MaxReceivedMessageSize);
this.urlResolver = responseMessage as IODataUrlResolver;
this.version = ODataUtilsInternal.GetDataServiceVersion(this.message, this.settings.MaxProtocolVersion);
this.model = model ?? EdmCoreModel.Instance;
ODataVersionChecker.CheckVersionSupported(this.version, this.settings);
}
/// <summary>
/// Creates an instance of the output context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which represents the pending create operation.</returns>
internal static Task <ODataOutputContext> CreateOutputContextAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
//// Metadata output is only supported in synchronous operation.
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return(ODataRawOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
/// <summary>
/// Creates an instance of the output context for this format.
/// </summary>
/// <param name="message">The message to use.</param>
/// <param name="mediaType">The specific media type being written.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which represents the pending create operation.</returns>
internal override Task <ODataOutputContext> CreateOutputContextAsync(
ODataMessage message,
MediaType mediaType,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
ExceptionUtils.CheckArgumentNotNull(message, "message");
ExceptionUtils.CheckArgumentNotNull(messageWriterSettings, "messageWriterSettings");
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataMetadataFormat_CreateOutputContextAsync));
}
/// <summary>
/// Asynchronously creates an instance of the input context for this format.
/// </summary>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="contentType">The content type of the message to read.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="payloadKindDetectionFormatState">Format specific state stored during payload kind detection
/// using the <see cref="ODataPayloadKindDetectionInfo.SetPayloadKindDetectionFormatState"/>.</param>
/// <returns>Task which when completed returned the newly created input context.</returns>
internal override Task <ODataInputContext> CreateInputContextAsync(
ODataPayloadKind readerPayloadKind,
ODataMessage message,
MediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
object payloadKindDetectionFormatState)
{
DebugUtils.CheckNoExternalCallers();
ExceptionUtils.CheckArgumentNotNull(message, "message");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataMetadataFormat_CreateInputContextAsync));
}
internal static ODataOutputContext CreateOutputContext(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if (format == ODataFormat.Metadata)
{
return(ODataMetadataOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
return(ODataRawOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
internal static ODataInputContext CreateInputContext(ODataFormat format, ODataPayloadKind readerPayloadKind, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return ODataAtomInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if (format == ODataFormat.VerboseJson)
{
return ODataJsonInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if (format == ODataFormat.Metadata)
{
return ODataMetadataInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
return ODataRawInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver, readerPayloadKind);
}
internal static Task<ODataOutputContext> CreateAsync(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
return message.GetStreamAsync().FollowOnSuccessWith<Stream, ODataOutputContext>(streamTask => new ODataRawOutputContext(format, streamTask.Result, encoding, messageWriterSettings, writingResponse, false, model, urlResolver));
}
internal static ODataOutputContext Create(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
return new ODataRawOutputContext(format, message.GetStream(), encoding, messageWriterSettings, writingResponse, true, model, urlResolver);
}
/// <summary>
/// Create RAW input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
Stream messageStream = message.GetStream();
return new ODataRawInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver,
readerPayloadKind);
}
internal static void SetDataServiceVersion(ODataMessage message, ODataMessageWriterSettings settings)
{
string headerValue = ODataUtils.ODataVersionToString(settings.Version.Value) + ";";
message.SetHeader("DataServiceVersion", headerValue);
}
internal static ODataInputContext Create(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind)
{
return new ODataRawInputContext(format, message.GetStream(), encoding, messageReaderSettings, version, readingResponse, true, model, urlResolver, readerPayloadKind);
}
/// <summary>
/// Asynchronously creates an instance of the input context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>Task which when completed returned the newly created input context.</returns>
internal static Task<ODataInputContext> CreateInputContextAsync(
ODataFormat format,
ODataPayloadKind readerPayloadKind,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format != ODataFormat.Metadata, "Async reading of metadata documents is not supported.");
Debug.Assert(readerPayloadKind != ODataPayloadKind.MetadataDocument, "Async reading of metadata documents is not supported.");
if (format == ODataFormat.Atom)
{
return ODataAtomInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver);
}
if (format == ODataFormat.VerboseJson)
{
return ODataJsonInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver);
}
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return ODataRawInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver,
readerPayloadKind);
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
/// <summary>
/// Creates an instance of the output context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which represents the pending create operation.</returns>
internal static Task<ODataOutputContext> CreateOutputContextAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
if (format == ODataFormat.Atom)
{
return ODataAtomOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver);
}
if (format == ODataFormat.VerboseJson)
{
return ODataJsonOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver);
}
//// Metadata output is only supported in synchronous operation.
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return ODataRawOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver);
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
internal static Task <ODataInputContext> CreateInputContextAsync(ODataFormat format, ODataPayloadKind readerPayloadKind, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return(ODataAtomInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver));
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
return(ODataRawInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver, readerPayloadKind));
}
/// <summary>
/// Create ATOM input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Stream messageStream = message.GetStream();
return new ODataAtomInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver);
}
/// <summary>
/// Asynchronously create ATOM input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>Task which when completed returns the newly create input context.</returns>
internal static Task<ODataInputContext> CreateAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
return message.GetStreamAsync()
.FollowOnSuccessWith(
(streamTask) => (ODataInputContext)new ODataAtomInputContext(
format,
streamTask.Result,
encoding,
messageReaderSettings,
version,
readingResponse,
false,
model,
urlResolver));
}
/// <summary>
/// Create RAW output context.
/// </summary>
/// <param name="format">The format to create the output context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>The newly created output context.</returns>
internal static ODataOutputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null");
Stream messageStream = message.GetStream();
return new ODataRawOutputContext(
format,
messageStream,
encoding,
messageWriterSettings,
writingResponse,
true,
model,
urlResolver);
}
/// <summary>
/// Asynchronously create RAW input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <returns>Task which when completed returns the newly create input context.</returns>
internal static Task<ODataInputContext> CreateAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
// TODO: Note that this will buffer the entire input. We need this for batch and for raw values since they
// both use TextReader - verify that this is really what we want to do.
return message.GetStreamAsync()
.FollowOnSuccessWith(
(streamTask) => (ODataInputContext)new ODataRawInputContext(
format,
streamTask.Result,
encoding,
messageReaderSettings,
version,
readingResponse,
false,
model,
urlResolver,
readerPayloadKind));
}
/// <summary>
/// Asynchronously create RAW output context.
/// </summary>
/// <param name="format">The format to create the outpu context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which when completed returns the newly created output context.</returns>
internal static Task<ODataOutputContext> CreateAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null");
return message.GetStreamAsync()
.FollowOnSuccessWith(
(streamTask) => (ODataOutputContext)new ODataRawOutputContext(
format,
streamTask.Result,
encoding,
messageWriterSettings,
writingResponse,
false,
model,
urlResolver));
}
internal static Task<ODataInputContext> CreateAsync(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind)
{
return message.GetStreamAsync().FollowOnSuccessWith<System.IO.Stream, ODataInputContext>(streamTask => new ODataRawInputContext(format, streamTask.Result, encoding, messageReaderSettings, version, readingResponse, false, model, urlResolver, readerPayloadKind));
}
internal static ODataOutputContext CreateOutputContext(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return ODataAtomOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver);
}
if (format == ODataFormat.VerboseJson)
{
return ODataJsonOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver);
}
if (format == ODataFormat.Metadata)
{
return ODataMetadataOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver);
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
return ODataRawOutputContext.Create(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver);
}
