public BadPrimitiveType(string qualifiedName, EdmPrimitiveTypeKind primitiveKind, IEnumerable<EdmError> errors)
: base(errors)
{
this.primitiveKind = primitiveKind;
qualifiedName = qualifiedName ?? string.Empty;
EdmUtil.TryGetNamespaceNameFromQualifiedName(qualifiedName, out this.namespaceName, out this.name);
}
public EdmPrimitiveType(EdmPrimitiveTypeKind kind)
{
this.PrimitiveKind = kind;
this.Namespace = "namespace";
this.Name = "name";
this.SchemaElementKind = EdmSchemaElementKind.None;
this.TypeKind = EdmTypeKind.None;
}
private PrimitiveType(Type clrType, string edmTypeName, EdmPrimitiveTypeKind primitiveKind, PrimitiveTypeConverter typeConverter, bool hasReverseMapping)
{
this.ClrType = clrType;
this.EdmTypeName = edmTypeName;
this.primitiveKind = primitiveKind;
this.TypeConverter = typeConverter;
this.HasReverseMapping = hasReverseMapping;
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind primitiveKind)
{
ODataDeserializerProvider deserializerProvider = new DefaultODataDeserializerProvider(_edmModel);
ODataDeserializer deserializer = deserializerProvider.GetODataDeserializer(type);
Assert.NotNull(deserializer);
ODataRawValueDeserializer rawValueDeserializer = Assert.IsType<ODataRawValueDeserializer>(deserializer);
Assert.Equal(ODataPayloadKind.Value, rawValueDeserializer.ODataPayloadKind);
Assert.Equal(primitiveKind, rawValueDeserializer.PrimitiveTypeReference.PrimitiveDefinition().PrimitiveKind);
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
var serializerProvider = new DefaultODataSerializerProvider(_edmModel);
var serializer = serializerProvider.GetODataPayloadSerializer(type);
Assert.NotNull(serializer);
var primitiveSerializer = Assert.IsType<ODataPrimitiveSerializer>(serializer);
Assert.Equal(primitiveSerializer.EdmType.AsPrimitive().PrimitiveKind(), edmPrimitiveTypeKind);
Assert.Equal(primitiveSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
public void GetODataDeserializer_Primitive(Type type, EdmPrimitiveTypeKind primitiveKind)
{
ODataDeserializerProvider deserializerProvider = new DefaultODataDeserializerProvider();
ODataDeserializer deserializer = deserializerProvider.GetODataDeserializer(_edmModel, type);
Assert.NotNull(deserializer);
ODataPrimitiveDeserializer rawValueDeserializer = Assert.IsType<ODataPrimitiveDeserializer>(deserializer);
Assert.Equal(ODataPayloadKind.Property, rawValueDeserializer.ODataPayloadKind);
Assert.Equal(primitiveKind, rawValueDeserializer.EdmType.AsPrimitive().PrimitiveDefinition().PrimitiveKind);
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
var primitiveSerializer = Assert.IsType<ODataPrimitiveSerializer>(serializer);
Assert.Equal(primitiveSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
private static bool PromotesTo(this EdmPrimitiveTypeKind startingKind, EdmPrimitiveTypeKind target)
{
if (startingKind == target)
{
return true;
}
else
{
return ExpressionTypeChecker.promotionMap[(int)startingKind, (int)target];
}
}
public void GetODataDeserializer_Primitive(Type type, EdmPrimitiveTypeKind primitiveKind)
{
ODataDeserializerProvider deserializerProvider = new DefaultODataDeserializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
ODataDeserializer deserializer = deserializerProvider.GetODataDeserializer(_edmModel, type, request);
Assert.NotNull(deserializer);
ODataPrimitiveDeserializer rawValueDeserializer = Assert.IsType<ODataPrimitiveDeserializer>(deserializer);
Assert.Equal(ODataPayloadKind.Property, rawValueDeserializer.ODataPayloadKind);
}
public BadPrimitiveType(string qualifiedName, EdmPrimitiveTypeKind primitiveKind, IEnumerable<EdmError> errors) : base(errors)
{
this.primitiveKind = primitiveKind;
string str = qualifiedName;
string empty = str;
if (str == null)
{
empty = string.Empty;
}
qualifiedName = empty;
EdmUtil.TryGetNamespaceNameFromQualifiedName(qualifiedName, out this.namespaceName, out this.name);
}
public void Constructor_SucceedsForValidPrimitiveType(EdmPrimitiveTypeKind primitiveTypeKind)
{
IEdmPrimitiveType edmPrimitiveType = EdmCoreModel.Instance.SchemaElements
.OfType<IEdmPrimitiveType>()
.Where(primitiveType => primitiveType.PrimitiveKind == primitiveTypeKind)
.FirstOrDefault();
IEdmPrimitiveTypeReference edmPrimitiveTypeReference = new EdmPrimitiveTypeReference(edmPrimitiveType, false);
var serializer = new ODataPrimitiveSerializer(edmPrimitiveTypeReference);
Assert.Equal(serializer.EdmType, edmPrimitiveTypeReference);
Assert.Equal(serializer.ODataPayloadKind, ODataPayloadKind.Property);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private static IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind kind)
{
return s_CoreModel.GetPrimitiveType(kind);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForValueRequests(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
// Arrange
ODataPath odataPath = new ODataPath(new ValueSegment(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32)));
var request = RequestFactory.CreateFromModel(_edmModel);
request.ODataContext().Path = odataPath;
// Act
var serializer = _serializerProvider.GetODataPayloadSerializer(type, request);
// Assert
Assert.NotEqual(EdmPrimitiveTypeKind.None, edmPrimitiveTypeKind);
Assert.NotNull(serializer);
Assert.Equal(ODataPayloadKind.Value, serializer.ODataPayloadKind);
}
public ClrDataType(EdmPrimitiveTypeKind edmPrimitiveType)
{
this.edmPrimitiveType = edmPrimitiveType;
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
IEdmProperty edmProperty = null;
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = property as PrimitivePropertyConfiguration;
EdmPrimitiveTypeKind typeKind = GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.OptionalProperty);
// Set concurrency token if is entity type, and concurrency token is true
EdmConcurrencyMode concurrencyMode = EdmConcurrencyMode.None;
if (config.Kind == EdmTypeKind.Entity && primitiveProperty.ConcurrencyToken)
{
concurrencyMode = EdmConcurrencyMode.Fixed;
}
edmProperty = type.AddStructuralProperty(
primitiveProperty.Name,
primitiveTypeReference,
defaultValue: null,
concurrencyMode: concurrencyMode);
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = GetEdmType(complexProperty.RelatedClrType) as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.Name,
new EdmComplexTypeReference(complexType, complexProperty.OptionalProperty));
break;
case PropertyKind.Collection:
edmProperty = CreateStructuralTypeCollectionPropertyBody(type, (CollectionPropertyConfiguration)property);
break;
case PropertyKind.Enum:
edmProperty = CreateStructuralTypeEnumPropertyBody(type, config, (EnumPropertyConfiguration)property);
break;
default:
break;
}
if (edmProperty != null)
{
if (property.PropertyInfo != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
if (property.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(property);
}
}
}
}
private static string GetDefaultValue(EdmPrimitiveTypeKind type) {
switch (type) {
case EdmPrimitiveTypeKind.String:
return "'0'";
case EdmPrimitiveTypeKind.Double:
return "0.0";
case EdmPrimitiveTypeKind.Int32:
return "0";
case EdmPrimitiveTypeKind.Boolean:
return "False";
default:
throw new InvalidOperationException();
}
}
private void ProcessTokenAsPath(NonSystemToken tokenIn)
{
Debug.Assert(tokenIn != null, "tokenIn != null");
List <ODataPathSegment> pathSoFar = new List <ODataPathSegment>();
IEdmStructuredType currentLevelType = this.edmType;
// first, walk through all type segments in a row, converting them from tokens into segments.
if (tokenIn.IsNamespaceOrContainerQualified() && !UriParserHelper.IsAnnotation(tokenIn.Identifier))
{
PathSegmentToken firstNonTypeToken;
pathSoFar.AddRange(SelectExpandPathBinder.FollowTypeSegments(tokenIn, this.model, this.maxDepth, this.resolver, ref currentLevelType, out firstNonTypeToken));
Debug.Assert(firstNonTypeToken != null, "Did not get last token.");
tokenIn = firstNonTypeToken as NonSystemToken;
if (tokenIn == null)
{
throw new ODataException(ODataErrorStrings.SelectPropertyVisitor_SystemTokenInSelect(firstNonTypeToken.Identifier));
}
}
// next, create a segment for the first non-type segment in the path.
ODataPathSegment lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(tokenIn, this.model, currentLevelType, resolver, this.state);
// next, create an ODataPath and add the segments to it.
if (lastSegment != null)
{
pathSoFar.Add(lastSegment);
// try create a complex type property path.
while (true)
{
// no need to go on if the current property is not of complex type or collection of complex type,
// unless the segment is a primitive type cast or a property on an open complex property.
currentLevelType = lastSegment.EdmType as IEdmStructuredType;
IEdmCollectionType collectionType = lastSegment.EdmType as IEdmCollectionType;
IEdmPrimitiveType primitiveType = lastSegment.EdmType as IEdmPrimitiveType;
DynamicPathSegment dynamicPath = lastSegment as DynamicPathSegment;
if ((currentLevelType == null || currentLevelType.TypeKind != EdmTypeKind.Complex) &&
(collectionType == null || collectionType.ElementType.TypeKind() != EdmTypeKind.Complex) &&
(primitiveType == null || primitiveType.TypeKind != EdmTypeKind.Primitive) &&
(dynamicPath == null || tokenIn.NextToken == null))
{
break;
}
NonSystemToken nextToken = tokenIn.NextToken as NonSystemToken;
if (nextToken == null)
{
break;
}
if (UriParserHelper.IsAnnotation(nextToken.Identifier))
{
lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(nextToken, this.model,
currentLevelType, resolver, null);
}
else if (primitiveType == null && dynamicPath == null)
{
// This means last segment a collection of complex type,
// current segment can only be type cast and cannot be property name.
if (currentLevelType == null)
{
currentLevelType = collectionType.ElementType.Definition as IEdmStructuredType;
}
// If there is no collection type in the path yet, will try to bind property for the next token
// first try bind the segment as property.
lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(nextToken, this.model,
currentLevelType, resolver, null);
}
else
{
// determine whether we are looking at a type cast or a dynamic path segment.
EdmPrimitiveTypeKind nextTypeKind = EdmCoreModel.Instance.GetPrimitiveTypeKind(nextToken.Identifier);
IEdmPrimitiveType castType = EdmCoreModel.Instance.GetPrimitiveType(nextTypeKind);
if (castType != null)
{
lastSegment = new TypeSegment(castType, castType, null);
}
else if (dynamicPath != null)
{
lastSegment = new DynamicPathSegment(nextToken.Identifier);
}
else
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
}
// then try bind the segment as type cast.
if (lastSegment == null)
{
IEdmStructuredType typeFromNextToken =
UriEdmHelpers.FindTypeFromModel(this.model, nextToken.Identifier, this.resolver) as
IEdmStructuredType;
if (typeFromNextToken.IsOrInheritsFrom(currentLevelType))
{
lastSegment = new TypeSegment(typeFromNextToken, /*entitySet*/ null);
}
}
// type cast failed too.
if (lastSegment == null)
{
break;
}
// try move to and add next path segment.
tokenIn = nextToken;
pathSoFar.Add(lastSegment);
}
}
ODataSelectPath selectedPath = new ODataSelectPath(pathSoFar);
var selectionItem = new PathSelectItem(selectedPath);
// non-navigation cases do not allow further segments in $select.
if (tokenIn.NextToken != null)
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
// if the selected item is a nav prop, then see if its already there before we add it.
NavigationPropertySegment trailingNavPropSegment = selectionItem.SelectedPath.LastSegment as NavigationPropertySegment;
if (trailingNavPropSegment != null)
{
if (this.expandClauseToDecorate.SelectedItems.Any(x => x is PathSelectItem &&
((PathSelectItem)x).SelectedPath.Equals(selectedPath)))
{
return;
}
}
this.expandClauseToDecorate.AddToSelectedItems(selectionItem);
}
private DataServiceContext CreateContextWithHardcodedResponse <TServer, TClient>(TServer serverPropertyValue, string contentType, bool complex, bool collection)
{
var payload = GeneratePayload <TServer, TClient>(serverPropertyValue, contentType, complex, collection);
var requestMessage = new ODataTestMessage();
var responseMessage = new ODataTestMessage {
StatusCode = 200, MemoryStream = new MemoryStream(Encoding.UTF8.GetBytes(payload))
};
responseMessage.SetHeader("Content-Type", contentType);
responseMessage.SetHeader("Content-Length", responseMessage.MemoryStream.Length.ToString());
responseMessage.SetHeader("OData-Version", "4.0");
var ctx = new DataServiceContextWithCustomTransportLayer(ODataProtocolVersion.V4, requestMessage, responseMessage);
//ctx.EnableAtom = true;
if (contentType == UnitTestsUtil.JsonLightMimeType || contentType == UnitTestsUtil.JsonLightMimeTypeIeee754Compatible)
{
var model = new EdmModel();
var edmEntityType = new EdmEntityType("Fake", "ServerType");
edmEntityType.AddKeys(edmEntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(edmEntityType);
EdmPrimitiveTypeKind kind = GetPrimitiveTypeKind <TServer>();
if (!complex)
{
if (!collection)
{
edmEntityType.AddStructuralProperty("Property", kind, true);
}
else
{
edmEntityType.AddStructuralProperty("Property", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(kind, false))));
}
}
else
{
var complexType = new EdmComplexType("Fake", "ComplexType");
complexType.AddStructuralProperty("Property", kind, true);
model.AddElement(complexType);
if (!collection)
{
edmEntityType.AddStructuralProperty("Property", new EdmComplexTypeReference(complexType, true));
}
else
{
edmEntityType.AddStructuralProperty("Property", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(complexType, false))));
}
}
var entityContainer = new EdmEntityContainer("Fake", "Container");
entityContainer.AddEntitySet("Entities", edmEntityType);
model.AddElement(entityContainer);
ctx.Format.UseJson(model);
ctx.ResolveType = n => n == "Fake.ServerType" ? typeof(ClientEntityType <TClient>) : null;
ctx.ResolveName = t => t == typeof(ClientEntityType <TClient>) ? "Fake.ServerType" : null;
}
return(ctx);
}
public EdmValidCoreModelPrimitiveType(string namespaceName, string name, EdmPrimitiveTypeKind primitiveKind)
{
this.namespaceName = namespaceName ?? string.Empty;
this.name = name ?? string.Empty;
this.primitiveKind = primitiveKind;
}
private EdmValidCoreModelPrimitiveType GetCoreModelPrimitiveType(EdmPrimitiveTypeKind kind)
{
EdmValidCoreModelPrimitiveType definition;
return(this.primitiveTypesByKind.TryGetValue(kind, out definition) ? definition : null);
}
/// <summary>
/// Determines if a <paramref name="sourcePrimitiveType"/> is convertibale according to OData rules to the
/// <paramref name="targetPrimitiveType"/>.
/// </summary>
/// <param name="sourceNodeOrNull">The node which is to be converted.</param>
/// <param name="sourcePrimitiveType">The type which is to be converted.</param>
/// <param name="targetPrimitiveType">The type to which we want to convert.</param>
/// <returns>true if the source type is convertible to the target type; otherwise false.</returns>
internal static bool CanConvertPrimitiveTypeTo(
SingleValueNode sourceNodeOrNull,
IEdmPrimitiveType sourcePrimitiveType,
IEdmPrimitiveType targetPrimitiveType)
{
Debug.Assert(sourcePrimitiveType != null, "sourcePrimitiveType != null");
Debug.Assert(targetPrimitiveType != null, "targetPrimitiveType != null");
EdmPrimitiveTypeKind sourcePrimitiveKind = sourcePrimitiveType.PrimitiveKind;
EdmPrimitiveTypeKind targetPrimitiveKind = targetPrimitiveType.PrimitiveKind;
switch (sourcePrimitiveKind)
{
case EdmPrimitiveTypeKind.SByte:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Decimal:
return(true);
}
break;
case EdmPrimitiveTypeKind.Byte:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Decimal:
return(true);
}
break;
case EdmPrimitiveTypeKind.Int16:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Decimal:
return(true);
}
break;
case EdmPrimitiveTypeKind.Int32:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Decimal:
return(true);
}
break;
case EdmPrimitiveTypeKind.Int64:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Decimal:
return(true);
}
break;
case EdmPrimitiveTypeKind.Single:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
return(true);
// allow single constant->decimal in order to made L,M,D,F optional
case EdmPrimitiveTypeKind.Decimal:
object tmp;
return(TryGetConstantNodePrimitiveLDMF(sourceNodeOrNull, out tmp));
}
break;
case EdmPrimitiveTypeKind.Double:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Double:
return(true);
// allow double constant->decimal in order to made L,M,D,F optional
// (if the double value actually has overflowed decimal.MaxValue, exception will occur later. more details in ExpressionLexer.cs)
case EdmPrimitiveTypeKind.Decimal:
object tmp;
return(TryGetConstantNodePrimitiveLDMF(sourceNodeOrNull, out tmp));
}
break;
case EdmPrimitiveTypeKind.Date:
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Date:
case EdmPrimitiveTypeKind.DateTimeOffset:
return(true);
}
break;
default:
return(sourcePrimitiveKind == targetPrimitiveKind || targetPrimitiveType.IsAssignableFrom(sourcePrimitiveType));
}
return(false);
}
/// <summary>
/// Gets primitive type by kind.
/// </summary>
/// <param name="kind">Kind of the primitive type.</param>
/// <returns>Primitive type definition.</returns>
public IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind kind)
{
return(this.GetCoreModelPrimitiveType(kind));
}
public static bool HasLength(EdmPrimitiveTypeKind primitiveTypeKind)
{
return(primitiveTypeKind == EdmPrimitiveTypeKind.Binary ||
primitiveTypeKind == EdmPrimitiveTypeKind.String);
}
internal static object CoerceNumericType(object primitiveValue, IEdmPrimitiveType targetEdmType)
{
// This is implemented to match TypePromotionUtils and MetadataUtilsCommon.CanConvertPrimitiveTypeTo()
ExceptionUtils.CheckArgumentNotNull(primitiveValue, "primitiveValue");
ExceptionUtils.CheckArgumentNotNull(targetEdmType, "targetEdmType");
EdmPrimitiveTypeKind targetPrimitiveKind = targetEdmType.PrimitiveKind;
if (primitiveValue is SByte)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.SByte:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int16:
return(Convert.ToInt16((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((SByte)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((SByte)primitiveValue));
}
}
if (primitiveValue is Byte)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Byte:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int16:
return(Convert.ToInt16((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Byte)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Byte)primitiveValue));
}
}
if (primitiveValue is Int16)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int16:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int32:
return(Convert.ToInt32((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int16)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int16)primitiveValue));
}
}
if (primitiveValue is Int32)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int32:
return(primitiveValue);
case EdmPrimitiveTypeKind.Int64:
return(Convert.ToInt64((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int32)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int32)primitiveValue));
}
}
if (primitiveValue is Int64)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int64:
return(primitiveValue);
case EdmPrimitiveTypeKind.Single:
return(Convert.ToSingle((Int64)primitiveValue));
case EdmPrimitiveTypeKind.Double:
return(Convert.ToDouble((Int64)primitiveValue));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Int64)primitiveValue));
}
}
if (primitiveValue is Single)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Single:
return(primitiveValue);
case EdmPrimitiveTypeKind.Double:
/*to string then to double, avoid losing precision like "(double)123.001f" which is 123.00099945068359, instead of 123.001d.*/
return(double.Parse(((Single)primitiveValue).ToString("R", CultureInfo.InvariantCulture),
CultureInfo.InvariantCulture));
case EdmPrimitiveTypeKind.Decimal:
return(Convert.ToDecimal((Single)primitiveValue));
}
}
if (primitiveValue is Double)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Double:
return(primitiveValue);
case EdmPrimitiveTypeKind.Decimal:
// TODO: extract these convertion steps to an individual function
decimal doubleToDecimalR;
// To keep the full presion of the current value, which if necessary is all 17 digits of precision supported by the Double type.
if (decimal.TryParse(((Double)primitiveValue).ToString("R", CultureInfo.InvariantCulture),
out doubleToDecimalR))
{
return(doubleToDecimalR);
}
return(Convert.ToDecimal((Double)primitiveValue));
}
}
if (primitiveValue is Decimal)
{
switch (targetPrimitiveKind)
{
case EdmPrimitiveTypeKind.Decimal:
return(primitiveValue);
}
}
return(null);
}
/// <summary>
/// Gets a reference to a primitive type of the specified kind.
/// </summary>
/// <param name="kind">Primitive kind of the type reference being created.</param>
/// <param name="isNullable">Flag specifying if the referenced type should be nullable.</param>
/// <returns>A new primitive type reference.</returns>
public IEdmPrimitiveTypeReference GetPrimitive(EdmPrimitiveTypeKind kind, bool isNullable)
{
IEdmPrimitiveType primitiveDefinition = this.GetCoreModelPrimitiveType(kind);
if (primitiveDefinition != null)
{
return primitiveDefinition.GetPrimitiveTypeReference(isNullable);
}
else
{
throw new InvalidOperationException(Edm.Strings.EdmPrimitive_UnexpectedKind);
}
}
internal static object ChangeType(this object v, EdmPrimitiveTypeKind t)
{
return(v.ChangeType(t.ToClrType()));
}
/// <summary>
/// Gets a reference to a spatial primitive type definition.
/// </summary>
/// <param name="kind">Primitive kind of the type reference being created.</param>
/// <param name="isNullable">Flag specifying if the referenced type should be nullable.</param>
/// <returns>A new spatial type reference.</returns>
public IEdmSpatialTypeReference GetSpatial(EdmPrimitiveTypeKind kind, bool isNullable)
{
switch (kind)
{
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 new EdmSpatialTypeReference(this.GetCoreModelPrimitiveType(kind), isNullable);
default:
throw new InvalidOperationException(Edm.Strings.EdmPrimitive_UnexpectedKind);
}
}
internal static Type ToClrType(this EdmPrimitiveTypeKind t)
{
EdmCoreModel.Instance.GetPrimitiveType(t);
switch (t)
{
case EdmPrimitiveTypeKind.Binary:
return(typeof(byte[]));
case EdmPrimitiveTypeKind.Boolean:
return(typeof(bool));
case EdmPrimitiveTypeKind.Byte:
return(typeof(Byte));
case EdmPrimitiveTypeKind.Date:
return(typeof(DateTime));
case EdmPrimitiveTypeKind.DateTimeOffset:
return(typeof(DateTimeOffset));
case EdmPrimitiveTypeKind.Decimal:
return(typeof(decimal));
case EdmPrimitiveTypeKind.Double:
return(typeof(double));
case EdmPrimitiveTypeKind.Duration:
return(typeof(TimeSpan));
case EdmPrimitiveTypeKind.Geography:
return(typeof(Geography));
case EdmPrimitiveTypeKind.GeographyCollection:
return(typeof(GeographyCollection));
case EdmPrimitiveTypeKind.GeographyLineString:
return(typeof(GeographyLineString));
case EdmPrimitiveTypeKind.GeographyMultiLineString:
return(typeof(GeographyMultiLineString));
case EdmPrimitiveTypeKind.GeographyMultiPoint:
return(typeof(GeographyMultiPoint));
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
return(typeof(GeographyMultiPolygon));
case EdmPrimitiveTypeKind.GeographyPoint:
return(typeof(GeographyPoint));
case EdmPrimitiveTypeKind.GeographyPolygon:
return(typeof(GeographyPolygon));
case EdmPrimitiveTypeKind.Geometry:
return(typeof(Geometry));
case EdmPrimitiveTypeKind.GeometryCollection:
return(typeof(GeometryCollection));
case EdmPrimitiveTypeKind.GeometryLineString:
return(typeof(GeometryLineString));
case EdmPrimitiveTypeKind.GeometryMultiLineString:
return(typeof(GeometryMultiLineString));
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return(typeof(GeometryMultiPoint));
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
return(typeof(GeometryMultiPolygon));
case EdmPrimitiveTypeKind.GeometryPoint:
return(typeof(GeometryMultiPoint));
case EdmPrimitiveTypeKind.GeometryPolygon:
return(typeof(GeometryPolygon));
case EdmPrimitiveTypeKind.Guid:
return(typeof(Guid));
case EdmPrimitiveTypeKind.Int16:
return(typeof(Int16));
case EdmPrimitiveTypeKind.Int32:
return(typeof(Int32));
case EdmPrimitiveTypeKind.Int64:
return(typeof(Int64));
case EdmPrimitiveTypeKind.None:
break;
case EdmPrimitiveTypeKind.SByte:
return(typeof(SByte));
case EdmPrimitiveTypeKind.Single:
return(typeof(float));
case EdmPrimitiveTypeKind.Stream:
return(typeof(Stream));
case EdmPrimitiveTypeKind.String:
return(typeof(string));
case EdmPrimitiveTypeKind.TimeOfDay:
return(typeof(TimeOfDay));
default:
break;
}
return(typeof(object));
}
private bool TryUriStringToPrimitive(string text, IEdmTypeReference targetType, out object targetValue, out UriLiteralParsingException exception)
{
Debug.Assert(text != null, "text != null");
Debug.Assert(targetType != null, "targetType != null");
exception = null;
try
{
if (targetType.IsNullable)
{
// COMPAT 38: Product does not support "null" literals in service operation arguments
// check for the 'null' constant for nullable types
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(this.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.Date)
{
Date dateValue;
bool result = UriUtils.TryUriStringToDate(text, out dateValue);
targetValue = dateValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.DateTimeOffset)
{
DateTimeOffset dateTimeOffsetValue;
bool result = UriUtils.ConvertUriStringToDateTimeOffset(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 exception);
targetValue = geographyValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.Geometry)
{
Geometry geometryValue;
bool result = TryUriStringToGeometry(text, out geometryValue, out exception);
targetValue = geometryValue;
return(result);
}
else if (targetTypeKind == EdmPrimitiveTypeKind.TimeOfDay)
{
TimeOfDay timeOfDayValue;
bool result = UriUtils.TryUriStringToTimeOfDay(text, out timeOfDayValue);
targetValue = timeOfDayValue;
return(result);
}
bool quoted = targetTypeKind == EdmPrimitiveTypeKind.String;
if (quoted != UriParserHelper.IsUriValueQuoted(text))
{
targetValue = null;
return(false);
}
if (quoted)
{
text = UriParserHelper.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:
UriParserHelper.TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixInt64, ref text);
targetValue = XmlConvert.ToInt64(text);
break;
case EdmPrimitiveTypeKind.Single:
UriParserHelper.TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixSingle, ref text);
targetValue = XmlConvert.ToSingle(text);
break;
case EdmPrimitiveTypeKind.Double:
UriParserHelper.TryRemoveLiteralSuffix(ExpressionConstants.LiteralSuffixDouble, ref text);
targetValue = XmlConvert.ToDouble(text);
break;
case EdmPrimitiveTypeKind.Decimal:
UriParserHelper.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);
}
}
catch (Exception primitiveParserException)
{
exception = new UriLiteralParsingException(
string.Format(CultureInfo.InvariantCulture, ODataErrorStrings.UriPrimitiveTypeParsers_FailedToParseTextToPrimitiveValue(text, targetType),
primitiveParserException));
targetValue = null;
return(false);
}
}
private static bool PromotesTo(this EdmPrimitiveTypeKind startingKind, EdmPrimitiveTypeKind target)
{
return(startingKind == target || promotionMap[(int)startingKind, (int)target]);
}
private static bool PromotesTo(this EdmPrimitiveTypeKind startingKind, EdmPrimitiveTypeKind target)
{
return startingKind == target || promotionMap[(int)startingKind, (int)target];
}
private static KeyValuePair <Type, IEdmPrimitiveTypeReference> BuildTypeMapping <T>(EdmPrimitiveTypeKind primitiveKind) => new KeyValuePair <Type, IEdmPrimitiveTypeReference>(typeof(T), EdmCoreModel.Instance.GetPrimitive(primitiveKind, IsNullable <T>()));
private static IEdmTypeReference CreatePrimitive(EdmPrimitiveTypeKind kind, IField field)
{
return(EdmCoreModel.Instance.GetPrimitive(kind, !field.RawProperties.IsRequired));
}
internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference)
{
Debug.Assert(text != null, "text != null");
Debug.Assert(targetTypeReference != null, "targetTypeReference != null");
try
{
EdmPrimitiveTypeKind primitiveKind = targetTypeReference.PrimitiveKind();
switch (primitiveKind)
{
case EdmPrimitiveTypeKind.Binary:
return(Convert.FromBase64String(text));
case EdmPrimitiveTypeKind.Boolean:
return(ConvertXmlBooleanValue(text));
case EdmPrimitiveTypeKind.Byte:
return(XmlConvert.ToByte(text));
case EdmPrimitiveTypeKind.DateTimeOffset:
return(PlatformHelper.ConvertStringToDateTimeOffset(text));
case EdmPrimitiveTypeKind.Decimal:
return(XmlConvert.ToDecimal(text));
case EdmPrimitiveTypeKind.Double:
return(XmlConvert.ToDouble(text));
case EdmPrimitiveTypeKind.Guid:
return(new Guid(text));
case EdmPrimitiveTypeKind.Int16:
return(XmlConvert.ToInt16(text));
case EdmPrimitiveTypeKind.Int32:
return(XmlConvert.ToInt32(text));
case EdmPrimitiveTypeKind.Int64:
return(XmlConvert.ToInt64(text));
case EdmPrimitiveTypeKind.SByte:
return(XmlConvert.ToSByte(text));
case EdmPrimitiveTypeKind.Single:
return(XmlConvert.ToSingle(text));
case EdmPrimitiveTypeKind.String:
return(text);
case EdmPrimitiveTypeKind.Duration:
return(EdmValueParser.ParseDuration(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, text);
}
}
public EdmStructuralProperty AddStructuralProperty(string name, EdmPrimitiveTypeKind type)
{
EdmStructuralProperty edmStructuralProperty = new EdmStructuralProperty(this, name, EdmCoreModel.Instance.GetPrimitive(type, true));
this.AddProperty(edmStructuralProperty);
return edmStructuralProperty;
}
public static Type GetClrType(EdmPrimitiveTypeKind primitiveKind)
{
return(_edmTypeMappings[primitiveKind]);
}
/// <summary>
/// Get Clr type
/// </summary>
/// <param name="typeKind">Edm Primitive Type Kind</param>
/// <param name="isNullable">Nullable value</param>
/// <returns>CLR type</returns>
private static Type GetPrimitiveClrType(EdmPrimitiveTypeKind typeKind, bool isNullable)
{
switch (typeKind)
{
case EdmPrimitiveTypeKind.Binary:
return typeof(byte[]);
case EdmPrimitiveTypeKind.Boolean:
return isNullable ? typeof(Boolean?) : typeof(Boolean);
case EdmPrimitiveTypeKind.Byte:
return isNullable ? typeof(Byte?) : typeof(Byte);
case EdmPrimitiveTypeKind.Date:
return isNullable ? typeof(Date?) : typeof(Date);
case EdmPrimitiveTypeKind.DateTimeOffset:
return isNullable ? typeof(DateTimeOffset?) : typeof(DateTimeOffset);
case EdmPrimitiveTypeKind.Decimal:
return isNullable ? typeof(Decimal?) : typeof(Decimal);
case EdmPrimitiveTypeKind.Double:
return isNullable ? typeof(Double?) : typeof(Double);
case EdmPrimitiveTypeKind.Geography:
return typeof(Geography);
case EdmPrimitiveTypeKind.GeographyCollection:
return typeof(GeographyCollection);
case EdmPrimitiveTypeKind.GeographyLineString:
return typeof(GeographyLineString);
case EdmPrimitiveTypeKind.GeographyMultiLineString:
return typeof(GeographyMultiLineString);
case EdmPrimitiveTypeKind.GeographyMultiPoint:
return typeof(GeographyMultiPoint);
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
return typeof(GeographyMultiPolygon);
case EdmPrimitiveTypeKind.GeographyPoint:
return typeof(GeographyPoint);
case EdmPrimitiveTypeKind.GeographyPolygon:
return typeof(GeographyPolygon);
case EdmPrimitiveTypeKind.Geometry:
return typeof(Geometry);
case EdmPrimitiveTypeKind.GeometryCollection:
return typeof(GeometryCollection);
case EdmPrimitiveTypeKind.GeometryLineString:
return typeof(GeometryLineString);
case EdmPrimitiveTypeKind.GeometryMultiLineString:
return typeof(GeometryMultiLineString);
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return typeof(GeometryMultiPoint);
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
return typeof(GeometryMultiPolygon);
case EdmPrimitiveTypeKind.GeometryPoint:
return typeof(GeometryPoint);
case EdmPrimitiveTypeKind.GeometryPolygon:
return typeof(GeometryPolygon);
case EdmPrimitiveTypeKind.Guid:
return isNullable ? typeof(Guid?) : typeof(Guid);
case EdmPrimitiveTypeKind.Int16:
return isNullable ? typeof(Int16?) : typeof(Int16);
case EdmPrimitiveTypeKind.Int32:
return isNullable ? typeof(Int32?) : typeof(Int32);
case EdmPrimitiveTypeKind.Int64:
return isNullable ? typeof(Int64?) : typeof(Int64);
case EdmPrimitiveTypeKind.SByte:
return isNullable ? typeof(SByte?) : typeof(SByte);
case EdmPrimitiveTypeKind.Single:
return isNullable ? typeof(Single?) : typeof(Single);
case EdmPrimitiveTypeKind.Stream:
return typeof(Stream);
case EdmPrimitiveTypeKind.String:
return typeof(String);
case EdmPrimitiveTypeKind.Duration:
return isNullable ? typeof(TimeSpan?) : typeof(TimeSpan);
case EdmPrimitiveTypeKind.TimeOfDay:
return isNullable ? typeof(TimeOfDay?) : typeof(TimeOfDay);
default:
return null;
}
}
private static IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind primitiveKind)
{
return(EdmCoreModel.Instance.GetPrimitiveType(primitiveKind));
}
/// <summary>
/// Creates a new enum type with the specified name.
/// </summary>
/// <param name="model">The <see cref="EntityModelSchema"/> to create the enum type in.</param>
/// <param name="localName">The local name (without namespace) for the enum type to create.</param>
/// <param name="namespaceName">The (optional) namespace name for the type to create.</param>
/// <param name="underlyingType">The (optional) underlying type of the enum.</param>
/// <param name="isFlags">If the enum type is flag (optional).</param>
/// <returns>The newly created enum type instance.</returns>
public static EdmEnumType EnumType(this EdmModel model, string localName, string namespaceName = null, EdmPrimitiveTypeKind underlyingType = EdmPrimitiveTypeKind.Int32, bool isFlags = false)
{
ExceptionUtilities.CheckArgumentNotNull(model, "model");
ExceptionUtilities.CheckStringArgumentIsNotNullOrEmpty(localName, "localName");
namespaceName = namespaceName ?? ModelNamespace;
EdmEnumType enumType = new EdmEnumType(namespaceName, localName, underlyingType, isFlags);
model.AddElement(enumType);
return(enumType);
}
private static IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind primitiveKind)
{
return(_coreModel.GetPrimitiveType(primitiveKind));
}
/// <summary>
/// Gets primitive type by kind.
/// </summary>
/// <param name="kind">Kind of the primitive type.</param>
/// <returns>Primitive type definition.</returns>
public IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind kind)
{
return this.GetCoreModelPrimitiveType(kind);
}
public CsdlSpatialTypeReference(EdmPrimitiveTypeKind kind, int?srid, string typeName, bool isNullable, CsdlLocation location)
: base(kind, typeName, isNullable, location)
{
this.srid = srid;
}
/// <summary>
/// Gets a reference to a temporal primitive type definition.
/// </summary>
/// <param name="kind">Primitive kind of the type reference being created.</param>
/// <param name="isNullable">Flag specifying if the referenced type should be nullable.</param>
/// <returns>A new temporal type reference.</returns>
public IEdmTemporalTypeReference GetTemporal(EdmPrimitiveTypeKind kind, bool isNullable)
{
switch (kind)
{
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
return new EdmTemporalTypeReference(this.GetCoreModelPrimitiveType(kind), isNullable);
default:
throw new InvalidOperationException(Edm.Strings.EdmPrimitive_UnexpectedKind);
}
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForValueRequests(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
request.ODataProperties().Path = new ODataPath(new ValuePathSegment());
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
Assert.Equal(ODataPayloadKind.Value, serializer.ODataPayloadKind);
}
private EdmValidCoreModelPrimitiveType GetCoreModelPrimitiveType(EdmPrimitiveTypeKind kind)
{
EdmValidCoreModelPrimitiveType definition;
return this.primitiveTypesByKind.TryGetValue(kind, out definition) ? definition : null;
}
public CsdlSpatialTypeReference(EdmPrimitiveTypeKind kind, int? srid, string typeName, bool isNullable, CsdlLocation location)
: base(kind, typeName, isNullable, location)
{
this.srid = srid;
}
private static void ValidateAssignableToType(bool isAssignableExpectedResult, EdmPrimitiveTypeKind isAssignableToTypeKind, params EdmPrimitiveTypeKind[] subTypeKinds)
{
var isAssignableToType = EdmCoreModel.Instance.GetPrimitiveType(isAssignableToTypeKind);
foreach (var assignableFromType in subTypeKinds.Select(tk=>EdmCoreModel.Instance.GetPrimitiveType(tk)))
{
Assert.AreEqual(isAssignableExpectedResult, isAssignableToType.IsAssignableFrom(assignableFromType));
}
}
private object GetAggregatedValue(string key, AggregateExpression expression, IEnumerable <Dictionary <string, object> > group, EdmPrimitiveTypeKind edmPrimitiveType = EdmPrimitiveTypeKind.None, EdmComplexType edmComplexType = null)
{
var clrType = GetCLRTypeFromEdmType(edmPrimitiveType);
var method = expression.Method;
switch (method)
{
case AggregationMethod.Max: return(Convert.ChangeType(group.Max(r => r.GetValueOrDefault(key)), clrType));
case AggregationMethod.Min: return(Convert.ChangeType(group.Min(r => r.GetValueOrDefault(key)), clrType));
case AggregationMethod.Average:
switch (edmPrimitiveType)
{
case EdmPrimitiveTypeKind.Double: return(group.Average(r => (double)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int16: return(group.Average(r => (short)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int32: return(group.Average(r => (int)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int64: return(group.Average(r => (long)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Decimal: return(group.Average(r => (decimal)r.GetValueOrDefault(key)));
default: return(group.Average(r => (int)r.GetValueOrDefault(key)));
}
case AggregationMethod.CountDistinct: return(group.Select(r => r.GetValueOrDefault(key)).Distinct().Count());
case AggregationMethod.VirtualPropertyCount: return(group.Select(r => r).Count());
case AggregationMethod.Sum:
switch (edmPrimitiveType)
{
case EdmPrimitiveTypeKind.Double: return(group.Sum(r => (double)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int16: return(group.Sum(r => (short)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int32: return(group.Sum(r => (int)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Int64: return(group.Sum(r => (long)r.GetValueOrDefault(key)));
case EdmPrimitiveTypeKind.Decimal: return(group.Sum(r => (decimal)r.GetValueOrDefault(key)));
default: return(Convert.ChangeType(group.Sum(r => (int)r.GetValueOrDefault(key)), clrType));
}
case AggregationMethod.Custom: return(ProcessCustomAggregationValue(expression.MethodDefinition.MethodLabel, group, edmComplexType, key));
}
return(null);
}
/// <summary>
/// Creates and adds a nullable structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <param name="isNullable">Flag specifying if the property is nullable.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, EdmPrimitiveTypeKind type, bool isNullable)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, EdmCoreModel.Instance.GetPrimitive(type, isNullable));
this.AddProperty(property);
return property;
}
public CsdlTemporalTypeReference(EdmPrimitiveTypeKind kind, int? precision, string typeName, bool isNullable, CsdlLocation location) : base(kind, typeName, isNullable, location)
{
this.precision = precision;
}
private string GetInputHtmlType(EdmPrimitiveTypeKind kind) {
switch (kind) {
case EdmPrimitiveTypeKind.Boolean:
return "checkbox";
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Double:
return "number";
default:
return "text";
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmTypeDefinition"/> class with <see cref="EdmPrimitiveTypeKind.Int32"/> underlying type.
/// </summary>
/// <param name="namespaceName">Namespace this type definition belongs to.</param>
/// <param name="name">Name of this type definition.</param>
/// <param name="underlyingType">The underlying type of this type definition.</param>
public EdmTypeDefinition(string namespaceName, string name, EdmPrimitiveTypeKind underlyingType)
: this(namespaceName, name, EdmCoreModel.Instance.GetPrimitiveType(underlyingType))
{
}
/// <summary>
/// Creates an instance of the client EDM primitive type.
/// </summary>
/// <param name="namespaceName">Namespace of the type.</param>
/// <param name="name">Name of the type.</param>
/// <param name="primitiveKind">Kind fo the primitive type.</param>
private ClientEdmPrimitiveType(string namespaceName, string name, EdmPrimitiveTypeKind primitiveKind)
{
this.namespaceName = namespaceName;
this.name = name;
this.primitiveKind = primitiveKind;
}
/// <summary>
/// Creates a new instance of the IEdmPrimitiveType
/// </summary>
/// <param name="primitiveKind">Kind of primitive type.</param>
/// <returns>Returns a new instance of the IEdmPrimitiveType</returns>
public static IEdmPrimitiveType CreateType(EdmPrimitiveTypeKind primitiveKind)
{
Debug.Assert(primitiveKind != EdmPrimitiveTypeKind.None, "primitiveKind != EdmPrimitiveTypeKind.None");
return(new ClientEdmPrimitiveType(XmlConstants.EdmNamespace, primitiveKind.ToString(), primitiveKind));
}
public static IEdmStructuralProperty AssertHasKey(this IEdmEntityType entity, IEdmModel model, string keyName, EdmPrimitiveTypeKind primitiveTypeKind)
{
IEdmStructuralProperty key = entity.AssertHasPrimitiveProperty(model, keyName, primitiveTypeKind, isNullable: false);
Assert.Contains(key, entity.Key());
return(key);
}
public void VisitPrimitiveTypeReference(IEdmPrimitiveTypeReference reference)
{
EdmPrimitiveTypeKind edmPrimitiveTypeKind = reference.PrimitiveKind();
switch (edmPrimitiveTypeKind)
{
case EdmPrimitiveTypeKind.None:
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:
{
this.ProcessPrimitiveTypeReference(reference);
return;
}
case EdmPrimitiveTypeKind.Binary:
{
this.ProcessBinaryTypeReference(reference.AsBinary());
return;
}
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
{
this.ProcessTemporalTypeReference(reference.AsTemporal());
return;
}
case EdmPrimitiveTypeKind.Decimal:
{
this.ProcessDecimalTypeReference(reference.AsDecimal());
return;
}
case EdmPrimitiveTypeKind.String:
{
this.ProcessStringTypeReference(reference.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:
{
this.ProcessSpatialTypeReference(reference.AsSpatial());
return;
}
}
throw new InvalidOperationException(Strings.UnknownEnumVal_PrimitiveKind(reference.PrimitiveKind().ToString()));
}
public EdmEnumType(string namespaceName, string name, EdmPrimitiveTypeKind underlyingType, bool isFlags) : this(namespaceName, name, EdmCoreModel.Instance.GetPrimitiveType(underlyingType), isFlags)
{
}
public static IEdmStructuralProperty AssertHasPrimitiveProperty(this IEdmStructuredType edmType, IEdmModel model, string propertyName, EdmPrimitiveTypeKind primitiveTypeKind, bool isNullable)
{
Type primitiveType = EdmLibHelpers.GetClrType(new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(primitiveTypeKind), isNullable), model);
return(edmType.AssertHasProperty <IEdmStructuralProperty>(model, propertyName, primitiveType, isNullable));
}
private static IEdmPrimitiveType GetPrimitiveType(EdmPrimitiveTypeKind primitiveKind)
{
return _coreModel.GetPrimitiveType(primitiveKind);
}
private static CsdlNamedTypeReference ParseNamedTypeReference(string typeName, bool isNullable,
bool isUnbounded,
int?maxLength,
bool?unicode,
int?precision,
int?scale,
int?srid,
CsdlLocation parentLocation)
{
EdmPrimitiveTypeKind kind = EdmCoreModel.Instance.GetPrimitiveTypeKind(typeName);
switch (kind)
{
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:
return(new CsdlPrimitiveTypeReference(kind, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.Binary:
return(new CsdlBinaryTypeReference(isUnbounded, maxLength, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Duration:
case EdmPrimitiveTypeKind.TimeOfDay:
return(new CsdlTemporalTypeReference(kind, precision, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.Decimal:
return(new CsdlDecimalTypeReference(precision, scale, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.String:
return(new CsdlStringTypeReference(isUnbounded, maxLength, unicode, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
return(new CsdlSpatialTypeReference(kind, srid, typeName, isNullable, parentLocation));
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(new CsdlSpatialTypeReference(kind, srid, typeName, isNullable, parentLocation));
case EdmPrimitiveTypeKind.None:
if (string.Equals(typeName, CsdlConstants.TypeName_Untyped, StringComparison.Ordinal))
{
return(new CsdlUntypedTypeReference(typeName, parentLocation));
}
break;
}
return(new CsdlNamedTypeReference(isUnbounded, maxLength, unicode, precision, scale, srid, typeName, isNullable, parentLocation));
}
