/// <summary> /// Gets the the CLR value for a primitive property. /// </summary> /// <param name="structuredValue">The structured value.</param> /// <param name="propertyName">Name of the property.</param> /// <returns>The clr value of the property.</returns> internal static object GetPrimitivePropertyClrValue(this IEdmStructuredValue structuredValue, string propertyName) { Debug.Assert(structuredValue != null, "entityInstance != null"); IEdmStructuredTypeReference valueType = structuredValue.Type.AsStructured(); IEdmPropertyValue propertyValue = structuredValue.FindPropertyValue(propertyName); if (propertyValue == null) { throw new ODataException(ErrorStrings.EdmValueUtils_PropertyDoesntExist(valueType.FullName(), propertyName)); } if (propertyValue.Value.ValueKind == EdmValueKind.Null) { return(null); } IEdmPrimitiveValue primitiveValue = propertyValue.Value as IEdmPrimitiveValue; if (primitiveValue == null) { throw new ODataException(ErrorStrings.EdmValueUtils_NonPrimitiveValue(propertyValue.Name, valueType.FullName())); } return(primitiveValue.ToClrValue()); }
public EdmEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value) : base(name) { EdmUtil.CheckArgumentNull <IEdmEnumType>(declaringType, "declaringType"); EdmUtil.CheckArgumentNull <IEdmPrimitiveValue>(value, "value"); this.declaringType = declaringType; this.@value = value; }
/// <summary> /// Converts the IEdmPrimitiveValue to a String. /// </summary> /// <param name="v">The value to convert.</param> /// <returns>A string representation of the IEdmPrimitiveValue.</returns> internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v) { switch (v.ValueKind) { case EdmValueKind.Boolean: return(BooleanAsXml(((IEdmBooleanValue)v).Value)); case EdmValueKind.Integer: return(LongAsXml(((IEdmIntegerValue)v).Value)); case EdmValueKind.Floating: return(FloatAsXml(((IEdmFloatingValue)v).Value)); case EdmValueKind.Guid: return(GuidAsXml(((IEdmGuidValue)v).Value)); case EdmValueKind.Binary: return(BinaryAsXml(((IEdmBinaryValue)v).Value)); case EdmValueKind.Decimal: return(DecimalAsXml(((IEdmDecimalValue)v).Value)); case EdmValueKind.String: return(StringAsXml(((IEdmStringValue)v).Value)); case EdmValueKind.DateTimeOffset: return(DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value)); case EdmValueKind.Duration: return(DurationAsXml(((IEdmDurationValue)v).Value)); default: throw new NotSupportedException(Edm.Strings.ValueWriter_NonSerializableValue(v.ValueKind)); } }
public EdmEnumMember AddMember(string name, IEdmPrimitiveValue value) { EdmEnumMember edmEnumMember = new EdmEnumMember(this, name, value); this.AddMember(edmEnumMember); return(edmEnumMember); }
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v) { switch (v.ValueKind) { case EdmValueKind.Boolean: return BooleanAsXml(((IEdmBooleanValue)v).Value); case EdmValueKind.Integer: return LongAsXml(((IEdmIntegerValue)v).Value); case EdmValueKind.Floating: return FloatAsXml(((IEdmFloatingValue)v).Value); case EdmValueKind.Guid: return GuidAsXml(((IEdmGuidValue)v).Value); case EdmValueKind.Binary: return BinaryAsXml(((IEdmBinaryValue)v).Value); case EdmValueKind.Decimal: return DecimalAsXml(((IEdmDecimalValue)v).Value); case EdmValueKind.String: return StringAsXml(((IEdmStringValue)v).Value); case EdmValueKind.DateTime: return DateTimeAsXml(((IEdmDateTimeValue)v).Value); case EdmValueKind.DateTimeOffset: return DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value); case EdmValueKind.Time: return TimeAsXml(((IEdmTimeValue)v).Value); default: throw new NotSupportedException(Edm.Strings.ValueWriter_NonSerializableValue(v.ValueKind)); } }
public EdmEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value) : base(name) { EdmUtil.CheckArgumentNull<IEdmEnumType>(declaringType, "declaringType"); EdmUtil.CheckArgumentNull<IEdmPrimitiveValue>(value, "value"); this.declaringType = declaringType; this.@value = value; }
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v) { EdmValueKind valueKind = v.ValueKind; switch (valueKind) { case EdmValueKind.Binary: { return EdmValueWriter.BinaryAsXml(((IEdmBinaryValue)v).Value); } case EdmValueKind.Boolean: { return EdmValueWriter.BooleanAsXml(((IEdmBooleanValue)v).Value); } case EdmValueKind.Collection: case EdmValueKind.Enum: case EdmValueKind.Null: case EdmValueKind.Structured: { throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue(v.ValueKind)); } case EdmValueKind.DateTimeOffset: { return EdmValueWriter.DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value); } case EdmValueKind.DateTime: { return EdmValueWriter.DateTimeAsXml(((IEdmDateTimeValue)v).Value); } case EdmValueKind.Decimal: { return EdmValueWriter.DecimalAsXml(((IEdmDecimalValue)v).Value); } case EdmValueKind.Floating: { return EdmValueWriter.FloatAsXml(((IEdmFloatingValue)v).Value); } case EdmValueKind.Guid: { return EdmValueWriter.GuidAsXml(((IEdmGuidValue)v).Value); } case EdmValueKind.Integer: { return EdmValueWriter.LongAsXml(((IEdmIntegerValue)v).Value); } case EdmValueKind.String: { return EdmValueWriter.StringAsXml(((IEdmStringValue)v).Value); } case EdmValueKind.Time: { return EdmValueWriter.TimeAsXml(((IEdmTimeValue)v).Value); } default: { throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue((object)v.ValueKind)); } } }
internal void WriteAnnotationStringElement(IEdmDirectValueAnnotation annotation) { IEdmPrimitiveValue value = (IEdmPrimitiveValue)annotation.Value; if (value != null) { this.xmlWriter.WriteRaw(((IEdmStringValue)value).Value); } }
internal void WriteAnnotationStringAttribute(IEdmDirectValueAnnotation annotation) { IEdmPrimitiveValue value = (IEdmPrimitiveValue)annotation.Value; if (value != null) { this.xmlWriter.WriteAttributeString(annotation.Name, annotation.NamespaceUri, EdmValueWriter.PrimitiveValueAsXml(value)); } }
private object ConvertToClrObject(IEdmPrimitiveValue edmPrimitiveValue) { IEdmIntegerValue integralValue = edmPrimitiveValue as IEdmIntegerValue; if (integralValue != null) { return(integralValue.Value); } throw new NotSupportedException("This method supports only integral types."); }
internal static bool TryCastPrimitiveAsType(this IEdmPrimitiveValue expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (!type.IsPrimitive()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.PrimitiveConstantExpressionNotValidForNonPrimitiveType, Edm.Strings.EdmModel_Validator_Semantic_PrimitiveConstantExpressionNotValidForNonPrimitiveType) }; return(false); } switch (expression.ValueKind) { case EdmValueKind.Binary: return(TryCastBinaryConstantAsType((IEdmBinaryConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Boolean: return(TryCastBooleanConstantAsType((IEdmBooleanConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.DateTimeOffset: return(TryCastDateTimeOffsetConstantAsType((IEdmDateTimeOffsetConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Decimal: return(TryCastDecimalConstantAsType((IEdmDecimalConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Floating: return(TryCastFloatingConstantAsType((IEdmFloatingConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Guid: return(TryCastGuidConstantAsType((IEdmGuidConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Integer: return(TryCastIntegerConstantAsType((IEdmIntegerConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.String: return(TryCastStringConstantAsType((IEdmStringConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Duration: return(TryCastDurationConstantAsType((IEdmDurationConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.Date: return(TryCastDateConstantAsType((IEdmDateConstantExpression)expression, type, out discoveredErrors)); case EdmValueKind.TimeOfDay: return(TryCastTimeOfDayConstantAsType((IEdmTimeOfDayConstantExpression)expression, type, out discoveredErrors)); default: discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) }; return(false); } }
/// <summary> /// Gets the clr value of the edm value based on its type. /// </summary> /// <param name="edmValue">The edm value.</param> /// <returns>The clr value</returns> internal static object ToClrValue(this IEdmPrimitiveValue edmValue) { #if !ASTORIA_CLIENT #endif Debug.Assert(edmValue != null, "edmValue != null"); EdmPrimitiveTypeKind primitiveKind = edmValue.Type.PrimitiveKind(); switch (edmValue.ValueKind) { case EdmValueKind.Binary: return(((IEdmBinaryValue)edmValue).Value); case EdmValueKind.Boolean: return(((IEdmBooleanValue)edmValue).Value); case EdmValueKind.DateTimeOffset: return(((IEdmDateTimeOffsetValue)edmValue).Value); case EdmValueKind.Decimal: return(((IEdmDecimalValue)edmValue).Value); case EdmValueKind.Guid: return(((IEdmGuidValue)edmValue).Value); case EdmValueKind.String: return(((IEdmStringValue)edmValue).Value); case EdmValueKind.Duration: return(((IEdmDurationValue)edmValue).Value); case EdmValueKind.Floating: return(ConvertFloatingValue((IEdmFloatingValue)edmValue, primitiveKind)); case EdmValueKind.Integer: return(ConvertIntegerValue((IEdmIntegerValue)edmValue, primitiveKind)); case EdmValueKind.Date: return(((IEdmDateValue)edmValue).Value); case EdmValueKind.TimeOfDay: return(((IEdmTimeOfDayValue)edmValue).Value); } throw new ODataException(ErrorStrings.EdmValueUtils_CannotConvertTypeToClrValue(edmValue.ValueKind)); }
/// <summary> /// Converts the IEdmPrimitiveValue to a String. /// </summary> /// <param name="v">The value to convert.</param> /// <returns>A string representation of the IEdmPrimitiveValue.</returns> internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v) { switch (v.ValueKind) { case EdmValueKind.Boolean: return(BooleanAsXml(((IEdmBooleanValue)v).Value)); case EdmValueKind.Integer: return(LongAsXml(((IEdmIntegerValue)v).Value)); case EdmValueKind.Floating: return(FloatAsXml(((IEdmFloatingValue)v).Value)); case EdmValueKind.Guid: return(GuidAsXml(((IEdmGuidValue)v).Value)); case EdmValueKind.Binary: return(BinaryAsXml(((IEdmBinaryValue)v).Value)); case EdmValueKind.Decimal: return(DecimalAsXml(((IEdmDecimalValue)v).Value)); case EdmValueKind.String: return(StringAsXml(((IEdmStringValue)v).Value)); case EdmValueKind.DateTimeOffset: return(DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value)); case EdmValueKind.Date: return(DateAsXml(((IEdmDateValue)v).Value)); case EdmValueKind.Duration: return(DurationAsXml(((IEdmDurationValue)v).Value)); case EdmValueKind.TimeOfDay: return(TimeOfDayAsXml(((IEdmTimeOfDayValue)v).Value)); default: return(null); } }
private static void ClrValueShouldMatch <TValue>(IEdmPrimitiveValue edmValue, TValue expected) { edmValue.ToClrValue().Should().Be(expected); }
public EdmEnumMember AddMember(string name, IEdmPrimitiveValue value) { EdmEnumMember edmEnumMember = new EdmEnumMember(this, name, value); this.AddMember(edmEnumMember); return edmEnumMember; }
/// <summary> /// Determines if the type of an expression is compatible with the provided type /// </summary> /// <param name="expression">The expression to assert the type of.</param> /// <param name="type">The type to assert the expression as.</param> /// <param name="context">The context paths are to be evaluated in.</param> /// <param name="matchExactly">A value indicating whether the expression must match the asserted type exactly, or simply be compatible.</param> /// <param name="discoveredErrors">Errors produced if the expression does not match the specified type.</param> /// <returns>A value indicating whether the expression is valid for the given type or not.</returns> /// <remarks>If the expression has an associated type, this function will check that it matches the expected type and stop looking further. /// If an expression claims a type, it must be validated that the type is valid for the expression. If the expression does not claim a type /// this method will attempt to check the validity of the expression itself with the asserted type.</remarks> public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, IEdmType context, bool matchExactly, out IEnumerable <EdmError> discoveredErrors) { EdmUtil.CheckArgumentNull(expression, "expression"); // If we don't have a type to assert this passes vacuously. if (type == null || type.TypeKind() == EdmTypeKind.None) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } switch (expression.ExpressionKind) { case EdmExpressionKind.IntegerConstant: case EdmExpressionKind.StringConstant: case EdmExpressionKind.BinaryConstant: case EdmExpressionKind.BooleanConstant: case EdmExpressionKind.DateTimeConstant: case EdmExpressionKind.DateTimeOffsetConstant: case EdmExpressionKind.DecimalConstant: case EdmExpressionKind.FloatingConstant: case EdmExpressionKind.GuidConstant: case EdmExpressionKind.TimeConstant: IEdmPrimitiveValue primitiveValue = (IEdmPrimitiveValue)expression; if (primitiveValue.Type != null) { return(TestTypeReferenceMatch(primitiveValue.Type, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertPrimitiveAsType(primitiveValue, type, out discoveredErrors)); case EdmExpressionKind.Null: return(TryAssertNullAsType((IEdmNullExpression)expression, type, out discoveredErrors)); case EdmExpressionKind.Path: return(TryAssertPathAsType((IEdmPathExpression)expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.FunctionApplication: IEdmApplyExpression applyExpression = (IEdmApplyExpression)expression; if (applyExpression.AppliedFunction != null) { IEdmFunctionBase function = applyExpression.AppliedFunction as IEdmFunctionBase; if (function != null) { return(TestTypeReferenceMatch(function.ReturnType, type, expression.Location(), matchExactly, out discoveredErrors)); } } // If we don't have the applied function we just assume that it will work. discoveredErrors = Enumerable.Empty <EdmError>(); return(true); case EdmExpressionKind.If: return(TryAssertIfAsType((IEdmIfExpression)expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.IsType: return(TestTypeReferenceMatch(EdmCoreModel.Instance.GetBoolean(false), type, expression.Location(), matchExactly, out discoveredErrors)); case EdmExpressionKind.Record: IEdmRecordExpression recordExpression = (IEdmRecordExpression)expression; if (recordExpression.DeclaredType != null) { return(TestTypeReferenceMatch(recordExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertRecordAsType(recordExpression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.Collection: IEdmCollectionExpression collectionExpression = (IEdmCollectionExpression)expression; if (collectionExpression.DeclaredType != null) { return(TestTypeReferenceMatch(collectionExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertCollectionAsType(collectionExpression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.Labeled: return(TryAssertType(((IEdmLabeledExpression)expression).Expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.AssertType: return(TestTypeReferenceMatch(((IEdmAssertTypeExpression)expression).Type, type, expression.Location(), matchExactly, out discoveredErrors)); case EdmExpressionKind.LabeledExpressionReference: return(TryAssertType(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, type, out discoveredErrors)); default: discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) }; return(false); } }
/// <summary> /// Initializes a new instance of the <see cref="EdmEnumValue"/> class. /// </summary> /// <param name="type">A reference to the enumeration type that describes this value.</param> /// <param name="value">The underlying type value.</param> public EdmEnumValue(IEdmEnumTypeReference type, IEdmPrimitiveValue value) : base(type) { this.value = value; }
private object ConvertToClrObject(IEdmPrimitiveValue edmPrimitiveValue) { IEdmIntegerValue integralValue = edmPrimitiveValue as IEdmIntegerValue; if (integralValue != null) { return integralValue.Value; } throw new NotSupportedException("This method supports only integral types."); }
internal static bool TryAssertPrimitiveAsType(this IEdmPrimitiveValue expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { EdmError[] edmError; if (type.IsPrimitive()) { EdmValueKind valueKind = expression.ValueKind; switch (valueKind) { case EdmValueKind.Binary: { return(ExpressionTypeChecker.TryAssertBinaryConstantAsType((IEdmBinaryConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Boolean: { return(ExpressionTypeChecker.TryAssertBooleanConstantAsType((IEdmBooleanConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Collection: case EdmValueKind.Enum: case EdmValueKind.Null: case EdmValueKind.Structured: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmError; return(false); } case EdmValueKind.DateTimeOffset: { return(ExpressionTypeChecker.TryAssertDateTimeOffsetConstantAsType((IEdmDateTimeOffsetConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.DateTime: { return(ExpressionTypeChecker.TryAssertDateTimeConstantAsType((IEdmDateTimeConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Decimal: { return(ExpressionTypeChecker.TryAssertDecimalConstantAsType((IEdmDecimalConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Floating: { return(ExpressionTypeChecker.TryAssertFloatingConstantAsType((IEdmFloatingConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Guid: { return(ExpressionTypeChecker.TryAssertGuidConstantAsType((IEdmGuidConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Integer: { return(ExpressionTypeChecker.TryAssertIntegerConstantAsType((IEdmIntegerConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.String: { return(ExpressionTypeChecker.TryAssertStringConstantAsType((IEdmStringConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Time: { return(ExpressionTypeChecker.TryAssertTimeConstantAsType((IEdmTimeConstantExpression)expression, type, out discoveredErrors)); } default: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmError; return(false); } } } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.PrimitiveConstantExpressionNotValidForNonPrimitiveType, Strings.EdmModel_Validator_Semantic_PrimitiveConstantExpressionNotValidForNonPrimitiveType); discoveredErrors = edmErrorArray; return(false); } }
public CustomEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value) : base(name) { this.declaringType = declaringType; this.value = value; }
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v) { EdmValueKind valueKind = v.ValueKind; switch (valueKind) { case EdmValueKind.Binary: { return(EdmValueWriter.BinaryAsXml(((IEdmBinaryValue)v).Value)); } case EdmValueKind.Boolean: { return(EdmValueWriter.BooleanAsXml(((IEdmBooleanValue)v).Value)); } case EdmValueKind.Collection: case EdmValueKind.Enum: case EdmValueKind.Null: case EdmValueKind.Structured: { throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue(v.ValueKind)); } case EdmValueKind.DateTimeOffset: { return(EdmValueWriter.DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value)); } case EdmValueKind.DateTime: { return(EdmValueWriter.DateTimeAsXml(((IEdmDateTimeValue)v).Value)); } case EdmValueKind.Decimal: { return(EdmValueWriter.DecimalAsXml(((IEdmDecimalValue)v).Value)); } case EdmValueKind.Floating: { return(EdmValueWriter.FloatAsXml(((IEdmFloatingValue)v).Value)); } case EdmValueKind.Guid: { return(EdmValueWriter.GuidAsXml(((IEdmGuidValue)v).Value)); } case EdmValueKind.Integer: { return(EdmValueWriter.LongAsXml(((IEdmIntegerValue)v).Value)); } case EdmValueKind.String: { return(EdmValueWriter.StringAsXml(((IEdmStringValue)v).Value)); } case EdmValueKind.Time: { return(EdmValueWriter.TimeAsXml(((IEdmTimeValue)v).Value)); } default: { throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue((object)v.ValueKind)); } } }
public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { EdmError[] edmError; EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression"); if (type == null || type.TypeKind() == EdmTypeKind.None) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } else { EdmExpressionKind expressionKind = expression.ExpressionKind; switch (expressionKind) { case EdmExpressionKind.BinaryConstant: case EdmExpressionKind.BooleanConstant: case EdmExpressionKind.DateTimeConstant: case EdmExpressionKind.DateTimeOffsetConstant: case EdmExpressionKind.DecimalConstant: case EdmExpressionKind.FloatingConstant: case EdmExpressionKind.GuidConstant: case EdmExpressionKind.IntegerConstant: case EdmExpressionKind.StringConstant: case EdmExpressionKind.TimeConstant: { IEdmPrimitiveValue edmPrimitiveValue = (IEdmPrimitiveValue)expression; if (edmPrimitiveValue.Type == null) { return(edmPrimitiveValue.TryAssertPrimitiveAsType(type, out discoveredErrors)); } else { return(edmPrimitiveValue.Type.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Null: { return(((IEdmNullExpression)expression).TryAssertNullAsType(type, out discoveredErrors)); } case EdmExpressionKind.Record: { IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression; if (edmRecordExpression.DeclaredType == null) { return(edmRecordExpression.TryAssertRecordAsType(type, out discoveredErrors)); } else { return(edmRecordExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Collection: { IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression; if (edmCollectionExpression.DeclaredType == null) { return(edmCollectionExpression.TryAssertCollectionAsType(type, out discoveredErrors)); } else { return(edmCollectionExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Path: { return(((IEdmPathExpression)expression).TryAssertPathAsType(type, out discoveredErrors)); } case EdmExpressionKind.ParameterReference: case EdmExpressionKind.FunctionReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: case EdmExpressionKind.EnumMemberReference: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return(false); } case EdmExpressionKind.If: { return(((IEdmIfExpression)expression).TryAssertIfAsType(type, out discoveredErrors)); } case EdmExpressionKind.AssertType: { return(((IEdmAssertTypeExpression)expression).Type.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } case EdmExpressionKind.IsType: { return(EdmCoreModel.Instance.GetBoolean(false).TestTypeMatch(type, expression.Location(), out discoveredErrors)); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression; if (edmApplyExpression.AppliedFunction != null) { IEdmFunctionBase appliedFunction = edmApplyExpression.AppliedFunction as IEdmFunctionBase; if (appliedFunction != null) { return(appliedFunction.ReturnType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } case EdmExpressionKind.LabeledExpressionReference: { return(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression.TryAssertType(type, out discoveredErrors)); } case EdmExpressionKind.Labeled: { return(((IEdmLabeledExpression)expression).Expression.TryAssertType(type, out discoveredErrors)); } default: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return(false); } } } }