/// <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;
}
}
/// <summary>
/// Creates an <see cref="ODataPrimitiveValue"/> for the object represented by <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The primitive value.</param>
/// <param name="primitiveType">The EDM primitive type of the value.</param>
/// <param name="writeContext">The serializer write context.</param>
/// <returns>The created <see cref="ODataPrimitiveValue"/>.</returns>
public override ODataPrimitiveValue CreateODataPrimitiveValue(
object graph,
IEdmPrimitiveTypeReference primitiveType,
ODataSerializerContext writeContext)
{
// The EDM type of the "graph" would override the EDM type of the property when
// OData Web API infers the primitiveType. Thus for "graph" of System.DateTime,
// the primitiveType is always Edm.DateTimeOffset.
//
// In EF, System.DateTime is used for SqlDate, SqlDateTime and SqlDateTime2.
// All of them have no time zone information thus it is safe to clear the time
// zone when converting the "graph" to a DateTimeOffset.
if (primitiveType != null && primitiveType.IsDateTimeOffset() && graph is DateTime)
{
// If DateTime.Kind equals Local, offset should equal the offset of the system's local time zone
if (((DateTime)graph).Kind == DateTimeKind.Local)
{
graph = new DateTimeOffset((DateTime)graph, TimeZoneInfo.Local.GetUtcOffset((DateTime)graph));
}
else
{
graph = new DateTimeOffset((DateTime)graph, TimeSpan.Zero);
}
}
return base.CreateODataPrimitiveValue(graph, primitiveType, writeContext);
}
public void Init()
{
this._intType = EdmCoreModel.Instance.GetInt32(false);
this._value1 = new EdmIntegerConstant(1);
this._value2 = new EdmIntegerConstant(2);
this._collection = new ClientEdmCollectionValue(this._intType, new IEdmValue[] { this._value1, this._value2 });
}
/// <summary>
/// Compute the result type of a binary operator based on the type of its operands and the operator kind.
/// </summary>
/// <param name="typeReference">The type reference of the operators.</param>
/// <param name="operatorKind">The kind of operator.</param>
/// <returns>The result type reference of the binary operator.</returns>
internal static IEdmPrimitiveTypeReference GetBinaryOperatorResultType(IEdmPrimitiveTypeReference typeReference, BinaryOperatorKind operatorKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(typeReference != null, "type != null");
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:
return EdmCoreModel.Instance.GetBoolean(typeReference.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 typeReference;
default:
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.QueryNodeUtils_BinaryOperatorResultType_UnreachableCodepath));
}
}
/// <summary>
/// Creates an <see cref="ODataPrimitiveValue"/> for the object represented by <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The primitive value.</param>
/// <param name="primitiveType">The EDM primitive type of the value.</param>
/// <param name="writeContext">The serializer write context.</param>
/// <returns>The created <see cref="ODataPrimitiveValue"/>.</returns>
public virtual ODataPrimitiveValue CreateODataPrimitiveValue(object graph, IEdmPrimitiveTypeReference primitiveType,
ODataSerializerContext writeContext)
{
ODataMetadataLevel metadataLevel = writeContext != null ? writeContext.MetadataLevel : ODataMetadataLevel.Default;
// TODO: Bug 467598: validate the type of the object being passed in here with the underlying primitive type.
return CreatePrimitive(graph, primitiveType, metadataLevel);
}
internal static object ReadPrimitiveValue(XmlReader reader, IEdmPrimitiveTypeReference primitiveTypeReference)
{
object obj2;
if (!PrimitiveConverter.Instance.TryTokenizeFromXml(reader, EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference), out obj2))
{
return ConvertStringToPrimitive(reader.ReadElementContentValue(), primitiveTypeReference);
}
return obj2;
}
/// <summary>
/// Converts a primitive OData value to the corresponding <see cref="IEdmDelayedValue"/>.
/// </summary>
/// <param name="primitiveValue">The primitive OData value to convert.</param>
/// <param name="type">The <see cref="IEdmTypeReference"/> for the primitive value (if available).</param>
/// <returns>An <see cref="IEdmDelayedValue"/> for the <paramref name="primitiveValue"/>.</returns>
internal static IEdmDelayedValue ConvertPrimitiveValue(object primitiveValue, IEdmPrimitiveTypeReference type)
{
#if !ASTORIA_CLIENT
#endif
Debug.Assert(primitiveValue != null, "primitiveValue != null");
TypeCode typeCode = PlatformHelpers.GetTypeCode(primitiveValue.GetType());
switch (typeCode)
{
case TypeCode.Boolean:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Boolean);
return new EdmBooleanConstant(type, (bool)primitiveValue);
case TypeCode.Byte:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Byte);
return new EdmIntegerConstant(type, (byte)primitiveValue);
case TypeCode.SByte:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.SByte);
return new EdmIntegerConstant(type, (sbyte)primitiveValue);
case TypeCode.Int16:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Int16);
return new EdmIntegerConstant(type, (Int16)primitiveValue);
case TypeCode.Int32:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Int32);
return new EdmIntegerConstant(type, (Int32)primitiveValue);
case TypeCode.Int64:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Int64);
return new EdmIntegerConstant(type, (Int64)primitiveValue);
case TypeCode.Decimal:
IEdmDecimalTypeReference decimalType = (IEdmDecimalTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Decimal);
return new EdmDecimalConstant(decimalType, (decimal)primitiveValue);
case TypeCode.Single:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Single);
return new EdmFloatingConstant(type, (Single)primitiveValue);
case TypeCode.Double:
type = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Double);
return new EdmFloatingConstant(type, (double)primitiveValue);
case TypeCode.String:
IEdmStringTypeReference stringType = (IEdmStringTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.String);
return new EdmStringConstant(stringType, (string)primitiveValue);
default:
return ConvertPrimitiveValueWithoutTypeCode(primitiveValue, type);
}
}
/// <summary>
/// Reads a value of an XML element and converts it to the target primitive value.
/// </summary>
/// <param name="reader">The XML reader to read the value from.</param>
/// <param name="primitiveTypeReference">The primitive type reference to convert the value to.</param>
/// <returns>The primitive value read.</returns>
/// <remarks>This method does not read null values, it only reads the actual element value (not its attributes).</remarks>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.Element - the element was empty.
/// XmlNodeType.EndElement - the element had some value.
/// </remarks>
internal static object ReadPrimitiveValue(XmlReader reader, IEdmPrimitiveTypeReference primitiveTypeReference)
{
Debug.Assert(reader != null, "reader != null");
object spatialValue;
if (!PrimitiveConverter.Instance.TryTokenizeFromXml(reader, EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference), out spatialValue))
{
string stringValue = reader.ReadElementContentValue();
return(ConvertStringToPrimitive(stringValue, primitiveTypeReference));
}
return(spatialValue);
}
public void GetClrTypeWorksAsExpectedForSpatialPrimitive(EdmPrimitiveTypeKind kind, Type type)
{
// Arrange
IEdmPrimitiveTypeReference primitiveType1 = EdmCoreModel.Instance.GetPrimitive(kind, true);
IEdmPrimitiveTypeReference primitiveType2 = EdmCoreModel.Instance.GetPrimitive(kind, false);
// Act
Type clrType1 = EdmModel.GetClrType(primitiveType1);
Type clrType2 = EdmModel.GetClrType(primitiveType2);
// Assert
Assert.Same(clrType1, clrType2);
Assert.Same(type, clrType1);
}
/// <summary>
/// Reads a value of an XML element and converts it to the target primitive value.
/// </summary>
/// <param name="reader">The XML reader to read the value from.</param>
/// <param name="primitiveTypeReference">The primitive type reference to convert the value to.</param>
/// <returns>The primitive value read.</returns>
/// <remarks>This method does not read null values, it only reads the actual element value (not its attributes).</remarks>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.Element - the element was empty.
/// XmlNodeType.EndElement - the element had some value.
/// </remarks>
internal static object ReadPrimitiveValue(XmlReader reader, IEdmPrimitiveTypeReference primitiveTypeReference)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(reader != null, "reader != null");
object spatialValue;
if (!PrimitiveConverter.Instance.TryTokenizeFromXml(reader, EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference), out spatialValue))
{
string stringValue = reader.ReadElementContentValue();
return ConvertStringToPrimitive(stringValue, primitiveTypeReference);
}
return spatialValue;
}
/// <summary>
/// Asynchronously reads the content of a text reader as string and, if <paramref name="expectedPrimitiveTypeReference"/> is specified and primitive type conversion
/// is enabled, converts the string to the expected type.
/// </summary>
/// <param name="expectedPrimitiveTypeReference">The expected type of the value being read or null if no type conversion should be performed.</param>
/// <returns>
/// A task that represents the asynchronous read operation.
/// The value of the TResult parameter contains the raw value that was read from the text reader
/// either as string or converted to the provided <paramref name="expectedPrimitiveTypeReference"/>.
/// </returns>
private async Task <object> ReadRawValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
string stringFromStream = await this.textReader.ReadToEndAsync()
.ConfigureAwait(false);
if (expectedPrimitiveTypeReference != null && this.MessageReaderSettings.EnablePrimitiveTypeConversion)
{
return(ODataRawValueUtils.ConvertStringToPrimitive(stringFromStream, expectedPrimitiveTypeReference));
}
else
{
return(stringFromStream);
}
}
/// <summary>
/// Try and parse spatial type from the json payload.
/// </summary>
/// <param name="jsonReader">The JSON reader to read from.</param>
/// <param name="insideJsonObjectValue">true if the reader is positioned on the first property of the value which is a JSON Object
/// (or the second property if the first one was odata.type).</param>
/// <param name="inputContext">The input context with all the settings.</param>
/// <param name="expectedValueTypeReference">Expected edm property type.</param>
/// <param name="validateNullValue">true to validate null values; otherwise false.</param>
/// <param name="recursionDepth">The recursion depth to start with.</param>
/// <param name="propertyName">The name of the property whose value is being read, if applicable (used for error reporting).</param>
/// <returns>An instance of the spatial type.</returns>
internal static async Task <ISpatial> ReadSpatialValueAsync(
IJsonReaderAsync jsonReader,
bool insideJsonObjectValue,
ODataInputContext inputContext,
IEdmPrimitiveTypeReference expectedValueTypeReference,
bool validateNullValue,
int recursionDepth,
string propertyName)
{
Debug.Assert(jsonReader != null, "jsonReader != null");
Debug.Assert(inputContext != null, "inputContext != null");
Debug.Assert(expectedValueTypeReference != null, "expectedValueTypeReference != null");
Debug.Assert(expectedValueTypeReference.IsSpatial(), "TryParseSpatialType must be called only with spatial types");
// Spatial value can be either null constant or a JSON object
// If it's a null primitive value, report a null value.
if (!insideJsonObjectValue &&
await TryReadNullValueAsync(jsonReader, inputContext, expectedValueTypeReference, validateNullValue, propertyName)
.ConfigureAwait(false))
{
return(null);
}
ISpatial spatialValue = null;
if (insideJsonObjectValue || jsonReader.NodeType == JsonNodeType.StartObject)
{
Dictionary <string, object> jsonObject = await ReadObjectValueAsync(jsonReader, insideJsonObjectValue, inputContext, recursionDepth)
.ConfigureAwait(false);
GeoJsonObjectFormatter jsonObjectFormatter =
SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter();
if (expectedValueTypeReference.IsGeography())
{
spatialValue = jsonObjectFormatter.Read <Geography>(jsonObject);
}
else
{
spatialValue = jsonObjectFormatter.Read <Geometry>(jsonObject);
}
}
if (spatialValue == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderCoreUtils_CannotReadSpatialPropertyValue);
}
return(spatialValue);
}
/// <summary>
/// Try to convert a value into an EDM primitive type, if template parsing enabled, the <paramref name="valueText"/> matching
/// template would be converted into corresponding UriTemplateExpression.
/// </summary>
/// <param name="primitiveType">the type to convert to</param>
/// <param name="valueText">the value to convert</param>
/// <param name="convertedValue">The converted value, if conversion succeeded.</param>
/// <returns>true if the conversion was successful.</returns>
private bool TryConvertValue(IEdmPrimitiveTypeReference primitiveType, string valueText, out object convertedValue)
{
UriTemplateExpression expression;
if (this.enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(valueText, primitiveType, out expression))
{
convertedValue = expression;
return(true);
}
Type primitiveClrType = EdmLibraryExtensions.GetPrimitiveClrType((IEdmPrimitiveType)primitiveType.Definition, primitiveType.IsNullable);
LiteralParser literalParser = LiteralParser.ForKeys(this.keysAsSegments);
return(literalParser.TryParseLiteral(primitiveClrType, valueText, out convertedValue));
}
/// <summary>Adds a key property to the specified <paramref name="structuredType"/>.</summary>
/// <param name="structuredType">The type to add the property to.</param>
/// <param name="name">The name of the property to add.</param>
/// <param name="propertyType">The CLR type of the property to add. This can be only a primitive type.</param>
/// <param name="concurrencyMode">Concurrency mode of the property to add.</param>
private IEdmStructuralProperty AddPrimitiveProperty(IEdmStructuredType structuredType, string name, Type propertyType, EdmConcurrencyMode concurrencyMode)
{
PropertyInfo propertyInfo = null;
if (propertyType == null)
{
//TODO: Fix this so GetInstanceType works
//propertyInfo = structuredType.GetInstanceType(this).GetProperty(name);
propertyType = propertyInfo != null ? propertyInfo.PropertyType : null;
}
IEdmPrimitiveTypeReference typeReference = MetadataUtils.GetPrimitiveTypeReference(propertyType);
return(AddStructuralProperty(structuredType, name, concurrencyMode, typeReference));
}
public void CreateODataValue_PrimitiveValue()
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType = typeof(int).GetEdmPrimitiveTypeReference();
var serializer = new ODataPrimitiveSerializer();
// Act
var odataValue = serializer.CreateODataValue(20, edmPrimitiveType, writeContext: null);
// Assert
Assert.NotNull(odataValue);
ODataPrimitiveValue primitiveValue = Assert.IsType <ODataPrimitiveValue>(odataValue);
Assert.Equal(20, primitiveValue.Value);
}
public void CreateODataValue_ReturnsDateTimeOffset_ForDateTime_ByDefault()
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType = typeof(DateTime).GetEdmPrimitiveTypeReference();
ODataPrimitiveSerializer serializer = new ODataPrimitiveSerializer();
DateTime dt = new DateTime(2014, 10, 27);
// Act
ODataValue odataValue = serializer.CreateODataValue(dt, edmPrimitiveType, new ODataSerializerContext());
// Assert
ODataPrimitiveValue primitiveValue = Assert.IsType <ODataPrimitiveValue>(odataValue);
Assert.Equal(new DateTimeOffset(dt), primitiveValue.Value);
}
public void AddTypeNameAnnotationAsNeeded_AddsAnnotation_InJsonLightMetadataMode()
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType = typeof(short).GetEdmPrimitiveTypeReference();
ODataPrimitiveValue primitive = new ODataPrimitiveValue((short)1);
// Act
ODataPrimitiveSerializer.AddTypeNameAnnotationAsNeeded(primitive, edmPrimitiveType, ODataMetadataLevel.Full);
// Assert
ODataTypeAnnotation annotation = primitive.TypeAnnotation;
Assert.NotNull(annotation); // Guard
Assert.Equal("Edm.Int16", annotation.TypeName);
}
private static bool TryParse <T>(string input, IEdmPrimitiveTypeReference asType, out T realResult)
{
realResult = default(T);
object result;
UriLiteralParsingException exception;
bool parseSuceeded = UriPrimitiveTypeParser.Instance.TryParseUriStringToType(input, asType, out result, out exception);
if (parseSuceeded)
{
realResult = (T)result;
}
return(parseSuceeded);
}
/// <summary>
/// Gets the type name from the given <paramref name="value"/>.
/// </summary>
/// <param name="value">The value to get the type name from. This can be an ODataPrimitiveValue, an ODataCollectionValue or a Clr primitive object.</param>
/// <returns>The type name for the given <paramref name="value"/>.</returns>
protected static string GetTypeNameFromValue(object value)
{
Debug.Assert(value != null, "value != null");
ODataPrimitiveValue primitiveValue = value as ODataPrimitiveValue;
if (primitiveValue != null)
{
// primitiveValueTypeReference == null means: the EDM type of the primitive value cannot be determined.
// This could possibly be due to value being an unsigned int.
// In this case, simply return null because:
// - If the property is regular property, the type is not needed since service model knows its exact type.
// - If the property is dynamic property, ODL does not support dynamic property containing unsigned int value
// since we don't know its underlying type as well as how to serialize it.
IEdmPrimitiveTypeReference primitiveValueTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(primitiveValue.Value.GetType());
return(primitiveValueTypeReference == null ? null : primitiveValueTypeReference.FullName());
}
ODataEnumValue enumValue = value as ODataEnumValue;
if (enumValue != null)
{
return(enumValue.TypeName);
}
ODataResourceValue resourceValue = value as ODataResourceValue;
if (resourceValue != null)
{
return(resourceValue.TypeName);
}
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
return(EdmLibraryExtensions.GetCollectionTypeFullName(collectionValue.TypeName));
}
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
return(primitiveTypeReference.FullName());
}
public void CreateODataValue_ReturnsDate_ForDateTime()
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(Date));
ODataPrimitiveSerializer serializer = new ODataPrimitiveSerializer();
DateTime dt = new DateTime(2014, 10, 27);
// Act
ODataValue odataValue = serializer.CreateODataValue(dt, edmPrimitiveType, new ODataSerializerContext());
// Assert
ODataPrimitiveValue primitiveValue = Assert.IsType <ODataPrimitiveValue>(odataValue);
Assert.IsType <Date>(primitiveValue.Value);
Assert.Equal(new Date(dt.Year, dt.Month, dt.Day), primitiveValue.Value);
}
private static IEdmPrimitiveTypeReference CreateSpatialTypeReference(IEdmPrimitiveTypeReference primitiveTypeReference, bool nullableFacet, List <KeyValuePair <string, object> > annotations)
{
object obj2;
if ((annotations.Count == 0) || !TryFindAndRemoveAnnotation(annotations, "SRID", out obj2))
{
if (primitiveTypeReference.IsNullable != nullableFacet)
{
return(new EdmSpatialTypeReference(primitiveTypeReference.PrimitiveDefinition(), nullableFacet, null));
}
return(primitiveTypeReference);
}
int num = ConvertAnnotationValue <int>(obj2, "SRID");
return(new EdmSpatialTypeReference(primitiveTypeReference.PrimitiveDefinition(), nullableFacet, new int?(num)));
}
private static IEdmPrimitiveTypeReference CreateBinaryTypeReference(IEdmPrimitiveTypeReference primitiveTypeReference, bool nullableFacet, List <KeyValuePair <string, object> > annotations)
{
bool flag;
if (annotations.Count == 0)
{
if (primitiveTypeReference.IsNullable != nullableFacet)
{
return(new EdmBinaryTypeReference(primitiveTypeReference.PrimitiveDefinition(), nullableFacet));
}
return(primitiveTypeReference);
}
int?maxLengthAnnotation = GetMaxLengthAnnotation(annotations, out flag);
return(new EdmBinaryTypeReference(primitiveTypeReference.PrimitiveDefinition(), nullableFacet, flag, maxLengthAnnotation, GetFixedLengthAnnotation(annotations)));
}
/// <summary>
/// Maps a CLR type to standard CLR type.
/// </summary>
/// <param name="clrType">The potential non-standard CLR type.</param>
/// <returns>The standard CLR type or the input CLR type itself.</returns>
public virtual Type MapTo(Type clrType)
{
if (clrType == null)
{
return(null);
}
IEdmPrimitiveTypeReference edmTypeRef = GetEdmPrimitiveType(clrType);
if (edmTypeRef != null)
{
return(GetClrPrimitiveType(edmTypeRef));
}
return(clrType);
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.FindDeclaredEntityContainer("Default.Container").FindEntitySet("Customers");
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_customer = new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType), isNullable: false);
_serializer = new ODataCollectionSerializer(serializerProvider);
}
public void ReadSpatialProperty(string propertyName, string payload, IEdmPrimitiveTypeReference edmPrimitiveTypeReference, Action <ISpatial> assertAction)
{
using (var reader = CreateJsonReader(payload))
{
var spatialValue = ODataJsonReaderCoreUtils.ReadSpatialValue(
jsonReader: reader,
insideJsonObjectValue: false,
inputContext: this.inputContext,
expectedValueTypeReference: edmPrimitiveTypeReference,
validateNullValue: false,
recursionDepth: -1,
propertyName: propertyName);
assertAction(spatialValue);
}
}
/// <summary>
/// Returns the instance type for the specified <paramref name="typeReference"/> or null if none exists.
/// </summary>
/// <param name="typeReference">The type reference to get the instance type for.</param>
/// <param name="model">The model containing annotations.</param>
/// <returns>The instance type for the <paramref name="typeReference"/> or null if no instance type exists.</returns>
/// <remarks>All primitive type references are guaranteed to have an instance type.</remarks>
public static Type GetInstanceType(this IEdmTypeReference typeReference, IEdmModel model)
{
ExceptionUtils.CheckArgumentNotNull(typeReference, "typeReference");
ExceptionUtils.CheckArgumentNotNull(model, "model");
if (typeReference.TypeKind() == EdmTypeKind.Primitive)
{
IEdmPrimitiveTypeReference primitiveTypeReference = typeReference.AsPrimitive();
return(EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference));
}
ODataQueryEdmTypeAnnotation annotation = model.GetAnnotationValue <ODataQueryEdmTypeAnnotation>(typeReference.Definition);
return(annotation == null ? null : annotation.InstanceType);
}
/// <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 = ReadAsBinary(expectedPrimitiveTypeReference);
if (readBinary)
{
return(this.ReadBinaryValue());
}
else
{
Debug.Assert(this.textReader == null, "this.textReader == null");
InitializeTextReader();
return(this.ReadRawValue(expectedPrimitiveTypeReference));
}
}
/// <summary>
/// Figures out if the given clr type is nonstandard edm primitive like uint, ushort, char[] etc.
/// and returns the corresponding clr type to which we map like uint => long.
/// </summary>
/// <param name="clrType">The potential non-standard CLR type.</param>
/// <param name="isNonstandardEdmPrimitive">A boolean value out to indicate whether the input CLR type is standard OData primitive type.</param>
/// <returns>The standard CLR type or the input CLR type itself.</returns>
public static Type IsNonstandardEdmPrimitive(this Type clrType, out bool isNonstandardEdmPrimitive)
{
IEdmPrimitiveTypeReference edmType = clrType?.GetEdmPrimitiveTypeReference();
if (edmType == null)
{
isNonstandardEdmPrimitive = false;
return(clrType);
}
Type reverseLookupClrType = edmType.GetClrPrimitiveType();
isNonstandardEdmPrimitive = (clrType != reverseLookupClrType);
return(reverseLookupClrType);
}
// figures out if the given clr type is nonstandard edm primitive like uint, ushort, char[] etc.
// and returns the corresponding clr type to which we map like uint => long.
public static Type IsNonstandardEdmPrimitive(Type type, out bool isNonstandardEdmPrimitive)
{
IEdmPrimitiveTypeReference edmType = GetEdmPrimitiveTypeReferenceOrNull(type);
if (edmType == null)
{
isNonstandardEdmPrimitive = false;
return(type);
}
Type reverseLookupClrType = GetClrType(edmType, EdmCoreModel.Instance);
isNonstandardEdmPrimitive = (type != reverseLookupClrType);
return(reverseLookupClrType);
}
public void CreateODataValue_ReturnsTimeOfDay_ForTimeSpan()
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType = typeof(TimeOfDay).GetEdmPrimitiveTypeReference();
ODataPrimitiveSerializer serializer = new ODataPrimitiveSerializer();
TimeSpan ts = new TimeSpan(0, 10, 11, 12, 13);
// Act
ODataValue odataValue = serializer.CreateODataValue(ts, edmPrimitiveType, new ODataSerializerContext());
// Assert
ODataPrimitiveValue primitiveValue = Assert.IsType <ODataPrimitiveValue>(odataValue);
Assert.IsType <TimeOfDay>(primitiveValue.Value);
Assert.Equal(new TimeOfDay(ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds), primitiveValue.Value);
}
internal static bool CanConvertTo(IEdmTypeReference sourceReference, IEdmTypeReference targetReference)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(sourceReference != null, "sourceReference != null");
Debug.Assert(targetReference != null, "targetReference != null");
//// Copy of the ResourceQueryParser.ExpressionParser.IsCompatibleWith method.
if (sourceReference.IsEquivalentTo(targetReference))
{
return(true);
}
if (targetReference.IsODataComplexTypeKind() || targetReference.IsODataEntityTypeKind())
{
// for structured types, use IsAssignableFrom
return(EdmLibraryExtensions.IsAssignableFrom(
(IEdmStructuredType)targetReference.Definition,
(IEdmStructuredType)sourceReference.Definition));
}
// NOTE: this is to deal with open types that are not yet supported.
if (IsOpenPropertyType(targetReference))
{
return(true);
}
//// This rule stops the parser from considering nullable types as incompatible
//// with non-nullable types. We have however implemented this rule because we just
//// access underlying rules. C# requires an explicit .Value access, and EDM has no
//// nullablity on types and (at the model level) implements null propagation.
////
//// if (sourceReference.IsNullable && !targetReference.IsNullable)
//// {
//// return false;
//// }
IEdmPrimitiveTypeReference sourcePrimitiveTypeReference = sourceReference.AsPrimitiveOrNull();
IEdmPrimitiveTypeReference targetPrimitiveTypeReference = targetReference.AsPrimitiveOrNull();
if (sourcePrimitiveTypeReference == null || targetPrimitiveTypeReference == null)
{
return(false);
}
return(MetadataUtilsCommon.CanConvertPrimitiveTypeTo(sourcePrimitiveTypeReference.PrimitiveDefinition(), targetPrimitiveTypeReference.PrimitiveDefinition()));
}
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));
}
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);
}
public override ODataPrimitiveValue CreateODataPrimitiveValue(object graph,
IEdmPrimitiveTypeReference primitiveType, ODataSerializerContext writeContext)
{
ODataPrimitiveValue result = base.CreateODataPrimitiveValue(graph, primitiveType, writeContext);
if (result?.Value is DateTimeOffset date)
{
IDependencyResolver dependencyResolver = writeContext.Request.GetOwinContext()
.GetDependencyResolver();
ITimeZoneManager timeZoneManager = dependencyResolver.Resolve <ITimeZoneManager>();
result = new ODataPrimitiveValue(timeZoneManager.MapFromServerToClient(date));
}
return(result);
}
/// <summary>
/// Converts a primitive data type to type.
/// </summary>
/// <param name="primitiveType">The primitive data type to convert.</param>
/// <returns>The corresponding primitive type.</returns>
private static IEdmPrimitiveTypeReference GetPrimitiveTypeReference(PrimitiveDataType primitiveType)
{
Debug.Assert(primitiveType != null, "primitiveType != null");
Type systemType = EntityModelUtils.GetPrimitiveClrType(primitiveType);
// NOTE: if the primitiveType is not nullable but the type reference constructed from the CLR type is,
// adjust the nullability if necessary.
IEdmPrimitiveTypeReference primitiveTypeReference = MetadataUtils.GetPrimitiveTypeReference(systemType);
if (primitiveType.IsNullable != primitiveTypeReference.IsNullable)
{
primitiveTypeReference = (IEdmPrimitiveTypeReference)primitiveTypeReference.Clone(primitiveType.IsNullable);
}
return(primitiveTypeReference);
}
/// <summary>
/// Parses typed literals.
/// </summary>
/// <param name="targetTypeReference">Expected type to be parsed.</param>
/// <returns>The literal token produced by building the given literal.</returns>
private object ParseTypedLiteral(IEdmPrimitiveTypeReference targetTypeReference)
{
object targetValue;
if (!UriPrimitiveTypeParser.TryUriStringToPrimitive(this.CurrentToken.Text, targetTypeReference, out targetValue))
{
string message = o.Strings.UriQueryExpressionParser_UnrecognizedLiteral(
targetTypeReference.FullName(),
this.CurrentToken.Text,
this.CurrentToken.Position,
this.ExpressionText);
throw ParseError(message);
}
this.NextToken();
return(targetValue);
}
private void VisitPrimitiveTypeReference(IEdmPrimitiveTypeReference reference)
{
string qualifiedName = reference.FullName();
if (_types.ContainsKey(qualifiedName))
{
return;
}
IEdmPrimitiveType primitiveType = reference.PrimitiveDefinition();
MetaPrimitiveType metaPrimitiveType = new MetaPrimitiveType();
metaPrimitiveType.QualifiedName = qualifiedName;
metaPrimitiveType.Name = primitiveType.Name;
_types[qualifiedName] = metaPrimitiveType;
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_customer = new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType));
_serializer = new ODataCollectionSerializer(serializerProvider);
}
public void ReadInline_Calls_ReadPrimitive()
{
// Arrange
IEdmPrimitiveTypeReference primitiveType = EdmCoreModel.Instance.GetInt32(isNullable: true);
Mock <ODataPrimitiveDeserializer> deserializer = new Mock <ODataPrimitiveDeserializer>();
ODataProperty property = new ODataProperty();
ODataDeserializerContext readContext = new ODataDeserializerContext();
deserializer.Setup(d => d.ReadPrimitive(property, readContext)).Returns(42).Verifiable();
// Act
var result = deserializer.Object.ReadInline(property, primitiveType, readContext);
// Assert
deserializer.Verify();
Assert.Equal(42, result);
}
/// <summary>
/// Reads the content of a text reader as string and, if <paramref name="expectedPrimitiveTypeReference"/> is specified and primitive type conversion
/// is enabled, converts the string to the expected type.
/// </summary>
/// <param name="expectedPrimitiveTypeReference">The expected type of the value being read or null if no type conversion should be performed.</param>
/// <returns>The raw value that was read from the text reader either as string or converted to the provided <paramref name="expectedPrimitiveTypeReference"/>.</returns>
private object ReadRawValue(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
string stringFromStream = this.textReader.ReadToEnd();
object rawValue;
if (expectedPrimitiveTypeReference != null && !this.MessageReaderSettings.DisablePrimitiveTypeConversion)
{
rawValue = AtomValueUtils.ConvertStringToPrimitive(stringFromStream, expectedPrimitiveTypeReference);
}
else
{
rawValue = stringFromStream;
}
return(rawValue);
}
/// <summary>
/// Try and parse spatial type from the json payload.
/// </summary>
/// <param name="jsonReader">The JSON reader to read from.</param>
/// <param name="insideJsonObjectValue">true if the reader is positioned on the first property of the value which is a JSON Object
/// (or the second property if the first one was odata.type).</param>
/// <param name="inputContext">The input context with all the settings.</param>
/// <param name="expectedValueTypeReference">Expected edm property type.</param>
/// <param name="validateNullValue">true to validate null values; otherwise false.</param>
/// <param name="recursionDepth">The recursion depth to start with.</param>
/// <param name="propertyName">The name of the property whose value is being read, if applicable (used for error reporting).</param>
/// <returns>An instance of the spatial type.</returns>
internal static ISpatial ReadSpatialValue(
BufferingJsonReader jsonReader,
bool insideJsonObjectValue,
ODataInputContext inputContext,
IEdmPrimitiveTypeReference expectedValueTypeReference,
bool validateNullValue,
int recursionDepth,
string propertyName)
{
Debug.Assert(jsonReader != null, "jsonReader != null");
Debug.Assert(inputContext != null, "inputContext != null");
Debug.Assert(expectedValueTypeReference != null, "expectedValueTypeReference != null");
Debug.Assert(expectedValueTypeReference.IsSpatial(), "TryParseSpatialType must be called only with spatial types");
// Spatial value can be either null constant or a JSON object
// If it's a null primitive value, report a null value.
if (!insideJsonObjectValue && TryReadNullValue(jsonReader, inputContext, expectedValueTypeReference, validateNullValue, propertyName))
{
return null;
}
Microsoft.Spatial.ISpatial spatialValue = null;
if (insideJsonObjectValue || jsonReader.NodeType == JsonNodeType.StartObject)
{
IDictionary<string, object> jsonObject = ReadObjectValue(jsonReader, insideJsonObjectValue, inputContext, recursionDepth);
Microsoft.Spatial.GeoJsonObjectFormatter jsonObjectFormatter =
Microsoft.Spatial.SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter();
if (EdmLibraryExtensions.IsGeographyType(expectedValueTypeReference))
{
spatialValue = jsonObjectFormatter.Read<Microsoft.Spatial.Geography>(jsonObject);
}
else
{
spatialValue = jsonObjectFormatter.Read<Microsoft.Spatial.Geometry>(jsonObject);
}
}
if (spatialValue == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonReaderCoreUtils_CannotReadSpatialPropertyValue);
}
return spatialValue;
}
public override ODataPrimitiveValue CreateODataPrimitiveValue(object graph, IEdmPrimitiveTypeReference primitiveType,
ODataSerializerContext writeContext)
{
var dbGeographyValue = graph as DbGeography;
if (dbGeographyValue != null)
{
// The logic is not included in Restier as publisher layer does not touch provider layer type
if (dbGeographyValue.SpatialTypeName == GeographyTypeNamePoint)
{
graph = dbGeographyValue.ToGeographyPoint();
}
else if (dbGeographyValue.SpatialTypeName == GeographyTypeNameLineString)
{
graph = dbGeographyValue.ToGeographyLineString();
}
else if (dbGeographyValue.SpatialTypeName == GeographyTypeNamePolygon)
{
// TODO, convert original value and return converted value
}
}
return base.CreateODataPrimitiveValue(graph, primitiveType, writeContext);
}
internal static void AddTypeNameAnnotationAsNeeded(ODataPrimitiveValue primitive, IEdmPrimitiveTypeReference primitiveType,
ODataMetadataLevel metadataLevel)
{
// ODataLib normally has the caller decide whether or not to serialize properties by leaving properties
// null when values should not be serialized. The TypeName property is different and should always be
// provided to ODataLib to enable model validation. A separate annotation is used to decide whether or not
// to serialize the type name (a null value prevents serialization).
// Note that this annotation should not be used for Atom or JSON verbose formats, as it will interfere with
// the correct default behavior for those formats.
Contract.Assert(primitive != null);
object value = primitive.Value;
// Only add an annotation if we want to override ODataLib's default type name serialization behavior.
if (ShouldAddTypeNameAnnotation(metadataLevel))
{
string typeName;
// Provide the type name to serialize (or null to force it not to serialize).
if (ShouldSuppressTypeNameSerialization(value, metadataLevel))
{
typeName = null;
}
else
{
typeName = primitiveType.FullName();
}
primitive.SetAnnotation<SerializationTypeNameAnnotation>(new SerializationTypeNameAnnotation
{
TypeName = typeName
});
}
}
internal static void AddTypeNameAnnotationAsNeeded(ODataPrimitiveValue primitive, IEdmPrimitiveTypeReference primitiveType,
ODataMetadataLevel metadataLevel)
{
// ODataLib normally has the caller decide whether or not to serialize properties by leaving properties
// null when values should not be serialized. The TypeName property is different and should always be
// provided to ODataLib to enable model validation. A separate annotation is used to decide whether or not
// to serialize the type name (a null value prevents serialization).
Contract.Assert(primitive != null);
object value = primitive.Value;
string typeName = null; // Set null to force the type name not to serialize.
// Provide the type name to serialize.
if (!ShouldSuppressTypeNameSerialization(value, metadataLevel))
{
typeName = primitiveType.FullName();
}
primitive.SetAnnotation<SerializationTypeNameAnnotation>(new SerializationTypeNameAnnotation
{
TypeName = typeName
});
}
private object ReadPrimitiveValueImplementation(IEdmPrimitiveTypeReference expectedValueTypeReference, bool validateNullValue)
{
if ((expectedValueTypeReference != null) && expectedValueTypeReference.IsSpatial())
{
return this.ReadSpatialValue(expectedValueTypeReference, validateNullValue);
}
object obj2 = base.JsonReader.ReadPrimitiveValue();
if ((expectedValueTypeReference != null) && !base.MessageReaderSettings.DisablePrimitiveTypeConversion)
{
obj2 = ODataJsonReaderUtils.ConvertValue(obj2, expectedValueTypeReference, base.MessageReaderSettings, base.Version, validateNullValue);
}
return obj2;
}
public ODataPrimitiveSerializer(IEdmPrimitiveTypeReference edmPrimitiveType)
: base(edmPrimitiveType, ODataPayloadKind.Property)
{
}
internal static ODataPrimitiveValue CreatePrimitive(object value, IEdmPrimitiveTypeReference primitveType,
ODataMetadataLevel metadataLevel)
{
if (value == null)
{
return null;
}
object supportedValue = ConvertUnsupportedPrimitives(value);
ODataPrimitiveValue primitive = new ODataPrimitiveValue(supportedValue);
AddTypeNameAnnotationAsNeeded(primitive, primitveType, metadataLevel);
return primitive;
}
/// <summary>
/// Reads the content of a text reader as string and, if <paramref name="expectedPrimitiveTypeReference"/> is specified and primitive type conversion
/// is enabled, converts the string to the expected type.
/// </summary>
/// <param name="expectedPrimitiveTypeReference">The expected type of the value being read or null if no type conversion should be performed.</param>
/// <returns>The raw value that was read from the text reader either as string or converted to the provided <paramref name="expectedPrimitiveTypeReference"/>.</returns>
private object ReadRawValue(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
string stringFromStream = this.textReader.ReadToEnd();
object rawValue;
if (expectedPrimitiveTypeReference != null && !this.MessageReaderSettings.DisablePrimitiveTypeConversion)
{
rawValue = AtomValueUtils.ConvertStringToPrimitive(stringFromStream, expectedPrimitiveTypeReference);
}
else
{
rawValue = stringFromStream;
}
return rawValue;
}
/// <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>
/// Asynchronously read a top-level value.
/// </summary>
/// <param name="expectedPrimitiveTypeReference">The expected type reference for the value to be read; null if no expected type is available.</param>
/// <returns>Task which when completed returns an <see cref="object"/> representing the read value.</returns>
internal override Task<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
DebugUtils.CheckNoExternalCallers();
// Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
return TaskUtils.GetTaskForSynchronousOperation(() => this.ReadValueImplementation(expectedPrimitiveTypeReference));
}
/// <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>
internal override object ReadValue(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
DebugUtils.CheckNoExternalCallers();
return this.ReadValueImplementation(expectedPrimitiveTypeReference);
}
/// <summary>
/// Creates an <see cref="ODataPrimitiveValue"/> for the object represented by <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The primitive value.</param>
/// <param name="primitiveType">The EDM primitive type of the value.</param>
/// <param name="writeContext">The serializer write context.</param>
/// <returns>The created <see cref="ODataPrimitiveValue"/>.</returns>
public virtual ODataPrimitiveValue CreateODataPrimitiveValue(object graph, IEdmPrimitiveTypeReference primitiveType,
ODataSerializerContext writeContext)
{
// TODO: Bug 467598: validate the type of the object being passed in here with the underlying primitive type.
return CreatePrimitive(graph, primitiveType, writeContext);
}
internal static ODataPrimitiveValue CreatePrimitive(object value, IEdmPrimitiveTypeReference primitveType,
ODataSerializerContext writeContext)
{
if (value == null)
{
return null;
}
object supportedValue = ConvertUnsupportedPrimitives(value);
ODataPrimitiveValue primitive = new ODataPrimitiveValue(supportedValue);
if (writeContext != null)
{
AddTypeNameAnnotationAsNeeded(primitive, primitveType, writeContext.MetadataLevel);
}
return primitive;
}
internal override Task<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
return TaskUtils.GetTaskForSynchronousOperation<object>(() => this.ReadValueImplementation(expectedPrimitiveTypeReference));
}
private ISpatial ReadSpatialValue(IEdmPrimitiveTypeReference expectedValueTypeReference, bool validateNullValue)
{
ODataVersionChecker.CheckSpatialValue(base.Version);
if (this.TryReadNullValue(expectedValueTypeReference, validateNullValue))
{
return null;
}
ISpatial spatial = null;
if (base.JsonReader.NodeType == JsonNodeType.StartObject)
{
IDictionary<string, object> source = this.ReadObjectValue(base.JsonReader);
GeoJsonObjectFormatter formatter = SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter();
if (expectedValueTypeReference.IsGeographyType())
{
spatial = formatter.Read<Geography>(source);
}
else
{
spatial = formatter.Read<Geometry>(source);
}
}
if (spatial == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_CannotReadSpatialPropertyValue);
}
return spatial;
}
private object ReadRawValue(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
string text = this.textReader.ReadToEnd();
if ((expectedPrimitiveTypeReference != null) && !base.MessageReaderSettings.DisablePrimitiveTypeConversion)
{
return AtomValueUtils.ConvertStringToPrimitive(text, expectedPrimitiveTypeReference);
}
return text;
}
internal override object ReadValue(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
{
return this.ReadValueImplementation(expectedPrimitiveTypeReference);
}
/// <summary>
/// Read a primitive value from the reader.
/// </summary>
/// <param name="actualValueTypeReference">The type of the value to read.</param>
/// <returns>The value read from the payload and converted as appropriate to the target type.</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.Element - the element was empty.
/// XmlNodeType.EndElement - the element had some value.
///
/// Note that this method will not read null values, those should be handled by the caller already.
/// </remarks>
private object ReadPrimitiveValue(IEdmPrimitiveTypeReference actualValueTypeReference)
{
Debug.Assert(actualValueTypeReference != null, "actualValueTypeReference != null");
Debug.Assert(actualValueTypeReference.TypeKind() == EdmTypeKind.Primitive, "Only primitive values can be read by this method.");
this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.Attribute);
object result = AtomValueUtils.ReadPrimitiveValue(this.XmlReader, actualValueTypeReference);
this.AssertXmlCondition(true, XmlNodeType.EndElement);
Debug.Assert(result != null, "The method should never return null since it doesn't handle null values.");
return result;
}
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);
}
public EdmFloatingConstant(IEdmPrimitiveTypeReference type, double value) : base(type)
{
this.@value = value;
}
