/// <summary>
/// Translates a <see cref="SingleComplexNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(SingleComplexNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(this.TranslatePropertyAccess(node.Source, node.Property.Name));
}
/// <summary>
/// Translates a <see cref="SingleResourceCastNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(SingleResourceCastNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(this.TranslatePropertyAccess(node.Source, node.StructuredTypeReference.Definition.ToString()));
}
/// <summary>
/// Translates an <see cref="CollectionOpenPropertyAccessNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(CollectionOpenPropertyAccessNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(this.TranslatePropertyAccess(node.Source, node.Name));
}
/// <summary>Returns the format used by the message reader for reading the payload.</summary>
/// <returns>The format used by the messageReader for reading the payload.</returns>
/// <param name="messageReader">The <see cref="T:Microsoft.OData.ODataMessageReader" /> to get the read format from.</param>
/// <remarks>This method must only be called once reading has started.
/// This means that a read method has been called on the <paramref name="messageReader"/> or that a reader (for entries, resource sets, collections, etc.) has been created.
/// If the method is called prior to that it will throw.</remarks>
public static ODataFormat GetReadFormat(ODataMessageReader messageReader)
{
ExceptionUtils.CheckArgumentNotNull(messageReader, "messageReader");
return(messageReader.GetFormat());
}
/// <summary>
/// Translates a <see cref="NonResourceRangeVariableReferenceNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(NonResourceRangeVariableReferenceNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(node.Name);
}
internal static object CoerceNumericType(object primitiveValue, IEdmPrimitiveType targetEdmType)
{
// This is implemented to match TypePromotionUtils and MetadataUtilsCommon.CanConvertPrimitiveTypeTo()
ExceptionUtils.CheckArgumentNotNull(primitiveValue, "primitiveValue");
ExceptionUtils.CheckArgumentNotNull(targetEdmType, "targetEdmType");
EdmPrimitiveTypeKind targetPrimitiveKind = targetEdmType.PrimitiveKind;
if (primitiveValue is SByte)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.SByte:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int16:
return(Convert.ToInt16((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((SByte)primitiveValue));
}
}
if (primitiveValue is Byte)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Byte:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int16:
return(Convert.ToInt16((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Byte)primitiveValue));
}
}
if (primitiveValue is Int16)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int16:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int16)primitiveValue));
}
}
if (primitiveValue is Int32)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int32:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int32)primitiveValue));
}
}
if (primitiveValue is Int64)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int64:
return(primitiveValue);
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int64)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int64)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int64)primitiveValue));
}
}
if (primitiveValue is Single)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Single:
return(primitiveValue);
case EdmPrimitiveTypeKind.Double:
/*to string then to double, avoid losing precision like "(double)123.001f" which is 123.00099945068359, instead of 123.001d.*/
return(double.Parse(((Single)primitiveValue).ToString("R", CultureInfo.InvariantCulture),
CultureInfo.InvariantCulture));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Single)primitiveValue));
}
}
if (primitiveValue is Double)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Double:
return(primitiveValue);
case EdmPrimitiveTypeKind.Decimal:
// TODO: extract these convertion steps to an individual function
decimal doubleToDecimalR;
// To keep the full presion of the current value, which if necessary is all 17 digits of precision supported by the Double type.
if (decimal.TryParse(((Double)primitiveValue).ToString("R", CultureInfo.InvariantCulture),
out doubleToDecimalR))
{
return(doubleToDecimalR);
}
return(Convert.ToDecimal((Double)primitiveValue));
}
}
if (primitiveValue is Decimal)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Decimal:
return(primitiveValue);
}
}
return(null);
}
/// <summary>
/// Converts the given payload value to the type defined in a type definition.
/// </summary>
/// <param name="value">The given payload value.</param>
/// <param name="edmTypeReference">The expected type reference from model.</param>
/// <returns>The converted value of the type.</returns>
public virtual object ConvertFromPayloadValue(object value, IEdmTypeReference edmTypeReference)
{
IEdmPrimitiveTypeReference primitiveTypeReference = edmTypeReference as IEdmPrimitiveTypeReference;
Debug.Assert(primitiveTypeReference != null, "primitiveTypeReference != null");
if (primitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.PrimitiveType)
{
return(value);
}
try
{
Type targetType = EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference.PrimitiveDefinition(), false);
string stringValue = value as string;
if (stringValue != null)
{
return(ConvertStringValue(stringValue, targetType));
}
else if (value is Int32)
{
return(ConvertInt32Value((int)value, targetType, primitiveTypeReference));
}
else if (value is Decimal)
{
Decimal decimalValue = (Decimal)value;
if (targetType == typeof(Int64))
{
return(Convert.ToInt64(decimalValue));
}
if (targetType == typeof(Double))
{
return(Convert.ToDouble(decimalValue));
}
if (targetType == typeof(Single))
{
return(Convert.ToSingle(decimalValue));
}
if (targetType != typeof(Decimal))
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDecimal(primitiveTypeReference.FullName()));
}
}
else if (value is Double)
{
return(ConvertDoubleValue((Double)value, targetType, primitiveTypeReference));
}
else if (value is bool)
{
if (targetType != typeof(bool))
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertBoolean(primitiveTypeReference.FullName()));
}
}
else if (value is DateTime)
{
if (targetType != typeof(DateTime))
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDateTime(primitiveTypeReference.FullName()));
}
}
else if (value is DateTimeOffset)
{
if (targetType != typeof(DateTimeOffset))
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDateTimeOffset(primitiveTypeReference.FullName()));
}
}
}
catch (Exception e)
{
if (!ExceptionUtils.IsCatchableExceptionType(e))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(primitiveTypeReference, e, value.ToString());
}
// otherwise just return the value without doing any conversion
return(value);
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="nestedResourceInfo"/>.
/// </summary>
/// <param name="nestedResourceInfo">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataNestedResourceInfo nestedResourceInfo, ODataNestedResourceInfoSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(nestedResourceInfo, "resource");
nestedResourceInfo.SerializationInfo = serializationInfo;
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="property"/>.
/// </summary>
/// <param name="property">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataProperty property, ODataPropertySerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(property, "property");
property.SerializationInfo = serializationInfo;
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltalink"/>.
/// </summary>
/// <param name="deltalink">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataDeltaLinkBase deltalink, ODataDeltaSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(deltalink, "deltalink");
deltalink.SerializationInfo = serializationInfo;
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="resource"/>.
/// </summary>
/// <param name="resource">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataResourceBase resource, ODataResourceSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(resource, "resource");
resource.SerializationInfo = serializationInfo;
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltaDeletedEntry"/>.
/// </summary>
/// <param name="deltaDeletedEntry">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataDeltaDeletedEntry deltaDeletedEntry, ODataDeltaSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(deltaDeletedEntry, "deltaDeletedEntry");
deltaDeletedEntry.SerializationInfo = serializationInfo;
}
/// <summary>
/// Converts a string to a primitive value.
/// </summary>
/// <param name="text">The string text to convert.</param>
/// <param name="targetTypeReference">Type to convert the string to.</param>
/// <returns>The value converted to the target type.</returns>
/// <remarks>This method does not convert null value.</remarks>
internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference)
{
Debug.Assert(text != null, "text != null");
Debug.Assert(targetTypeReference != null, "targetTypeReference != null");
try
{
EdmPrimitiveTypeKind primitiveKind = targetTypeReference.PrimitiveKind();
switch (primitiveKind)
{
case EdmPrimitiveTypeKind.Binary:
return(Convert.FromBase64String(text));
case EdmPrimitiveTypeKind.Boolean:
return(ConvertXmlBooleanValue(text));
case EdmPrimitiveTypeKind.Byte:
return(XmlConvert.ToByte(text));
case EdmPrimitiveTypeKind.DateTimeOffset:
return(PlatformHelper.ConvertStringToDateTimeOffset(text));
case EdmPrimitiveTypeKind.Decimal:
return(XmlConvert.ToDecimal(text));
case EdmPrimitiveTypeKind.Double:
return(XmlConvert.ToDouble(text));
case EdmPrimitiveTypeKind.Guid:
return(new Guid(text));
case EdmPrimitiveTypeKind.Int16:
return(XmlConvert.ToInt16(text));
case EdmPrimitiveTypeKind.Int32:
return(XmlConvert.ToInt32(text));
case EdmPrimitiveTypeKind.Int64:
return(XmlConvert.ToInt64(text));
case EdmPrimitiveTypeKind.SByte:
return(XmlConvert.ToSByte(text));
case EdmPrimitiveTypeKind.Single:
return(XmlConvert.ToSingle(text));
case EdmPrimitiveTypeKind.String:
case EdmPrimitiveTypeKind.PrimitiveType:
return(text);
case EdmPrimitiveTypeKind.Duration:
return(EdmValueParser.ParseDuration(text));
case EdmPrimitiveTypeKind.Date:
return(PlatformHelper.ConvertStringToDate(text));
case EdmPrimitiveTypeKind.TimeOfDay:
return(PlatformHelper.ConvertStringToTimeOfDay(text));
case EdmPrimitiveTypeKind.Stream:
case EdmPrimitiveTypeKind.None:
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
default:
// Note that Astoria supports XElement and Binary as well, but they are serialized as string or byte[]
// and the metadata will actually talk about string and byte[] as well. Astoria will perform the conversion if necessary.
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataRawValueUtils_ConvertStringToPrimitive));
}
}
catch (Exception e)
{
if (!ExceptionUtils.IsCatchableExceptionType(e))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, e, text);
}
}
/// <summary>
/// Gets the <see cref="ODataPreferenceHeader"/> instance to get or set preferences on the "Preference-Applied" header of the <paramref name="responseMessage"/>.
/// </summary>
/// <param name="responseMessage">The response message to get or set the "Preference-Applied" header.</param>
/// <returns>Returns the <see cref="ODataPreferenceHeader"/> instance to get or set preferences on the "Preference-Applied" header of the <paramref name="responseMessage"/>.</returns>
public static ODataPreferenceHeader PreferenceAppliedHeader(this IODataResponseMessage responseMessage)
{
ExceptionUtils.CheckArgumentNotNull(responseMessage, "responseMessage");
return(new ODataPreferenceHeader(responseMessage));
}
/// <summary>
/// Translates a <see cref="ParameterAliasNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(ParameterAliasNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(node.Alias);
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataCollectionWriter"/> for <paramref name="collectionStart"/>.
/// </summary>
/// <param name="collectionStart">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataCollectionStart collectionStart, ODataCollectionStartSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(collectionStart, "collectionStart");
collectionStart.SerializationInfo = serializationInfo;
}
/// <summary>
/// Translates a <see cref="NamedFunctionParameterNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String of NamedFunctionParameterNode.</returns>
public override string Visit(NamedFunctionParameterNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(String.Concat(node.Name, ExpressionConstants.SymbolEqual, this.TranslateNode(node.Value)));
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltaResourceSet"/>.
/// </summary>
/// <param name="deltaResourceSet">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataDeltaResourceSet deltaResourceSet, ODataResourceSerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(deltaResourceSet, "deltaResourceSet");
deltaResourceSet.SerializationInfo = serializationInfo;
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.OData.ODataInnerError" /> class with a dictionary of property names and corresponding ODataValues.
/// </summary>
/// <param name="properties">Dictionary of string keys with ODataValue as value. Key string indicates the property name where as the value of the property is encapsulated in ODataValue.</param>
public ODataInnerError(IDictionary <string, ODataValue> properties)
{
ExceptionUtils.CheckArgumentNotNull(properties, "properties");
Properties = new Dictionary <string, ODataValue>(properties);
}
/// <summary>
/// Translates a <see cref="ConvertNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(ConvertNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(this.TranslateNode(node.Source));
}
/// <summary>
/// Returns enumeration of tasks to run to buffer the entire input stream.
/// </summary>
/// <returns>Enumeration of tasks to run to buffer the input stream.</returns>
/// <remarks>This method relies on lazy eval of the enumerator, never enumerate through it synchronously.</remarks>
private IEnumerable <Task> BufferInputStream()
{
while (this.inputStream != null)
{
Debug.Assert(this.currentBufferIndex >= -1 && this.currentBufferIndex < this.buffers.Count, "The currentBufferIndex is outside of the valid range.");
DataBuffer currentBuffer = this.currentBufferIndex == -1 ? null : this.buffers[this.currentBufferIndex];
// Here we intentionally leave some memory unused (smaller than MinReadBufferSize)
// in order to issue big enough read requests. This is a perf optimization.
if (currentBuffer != null && currentBuffer.FreeBytes < DataBuffer.MinReadBufferSize)
{
currentBuffer = null;
}
if (currentBuffer == null)
{
currentBuffer = this.AddNewBuffer();
}
#if PORTABLELIB
yield return(inputStream.ReadAsync(currentBuffer.Buffer, currentBuffer.OffsetToWriteTo, currentBuffer.FreeBytes)
.ContinueWith(t =>
{
try
{
int bytesRead = t.Result;
if (bytesRead == 0)
{
this.inputStream = null;
}
else
{
currentBuffer.MarkBytesAsWritten(bytesRead);
}
}
catch (Exception exception)
{
if (!ExceptionUtils.IsCatchableExceptionType(exception))
{
throw;
}
this.inputStream = null;
throw;
}
}));
#else
yield return(Task.Factory.FromAsync(
(asyncCallback, asyncState) => this.inputStream.BeginRead(
currentBuffer.Buffer,
currentBuffer.OffsetToWriteTo,
currentBuffer.FreeBytes,
asyncCallback,
asyncState),
(asyncResult) =>
{
try
{
int bytesRead = this.inputStream.EndRead(asyncResult);
if (bytesRead == 0)
{
this.inputStream = null;
}
else
{
currentBuffer.MarkBytesAsWritten(bytesRead);
}
}
catch (Exception exception)
{
if (!ExceptionUtils.IsCatchableExceptionType(exception))
{
throw;
}
this.inputStream = null;
throw;
}
},
null));
#endif
}
}
/// <summary>
/// Sets the custom instance annotations.
/// </summary>
/// <param name="value">The new value to set.</param>
internal void SetInstanceAnnotations(ICollection <ODataInstanceAnnotation> value)
{
ExceptionUtils.CheckArgumentNotNull(value, "value");
this.instanceAnnotations = value;
}
