/// <summary>
/// Determines if the given primitive value is of a basic type where we can rely on just the JSON representation to convey type information.
/// If so, we don't have to write the type name.
/// </summary>
/// <param name="primitiveValue">The primitive value in question.</param>
/// <param name="valueTypeReference">The type of the primitive value.</param>
/// <returns>true if the given primitive value is of a basic JSON type, false otherwise.</returns>
internal static bool ValueTypeMatchesJsonType(ODataPrimitiveValue primitiveValue, IEdmPrimitiveTypeReference valueTypeReference)
{
#if ODATALIB
#endif
switch (valueTypeReference.PrimitiveKind())
{
// If the value being serialized is of a basic type where we can rely on just the JSON representation to convey type information, then never write the type name.
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.String:
case EdmPrimitiveTypeKind.Boolean:
return true;
case EdmPrimitiveTypeKind.Double:
double doubleValue = (double)primitiveValue.Value;
// If a double value is positive infinity, negative infinity, or NaN, we serialize the double as a string.
// Thus the reader can't infer the type from the JSON representation, and we must write the type name explicitly
// (i.e., if the property is open or the property type is assumed to be unknown, as is the case when writing in full metadata mode).
return !IsDoubleValueSerializedAsString(doubleValue);
default:
return false;
}
}
public static DataType ConvertToTaupoPrimitiveDataType(IEdmPrimitiveTypeReference edmPrimitiveTypeReference)
{
PrimitiveDataType result = null;
EdmPrimitiveTypeKind primitiveKind = edmPrimitiveTypeReference.PrimitiveKind();
if (!facetlessDataTypeLookup.TryGetValue(primitiveKind, out result))
{
switch (primitiveKind)
{
case EdmPrimitiveTypeKind.Binary:
var edmBinary = edmPrimitiveTypeReference.AsBinary();
result = EdmDataTypes.Binary(edmBinary.MaxLength);
break;
case EdmPrimitiveTypeKind.DateTimeOffset:
var edmDateTimeOffset = edmPrimitiveTypeReference.AsTemporal();
result = EdmDataTypes.DateTimeOffset(edmDateTimeOffset.Precision);
break;
case EdmPrimitiveTypeKind.Decimal:
var edmDecimal = edmPrimitiveTypeReference.AsDecimal();
result = EdmDataTypes.Decimal(edmDecimal.Precision, edmDecimal.Scale);
break;
case EdmPrimitiveTypeKind.String:
var edmString = edmPrimitiveTypeReference.AsString();
var maxLength = edmString.MaxLength;
if (edmString.IsUnbounded == true)
{
maxLength = MaxLengthMaxTaupoDefaultValue;
}
result = EdmDataTypes.String(maxLength, edmString.IsUnicode);
break;
case EdmPrimitiveTypeKind.Duration:
var edmTime = edmPrimitiveTypeReference.AsTemporal();
result = EdmDataTypes.Time(edmTime.Precision);
break;
default:
throw new TaupoInvalidOperationException("unexpected Edm Primitive Type Kind: " + primitiveKind);
}
}
return result.Nullable(edmPrimitiveTypeReference.IsNullable);
}
private static bool IsEquivalentTo(this IEdmPrimitiveTypeReference thisType, IEdmPrimitiveTypeReference otherType)
{
EdmPrimitiveTypeKind thisTypePrimitiveKind = thisType.PrimitiveKind();
if (thisTypePrimitiveKind != otherType.PrimitiveKind())
{
return(false);
}
switch (thisTypePrimitiveKind)
{
case EdmPrimitiveTypeKind.Binary:
return(((IEdmBinaryTypeReference)thisType).IsEquivalentTo((IEdmBinaryTypeReference)otherType));
case EdmPrimitiveTypeKind.Decimal:
return(((IEdmDecimalTypeReference)thisType).IsEquivalentTo((IEdmDecimalTypeReference)otherType));
case EdmPrimitiveTypeKind.String:
return(((IEdmStringTypeReference)thisType).IsEquivalentTo((IEdmStringTypeReference)otherType));
case EdmPrimitiveTypeKind.Time:
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
return(((IEdmTemporalTypeReference)thisType).IsEquivalentTo((IEdmTemporalTypeReference)otherType));
default:
if (thisTypePrimitiveKind.IsSpatial())
{
return(((IEdmSpatialTypeReference)thisType).IsEquivalentTo((IEdmSpatialTypeReference)otherType));
}
else
{
return(thisType.IsNullable == otherType.IsNullable &&
thisType.Definition.IsEquivalentTo(otherType.Definition));
}
}
}
private void VisitPrimitiveTypeReference(IEdmPrimitiveTypeReference reference)
{
switch (reference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
IsSpatialTypeUsed = true;
break;
}
}
/// <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)
{
DebugUtils.CheckNoExternalCallers();
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.DateTime:
return PlatformHelper.ConvertStringToDateTime(text);
case EdmPrimitiveTypeKind.DateTimeOffset:
return XmlConvert.ToDateTimeOffset(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:
return text;
case EdmPrimitiveTypeKind.Time:
return XmlConvert.ToTimeSpan(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.AtomValueUtils_ConvertStringToPrimitive));
}
}
catch (Exception e)
{
if (!ExceptionUtils.IsCatchableExceptionType(e))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, e);
}
}
internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference)
{
object obj2;
try
{
switch (targetTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
return(Convert.FromBase64String(text));
case EdmPrimitiveTypeKind.Boolean:
return(XmlConvert.ToBoolean(text));
case EdmPrimitiveTypeKind.Byte:
return(XmlConvert.ToByte(text));
case EdmPrimitiveTypeKind.DateTime:
return(Microsoft.Data.OData.PlatformHelper.ConvertStringToDateTime(text));
case EdmPrimitiveTypeKind.DateTimeOffset:
return(XmlConvert.ToDateTimeOffset(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:
return(text);
case EdmPrimitiveTypeKind.Time:
return(XmlConvert.ToTimeSpan(text));
}
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.AtomValueUtils_ConvertStringToPrimitive));
}
catch (Exception exception)
{
if (!ExceptionUtils.IsCatchableExceptionType(exception))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, exception);
}
return(obj2);
}
internal static bool TryUriStringToPrimitive(string text, IEdmTypeReference targetType, out object targetValue)
{
byte[] buffer;
bool flag9;
if (targetType.IsNullable && (text == "null"))
{
targetValue = null;
return(true);
}
IEdmPrimitiveTypeReference type = targetType.AsPrimitiveOrNull();
if (type == null)
{
targetValue = null;
return(false);
}
EdmPrimitiveTypeKind kind = type.PrimitiveKind();
bool flag = TryUriStringToByteArray(text, out buffer);
if (kind == EdmPrimitiveTypeKind.Binary)
{
targetValue = buffer;
return(flag);
}
if (flag)
{
return(TryUriStringToPrimitive(Encoding.UTF8.GetString(buffer, 0, buffer.Length), targetType, out targetValue));
}
switch (kind)
{
case EdmPrimitiveTypeKind.Guid:
{
Guid guid;
bool flag2 = TryUriStringToGuid(text, out guid);
targetValue = guid;
return(flag2);
}
case EdmPrimitiveTypeKind.DateTime:
{
DateTime time;
bool flag3 = TryUriStringToDateTime(text, out time);
targetValue = time;
return(flag3);
}
case EdmPrimitiveTypeKind.DateTimeOffset:
{
DateTimeOffset offset;
bool flag4 = TryUriStringToDateTimeOffset(text, out offset);
targetValue = offset;
return(flag4);
}
case EdmPrimitiveTypeKind.Time:
{
TimeSpan span;
bool flag5 = TryUriStringToTime(text, out span);
targetValue = span;
return(flag5);
}
case EdmPrimitiveTypeKind.Geography:
{
Geography geography;
bool flag6 = TryUriStringToGeography(text, out geography);
targetValue = geography;
return(flag6);
}
case EdmPrimitiveTypeKind.Geometry:
{
Geometry geometry;
bool flag7 = TryUriStringToGeometry(text, out geometry);
targetValue = geometry;
return(flag7);
}
}
bool flag8 = kind == EdmPrimitiveTypeKind.String;
if (flag8 != IsUriValueQuoted(text))
{
targetValue = null;
return(false);
}
if (flag8)
{
text = RemoveQuotes(text);
}
try
{
switch (kind)
{
case EdmPrimitiveTypeKind.Boolean:
targetValue = XmlConvert.ToBoolean(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Byte:
targetValue = XmlConvert.ToByte(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Decimal:
if (TryRemoveLiteralSuffix("M", ref text))
{
try
{
targetValue = XmlConvert.ToDecimal(text);
goto Label_02B3;
}
catch (FormatException)
{
decimal num;
if (decimal.TryParse(text, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out num))
{
targetValue = num;
goto Label_02B3;
}
targetValue = 0M;
return(false);
}
}
targetValue = 0M;
return(false);
case EdmPrimitiveTypeKind.Double:
TryRemoveLiteralSuffix("D", ref text);
targetValue = XmlConvert.ToDouble(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Int16:
targetValue = XmlConvert.ToInt16(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Int32:
targetValue = XmlConvert.ToInt32(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Int64:
if (!TryRemoveLiteralSuffix("L", ref text))
{
break;
}
targetValue = XmlConvert.ToInt64(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.SByte:
targetValue = XmlConvert.ToSByte(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.Single:
if (!TryRemoveLiteralSuffix("f", ref text))
{
goto Label_020F;
}
targetValue = XmlConvert.ToSingle(text);
goto Label_02B3;
case EdmPrimitiveTypeKind.String:
targetValue = text;
goto Label_02B3;
default:
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(Microsoft.Data.OData.Query.InternalErrorCodes.UriPrimitiveTypeParser_TryUriStringToPrimitive));
}
targetValue = 0L;
return(false);
Label_020F:
targetValue = 0f;
return(false);
Label_02B3:
flag9 = true;
}
catch (FormatException)
{
targetValue = null;
flag9 = false;
}
catch (OverflowException)
{
targetValue = null;
flag9 = false;
}
return(flag9);
}
private static CsdlConstantExpression BuildPrimitiveExpression(IEdmPrimitiveTypeReference primitiveTypeReference, CsdlConstantExpression expression)
{
Debug.Assert(expression.ExpressionKind == EdmExpressionKind.StringConstant);
CsdlLocation location = expression.Location as CsdlLocation;
switch (primitiveTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
return(new CsdlConstantExpression(EdmValueKind.Binary, expression.Value, location));
case EdmPrimitiveTypeKind.Date:
return(new CsdlConstantExpression(EdmValueKind.Date, expression.Value, location));
case EdmPrimitiveTypeKind.DateTimeOffset:
return(new CsdlConstantExpression(EdmValueKind.DateTimeOffset, expression.Value, location));
case EdmPrimitiveTypeKind.Decimal:
// it maybe use the string for decimal
// The IEEE754Compatible=true parameter indicates that the service MUST serialize Edm.Decimal numbers as strings.
// The special values INF, -INF, or NaN are represented as strings.
return(new CsdlConstantExpression(EdmValueKind.Decimal, expression.Value, location));
case EdmPrimitiveTypeKind.Int64:
// The IEEE754Compatible=true parameter indicates that the service MUST serialize Edm.Int64 numbers as strings.
return(new CsdlConstantExpression(EdmValueKind.Integer, expression.Value, location));
case EdmPrimitiveTypeKind.Duration:
return(new CsdlConstantExpression(EdmValueKind.Duration, expression.Value, location));
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
// may have a string containing one of the special values INF, -INF, or NaN.
return(new CsdlConstantExpression(EdmValueKind.Floating, expression.Value, location));
case EdmPrimitiveTypeKind.Guid:
return(new CsdlConstantExpression(EdmValueKind.Guid, expression.Value, location));
case EdmPrimitiveTypeKind.TimeOfDay:
return(new CsdlConstantExpression(EdmValueKind.TimeOfDay, expression.Value, location));
case EdmPrimitiveTypeKind.String:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Stream:
case EdmPrimitiveTypeKind.PrimitiveType:
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
case EdmPrimitiveTypeKind.None:
default:
return(expression);
}
}
private static bool IsEquivalentTo(this IEdmPrimitiveTypeReference thisType, IEdmPrimitiveTypeReference otherType)
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind = thisType.PrimitiveKind();
if (edmPrimitiveTypeKind == otherType.PrimitiveKind())
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind1 = edmPrimitiveTypeKind;
switch (edmPrimitiveTypeKind1)
{
case EdmPrimitiveTypeKind.Binary:
{
return thisType.IsEquivalentTo((IEdmBinaryTypeReference)otherType);
}
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
{
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return false;
}
else
{
return thisType.Definition.IsEquivalentTo(otherType.Definition);
}
}
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
{
return thisType.IsEquivalentTo((IEdmTemporalTypeReference)otherType);
}
case EdmPrimitiveTypeKind.Decimal:
{
return thisType.IsEquivalentTo((IEdmDecimalTypeReference)otherType);
}
default:
{
if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.String)
{
return thisType.IsEquivalentTo((IEdmStringTypeReference)otherType);
}
else if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.Stream)
{
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return false;
}
else
{
return thisType.Definition.IsEquivalentTo(otherType.Definition);
}
}
else if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.Time)
{
return thisType.IsEquivalentTo((IEdmTemporalTypeReference)otherType);
}
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return false;
}
else
{
return thisType.Definition.IsEquivalentTo(otherType.Definition);
}
}
}
return thisType.IsEquivalentTo((IEdmSpatialTypeReference)otherType);
}
else
{
return false;
}
}
private static IOpenApiAny CreateDefault(this IEdmStructuralProperty property)
{
if (property == null ||
property.DefaultValueString == null)
{
return(null);
}
if (property.Type.IsEnum())
{
return(new OpenApiString(property.DefaultValueString));
}
if (!property.Type.IsPrimitive())
{
return(null);
}
IEdmPrimitiveTypeReference primitiveTypeReference = property.Type.AsPrimitive();
switch (primitiveTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Boolean:
{
bool result;
if (Boolean.TryParse(property.DefaultValueString, out result))
{
return(new OpenApiBoolean(result));
}
}
break;
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
{
int result;
if (Int32.TryParse(property.DefaultValueString, out result))
{
return(new OpenApiInteger(result));
}
}
break;
case EdmPrimitiveTypeKind.Int64:
break;
// The type 'System.Double' is not supported in Open API document.
case EdmPrimitiveTypeKind.Double:
/*
* {
* double result;
* if (Double.TryParse(property.DefaultValueString, out result))
* {
* return new OpenApiDouble((float)result);
* }
* }*/
break;
}
return(new OpenApiString(property.DefaultValueString));
}
private static bool IsOpenPropertyType(IEdmTypeReference typeReference)
{
IEdmPrimitiveTypeReference type = typeReference.AsPrimitiveOrNull();
return((type != null) && (type.PrimitiveKind() == EdmPrimitiveTypeKind.None));
}
/// <summary>
/// Compute the result type of a binary operator based on the type of its operands and the operator kind.
/// </summary>
/// <param name="left">The type reference on the left hand.</param>
/// <param name="right">The type reference on the right hand.</param>
/// <param name="operatorKind">The kind of operator.</param>
/// <returns>The result type reference of the binary operator.</returns>
internal static IEdmPrimitiveTypeReference GetBinaryOperatorResultType(IEdmPrimitiveTypeReference left, IEdmPrimitiveTypeReference right, BinaryOperatorKind operatorKind)
{
Debug.Assert(left != null, "type != null");
Debug.Assert(right != null, "type != null");
EdmPrimitiveTypeKind kind;
if (additionalMap.TryGetValue(new Tuple <BinaryOperatorKind, EdmPrimitiveTypeKind, EdmPrimitiveTypeKind>(operatorKind, left.PrimitiveKind(), right.PrimitiveKind()), out kind))
{
return(EdmCoreModel.Instance.GetPrimitive(kind, left.IsNullable));
}
switch (operatorKind)
{
case BinaryOperatorKind.Or: // fall through
case BinaryOperatorKind.And: // fall through
case BinaryOperatorKind.Equal: // fall through
case BinaryOperatorKind.NotEqual: // fall through
case BinaryOperatorKind.GreaterThan: // fall through
case BinaryOperatorKind.GreaterThanOrEqual: // fall through
case BinaryOperatorKind.LessThan: // fall through
case BinaryOperatorKind.LessThanOrEqual:
case BinaryOperatorKind.Has:
return(EdmCoreModel.Instance.GetBoolean(left.IsNullable));
case BinaryOperatorKind.Add: // fall through
case BinaryOperatorKind.Subtract: // fall through
case BinaryOperatorKind.Multiply: // fall through
case BinaryOperatorKind.Divide: // fall through
case BinaryOperatorKind.Modulo:
return(left);
default:
throw new ODataException(ODataErrorStrings.General_InternalError(InternalErrorCodes.QueryNodeUtils_BinaryOperatorResultType_UnreachableCodepath));
}
}
/// <summary>
/// Determines if the given primitive value is of a basic type where we can rely on just the JSON representation to convey type information.
/// If so, we don't have to write the type name.
/// </summary>
/// <param name="primitiveValue">The primitive value in question.</param>
/// <param name="valueTypeReference">The type of the primitive value.</param>
/// <returns>true if the given primitive value is of a basic JSON type, false otherwise.</returns>
internal static bool ValueTypeMatchesJsonType(ODataPrimitiveValue primitiveValue, IEdmPrimitiveTypeReference valueTypeReference)
{
return(ValueTypeMatchesJsonType(primitiveValue, valueTypeReference.PrimitiveKind()));
}
private static bool IsEquivalentTo(this IEdmPrimitiveTypeReference thisType, IEdmPrimitiveTypeReference otherType)
{
EdmPrimitiveTypeKind thisTypePrimitiveKind = thisType.PrimitiveKind();
if (thisTypePrimitiveKind != otherType.PrimitiveKind())
{
return false;
}
switch (thisTypePrimitiveKind)
{
case EdmPrimitiveTypeKind.Binary:
return ((IEdmBinaryTypeReference)thisType).IsEquivalentTo((IEdmBinaryTypeReference)otherType);
case EdmPrimitiveTypeKind.Decimal:
return ((IEdmDecimalTypeReference)thisType).IsEquivalentTo((IEdmDecimalTypeReference)otherType);
case EdmPrimitiveTypeKind.String:
return ((IEdmStringTypeReference)thisType).IsEquivalentTo((IEdmStringTypeReference)otherType);
case EdmPrimitiveTypeKind.Time:
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
return ((IEdmTemporalTypeReference)thisType).IsEquivalentTo((IEdmTemporalTypeReference)otherType);
default:
if (thisTypePrimitiveKind.IsSpatial())
{
return ((IEdmSpatialTypeReference)thisType).IsEquivalentTo((IEdmSpatialTypeReference)otherType);
}
else
{
return thisType.IsNullable == otherType.IsNullable &&
thisType.Definition.IsEquivalentTo(otherType.Definition);
}
}
}
internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference)
{
object obj2;
try
{
switch (targetTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
return Convert.FromBase64String(text);
case EdmPrimitiveTypeKind.Boolean:
return XmlConvert.ToBoolean(text);
case EdmPrimitiveTypeKind.Byte:
return XmlConvert.ToByte(text);
case EdmPrimitiveTypeKind.DateTime:
return Microsoft.Data.OData.PlatformHelper.ConvertStringToDateTime(text);
case EdmPrimitiveTypeKind.DateTimeOffset:
return XmlConvert.ToDateTimeOffset(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:
return text;
case EdmPrimitiveTypeKind.Time:
return XmlConvert.ToTimeSpan(text);
}
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.AtomValueUtils_ConvertStringToPrimitive));
}
catch (Exception exception)
{
if (!ExceptionUtils.IsCatchableExceptionType(exception))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, exception);
}
return obj2;
}
private static IEdmPrimitiveTypeReference ApplyFacetAnnotations(this IEdmPrimitiveTypeReference primitiveTypeReference, List <KeyValuePair <string, object> > annotations)
{
object obj2;
if ((annotations == null) || (annotations.Count == 0))
{
return(primitiveTypeReference);
}
IEdmPrimitiveTypeReference reference = primitiveTypeReference;
bool isNullable = primitiveTypeReference.IsNullable;
if (TryFindAndRemoveAnnotation(annotations, "Nullable", out obj2))
{
isNullable = ConvertAnnotationValue <bool>(obj2, "Nullable");
}
EdmPrimitiveTypeKind kind = primitiveTypeReference.PrimitiveKind();
switch (kind)
{
case EdmPrimitiveTypeKind.Binary:
return(CreateBinaryTypeReference(primitiveTypeReference, isNullable, annotations));
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
if (primitiveTypeReference.IsNullable != isNullable)
{
reference = new EdmPrimitiveTypeReference(primitiveTypeReference.PrimitiveDefinition(), isNullable);
}
return(reference);
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
return(CreateTemporalTypeReference(primitiveTypeReference, isNullable, annotations));
case EdmPrimitiveTypeKind.Decimal:
return(CreateDecimalTypeReference(primitiveTypeReference, isNullable, annotations));
case EdmPrimitiveTypeKind.String:
return(CreateStringTypeReference(primitiveTypeReference, isNullable, annotations));
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return(CreateSpatialTypeReference(primitiveTypeReference, isNullable, annotations));
}
throw new InvalidOperationException(System.Data.Services.Strings.MetadataProviderUtils_UnsupportedPrimitiveTypeKind(kind.ToString()));
}
/// <summary>
/// Reads the next parameter from the parameters payload.
/// </summary>
/// <param name="propertyAndAnnotationCollector">The duplicate property names checker used to read a parameter payload.</param>
/// <returns>true if a parameter was read from the payload; otherwise false.</returns>
/// <remarks>
/// Pre-Condition: Property or EndObject the property node of the parameter to read or the end object node if there are not parameters
/// Post-Condition: Property or EndObject the node after the property value of a primitive, complex or null collection parameter
/// Any the start of the value representing a non-null collection parameter (the collection reader will fail if this is not a StartArray node)
/// </remarks>
internal bool ReadNextParameter(PropertyAndAnnotationCollector propertyAndAnnotationCollector)
{
Debug.Assert(propertyAndAnnotationCollector != null, "propertyAndAnnotationCollector != null");
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
bool parameterRead = false;
if (this.JsonReader.NodeType == JsonNodeType.Property)
{
bool foundCustomInstanceAnnotation = false;
this.ProcessProperty(
propertyAndAnnotationCollector,
propertyAnnotationValueReader,
(propertyParsingResult, parameterName) =>
{
if (this.JsonReader.NodeType == JsonNodeType.Property)
{
// Read over property name
this.JsonReader.Read();
}
switch (propertyParsingResult)
{
case PropertyParsingResult.ODataInstanceAnnotation:
// OData instance annotations are not supported in parameter payloads.
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_UnexpectedAnnotationProperties(parameterName));
case PropertyParsingResult.CustomInstanceAnnotation:
this.JsonReader.SkipValue();
foundCustomInstanceAnnotation = true;
break;
case PropertyParsingResult.PropertyWithoutValue:
throw new ODataException(ODataErrorStrings.ODataJsonLightParameterDeserializer_PropertyAnnotationWithoutPropertyForParameters(parameterName));
case PropertyParsingResult.EndOfObject:
break;
case PropertyParsingResult.MetadataReferenceProperty:
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_UnexpectedMetadataReferenceProperty(parameterName));
case PropertyParsingResult.PropertyWithValue:
IEdmTypeReference parameterTypeReference = this.parameterReader.GetParameterTypeReference(parameterName);
Debug.Assert(parameterTypeReference != null, "parameterTypeReference != null");
ODataParameterReaderState state;
object parameterValue;
EdmTypeKind parameterTypeKind = parameterTypeReference.TypeKind();
switch (parameterTypeKind)
{
case EdmTypeKind.Primitive:
IEdmPrimitiveTypeReference primitiveTypeReference = parameterTypeReference.AsPrimitive();
if (primitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.Stream)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightParameterDeserializer_UnsupportedPrimitiveParameterType(parameterName, primitiveTypeReference.PrimitiveKind()));
}
parameterValue = this.ReadNonEntityValue(
/*payloadTypeName*/ null,
primitiveTypeReference,
/*propertyAndAnnotationCollector*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
parameterName);
state = ODataParameterReaderState.Value;
break;
case EdmTypeKind.Enum:
IEdmEnumTypeReference enumTypeReference = parameterTypeReference.AsEnum();
parameterValue = this.ReadNonEntityValue(
/*payloadTypeName*/ null,
enumTypeReference,
/*propertyAndAnnotationCollector*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
parameterName);
state = ODataParameterReaderState.Value;
break;
case EdmTypeKind.TypeDefinition:
IEdmTypeDefinitionReference typeDefinitionReference = parameterTypeReference.AsTypeDefinition();
parameterValue = this.ReadNonEntityValue(
/*payloadTypeName*/ null,
typeDefinitionReference,
/*propertyAndAnnotationCollector*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
parameterName);
state = ODataParameterReaderState.Value;
break;
case EdmTypeKind.Complex:
case EdmTypeKind.Entity:
parameterValue = null;
state = ODataParameterReaderState.Resource;
break;
case EdmTypeKind.Collection:
parameterValue = null;
if (this.JsonReader.NodeType == JsonNodeType.PrimitiveValue)
{
// NOTE: we support null collections in parameter payloads but nowhere else.
parameterValue = this.JsonReader.ReadPrimitiveValue();
if (parameterValue != null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightParameterDeserializer_NullCollectionExpected(JsonNodeType.PrimitiveValue, parameterValue));
}
state = ODataParameterReaderState.Value;
}
else if (((IEdmCollectionType)parameterTypeReference.Definition).ElementType.IsStructured())
{
state = ODataParameterReaderState.ResourceSet;
}
else
{
state = ODataParameterReaderState.Collection;
}
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightParameterDeserializer_UnsupportedParameterTypeKind(parameterName, parameterTypeReference.TypeKind()));
}
parameterRead = true;
this.parameterReader.EnterScope(state, parameterName, parameterValue);
Debug.Assert(
state == ODataParameterReaderState.Collection || state == ODataParameterReaderState.Resource || state == ODataParameterReaderState.ResourceSet || this.JsonReader.NodeType == JsonNodeType.Property || this.JsonReader.NodeType == JsonNodeType.EndObject,
"Expected any node for a collection; 'Property' or 'EndObject' if it is a primitive or complex value.");
break;
default:
throw new ODataException(ODataErrorStrings.General_InternalError(InternalErrorCodes.ODataJsonLightParameterDeserializer_ReadNextParameter));
}
});
if (foundCustomInstanceAnnotation)
{
return(this.ReadNextParameter(propertyAndAnnotationCollector));
}
}
if (!parameterRead && this.JsonReader.NodeType == JsonNodeType.EndObject)
{
this.JsonReader.ReadEndObject();
this.ReadPayloadEnd(/*isReadingNestedPayload*/ false);
// Pop the scope for the previous parameter if there is any
if (this.parameterReader.State != ODataParameterReaderState.Start)
{
this.parameterReader.PopScope(this.parameterReader.State);
}
// Pop the 'Start' scope and enter the 'Completed' scope
this.parameterReader.PopScope(ODataParameterReaderState.Start);
this.parameterReader.EnterScope(ODataParameterReaderState.Completed, /*parameterName*/ null, /*parameterValue*/ null);
this.AssertJsonCondition(JsonNodeType.EndOfInput);
}
return(parameterRead);
}
/// <summary>
/// Reads the next parameter from the parameters payload.
/// </summary>
private void ReadNextParameter()
{
ODataParameterReaderState state;
string parameterName = this.verboseJsonPropertyAndValueDeserializer.JsonReader.ReadPropertyName();
Debug.Assert(!string.IsNullOrEmpty(parameterName), "!string.IsNullOrEmpty(parameterName)");
IEdmTypeReference parameterTypeReference = this.GetParameterTypeReference(parameterName);
Debug.Assert(parameterTypeReference != null, "parameterTypeReference != null");
object parameterValue;
switch (parameterTypeReference.TypeKind())
{
case EdmTypeKind.Primitive:
IEdmPrimitiveTypeReference primitiveTypeReference = parameterTypeReference.AsPrimitive();
if (primitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.Stream)
{
throw new ODataException(ODataErrorStrings.ODataJsonParameterReader_UnsupportedPrimitiveParameterType(parameterName, primitiveTypeReference.PrimitiveKind()));
}
parameterValue = this.verboseJsonPropertyAndValueDeserializer.ReadNonEntityValue(
primitiveTypeReference,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
parameterName);
state = ODataParameterReaderState.Value;
break;
case EdmTypeKind.Complex:
parameterValue = this.verboseJsonPropertyAndValueDeserializer.ReadNonEntityValue(
parameterTypeReference,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
parameterName);
state = ODataParameterReaderState.Value;
break;
#if SUPPORT_ENTITY_PARAMETER
case EdmTypeKind.Entity:
parameterValue = null;
state = ODataParameterReaderState.Entry;
break;
#endif
case EdmTypeKind.Collection:
parameterValue = null;
if (this.verboseJsonPropertyAndValueDeserializer.JsonReader.NodeType == JsonNodeType.PrimitiveValue)
{
parameterValue = this.verboseJsonPropertyAndValueDeserializer.JsonReader.ReadPrimitiveValue();
if (parameterValue != null)
{
throw new ODataException(ODataErrorStrings.ODataJsonParameterReader_NullCollectionExpected(JsonNodeType.PrimitiveValue, parameterValue));
}
state = ODataParameterReaderState.Value;
}
else if (((IEdmCollectionType)parameterTypeReference.Definition).ElementType.TypeKind() == EdmTypeKind.Entity)
{
#if SUPPORT_ENTITY_PARAMETER
state = ODataParameterReaderState.Feed;
#else
throw new ODataException(ODataErrorStrings.ODataJsonParameterReader_UnsupportedParameterTypeKind(parameterName, "Entity Collection"));
#endif
}
else
{
state = ODataParameterReaderState.Collection;
}
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonParameterReader_UnsupportedParameterTypeKind(parameterName, parameterTypeReference.TypeKind()));
}
this.EnterScope(state, parameterName, parameterValue);
}
/// <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)
{
DebugUtils.CheckNoExternalCallers();
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.DateTime:
return(PlatformHelper.ConvertStringToDateTime(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:
return(text);
case EdmPrimitiveTypeKind.Time:
return(XmlConvert.ToTimeSpan(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.AtomValueUtils_ConvertStringToPrimitive));
}
}
catch (Exception e)
{
if (!ExceptionUtils.IsCatchableExceptionType(e))
{
throw;
}
throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, e);
}
}
public void VisitPrimitiveTypeReference(IEdmPrimitiveTypeReference reference)
{
switch (reference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
this.ProcessBinaryTypeReference(reference.AsBinary());
break;
case EdmPrimitiveTypeKind.Decimal:
this.ProcessDecimalTypeReference(reference.AsDecimal());
break;
case EdmPrimitiveTypeKind.String:
this.ProcessStringTypeReference(reference.AsString());
break;
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Duration:
case EdmPrimitiveTypeKind.TimeOfDay:
this.ProcessTemporalTypeReference(reference.AsTemporal());
break;
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
this.ProcessSpatialTypeReference(reference.AsSpatial());
break;
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
case EdmPrimitiveTypeKind.Date:
case EdmPrimitiveTypeKind.PrimitiveType:
case EdmPrimitiveTypeKind.None:
this.ProcessPrimitiveTypeReference(reference);
break;
default:
throw new InvalidOperationException(Edm.Strings.UnknownEnumVal_PrimitiveKind(reference.PrimitiveKind().ToString()));
}
}
private static void AppendFacets(this StringBuilder sb, IEdmPrimitiveTypeReference type)
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind = type.PrimitiveKind();
switch (edmPrimitiveTypeKind)
{
case EdmPrimitiveTypeKind.Binary:
{
sb.AppendBinaryFacets(type.AsBinary());
return;
}
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
{
return;
}
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
{
sb.AppendTemporalFacets(type.AsTemporal());
return;
}
case EdmPrimitiveTypeKind.Decimal:
{
sb.AppendDecimalFacets(type.AsDecimal());
return;
}
case EdmPrimitiveTypeKind.String:
{
sb.AppendStringFacets(type.AsString());
return;
}
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
{
sb.AppendSpatialFacets(type.AsSpatial());
return;
}
default:
{
return;
}
}
}
internal static bool TryUriStringToPrimitive(string text, IEdmTypeReference targetType, out object targetValue, out string reason)
{
Debug.Assert(text != null, "text != null");
Debug.Assert(targetType != null, "targetType != null");
reason = null;
if (targetType.IsNullable)
{
if (text == ExpressionConstants.KeywordNull)
{
targetValue = null;
return(true);
}
}
IEdmPrimitiveTypeReference primitiveTargetType = targetType.AsPrimitiveOrNull();
if (primitiveTargetType == null)
{
targetValue = null;
return(false);
}
EdmPrimitiveTypeKind targetTypeKind = primitiveTargetType.PrimitiveKind();
byte[] byteArrayValue;
bool binaryResult = TryUriStringToByteArray(text, out byteArrayValue);
if (targetTypeKind == EdmPrimitiveTypeKind.Binary)
{
targetValue = (object)byteArrayValue;
return(binaryResult);
}
else if (binaryResult)
{
string keyValue = Encoding.UTF8.GetString(byteArrayValue, 0, byteArrayValue.Length);
return(TryUriStringToPrimitive(keyValue, targetType, out targetValue));
}
else if (targetTypeKind == EdmPrimitiveTypeKind.Guid)
{
Guid guidValue;
bool result = UriUtils.TryUriStringToGuid(text, out guidValue);
targetValue = guidValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.DateTimeOffset)
{
DateTimeOffset dateTimeOffsetValue;
bool result = UriUtils.TryUriStringToDateTimeOffset(text, out dateTimeOffsetValue);
targetValue = dateTimeOffsetValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.Duration)
{
TimeSpan timespanValue;
bool result = TryUriStringToDuration(text, out timespanValue);
targetValue = timespanValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.Geography)
{
Geography geographyValue;
bool result = TryUriStringToGeography(text, out geographyValue, out reason);
targetValue = geographyValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.Geometry)
{
Geometry geometryValue;
bool result = TryUriStringToGeometry(text, out geometryValue, out reason);
targetValue = geometryValue;
return(result);
}
bool quoted = targetTypeKind == EdmPrimitiveTypeKind.String;
if (quoted != IsUriValueQuoted(text))
{
targetValue = null;
return(false);
}
if (quoted)
{
text = RemoveQuotes(text);
}
try
{
switch (targetTypeKind)
{
case EdmPrimitiveTypeKind.String:
targetValue = text;
break;
case EdmPrimitiveTypeKind.Boolean:
targetValue = XmlConvert.ToBoolean(text);
break;
case EdmPrimitiveTypeKind.Byte:
targetValue = XmlConvert.ToByte(text);
break;
case EdmPrimitiveTypeKind.SByte:
targetValue = XmlConvert.ToSByte(text);
break;
case EdmPrimitiveTypeKind.Int16:
targetValue = XmlConvert.ToInt16(text);
break;
case EdmPrimitiveTypeKind.Int32:
targetValue = XmlConvert.ToInt32(text);
break;
case EdmPrimitiveTypeKind.Int64:
TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixInt64, ref text);
targetValue = XmlConvert.ToInt64(text);
break;
case EdmPrimitiveTypeKind.Single:
TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixSingle, ref text);
targetValue = XmlConvert.ToSingle(text);
break;
case EdmPrimitiveTypeKind.Double:
TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixDouble, ref text);
targetValue = XmlConvert.ToDouble(text);
break;
case EdmPrimitiveTypeKind.Decimal:
TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixDecimal, ref text);
try
{
targetValue = XmlConvert.ToDecimal(text);
}
catch (FormatException)
{
// we need to support exponential format for decimals since we used to support them in V1
decimal result;
if (Decimal.TryParse(text, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out result))
{
targetValue = result;
}
else
{
targetValue = default(Decimal);
return(false);
}
}
break;
default:
throw new ODataException(ODataErrorStrings.General_InternalError(InternalErrorCodes.UriPrimitiveTypeParser_TryUriStringToPrimitive));
}
return(true);
}
catch (FormatException)
{
targetValue = null;
return(false);
}
catch (OverflowException)
{
targetValue = null;
return(false);
}
}
private static void AppendFacets(this StringBuilder sb, IEdmPrimitiveTypeReference type)
{
switch (type.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
sb.AppendBinaryFacets(type.AsBinary());
break;
case EdmPrimitiveTypeKind.Decimal:
sb.AppendDecimalFacets(type.AsDecimal());
break;
case EdmPrimitiveTypeKind.String:
sb.AppendStringFacets(type.AsString());
break;
case EdmPrimitiveTypeKind.Time:
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
sb.AppendTemporalFacets(type.AsTemporal());
break;
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
sb.AppendSpatialFacets(type.AsSpatial());
break;
}
}
/// <summary>
/// Writes the value of a primitive instance annotation.
/// </summary>
/// <param name="primitiveValue">The primitive value to write.</param>
/// <param name="expectedTypeReference">The expected type of the annotation from the metadata.</param>
private void WritePrimitiveInstanceAnnotationValue(ODataPrimitiveValue primitiveValue, IEdmTypeReference expectedTypeReference)
{
object clrValue = primitiveValue.Value;
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(clrValue.GetType());
string attributeValueNotationName = AtomInstanceAnnotation.LookupAttributeValueNotationNameByEdmTypeKind(primitiveTypeReference.PrimitiveKind());
// Some primitive values can be specified more concisely via an attribute rather than in the content of the xml element. This is called "attribute value notation".
// If we're writing a type that supports this, then we always prefer attribute value notation over writing the value in the element content.
if (attributeValueNotationName != null)
{
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(primitiveValue.Value, primitiveTypeReference, expectedTypeReference);
}
this.XmlWriter.WriteAttributeString(attributeValueNotationName, AtomValueUtils.ConvertPrimitiveToString(clrValue));
}
else
{
this.WritePrimitiveValue(clrValue, /*collectionValidator*/ null, expectedTypeReference, primitiveValue.GetAnnotation <SerializationTypeNameAnnotation>());
}
}
private static bool IsEquivalentTo(this IEdmPrimitiveTypeReference thisType, IEdmPrimitiveTypeReference otherType)
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind = thisType.PrimitiveKind();
if (edmPrimitiveTypeKind == otherType.PrimitiveKind())
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind1 = edmPrimitiveTypeKind;
switch (edmPrimitiveTypeKind1)
{
case EdmPrimitiveTypeKind.Binary:
{
return(thisType.IsEquivalentTo((IEdmBinaryTypeReference)otherType));
}
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
{
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return(false);
}
else
{
return(thisType.Definition.IsEquivalentTo(otherType.Definition));
}
}
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
{
return(thisType.IsEquivalentTo((IEdmTemporalTypeReference)otherType));
}
case EdmPrimitiveTypeKind.Decimal:
{
return(thisType.IsEquivalentTo((IEdmDecimalTypeReference)otherType));
}
default:
{
if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.String)
{
return(thisType.IsEquivalentTo((IEdmStringTypeReference)otherType));
}
else if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.Stream)
{
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return(false);
}
else
{
return(thisType.Definition.IsEquivalentTo(otherType.Definition));
}
}
else if (edmPrimitiveTypeKind1 == EdmPrimitiveTypeKind.Time)
{
return(thisType.IsEquivalentTo((IEdmTemporalTypeReference)otherType));
}
if (edmPrimitiveTypeKind.IsSpatial())
{
break;
}
if (thisType.IsNullable != otherType.IsNullable)
{
return(false);
}
else
{
return(thisType.Definition.IsEquivalentTo(otherType.Definition));
}
}
}
return(thisType.IsEquivalentTo((IEdmSpatialTypeReference)otherType));
}
else
{
return(false);
}
}
/// <summary>
/// Read a top-level value.
/// </summary>
/// <param name="expectedPrimitiveTypeReference">The expected primitive type for the value to be read; null if no expected type is available.</param>
/// <returns>An <see cref="object"/> representing the read value.</returns>
private object ReadValueImplementation(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
// if an expected primitive type is specified it trumps the content type/reader payload kind
bool readBinary;
if (expectedPrimitiveTypeReference == null)
{
readBinary = this.readerPayloadKind == ODataPayloadKind.BinaryValue;
}
else
{
if (expectedPrimitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.Binary)
{
readBinary = true;
}
else
{
readBinary = false;
}
}
if (readBinary)
{
return this.ReadBinaryValue();
}
else
{
Debug.Assert(this.textReader == null, "this.textReader == null");
this.textReader = this.encoding == null ? new StreamReader(this.stream) : new StreamReader(this.stream, this.encoding);
return this.ReadRawValue(expectedPrimitiveTypeReference);
}
}
/// <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)
{
Double doubleValue = (Double)value;
if (targetType == typeof(Single))
{
return(Convert.ToSingle(doubleValue));
}
if (targetType != typeof(Double))
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDouble(primitiveTypeReference.FullName()));
}
}
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);
}
private object ReadValueImplementation(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
bool flag;
if (expectedPrimitiveTypeReference == null)
{
flag = this.readerPayloadKind == ODataPayloadKind.BinaryValue;
}
else if (expectedPrimitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.Binary)
{
flag = true;
}
else
{
flag = false;
}
if (flag)
{
return this.ReadBinaryValue();
}
this.textReader = (this.encoding == null) ? new StreamReader(this.stream) : new StreamReader(this.stream, this.encoding);
return this.ReadRawValue(expectedPrimitiveTypeReference);
}
private static void AppendFacets(this StringBuilder sb, IEdmPrimitiveTypeReference type)
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind = type.PrimitiveKind();
switch (edmPrimitiveTypeKind)
{
case EdmPrimitiveTypeKind.Binary:
{
sb.AppendBinaryFacets(type.AsBinary());
return;
}
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
{
return;
}
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
{
sb.AppendTemporalFacets(type.AsTemporal());
return;
}
case EdmPrimitiveTypeKind.Decimal:
{
sb.AppendDecimalFacets(type.AsDecimal());
return;
}
case EdmPrimitiveTypeKind.String:
{
sb.AppendStringFacets(type.AsString());
return;
}
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
{
sb.AppendSpatialFacets(type.AsSpatial());
return;
}
default:
{
return;
}
}
}
