protected override void ProcessFunctionApplicationExpression(IEdmApplyExpression expression) { bool isFunction = expression.AppliedFunction.ExpressionKind == EdmExpressionKind.FunctionReference; this.BeginElement(expression, e => this.schemaWriter.WriteFunctionApplicationElementHeader(e, isFunction)); if (!isFunction) { this.VisitExpression(expression.AppliedFunction); } this.VisitExpressions(expression.Arguments); this.EndElement(expression); }
protected override void ProcessFunctionApplicationExpression(IEdmApplyExpression expression) { this.BeginElement(expression, e => this.schemaWriter.WriteFunctionApplicationElementHeader(e)); this.VisitExpressions(expression.Arguments); this.EndElement(expression, e => this.schemaWriter.WriteFunctionApplicationElementEnd(e)); }
internal override void WriteFunctionApplicationElementEnd(IEdmApplyExpression expression) { this.WriteEndElement(); }
internal override void WriteFunctionApplicationElementHeader(IEdmApplyExpression expression) { this.xmlWriter.WriteStartElement(CsdlConstants.Element_Apply); this.WriteRequiredAttribute(CsdlConstants.Attribute_Function, expression.AppliedFunction, this.FunctionAsXml); }
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context) { switch (expression.ExpressionKind) { case EdmExpressionKind.IntegerConstant: return((IEdmIntegerConstantExpression)expression); case EdmExpressionKind.StringConstant: return((IEdmStringConstantExpression)expression); case EdmExpressionKind.BinaryConstant: return((IEdmBinaryConstantExpression)expression); case EdmExpressionKind.BooleanConstant: return((IEdmBooleanConstantExpression)expression); case EdmExpressionKind.DateTimeOffsetConstant: return((IEdmDateTimeOffsetConstantExpression)expression); case EdmExpressionKind.DecimalConstant: return((IEdmDecimalConstantExpression)expression); case EdmExpressionKind.FloatingConstant: return((IEdmFloatingConstantExpression)expression); case EdmExpressionKind.GuidConstant: return((IEdmGuidConstantExpression)expression); case EdmExpressionKind.DurationConstant: return((IEdmDurationConstantExpression)expression); case EdmExpressionKind.DateConstant: return((IEdmDateConstantExpression)expression); case EdmExpressionKind.TimeOfDayConstant: return((IEdmTimeOfDayConstantExpression)expression); case EdmExpressionKind.Null: return((IEdmNullExpression)expression); case EdmExpressionKind.Path: { if (context == null) { throw new InvalidOperationException(Strings.Edm_Evaluator_NoContextPath); } IEdmPathExpression pathExpression = (IEdmPathExpression)expression; IEdmValue result = context; #if NET35 // [EdmLib] Need to handle paths that bind to things other than properties. foreach (string hop in pathExpression.PathSegments) { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop)); } } #else // Only Support Annotation in EntityType or ComplexType or Property or NavigationProperty. // Empty Path is not supported. foreach (string hop in pathExpression.PathSegments) { if (hop.Contains("@")) { var currentPathSegementInfos = hop.Split('@'); var propertyName = currentPathSegementInfos[0]; var termInfo = currentPathSegementInfos[1]; IEdmExpression termCastExpression = null; if (!Utils.StringIsNullOrWhitespace(termInfo)) { var termInfos = termInfo.Split('#'); if (termInfos.Length <= 2) { string termName = termInfos[0]; string qualifier = termInfos.Length == 2 ? termInfos[1] : null; if (Utils.StringIsNullOrWhitespace(propertyName) && this.getAnnotationExpressionForType != null) { termCastExpression = this.getAnnotationExpressionForType(this.edmModel, context.Type.Definition, termName, qualifier); } else if (!Utils.StringIsNullOrWhitespace(propertyName) && this.getAnnotationExpressionForProperty != null) { termCastExpression = this.getAnnotationExpressionForProperty(this.edmModel, context.Type.Definition, propertyName, termName, qualifier); } } } if (termCastExpression == null) { result = null; break; } result = this.Eval(termCastExpression, context); } else if (hop == "$count") { var edmCollectionValue = result as IEdmCollectionValue; if (edmCollectionValue != null) { result = new EdmIntegerConstant(edmCollectionValue.Elements.Count()); } else { result = null; break; } } else if (hop.Contains(".")) { if (this.edmModel == null) { throw new InvalidOperationException(Strings.Edm_Evaluator_TypeCastNeedsEdmModel); } IEdmType typeSegmentClientType = this.resolveTypeFromName(hop, this.edmModel); if (typeSegmentClientType == null) { result = null; break; } IEdmTypeReference operandType = result.Type; EdmValueKind operandKind = result.ValueKind; if (operandKind == EdmValueKind.Collection) { List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>(); var collection = result as IEdmCollectionValue; foreach (IEdmDelayedValue element in collection.Elements) { if (element.Value.Type.Definition.IsOrInheritsFrom(typeSegmentClientType)) { elementValues.Add(element); } } result = new EdmCollectionValue( new EdmCollectionTypeReference(new EdmCollectionType(typeSegmentClientType.GetTypeReference(false))), elementValues); } else if (operandKind != EdmValueKind.Structured || (operandKind == EdmValueKind.Structured && !operandType.Definition.IsOrInheritsFrom(typeSegmentClientType))) { result = null; break; } } else { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop)); } } } #endif return(result); } case EdmExpressionKind.PropertyPath: case EdmExpressionKind.NavigationPropertyPath: { EdmUtil.CheckArgumentNull(context, "context"); IEdmPathExpression pathExpression = (IEdmPathExpression)expression; IEdmValue result = context; // [EdmLib] Need to handle paths that bind to things other than properties. foreach (string hop in pathExpression.PathSegments) { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop)); } } return(result); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression apply = (IEdmApplyExpression)expression; IEdmFunction target = apply.AppliedFunction; if (target != null) { IList <IEdmExpression> argumentExpressions = apply.Arguments.ToList(); IEdmValue[] arguments = new IEdmValue[argumentExpressions.Count()]; { int argumentIndex = 0; foreach (IEdmExpression argument in argumentExpressions) { arguments[argumentIndex++] = this.Eval(argument, context); } } //// Static validation will have checked that the number and types of arguments are correct, //// so those checks are not performed dynamically. Func <IEdmValue[], IEdmValue> operationEvaluator; if (this.builtInFunctions.TryGetValue(target, out operationEvaluator)) { return(operationEvaluator(arguments)); } if (this.lastChanceOperationApplier != null) { return(this.lastChanceOperationApplier(target.FullName(), arguments)); } } throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundFunction(target != null ? target.ToTraceString() : string.Empty)); } case EdmExpressionKind.If: { IEdmIfExpression ifExpression = (IEdmIfExpression)expression; if (((IEdmBooleanValue)this.Eval(ifExpression.TestExpression, context)).Value) { return(this.Eval(ifExpression.TrueExpression, context)); } return(this.Eval(ifExpression.FalseExpression, context)); } case EdmExpressionKind.IsType: { IEdmIsTypeExpression isType = (IEdmIsTypeExpression)expression; IEdmValue operand = this.Eval(isType.Operand, context); IEdmTypeReference targetType = isType.Type; return(new EdmBooleanConstant(MatchesType(targetType, operand))); } case EdmExpressionKind.Cast: { IEdmCastExpression castType = (IEdmCastExpression)expression; IEdmValue operand = this.Eval(castType.Operand, context); IEdmTypeReference targetType = castType.Type; return(Cast(targetType, operand)); } case EdmExpressionKind.Record: { IEdmRecordExpression record = (IEdmRecordExpression)expression; DelayedExpressionContext recordContext = new DelayedExpressionContext(this, context); List <IEdmPropertyValue> propertyValues = new List <IEdmPropertyValue>(); //// Static validation will have checked that the set of supplied properties are appropriate //// for the supplied type and have no duplicates, so those checks are not performed dynamically. foreach (IEdmPropertyConstructor propertyConstructor in record.Properties) { propertyValues.Add(new DelayedRecordProperty(recordContext, propertyConstructor)); } EdmStructuredValue result = new EdmStructuredValue(record.DeclaredType != null ? record.DeclaredType.AsStructured() : null, propertyValues); return(result); } case EdmExpressionKind.Collection: { IEdmCollectionExpression collection = (IEdmCollectionExpression)expression; DelayedExpressionContext collectionContext = new DelayedExpressionContext(this, context); List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>(); //// Static validation will have checked that the result types of the element expressions are //// appropriate and so these checks are not performed dynamically. foreach (IEdmExpression element in collection.Elements) { elementValues.Add(this.MapLabeledExpressionToDelayedValue(element, collectionContext, context)); } EdmCollectionValue result = new EdmCollectionValue(collection.DeclaredType != null ? collection.DeclaredType.AsCollection() : null, elementValues); return(result); } case EdmExpressionKind.LabeledExpressionReference: { return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value); } case EdmExpressionKind.Labeled: return(this.MapLabeledExpressionToDelayedValue(expression, new DelayedExpressionContext(this, context), context).Value); case EdmExpressionKind.EnumMember: IEdmEnumMemberExpression enumMemberExpression = (IEdmEnumMemberExpression)expression; var enumMembers = enumMemberExpression.EnumMembers.ToList(); IEdmEnumType enumType = enumMembers.First().DeclaringType; IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, false); if (enumMembers.Count() == 1) { return(new EdmEnumValue(enumTypeReference, enumMemberExpression.EnumMembers.Single())); } else { if (!enumType.IsFlags || !EdmEnumValueParser.IsEnumIntegerType(enumType)) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Type {0} cannot be assigned with multi-values.", enumType.FullName())); } long result = 0; foreach (var enumMember in enumMembers) { long value = enumMember.Value.Value; result |= value; } return(new EdmEnumValue(enumTypeReference, new EdmEnumMemberValue(result))); } default: throw new InvalidOperationException(Strings.Edm_Evaluator_UnrecognizedExpressionKind(((int)expression.ExpressionKind).ToString(System.Globalization.CultureInfo.InvariantCulture))); } }
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context) { switch (expression.ExpressionKind) { case EdmExpressionKind.IntegerConstant: return((IEdmIntegerConstantExpression)expression); case EdmExpressionKind.StringConstant: return((IEdmStringConstantExpression)expression); case EdmExpressionKind.BinaryConstant: return((IEdmBinaryConstantExpression)expression); case EdmExpressionKind.BooleanConstant: return((IEdmBooleanConstantExpression)expression); case EdmExpressionKind.DateTimeConstant: return((IEdmDateTimeConstantExpression)expression); case EdmExpressionKind.DateTimeOffsetConstant: return((IEdmDateTimeOffsetConstantExpression)expression); case EdmExpressionKind.DecimalConstant: return((IEdmDecimalConstantExpression)expression); case EdmExpressionKind.FloatingConstant: return((IEdmFloatingConstantExpression)expression); case EdmExpressionKind.GuidConstant: return((IEdmGuidConstantExpression)expression); case EdmExpressionKind.TimeConstant: return((IEdmTimeConstantExpression)expression); case EdmExpressionKind.Null: return((IEdmNullExpression)expression); case EdmExpressionKind.Path: { EdmUtil.CheckArgumentNull(context, "context"); IEdmPathExpression pathExpression = (IEdmPathExpression)expression; IEdmValue result = context; foreach (string hop in pathExpression.Path) { result = this.FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundPath(hop)); } } return(result); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression apply = (IEdmApplyExpression)expression; IEdmExpression targetReference = apply.AppliedFunction; IEdmFunctionReferenceExpression targetFunctionReference = targetReference as IEdmFunctionReferenceExpression; if (targetFunctionReference != null) { IList <IEdmExpression> argumentExpressions = apply.Arguments.ToList(); IEdmValue[] arguments = new IEdmValue[argumentExpressions.Count()]; { int argumentIndex = 0; foreach (IEdmExpression argument in argumentExpressions) { arguments[argumentIndex++] = this.Eval(argument, context); } } IEdmFunction target = targetFunctionReference.ReferencedFunction; if (!target.IsBad()) { //// Static validation will have checked that the number and types of arguments are correct, //// so those checks are not performed dynamically. Func <IEdmValue[], IEdmValue> functionEvaluator; if (this.builtInFunctions.TryGetValue(target, out functionEvaluator)) { return(functionEvaluator(arguments)); } } if (this.lastChanceFunctionApplier != null) { return(this.lastChanceFunctionApplier(target.FullName(), arguments)); } } throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundFunction(targetFunctionReference != null ? targetFunctionReference.ReferencedFunction.ToTraceString() : string.Empty)); } case EdmExpressionKind.If: { IEdmIfExpression ifExpression = (IEdmIfExpression)expression; if (((IEdmBooleanValue)this.Eval(ifExpression.TestExpression, context)).Value) { return(this.Eval(ifExpression.TrueExpression, context)); } return(this.Eval(ifExpression.FalseExpression, context)); } case EdmExpressionKind.IsType: { IEdmIsTypeExpression isType = (IEdmIsTypeExpression)expression; IEdmValue operand = this.Eval(isType.Operand, context); IEdmTypeReference targetType = isType.Type; return(new EdmBooleanConstant(MatchesType(targetType, operand))); } case EdmExpressionKind.AssertType: { IEdmAssertTypeExpression assertType = (IEdmAssertTypeExpression)expression; IEdmValue operand = this.Eval(assertType.Operand, context); IEdmTypeReference targetType = assertType.Type; return(AssertType(targetType, operand)); } case EdmExpressionKind.Record: { IEdmRecordExpression record = (IEdmRecordExpression)expression; DelayedExpressionContext recordContext = new DelayedExpressionContext(this, context); List <IEdmPropertyValue> propertyValues = new List <IEdmPropertyValue>(); //// Static validation will have checked that the set of supplied properties are appropriate //// for the supplied type and have no duplicates, so those checks are not performed dynamically. foreach (IEdmPropertyConstructor propertyConstructor in record.Properties) { propertyValues.Add(new DelayedRecordProperty(recordContext, propertyConstructor)); } EdmStructuredValue result = new EdmStructuredValue(record.DeclaredType != null ? record.DeclaredType.AsStructured() : null, propertyValues); return(result); } case EdmExpressionKind.Collection: { IEdmCollectionExpression collection = (IEdmCollectionExpression)expression; DelayedExpressionContext collectionContext = new DelayedExpressionContext(this, context); List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>(); //// Static validation will have checked that the result types of the element expressions are //// appropriate and so these checks are not performed dynamically. foreach (IEdmExpression element in collection.Elements) { elementValues.Add(this.MapLabeledExpressionToDelayedValue(element, collectionContext, context)); } EdmCollectionValue result = new EdmCollectionValue(collection.DeclaredType != null ? collection.DeclaredType.AsCollection() : null, elementValues); return(result); } case EdmExpressionKind.LabeledExpressionReference: { return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value); } case EdmExpressionKind.Labeled: return(this.MapLabeledExpressionToDelayedValue(expression, new DelayedExpressionContext(this, context), context).Value); case EdmExpressionKind.ParameterReference: case EdmExpressionKind.FunctionReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: case EdmExpressionKind.EnumMemberReference: throw new InvalidOperationException("Not yet implemented: evaluation of " + expression.ExpressionKind.ToString() + " expressions."); default: throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnrecognizedExpressionKind(((int)expression.ExpressionKind).ToString(System.Globalization.CultureInfo.InvariantCulture))); } }
/// <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); } }
protected virtual void ProcessFunctionApplicationExpression(IEdmApplyExpression expression) { this.ProcessExpression(expression); this.VisitExpressions(expression.Arguments); }
internal abstract void WriteFunctionApplicationElementEnd(IEdmApplyExpression expression);
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); } } } }
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context) { Func <IEdmValue[], IEdmValue> func = null; IEdmStructuredTypeReference edmStructuredTypeReference; IEdmCollectionTypeReference edmCollectionTypeReference; object traceString; EdmExpressionKind expressionKind = expression.ExpressionKind; switch (expressionKind) { case EdmExpressionKind.BinaryConstant: { return((IEdmBinaryConstantExpression)expression); } case EdmExpressionKind.BooleanConstant: { return((IEdmBooleanConstantExpression)expression); } case EdmExpressionKind.DateTimeConstant: { return((IEdmDateTimeConstantExpression)expression); } case EdmExpressionKind.DateTimeOffsetConstant: { return((IEdmDateTimeOffsetConstantExpression)expression); } case EdmExpressionKind.DecimalConstant: { return((IEdmDecimalConstantExpression)expression); } case EdmExpressionKind.FloatingConstant: { return((IEdmFloatingConstantExpression)expression); } case EdmExpressionKind.GuidConstant: { return((IEdmGuidConstantExpression)expression); } case EdmExpressionKind.IntegerConstant: { return((IEdmIntegerConstantExpression)expression); } case EdmExpressionKind.StringConstant: { return((IEdmStringConstantExpression)expression); } case EdmExpressionKind.TimeConstant: { return((IEdmTimeConstantExpression)expression); } case EdmExpressionKind.Null: { return((IEdmNullExpression)expression); } case EdmExpressionKind.Record: { IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression; EdmExpressionEvaluator.DelayedExpressionContext delayedExpressionContext = new EdmExpressionEvaluator.DelayedExpressionContext(this, context); List <IEdmPropertyValue> edmPropertyValues = new List <IEdmPropertyValue>(); foreach (IEdmPropertyConstructor property in edmRecordExpression.Properties) { edmPropertyValues.Add(new EdmExpressionEvaluator.DelayedRecordProperty(delayedExpressionContext, property)); } if (edmRecordExpression.DeclaredType != null) { edmStructuredTypeReference = edmRecordExpression.DeclaredType.AsStructured(); } else { edmStructuredTypeReference = null; } EdmStructuredValue edmStructuredValue = new EdmStructuredValue(edmStructuredTypeReference, edmPropertyValues); return(edmStructuredValue); } case EdmExpressionKind.Collection: { IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression; EdmExpressionEvaluator.DelayedExpressionContext delayedExpressionContext1 = new EdmExpressionEvaluator.DelayedExpressionContext(this, context); List <IEdmDelayedValue> edmDelayedValues = new List <IEdmDelayedValue>(); foreach (IEdmExpression element in edmCollectionExpression.Elements) { edmDelayedValues.Add(this.MapLabeledExpressionToDelayedValue(element, delayedExpressionContext1, context)); } if (edmCollectionExpression.DeclaredType != null) { edmCollectionTypeReference = edmCollectionExpression.DeclaredType.AsCollection(); } else { edmCollectionTypeReference = null; } EdmCollectionValue edmCollectionValue = new EdmCollectionValue(edmCollectionTypeReference, edmDelayedValues); return(edmCollectionValue); } case EdmExpressionKind.Path: { EdmUtil.CheckArgumentNull <IEdmStructuredValue>(context, "context"); IEdmPathExpression edmPathExpression = (IEdmPathExpression)expression; IEdmValue edmValue = context; foreach (string path in edmPathExpression.Path) { edmValue = this.FindProperty(path, edmValue); if (edmValue != null) { continue; } throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(path)); } return(edmValue); } case EdmExpressionKind.ParameterReference: case EdmExpressionKind.FunctionReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: case EdmExpressionKind.EnumMemberReference: { throw new InvalidOperationException(string.Concat("Not yet implemented: evaluation of ", expression.ExpressionKind.ToString(), " expressions.")); } case EdmExpressionKind.If: { IEdmIfExpression edmIfExpression = (IEdmIfExpression)expression; if (!((IEdmBooleanValue)this.Eval(edmIfExpression.TestExpression, context)).Value) { return(this.Eval(edmIfExpression.FalseExpression, context)); } else { return(this.Eval(edmIfExpression.TrueExpression, context)); } } case EdmExpressionKind.AssertType: { IEdmAssertTypeExpression edmAssertTypeExpression = (IEdmAssertTypeExpression)expression; IEdmValue edmValue1 = this.Eval(edmAssertTypeExpression.Operand, context); IEdmTypeReference type = edmAssertTypeExpression.Type; return(EdmExpressionEvaluator.AssertType(type, edmValue1)); } case EdmExpressionKind.IsType: { IEdmIsTypeExpression edmIsTypeExpression = (IEdmIsTypeExpression)expression; IEdmValue edmValue2 = this.Eval(edmIsTypeExpression.Operand, context); IEdmTypeReference edmTypeReference = edmIsTypeExpression.Type; return(new EdmBooleanConstant(EdmExpressionEvaluator.MatchesType(edmTypeReference, edmValue2))); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression; IEdmExpression appliedFunction = edmApplyExpression.AppliedFunction; IEdmFunctionReferenceExpression edmFunctionReferenceExpression = appliedFunction as IEdmFunctionReferenceExpression; if (edmFunctionReferenceExpression != null) { IList <IEdmExpression> list = edmApplyExpression.Arguments.ToList <IEdmExpression>(); IEdmValue[] edmValueArray = new IEdmValue[list.Count <IEdmExpression>()]; int num = 0; foreach (IEdmExpression edmExpression in list) { int num1 = num; num = num1 + 1; edmValueArray[num1] = this.Eval(edmExpression, context); } IEdmFunction referencedFunction = edmFunctionReferenceExpression.ReferencedFunction; if (referencedFunction.IsBad() || !this.builtInFunctions.TryGetValue(referencedFunction, out func)) { if (this.lastChanceFunctionApplier != null) { return(this.lastChanceFunctionApplier(referencedFunction.FullName(), edmValueArray)); } } else { return(func(edmValueArray)); } } if (edmFunctionReferenceExpression != null) { traceString = edmFunctionReferenceExpression.ReferencedFunction.ToTraceString(); } else { traceString = string.Empty; } throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundFunction(traceString)); } case EdmExpressionKind.LabeledExpressionReference: { return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value); } case EdmExpressionKind.Labeled: { return(this.MapLabeledExpressionToDelayedValue(expression, new EdmExpressionEvaluator.DelayedExpressionContext(this, context), context).Value); } } int expressionKind1 = (int)expression.ExpressionKind; throw new InvalidOperationException(Strings.Edm_Evaluator_UnrecognizedExpressionKind(expressionKind1.ToString(CultureInfo.InvariantCulture))); }