internal override void WriteTypeDefinitionAttributes(IEdmTypeDefinitionReference reference) { IEdmTypeReference actualTypeReference = reference.AsActualTypeReference(); if (actualTypeReference.IsBinary()) { this.WriteBinaryTypeAttributes(actualTypeReference.AsBinary()); } else if (actualTypeReference.IsString()) { this.WriteStringTypeAttributes(actualTypeReference.AsString()); } else if (actualTypeReference.IsTemporal()) { this.WriteTemporalTypeAttributes(actualTypeReference.AsTemporal()); } else if (actualTypeReference.IsDecimal()) { this.WriteDecimalTypeAttributes(actualTypeReference.AsDecimal()); } else if (actualTypeReference.IsSpatial()) { this.WriteSpatialTypeAttributes(actualTypeReference.AsSpatial()); } }
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (type.IsBinary()) { IEdmBinaryTypeReference edmBinaryTypeReference = type.AsBinary(); int?maxLength = edmBinaryTypeReference.MaxLength; if (maxLength.HasValue) { int?nullable = edmBinaryTypeReference.MaxLength; if ((int)expression.Value.Length > nullable.Value) { EdmError[] edmError = new EdmError[1]; int? maxLength1 = edmBinaryTypeReference.MaxLength; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange((int)expression.Value.Length, maxLength1.Value)); discoveredErrors = edmError; return(false); } } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmErrorArray; return(false); } }
private static IEdmTypeReference CreatePrimitveStockTypeReference(IEdmTypeReference edmTypeReference, EdmModel stockModel) { IEdmTypeReference stockTypeReference = null; switch (edmTypeReference.PrimitiveKind()) { case EdmPrimitiveTypeKind.Binary: var binaryTypeReference = edmTypeReference.AsBinary(); stockTypeReference = EdmCoreModel.Instance.GetBinary(binaryTypeReference.IsUnbounded, binaryTypeReference.MaxLength, binaryTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.String: var stringTypeReference = edmTypeReference.AsString(); stockTypeReference = EdmCoreModel.Instance.GetString(stringTypeReference.IsUnbounded, stringTypeReference.MaxLength, stringTypeReference.IsUnicode ?? true, stringTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.DateTimeOffset: case EdmPrimitiveTypeKind.Duration: var temporalTypeReference = edmTypeReference.AsTemporal(); stockTypeReference = EdmCoreModel.Instance.GetTemporal(temporalTypeReference.PrimitiveKind(), temporalTypeReference.Precision ?? 0, temporalTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.Decimal: var decimalTypeReference = edmTypeReference.AsDecimal(); stockTypeReference = EdmCoreModel.Instance.GetDecimal(decimalTypeReference.Precision, decimalTypeReference.Scale, decimalTypeReference.IsNullable); break; default: stockTypeReference = EdmCoreModel.Instance.GetPrimitive(edmTypeReference.PrimitiveKind(), edmTypeReference.IsNullable); break; } return(stockTypeReference); }
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (!type.IsBinary()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) }; return(false); } IEdmBinaryTypeReference binaryType = type.AsBinary(); if (binaryType.MaxLength.HasValue && expression.Value.Length > binaryType.MaxLength.Value) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange(expression.Value.Length, binaryType.MaxLength.Value)) }; return(false); } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); }
// The As*** functions never return null -- if the supplied type does not have the appropriate shape, an encoding of a bad type is returned. #region AsPrimitive, AsCollection, AsStructured, ... /// <summary> /// If this reference is of a primitive type, this will return a valid primitive type reference to the type definition. Otherwise, it will return a bad primitive type reference. /// </summary> /// <param name="type">Reference to the calling object.</param> /// <returns>A valid primitive type reference if the definition of the reference is of a primitive type. Otherwise a bad primitive type reference.</returns> public static IEdmPrimitiveTypeReference AsPrimitive(this IEdmTypeReference type) { EdmUtil.CheckArgumentNull(type, "type"); IEdmPrimitiveTypeReference reference = type as IEdmPrimitiveTypeReference; if (reference != null) { return(reference); } IEdmType typeDefinition = type.Definition; if (typeDefinition.TypeKind == EdmTypeKind.Primitive) { var primitiveDefinition = typeDefinition as IEdmPrimitiveType; if (primitiveDefinition != null) { switch (primitiveDefinition.PrimitiveKind) { case EdmPrimitiveTypeKind.Boolean: case EdmPrimitiveTypeKind.Byte: case EdmPrimitiveTypeKind.Double: case EdmPrimitiveTypeKind.Guid: case EdmPrimitiveTypeKind.Int16: case EdmPrimitiveTypeKind.Int32: case EdmPrimitiveTypeKind.Int64: case EdmPrimitiveTypeKind.SByte: case EdmPrimitiveTypeKind.Single: case EdmPrimitiveTypeKind.Stream: return(new EdmPrimitiveTypeReference(primitiveDefinition, type.IsNullable)); case EdmPrimitiveTypeKind.Binary: return(type.AsBinary()); case EdmPrimitiveTypeKind.Decimal: return(type.AsDecimal()); case EdmPrimitiveTypeKind.String: return(type.AsString()); case EdmPrimitiveTypeKind.Duration: case EdmPrimitiveTypeKind.DateTimeOffset: return(type.AsTemporal()); 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(type.AsSpatial()); case EdmPrimitiveTypeKind.None: break; } } } string typeFullName = type.FullName(); List <EdmError> errors = new List <EdmError>(type.Errors()); if (errors.Count == 0) { errors.AddRange(ConversionError(type.Location(), typeFullName, EdmConstants.Type_Primitive)); } return(new BadPrimitiveTypeReference(typeFullName, type.IsNullable, errors)); }
private static bool MatchesType(IEdmTypeReference targetType, IEdmValue operand, bool testPropertyTypes) { IEdmTypeReference operandType = operand.Type; EdmValueKind operandKind = operand.ValueKind; if (operandType != null && operandKind != EdmValueKind.Null && operandType.Definition.IsOrInheritsFrom(targetType.Definition)) { return(true); } switch (operandKind) { case EdmValueKind.Binary: if (targetType.IsBinary()) { IEdmBinaryTypeReference targetBinary = targetType.AsBinary(); return(targetBinary.IsUnbounded || !targetBinary.MaxLength.HasValue || targetBinary.MaxLength.Value >= ((IEdmBinaryValue)operand).Value.Length); } break; case EdmValueKind.Boolean: return(targetType.IsBoolean()); case EdmValueKind.Date: return(targetType.IsDate()); case EdmValueKind.DateTimeOffset: return(targetType.IsDateTimeOffset()); case EdmValueKind.Decimal: return(targetType.IsDecimal()); case EdmValueKind.Guid: return(targetType.IsGuid()); case EdmValueKind.Null: return(targetType.IsNullable); case EdmValueKind.Duration: return(targetType.IsDuration()); case EdmValueKind.String: if (targetType.IsString()) { IEdmStringTypeReference targetString = targetType.AsString(); return(targetString.IsUnbounded || !targetString.MaxLength.HasValue || targetString.MaxLength.Value >= ((IEdmStringValue)operand).Value.Length); } break; case EdmValueKind.TimeOfDay: return(targetType.IsTimeOfDay()); case EdmValueKind.Floating: return(targetType.IsDouble() || (targetType.IsSingle() && FitsInSingle(((IEdmFloatingValue)operand).Value))); case EdmValueKind.Integer: if (targetType.TypeKind() == EdmTypeKind.Primitive) { switch (targetType.AsPrimitive().PrimitiveKind()) { case EdmPrimitiveTypeKind.Int16: return(InRange(((IEdmIntegerValue)operand).Value, Int16.MinValue, Int16.MaxValue)); case EdmPrimitiveTypeKind.Int32: return(InRange(((IEdmIntegerValue)operand).Value, Int32.MinValue, Int32.MaxValue)); case EdmPrimitiveTypeKind.SByte: return(InRange(((IEdmIntegerValue)operand).Value, SByte.MinValue, SByte.MaxValue)); case EdmPrimitiveTypeKind.Byte: return(InRange(((IEdmIntegerValue)operand).Value, Byte.MinValue, Byte.MaxValue)); case EdmPrimitiveTypeKind.Int64: case EdmPrimitiveTypeKind.Single: case EdmPrimitiveTypeKind.Double: return(true); } } break; case EdmValueKind.Collection: if (targetType.IsCollection()) { IEdmTypeReference targetElementType = targetType.AsCollection().ElementType(); // This enumerates the entire collection, which is unfortunate. foreach (IEdmDelayedValue elementValue in ((IEdmCollectionValue)operand).Elements) { if (!MatchesType(targetElementType, elementValue.Value)) { return(false); } } return(true); } break; case EdmValueKind.Enum: return(((IEdmEnumValue)operand).Type.Definition.IsEquivalentTo(targetType.Definition)); case EdmValueKind.Structured: if (targetType.IsStructured()) { return(AssertOrMatchStructuredType(targetType.AsStructured(), (IEdmStructuredValue)operand, testPropertyTypes, null)); } break; } return(false); }
private static bool TryCastBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors) { if (!type.IsBinary()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) }; return false; } IEdmBinaryTypeReference binaryType = type.AsBinary(); if (binaryType.MaxLength.HasValue && expression.Value.Length > binaryType.MaxLength.Value) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange(expression.Value.Length, binaryType.MaxLength.Value)) }; return false; } discoveredErrors = Enumerable.Empty<EdmError>(); return true; }
public static IEdmPrimitiveTypeReference AsPrimitive(this IEdmTypeReference type) { string str; List <EdmError> edmErrors; EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type"); IEdmPrimitiveTypeReference edmPrimitiveTypeReference = type as IEdmPrimitiveTypeReference; if (edmPrimitiveTypeReference == null) { IEdmType definition = type.Definition; if (definition.TypeKind == EdmTypeKind.Primitive) { IEdmPrimitiveType edmPrimitiveType = definition as IEdmPrimitiveType; if (edmPrimitiveType != null) { EdmPrimitiveTypeKind primitiveKind = edmPrimitiveType.PrimitiveKind; if (primitiveKind == EdmPrimitiveTypeKind.None) { str = type.FullName(); edmErrors = new List <EdmError>(type.Errors()); if (edmErrors.Count == 0) { edmErrors.AddRange(EdmTypeSemantics.ConversionError(type.Location(), str, "Primitive")); } return(new BadPrimitiveTypeReference(str, type.IsNullable, edmErrors)); } else if (primitiveKind == EdmPrimitiveTypeKind.Binary) { return(type.AsBinary()); } else if (primitiveKind == EdmPrimitiveTypeKind.Boolean || primitiveKind == EdmPrimitiveTypeKind.Byte || primitiveKind == EdmPrimitiveTypeKind.Double || primitiveKind == EdmPrimitiveTypeKind.Guid || primitiveKind == EdmPrimitiveTypeKind.Int16 || primitiveKind == EdmPrimitiveTypeKind.Int32 || primitiveKind == EdmPrimitiveTypeKind.Int64 || primitiveKind == EdmPrimitiveTypeKind.SByte || primitiveKind == EdmPrimitiveTypeKind.Single || primitiveKind == EdmPrimitiveTypeKind.Stream) { return(new EdmPrimitiveTypeReference(edmPrimitiveType, type.IsNullable)); } else if (primitiveKind == EdmPrimitiveTypeKind.DateTime || primitiveKind == EdmPrimitiveTypeKind.DateTimeOffset || primitiveKind == EdmPrimitiveTypeKind.Time) { return(type.AsTemporal()); } else if (primitiveKind == EdmPrimitiveTypeKind.Decimal) { return(type.AsDecimal()); } else if (primitiveKind == EdmPrimitiveTypeKind.String) { return(type.AsString()); } else if (primitiveKind == EdmPrimitiveTypeKind.Geography || primitiveKind == EdmPrimitiveTypeKind.GeographyPoint || primitiveKind == EdmPrimitiveTypeKind.GeographyLineString || primitiveKind == EdmPrimitiveTypeKind.GeographyPolygon || primitiveKind == EdmPrimitiveTypeKind.GeographyCollection || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiPolygon || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiLineString || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiPoint || primitiveKind == EdmPrimitiveTypeKind.Geometry || primitiveKind == EdmPrimitiveTypeKind.GeometryPoint || primitiveKind == EdmPrimitiveTypeKind.GeometryLineString || primitiveKind == EdmPrimitiveTypeKind.GeometryPolygon || primitiveKind == EdmPrimitiveTypeKind.GeometryCollection || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiPolygon || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiLineString || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiPoint) { return(type.AsSpatial()); } } } str = type.FullName(); edmErrors = new List <EdmError>(type.Errors()); if (edmErrors.Count == 0) { edmErrors.AddRange(EdmTypeSemantics.ConversionError(type.Location(), str, "Primitive")); } return(new BadPrimitiveTypeReference(str, type.IsNullable, edmErrors)); } else { return(edmPrimitiveTypeReference); } }
private static IEdmTypeReference CreatePrimitveStockTypeReference(IEdmTypeReference edmTypeReference, EdmModel stockModel) { IEdmTypeReference stockTypeReference = null; switch (edmTypeReference.PrimitiveKind()) { case EdmPrimitiveTypeKind.Binary: var binaryTypeReference = edmTypeReference.AsBinary(); stockTypeReference = EdmCoreModel.Instance.GetBinary(binaryTypeReference.IsUnbounded, binaryTypeReference.MaxLength, binaryTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.String: var stringTypeReference = edmTypeReference.AsString(); stockTypeReference = EdmCoreModel.Instance.GetString(stringTypeReference.IsUnbounded, stringTypeReference.MaxLength, stringTypeReference.IsUnicode ?? true, stringTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.DateTimeOffset: case EdmPrimitiveTypeKind.Duration: var temporalTypeReference = edmTypeReference.AsTemporal(); stockTypeReference = EdmCoreModel.Instance.GetTemporal(temporalTypeReference.PrimitiveKind(), temporalTypeReference.Precision ?? 0, temporalTypeReference.IsNullable); break; case EdmPrimitiveTypeKind.Decimal: var decimalTypeReference = edmTypeReference.AsDecimal(); stockTypeReference = EdmCoreModel.Instance.GetDecimal(decimalTypeReference.Precision, decimalTypeReference.Scale, decimalTypeReference.IsNullable); break; default: stockTypeReference = EdmCoreModel.Instance.GetPrimitive(edmTypeReference.PrimitiveKind(), edmTypeReference.IsNullable); break; } return stockTypeReference; }
private static bool MatchesType(IEdmTypeReference targetType, IEdmValue operand, bool testPropertyTypes) { bool flag; IEdmTypeReference type = operand.Type; EdmValueKind valueKind = operand.ValueKind; if (type == null || valueKind == EdmValueKind.Null || !type.Definition.IsOrInheritsFrom(targetType.Definition)) { EdmValueKind edmValueKind = valueKind; switch (edmValueKind) { case EdmValueKind.Binary: { if (!targetType.IsBinary()) { break; } IEdmBinaryTypeReference edmBinaryTypeReference = targetType.AsBinary(); if (!edmBinaryTypeReference.IsUnbounded) { int?maxLength = edmBinaryTypeReference.MaxLength; if (maxLength.HasValue) { int?nullable = edmBinaryTypeReference.MaxLength; return(nullable.Value >= (int)((IEdmBinaryValue)operand).Value.Length); } } return(true); } case EdmValueKind.Boolean: { return(targetType.IsBoolean()); } case EdmValueKind.Collection: { if (!targetType.IsCollection()) { break; } IEdmTypeReference edmTypeReference = targetType.AsCollection().ElementType(); IEnumerator <IEdmDelayedValue> enumerator = ((IEdmCollectionValue)operand).Elements.GetEnumerator(); using (enumerator) { while (enumerator.MoveNext()) { IEdmDelayedValue current = enumerator.Current; if (EdmExpressionEvaluator.MatchesType(edmTypeReference, current.Value)) { continue; } flag = false; return(flag); } return(true); } return(flag); } case EdmValueKind.DateTimeOffset: { return(targetType.IsDateTimeOffset()); } case EdmValueKind.DateTime: { return(targetType.IsDateTime()); } case EdmValueKind.Decimal: { return(targetType.IsDecimal()); } case EdmValueKind.Enum: { return(((IEdmEnumValue)operand).Type.Definition.IsEquivalentTo(targetType.Definition)); } case EdmValueKind.Floating: { if (targetType.IsDouble()) { return(true); } else { if (!targetType.IsSingle()) { return(false); } else { return(EdmExpressionEvaluator.FitsInSingle(((IEdmFloatingValue)operand).Value)); } } } case EdmValueKind.Guid: { return(targetType.IsGuid()); } case EdmValueKind.Integer: { if (targetType.TypeKind() != EdmTypeKind.Primitive) { break; } EdmPrimitiveTypeKind edmPrimitiveTypeKind = targetType.AsPrimitive().PrimitiveKind(); if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Byte) { return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)0, (long)0xff)); } else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.DateTime || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.DateTimeOffset || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Decimal || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Guid) { break; } else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Double || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int64 || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Single) { return(true); } else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int16) { return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-32768, (long)0x7fff)); } else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int32) { return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-2147483648, (long)0x7fffffff)); } else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.SByte) { return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-128, (long)127)); } break; } case EdmValueKind.Null: { return(targetType.IsNullable); } case EdmValueKind.String: { if (!targetType.IsString()) { break; } IEdmStringTypeReference edmStringTypeReference = targetType.AsString(); if (!edmStringTypeReference.IsUnbounded) { int?maxLength1 = edmStringTypeReference.MaxLength; if (maxLength1.HasValue) { int?nullable1 = edmStringTypeReference.MaxLength; return(nullable1.Value >= ((IEdmStringValue)operand).Value.Length); } } return(true); } case EdmValueKind.Structured: { if (!targetType.IsStructured()) { break; } return(EdmExpressionEvaluator.AssertOrMatchStructuredType(targetType.AsStructured(), (IEdmStructuredValue)operand, testPropertyTypes, null)); } case EdmValueKind.Time: { return(targetType.IsTime()); } } return(false); } else { return(true); } return(true); }
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors) { if (type.IsBinary()) { IEdmBinaryTypeReference edmBinaryTypeReference = type.AsBinary(); int? maxLength = edmBinaryTypeReference.MaxLength; if (maxLength.HasValue) { int? nullable = edmBinaryTypeReference.MaxLength; if ((int)expression.Value.Length > nullable.Value) { EdmError[] edmError = new EdmError[1]; int? maxLength1 = edmBinaryTypeReference.MaxLength; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange((int)expression.Value.Length, maxLength1.Value)); discoveredErrors = edmError; return false; } } discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmErrorArray; return false; } }