public void ConstructableTypeReferenceToStringTest() { IEdmEntityType astonishing = new EdmEntityType("AwesomeNamespace", "AstonishingEntity", null, false, false); IEdmComplexType breathTaking = new EdmComplexType("AwesomeNamespace", "BreathtakingComplex", null, false); IEdmEntityTypeReference entity = new EdmEntityTypeReference(astonishing, true); IEdmComplexTypeReference complex = new EdmComplexTypeReference(breathTaking, true); IEdmPrimitiveTypeReference primitive = EdmCoreModel.Instance.GetInt32(true); IEdmStringTypeReference stringType = EdmCoreModel.Instance.GetString(false, 128, false, true); IEdmBinaryTypeReference binary = EdmCoreModel.Instance.GetBinary(true, null, true); IEdmTemporalTypeReference temporal = EdmCoreModel.Instance.GetTemporal(EdmPrimitiveTypeKind.DateTimeOffset, 1, true); IEdmDecimalTypeReference decimalType = EdmCoreModel.Instance.GetDecimal(3, 2, true); IEdmSpatialTypeReference spatial = EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, 1, true); IEdmEntityReferenceTypeReference entityRef = new EdmEntityReferenceTypeReference(new EdmEntityReferenceType(astonishing), true); IEdmCollectionTypeReference collection = EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(true)); IEdmTypeReference type = new EdmEntityTypeReference(astonishing, true); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", entity.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.BreathtakingComplex Nullable=True]", complex.ToString(), "To string correct"); Assert.AreEqual("[Edm.Int32 Nullable=True]", primitive.ToString(), "To string correct"); Assert.AreEqual("[Edm.String Nullable=True MaxLength=128 Unicode=False]", stringType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Binary Nullable=True MaxLength=max]", binary.ToString(), "To string correct"); Assert.AreEqual("[Edm.DateTimeOffset Nullable=True Precision=1]", temporal.ToString(), "To string correct"); Assert.AreEqual("[Edm.Decimal Nullable=True Precision=3 Scale=2]", decimalType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Geography Nullable=True SRID=1]", spatial.ToString(), "To string correct"); Assert.AreEqual("[Collection([Edm.Int32 Nullable=True]) Nullable=True]", collection.ToString(), "To string correct"); Assert.AreEqual("[EntityReference(AwesomeNamespace.AstonishingEntity) Nullable=True]", entityRef.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", type.ToString(), "To string correct"); }
private static bool TryAssertStringConstantAsType(IEdmStringConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (type.IsString()) { IEdmStringTypeReference edmStringTypeReference = type.AsString(); int?maxLength = edmStringTypeReference.MaxLength; if (maxLength.HasValue) { int?nullable = edmStringTypeReference.MaxLength; if (expression.Value.Length > nullable.Value) { EdmError[] edmError = new EdmError[1]; int? maxLength1 = edmStringTypeReference.MaxLength; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.StringConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_StringConstantLengthOutOfRange(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 bool IsEquivalentTo(this IEdmStringTypeReference thisType, IEdmStringTypeReference otherType) { return(thisType != null && otherType != null && thisType.IsNullable == otherType.IsNullable && thisType.IsUnbounded == otherType.IsUnbounded && thisType.MaxLength == otherType.MaxLength && thisType.IsUnicode == otherType.IsUnicode); }
/// <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 DebugUtils.CheckNoExternalCallers(); #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.DateTime: IEdmTemporalTypeReference dateTimeType = (IEdmTemporalTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.DateTime); return(new EdmDateTimeConstant(dateTimeType, (DateTime)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)); } }
private static void AppendStringFacets(this StringBuilder sb, IEdmStringTypeReference type) { bool? isUnicode; bool? nullable; string str; bool? isFixedLength = type.IsFixedLength; if (isFixedLength.HasValue) { bool?isFixedLength1 = type.IsFixedLength; sb.AppendKeyValue("FixedLength", isFixedLength1.ToString()); } if (!type.IsUnbounded) { int?maxLength = type.MaxLength; if (!maxLength.HasValue) { isUnicode = type.IsUnicode; if (isUnicode.HasValue) { nullable = type.IsUnicode; sb.AppendKeyValue("Unicode", nullable.ToString()); } if (type.Collation != null) { sb.AppendKeyValue("Collation", type.Collation.ToString()); } return; } } StringBuilder stringBuilder = sb; string str1 = "MaxLength"; if (type.IsUnbounded) { str = "Max"; } else { int?maxLength1 = type.MaxLength; str = maxLength1.ToString(); } stringBuilder.AppendKeyValue(str1, str); isUnicode = type.IsUnicode; if (isUnicode.HasValue) { nullable = type.IsUnicode; sb.AppendKeyValue("Unicode", nullable.ToString()); } if (type.Collation != null) { sb.AppendKeyValue("Collation", type.Collation.ToString()); } }
private static void AppendStringFacets(this StringBuilder sb, IEdmStringTypeReference type) { if (type.IsUnbounded == true || type.MaxLength != null) { sb.AppendKeyValue(EdmConstants.FacetName_MaxLength, (type.IsUnbounded) ? EdmConstants.Value_Max : type.MaxLength.ToString()); } if (type.IsUnicode != null) { sb.AppendKeyValue(EdmConstants.FacetName_Unicode, type.IsUnicode.ToString()); } }
/// <summary> /// Create a <see cref="OpenApiSchema"/> for a <see cref="IEdmPrimitiveTypeReference"/>. /// </summary> /// <param name="context">The OData context.</param> /// <param name="primitiveType">The Edm primitive reference.</param> /// <returns>The created <see cref="OpenApiSchema"/>.</returns> public static OpenApiSchema CreateSchema(this ODataContext context, IEdmPrimitiveTypeReference primitiveType) { Utils.CheckArgumentNull(context, nameof(context)); Utils.CheckArgumentNull(primitiveType, nameof(primitiveType)); OpenApiSchema schema = context.CreateSchema(primitiveType.PrimitiveDefinition()); if (schema != null) { switch (primitiveType.PrimitiveKind()) { case EdmPrimitiveTypeKind.Binary: // binary IEdmBinaryTypeReference binaryTypeReference = (IEdmBinaryTypeReference)primitiveType; schema.MaxLength = binaryTypeReference.MaxLength; break; case EdmPrimitiveTypeKind.Decimal: // decimal IEdmDecimalTypeReference decimalTypeReference = (IEdmDecimalTypeReference)primitiveType; if (decimalTypeReference.Precision != null) { if (decimalTypeReference.Scale != null) { // The precision is represented with the maximum and minimum keywords and a value of ±(10^ (precision - scale) - 10^ scale). double tmp = Math.Pow(10, decimalTypeReference.Precision.Value - decimalTypeReference.Scale.Value) - Math.Pow(10, -decimalTypeReference.Scale.Value); schema.Minimum = (decimal?)(tmp * -1.0); schema.Maximum = (decimal?)(tmp); } else { // If the scale facet has a numeric value, and ±(10^precision - 1) if the scale is variable double tmp = Math.Pow(10, decimalTypeReference.Precision.Value) - 1; schema.Minimum = (decimal?)(tmp * -1.0); schema.Maximum = (decimal?)(tmp); } } // The scale of properties of type Edm.Decimal are represented with the OpenAPI Specification keyword multipleOf and a value of 10 ^ -scale schema.MultipleOf = decimalTypeReference.Scale == null ? null : (decimal?)(Math.Pow(10, decimalTypeReference.Scale.Value * -1)); break; case EdmPrimitiveTypeKind.String: // string IEdmStringTypeReference stringTypeReference = (IEdmStringTypeReference)primitiveType; schema.MaxLength = stringTypeReference.MaxLength; break; } // Nullable properties are marked with the keyword nullable and a value of true. schema.Nullable = primitiveType.IsNullable ? true : false; } return(schema); }
private static bool IsEquivalentTo(this IEdmStringTypeReference thisType, IEdmStringTypeReference otherType) { bool hasValue; bool flag; bool hasValue1; if (thisType.IsNullable == otherType.IsNullable) { bool?isFixedLength = thisType.IsFixedLength; bool?nullable = otherType.IsFixedLength; if (isFixedLength.GetValueOrDefault() != nullable.GetValueOrDefault()) { hasValue = false; } else { hasValue = isFixedLength.HasValue == nullable.HasValue; } if (hasValue && thisType.IsUnbounded == otherType.IsUnbounded) { int?maxLength = thisType.MaxLength; int?maxLength1 = otherType.MaxLength; if (maxLength.GetValueOrDefault() != maxLength1.GetValueOrDefault()) { flag = false; } else { flag = maxLength.HasValue == maxLength1.HasValue; } if (flag) { bool?isUnicode = thisType.IsUnicode; bool?isUnicode1 = otherType.IsUnicode; if (isUnicode.GetValueOrDefault() != isUnicode1.GetValueOrDefault()) { hasValue1 = false; } else { hasValue1 = isUnicode.HasValue == isUnicode1.HasValue; } if (hasValue1) { return(thisType.Collation == otherType.Collation); } } } } return(false); }
internal void WriteStringTypeAttributes(IEdmStringTypeReference reference) { this.WriteOptionalAttribute <string>("Collation", reference.Collation, new Func <string, string>(EdmValueWriter.StringAsXml)); if (!reference.IsUnbounded) { this.WriteOptionalAttribute <int?>("MaxLength", reference.MaxLength, new Func <int?, string>(EdmValueWriter.IntAsXml)); } else { this.WriteRequiredAttribute <string>("MaxLength", "Max", new Func <string, string>(EdmValueWriter.StringAsXml)); } this.WriteOptionalAttribute <bool?>("FixedLength", reference.IsFixedLength, new Func <bool?, string>(EdmValueWriter.BooleanAsXml)); this.WriteOptionalAttribute <bool?>("Unicode", reference.IsUnicode, new Func <bool?, string>(EdmValueWriter.BooleanAsXml)); }
internal void WriteStringTypeAttributes(IEdmStringTypeReference reference) { this.WriteOptionalAttribute(CsdlConstants.Attribute_Collation, reference.Collation, EdmValueWriter.StringAsXml); if (reference.IsUnbounded) { this.WriteRequiredAttribute(CsdlConstants.Attribute_MaxLength, CsdlConstants.Value_Max, EdmValueWriter.StringAsXml); } else { this.WriteOptionalAttribute(CsdlConstants.Attribute_MaxLength, reference.MaxLength, EdmValueWriter.IntAsXml); } this.WriteOptionalAttribute(CsdlConstants.Attribute_FixedLength, reference.IsFixedLength, EdmValueWriter.BooleanAsXml); this.WriteOptionalAttribute(CsdlConstants.Attribute_Unicode, reference.IsUnicode, EdmValueWriter.BooleanAsXml); }
/// <summary> /// Sets the annotation with the OData metadata namespace and the specified <paramref name="localName" /> on the <paramref name="annotatable"/>. /// </summary> /// <param name="model">The <see cref="IEdmModel"/> containing the annotations."/></param> /// <param name="annotatable">The <see cref="IEdmElement"/> to set the annotation on.</param> /// <param name="localName">The local name of the annotation to set.</param> /// <param name="value">The value of the annotation to set.</param> internal static void SetAnnotation(this IEdmModel model, IEdmElement annotatable, string localName, string value) { Debug.Assert(model != null, "model != null"); Debug.Assert(annotatable != null, "annotatable != null"); Debug.Assert(!String.IsNullOrEmpty(localName), "!string.IsNullOrEmpty(localName)"); IEdmStringValue stringValue = null; if (value != null) { IEdmStringTypeReference typeReference = EdmCoreModel.Instance.GetString(/*nullable*/true); stringValue = new EdmStringConstant(typeReference, value); } model.SetAnnotationValue(annotatable, CsdlConstants.ODataMetadataNamespace, localName, stringValue); }
internal void WriteStringTypeAttributes(IEdmStringTypeReference reference) { if (reference.IsUnbounded) { this.WriteRequiredAttribute(CsdlConstants.Attribute_MaxLength, CsdlConstants.Value_Max, EdmValueWriter.StringAsXml); } else { this.WriteOptionalAttribute(CsdlConstants.Attribute_MaxLength, reference.MaxLength, EdmValueWriter.IntAsXml); } if (reference.IsUnicode != null) { this.WriteOptionalAttribute(CsdlConstants.Attribute_Unicode, reference.IsUnicode, CsdlConstants.Default_IsUnicode, EdmValueWriter.BooleanAsXml); } }
private static bool TryAssertStringConstantAsType(IEdmStringConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (!type.IsString()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) }; return(false); } IEdmStringTypeReference stringType = type.AsString(); if (stringType.MaxLength.HasValue && expression.Value.Length > stringType.MaxLength.Value) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.StringConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_StringConstantLengthOutOfRange(expression.Value.Length, stringType.MaxLength.Value)) }; return(false); } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); }
/// <summary> /// If this reference is of a string type, this will return a valid string type reference to the type definition. Otherwise, it will return a bad string type reference. /// </summary> /// <param name="type">Reference to the calling object.</param> /// <returns>A valid string type reference if the definition of the reference is of a string type. Otherwise a bad string type reference.</returns> public static IEdmStringTypeReference AsString(this IEdmTypeReference type) { EdmUtil.CheckArgumentNull(type, "type"); IEdmStringTypeReference stringType = type as IEdmStringTypeReference; if (stringType != null) { return(stringType); } string typeFullName = type.FullName(); List <EdmError> errors = new List <EdmError>(type.Errors()); if (errors.Count == 0) { errors.AddRange(ConversionError(type.Location(), typeFullName, EdmConstants.Type_String)); } return(new BadStringTypeReference(typeFullName, type.IsNullable, errors)); }
public static IEdmStringTypeReference AsString(this IEdmTypeReference type) { EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type"); IEdmStringTypeReference edmStringTypeReference = type as IEdmStringTypeReference; if (edmStringTypeReference == null) { string str = type.FullName(); List <EdmError> edmErrors = new List <EdmError>(type.Errors()); if (edmErrors.Count == 0) { edmErrors.AddRange(EdmTypeSemantics.ConversionError(type.Location(), str, "String")); } return(new BadStringTypeReference(str, type.IsNullable, edmErrors)); } else { return(edmStringTypeReference); } }
public void CanConfig_MaxLengthOfStringAndBinaryType() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); var entity = builder.EntityType <PrecisionEnitity>().HasKey(p => p.Id); entity.Property(p => p.StringProperty).MaxLength = 5; entity.Property(p => p.BinaryProperty).MaxLength = 3; // Act IEdmModel model = builder.GetEdmModel(); IEdmEntityType edmEntityType = model.SchemaElements.OfType <IEdmEntityType>().First(p => p.Name == "PrecisionEnitity"); IEdmStringTypeReference stringType = (IEdmStringTypeReference)edmEntityType.DeclaredProperties.First(p => p.Name.Equals("StringProperty")).Type; IEdmBinaryTypeReference binaryType = (IEdmBinaryTypeReference)edmEntityType.DeclaredProperties.First(p => p.Name.Equals("BinaryProperty")).Type; // Assert Assert.Equal(stringType.MaxLength.Value, 5); Assert.Equal(binaryType.MaxLength.Value, 3); }
public void DefaultValue_PrecisionScaleAndMaxLength() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); var entity = builder.EntityType <PrecisionEnitity>().HasKey(p => p.Id); entity.Property(p => p.DecimalProperty); entity.Property(p => p.StringProperty); // Act IEdmModel model = builder.GetEdmModel(); IEdmEntityType edmEntityType = model.SchemaElements.OfType <IEdmEntityType>().First(p => p.Name == "PrecisionEnitity"); IEdmStringTypeReference stringType = (IEdmStringTypeReference)edmEntityType.DeclaredProperties.First(p => p.Name.Equals("StringProperty")).Type; IEdmDecimalTypeReference decimalType = (IEdmDecimalTypeReference)edmEntityType.DeclaredProperties.First(p => p.Name.Equals("DecimalProperty")).Type; // Assert Assert.Equal(decimalType.Precision, null); Assert.Equal(decimalType.Scale, 0); Assert.Equal(stringType.MaxLength, null); }
private static bool IsEquivalentTo(this IEdmStringTypeReference thisType, IEdmStringTypeReference otherType) { bool hasValue; bool flag; bool hasValue1; if (thisType.IsNullable == otherType.IsNullable) { bool? isFixedLength = thisType.IsFixedLength; bool? nullable = otherType.IsFixedLength; if (isFixedLength.GetValueOrDefault() != nullable.GetValueOrDefault()) { hasValue = false; } else { hasValue = isFixedLength.HasValue == nullable.HasValue; } if (hasValue && thisType.IsUnbounded == otherType.IsUnbounded) { int? maxLength = thisType.MaxLength; int? maxLength1 = otherType.MaxLength; if (maxLength.GetValueOrDefault() != maxLength1.GetValueOrDefault()) { flag = false; } else { flag = maxLength.HasValue == maxLength1.HasValue; } if (flag) { bool? isUnicode = thisType.IsUnicode; bool? isUnicode1 = otherType.IsUnicode; if (isUnicode.GetValueOrDefault() != isUnicode1.GetValueOrDefault()) { hasValue1 = false; } else { hasValue1 = isUnicode.HasValue == isUnicode1.HasValue; } if (hasValue1) { return thisType.Collation == otherType.Collation; } } } } return false; }
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); }
public void CsdlTypeReferenceToStringTest() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""AwesomeNamespace"" Alias=""Alias"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""AstonishingEntity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> </EntityType> <EntityType Name=""AweInspiringEntity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> <Property Name=""AstonishingID"" Type=""Int32"" /> </EntityType> <ComplexType Name=""BreathtakingComplex""> <Property Name=""Par1"" Type=""Int32"" Nullable=""false"" /> <Property Name=""Par2"" Type=""Int32"" Nullable=""false"" /> </ComplexType> <Function Name=""Function1""><ReturnType Type=""Edm.Int32""/> <Parameter Name=""P1"" Type=""AwesomeNamespace.AstonishingEntity"" /> <Parameter Name=""P2"" Type=""AwesomeNamespace.BreathtakingComplex"" /> <Parameter Name=""P3"" Type=""AwesomeNamespace.ExaltedAssociation"" /> <Parameter Name=""P4"" Type=""Edm.Int32"" /> <Parameter Name=""P5"" Type=""Edm.String"" MaxLength=""128"" Unicode=""false"" /> <Parameter Name=""P6"" Type=""Edm.Stream"" /> <Parameter Name=""P7"" Type=""Edm.Binary"" MaxLength=""max""/> <Parameter Name=""P8"" Type=""Edm.DateTimeOffset"" Precision=""1"" /> <Parameter Name=""P9"" Type=""Edm.Decimal"" Precision=""3"" Scale=""2""/> <Parameter Name=""P10"" Type=""Edm.Geography"" SRID=""1"" /> <Parameter Name=""P11"" Type=""Ref(AwesomeNamespace.AstonishingEntity)"" /> <Parameter Name=""P12"" Type=""Collection(Edm.Int32)"" /> <Parameter Name=""P14"" Type=""AwesomeNamespace.FabulousEnum"" /> </Function> <EnumType Name=""FabulousEnum""> <Member Name=""m1"" /> <Member Name=""m2"" /> </EnumType> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = CsdlReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); IEdmOperation operation = (IEdmOperation)(model.FindOperations("AwesomeNamespace.Function1")).First(); IEdmEntityTypeReference entity = operation.FindParameter("P1").Type.AsEntity(); IEdmComplexTypeReference complex = operation.FindParameter("P2").Type.AsComplex(); IEdmTypeReference association = operation.FindParameter("P3").Type; IEdmPrimitiveTypeReference primitive = operation.FindParameter("P4").Type.AsPrimitive(); IEdmStringTypeReference stringType = operation.FindParameter("P5").Type.AsString(); IEdmPrimitiveTypeReference stream = operation.FindParameter("P6").Type.AsPrimitive(); IEdmBinaryTypeReference binary = operation.FindParameter("P7").Type.AsBinary(); IEdmTemporalTypeReference temporal = operation.FindParameter("P8").Type.AsTemporal(); IEdmDecimalTypeReference decimalType = operation.FindParameter("P9").Type.AsDecimal(); IEdmSpatialTypeReference spatial = operation.FindParameter("P10").Type.AsSpatial(); IEdmEntityReferenceTypeReference entityRef = operation.FindParameter("P11").Type.AsEntityReference(); IEdmCollectionTypeReference collection = operation.FindParameter("P12").Type.AsCollection(); IEdmEnumTypeReference enumTypeRef = operation.FindParameter("P14").Type.AsEnum(); IEdmTypeReference type = operation.FindParameter("P1").Type; Assert.IsFalse(association.IsBad(), "Associations cannot be types"); Assert.IsTrue(association.Definition.IsBad(), "Associations cannot be types"); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", entity.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.BreathtakingComplex Nullable=True]", complex.ToString(), "To string correct"); Assert.AreEqual("[Edm.Int32 Nullable=True]", primitive.ToString(), "To string correct"); Assert.AreEqual("[Edm.String Nullable=True MaxLength=128 Unicode=False]", stringType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Stream Nullable=True]", stream.ToString(), "To string correct"); Assert.AreEqual("[Edm.Binary Nullable=True MaxLength=max]", binary.ToString(), "To string correct"); Assert.AreEqual("[Edm.DateTimeOffset Nullable=True Precision=1]", temporal.ToString(), "To string correct"); Assert.AreEqual("[Edm.Decimal Nullable=True Precision=3 Scale=2]", decimalType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Geography Nullable=True SRID=1]", spatial.ToString(), "To string correct"); Assert.AreEqual("[Collection([Edm.Int32 Nullable=True]) Nullable=True]", collection.ToString(), "To string correct"); Assert.AreEqual("[EntityReference(AwesomeNamespace.AstonishingEntity) Nullable=True]", entityRef.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.FabulousEnum Nullable=True]", enumTypeRef.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", type.ToString(), "To string correct"); }
private static bool IsEquivalentTo(this IEdmStringTypeReference thisType, IEdmStringTypeReference otherType) { return thisType.IsNullable == otherType.IsNullable && thisType.IsFixedLength == otherType.IsFixedLength && thisType.IsUnbounded == otherType.IsUnbounded && thisType.MaxLength == otherType.MaxLength && thisType.IsUnicode == otherType.IsUnicode && thisType.Collation == otherType.Collation; }
/// <summary> /// Clones the specified type reference. /// </summary> /// <param name="typeReference">The type reference to clone.</param> /// <param name="nullable">true to make the cloned type reference nullable; false to make it non-nullable.</param> /// <returns>The cloned <see cref="IEdmTypeReference"/> instance.</returns> public static IEdmTypeReference Clone(this IEdmTypeReference typeReference, bool nullable) { if (typeReference == null) { return(null); } EdmTypeKind typeKind = typeReference.TypeKind(); switch (typeKind) { case EdmTypeKind.Primitive: EdmPrimitiveTypeKind kind = typeReference.PrimitiveKind(); IEdmPrimitiveType primitiveType = (IEdmPrimitiveType)typeReference.Definition; 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: return(new EdmPrimitiveTypeReference(primitiveType, nullable)); case EdmPrimitiveTypeKind.Binary: IEdmBinaryTypeReference binaryTypeReference = (IEdmBinaryTypeReference)typeReference; return(new EdmBinaryTypeReference( primitiveType, nullable, binaryTypeReference.IsUnbounded, binaryTypeReference.MaxLength)); case EdmPrimitiveTypeKind.String: IEdmStringTypeReference stringTypeReference = (IEdmStringTypeReference)typeReference; return(new EdmStringTypeReference( primitiveType, nullable, stringTypeReference.IsUnbounded, stringTypeReference.MaxLength, stringTypeReference.IsUnicode)); case EdmPrimitiveTypeKind.Decimal: IEdmDecimalTypeReference decimalTypeReference = (IEdmDecimalTypeReference)typeReference; return(new EdmDecimalTypeReference(primitiveType, nullable, decimalTypeReference.Precision, decimalTypeReference.Scale)); case EdmPrimitiveTypeKind.DateTimeOffset: case EdmPrimitiveTypeKind.Duration: IEdmTemporalTypeReference temporalTypeReference = (IEdmTemporalTypeReference)typeReference; return(new EdmTemporalTypeReference(primitiveType, nullable, temporalTypeReference.Precision)); 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.GeometryCollection: case EdmPrimitiveTypeKind.GeometryPoint: case EdmPrimitiveTypeKind.GeometryLineString: case EdmPrimitiveTypeKind.GeometryPolygon: case EdmPrimitiveTypeKind.GeometryMultiPolygon: case EdmPrimitiveTypeKind.GeometryMultiLineString: case EdmPrimitiveTypeKind.GeometryMultiPoint: IEdmSpatialTypeReference spatialTypeReference = (IEdmSpatialTypeReference)typeReference; return(new EdmSpatialTypeReference(primitiveType, nullable, spatialTypeReference.SpatialReferenceIdentifier)); default: throw new TaupoNotSupportedException("Invalid primitive type kind: " + typeKind.ToString()); } case EdmTypeKind.Entity: return(new EdmEntityTypeReference((IEdmEntityType)typeReference.Definition, nullable)); case EdmTypeKind.Complex: return(new EdmComplexTypeReference((IEdmComplexType)typeReference.Definition, nullable)); case EdmTypeKind.Collection: return(new EdmCollectionTypeReference((IEdmCollectionType)typeReference.Definition)); case EdmTypeKind.EntityReference: return(new EdmEntityReferenceTypeReference((IEdmEntityReferenceType)typeReference.Definition, nullable)); case EdmTypeKind.Enum: return(new EdmEnumTypeReference((IEdmEnumType)typeReference.Definition, nullable)); case EdmTypeKind.None: // fall through default: throw new TaupoNotSupportedException("Invalid type kind: " + typeKind.ToString()); } }
internal static IEdmTypeReference Clone(this IEdmTypeReference typeReference, bool nullable) { if (typeReference == null) { return(null); } switch (typeReference.TypeKind()) { case EdmTypeKind.Primitive: { EdmPrimitiveTypeKind kind2 = typeReference.PrimitiveKind(); IEdmPrimitiveType definition = (IEdmPrimitiveType)typeReference.Definition; switch (kind2) { case EdmPrimitiveTypeKind.Binary: { IEdmBinaryTypeReference reference = (IEdmBinaryTypeReference)typeReference; return(new EdmBinaryTypeReference(definition, nullable, reference.IsUnbounded, reference.MaxLength, reference.IsFixedLength)); } 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(definition, nullable)); case EdmPrimitiveTypeKind.DateTime: case EdmPrimitiveTypeKind.DateTimeOffset: case EdmPrimitiveTypeKind.Time: { IEdmTemporalTypeReference reference4 = (IEdmTemporalTypeReference)typeReference; return(new EdmTemporalTypeReference(definition, nullable, reference4.Precision)); } case EdmPrimitiveTypeKind.Decimal: { IEdmDecimalTypeReference reference3 = (IEdmDecimalTypeReference)typeReference; return(new EdmDecimalTypeReference(definition, nullable, reference3.Precision, reference3.Scale)); } case EdmPrimitiveTypeKind.String: { IEdmStringTypeReference reference2 = (IEdmStringTypeReference)typeReference; return(new EdmStringTypeReference(definition, nullable, reference2.IsUnbounded, reference2.MaxLength, reference2.IsFixedLength, reference2.IsUnicode, reference2.Collation)); } 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: { IEdmSpatialTypeReference reference5 = (IEdmSpatialTypeReference)typeReference; return(new EdmSpatialTypeReference(definition, nullable, reference5.SpatialReferenceIdentifier)); } } throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodesCommon.EdmLibraryExtensions_Clone_PrimitiveTypeKind)); } case EdmTypeKind.Entity: return(new EdmEntityTypeReference((IEdmEntityType)typeReference.Definition, nullable)); case EdmTypeKind.Complex: return(new EdmComplexTypeReference((IEdmComplexType)typeReference.Definition, nullable)); case EdmTypeKind.Row: return(new EdmRowTypeReference((IEdmRowType)typeReference.Definition, nullable)); case EdmTypeKind.Collection: return(new EdmCollectionTypeReference((IEdmCollectionType)typeReference.Definition, nullable)); case EdmTypeKind.EntityReference: return(new EdmEntityReferenceTypeReference((IEdmEntityReferenceType)typeReference.Definition, nullable)); case EdmTypeKind.Enum: return(new EdmEnumTypeReference((IEdmEnumType)typeReference.Definition, nullable)); } throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodesCommon.EdmLibraryExtensions_Clone_TypeKind)); }
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 void AppendStringFacets(this StringBuilder sb, IEdmStringTypeReference type) { if (type.IsFixedLength != null) { sb.AppendKeyValue(EdmConstants.FacetName_FixedLength, type.IsFixedLength.ToString()); } if (type.IsUnbounded == true || type.MaxLength != null) { sb.AppendKeyValue(EdmConstants.FacetName_MaxLength, (type.IsUnbounded) ? EdmConstants.Value_Max : type.MaxLength.ToString()); } if (type.IsUnicode != null) { sb.AppendKeyValue(EdmConstants.FacetName_Unicode, type.IsUnicode.ToString()); } if (type.Collation != null) { sb.AppendKeyValue(EdmConstants.FacetName_Collation, type.Collation.ToString()); } }
protected virtual void ProcessStringTypeReference(IEdmStringTypeReference reference) { this.ProcessPrimitiveTypeReference(reference); }
internal abstract void WriteStringTypeAttributes(IEdmStringTypeReference reference);
public EdmStringConstant(IEdmStringTypeReference type, string value) : base(type) { EdmUtil.CheckArgumentNull<string>(value, "value"); this.@value = value; }
protected override void ProcessStringTypeReference(IEdmStringTypeReference element) { this.schemaWriter.WriteStringTypeAttributes(element); }
/// <summary> /// Initializes a new instance of the <see cref="EdmStringConstant"/> class. /// </summary> /// <param name="type">Type of the string.</param> /// <param name="value">String value represented by this value.</param> public EdmStringConstant(IEdmStringTypeReference type, string value) : base(type) { EdmUtil.CheckArgumentNull(value, "value"); this.value = value; }
private static void AppendStringFacets(this StringBuilder sb, IEdmStringTypeReference type) { bool? isUnicode; bool? nullable; string str; bool? isFixedLength = type.IsFixedLength; if (isFixedLength.HasValue) { bool? isFixedLength1 = type.IsFixedLength; sb.AppendKeyValue("FixedLength", isFixedLength1.ToString()); } if (!type.IsUnbounded) { int? maxLength = type.MaxLength; if (!maxLength.HasValue) { isUnicode = type.IsUnicode; if (isUnicode.HasValue) { nullable = type.IsUnicode; sb.AppendKeyValue("Unicode", nullable.ToString()); } if (type.Collation != null) { sb.AppendKeyValue("Collation", type.Collation.ToString()); } return; } } StringBuilder stringBuilder = sb; string str1 = "MaxLength"; if (type.IsUnbounded) { str = "Max"; } else { int? maxLength1 = type.MaxLength; str = maxLength1.ToString(); } stringBuilder.AppendKeyValue(str1, str); isUnicode = type.IsUnicode; if (isUnicode.HasValue) { nullable = type.IsUnicode; sb.AppendKeyValue("Unicode", nullable.ToString()); } if (type.Collation != null) { sb.AppendKeyValue("Collation", type.Collation.ToString()); } }