private CsdlPropertyValue OnPropertyValueElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string property = Required(CsdlConstants.Attribute_Property);
CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);
return(new CsdlPropertyValue(property, expression, element.Location));
}
private IEdmExpression ComputeValue()
{
IEdmTypeReference termType = Term is UnresolvedVocabularyTerm ? null : Term.Type;
CsdlExpressionBase adjustedExpression = AdjustStringConstantUsingTermType((this.Annotation).Expression, termType);
return(CsdlSemanticsModel.WrapExpression(adjustedExpression, TargetBindingContext, this.Schema));
}
public CsdlAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
: base(location)
{
this.expression = expression;
this.qualifier = qualifier;
this.term = term;
}
/// <summary>
/// Parse the IsOf expression using <see cref="JsonElement"/>.
/// </summary>
/// <param name="element">The input JSON element.</param>
/// <param name="context">The parser context.</param>
/// <param name="isOfExp">The built IsOf expression.</param>
/// <returns>true/false</returns>
private static bool BuildIsOfExpression(JsonElement element, JsonParserContext context, out CsdlIsTypeExpression isOfExp)
{
Debug.Assert(context != null);
isOfExp = null;
// Is-of expressions are represented as an object with a member $IsOf whose value is an annotation expression,
JsonElement propertyValue;
if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$IsOf", out propertyValue))
{
return(false);
}
// whose value is an annotation expression,
CsdlExpressionBase expression = propertyValue.ProcessProperty("$IsOf", context, ParseExpression);
// a member $Type whose value is a string containing an qualified type name, and optionally a member $Collection with a value of true.
// If the specified type is a primitive type or a collection of primitive types,
// the facet members $MaxLength, $Unicode, $Precision, $Scale, and $SRID MAY be specified if applicable to the specified primitive type.
// If the facet members are not specified, their values are considered unspecified.
CsdlTypeReference typeReference = CsdlJsonParseHelper.ParseCsdlTypeReference(element, context);
isOfExp = new CsdlIsTypeExpression(typeReference, expression, context.Location());
return(true);
}
public CsdlAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
: base(location)
{
this.expression = expression;
this.qualifier = qualifier;
this.term = term;
}
public CsdlIfExpression(CsdlExpressionBase test, CsdlExpressionBase ifTrue, CsdlExpressionBase ifFalse, CsdlLocation location)
: base(location)
{
this.test = test;
this.ifTrue = ifTrue;
this.ifFalse = ifFalse;
}
public void ParseIfExpressionWorksAsExpected()
{
string json = @" {
""$If"": [
{
""$Path"": ""IsFemale""
},
""Female"",
""Male""
]
}";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlIfExpression ifExp = Assert.IsType <CsdlIfExpression>(expressionBase);
Assert.NotNull(ifExp.Test);
CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(ifExp.Test);
Assert.Equal("IsFemale", pathExp.Path);
Assert.NotNull(ifExp.IfTrue);
CsdlConstantExpression trueExp = Assert.IsType <CsdlConstantExpression>(ifExp.IfTrue);
Assert.Equal(EdmValueKind.String, trueExp.ValueKind);
Assert.Equal("Female", trueExp.Value);
Assert.NotNull(ifExp.IfFalse);
CsdlConstantExpression falseExp = Assert.IsType <CsdlConstantExpression>(ifExp.IfFalse);
Assert.Equal(EdmValueKind.String, falseExp.ValueKind);
Assert.Equal("Male", falseExp.Value);
}
public void ParseCastExpressionWorksAsExpected()
{
string json = @" {
""$Cast"": {
""$Path"": ""Average""
},
""$Type"": ""Edm.Decimal"",
""$Precision"": 42
}";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlCastExpression castExp = Assert.IsType <CsdlCastExpression>(expressionBase);
Assert.NotNull(castExp.Operand);
CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(castExp.Operand);
Assert.Equal("Average", pathExp.Path);
Assert.NotNull(castExp.Type);
CsdlDecimalTypeReference decimalType = Assert.IsType <CsdlDecimalTypeReference>(castExp.Type);
Assert.NotNull(decimalType.Precision);
Assert.Equal(42, decimalType.Precision.Value);
Assert.Null(decimalType.Scale);
}
/// <summary>
/// Parse the If expression using <see cref="JsonElement"/>.
/// </summary>
/// <param name="element">The input JSON element.</param>
/// <param name="context">The parser context.</param>
/// <param name="ifExp">The built if expression.</param>
/// <returns>true/false</returns>
private static bool TryParseIfExpression(JsonElement element, JsonParserContext context, out CsdlIfExpression ifExp)
{
Debug.Assert(context != null);
ifExp = null;
// Conditional expressions are represented as an object with a member $If whose value is an array of two or three annotation expressions.
JsonElement propertyValue;
if (element.ValueKind != JsonValueKind.Object ||
!element.TryGetProperty("$If", out propertyValue) ||
propertyValue.ValueKind != JsonValueKind.Array)
{
return(false);
}
// first child is the test
CsdlExpressionBase testExpression = propertyValue.ProcessItem(0, context, ParseExpression);
// the second child is ture clause
CsdlExpressionBase trueExpression = propertyValue.ProcessItem(1, context, ParseExpression);
// the third child is false clause
CsdlExpressionBase falseExpression = null;
if (propertyValue.GetArrayLength() >= 3)
{
// if and only if the if-then-else expression is an item of a collection expression,
// the third child expression MAY be omitted, reducing it to an if-then expression.
falseExpression = propertyValue.ProcessItem(2, context, ParseExpression);
}
ifExp = new CsdlIfExpression(testExpression, trueExpression, falseExpression, context.Location());
return(true);
}
public CsdlIfExpression(CsdlExpressionBase test, CsdlExpressionBase ifTrue, CsdlExpressionBase ifFalse, CsdlLocation location)
: base(location)
{
this.test = test;
this.ifTrue = ifTrue;
this.ifFalse = ifFalse;
}
public CsdlSemanticsLabeledExpression(string name, CsdlExpressionBase element, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(element)
{
this.name = name;
this.sourceElement = element;
this.bindingContext = bindingContext;
this.schema = schema;
}
private CsdlAnnotation OnAnnotationElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string term = RequiredQualifiedName(CsdlConstants.Attribute_Term);
string qualifier = Optional(CsdlConstants.Attribute_Qualifier);
CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);
return(new CsdlAnnotation(term, qualifier, expression, element.Location));
}
public void ParseRecordExpressionWorksAsExpected()
{
string json = @" {
""@type"": ""org.example.person.Manager"",
""@Core.Description"": ""Annotation on record"",
""GivenName"": {
""$Path"": ""FirstName""
},
""*****@*****.**"": ""Annotation on record member"",
""Surname"": {
""$Path"": ""LastName""
},
""DirectSupervisor"": {
""$Path"": ""Manager""
},
""CostCenter"": ""CostCenter Value""
}";
CsdlExpressionBase expressionBase = ParseExpression(json, out JsonParserContext context);
Assert.NotEmpty(context.Errors);
Assert.Equal(2, context.Errors.Count);
Assert.Equal("A member at JSON path '[email protected]' is not supported.", context.Errors.First().ErrorMessage);
Assert.Equal("A member at JSON path '[email protected]' is not supported.", context.Errors.Last().ErrorMessage);
Assert.NotNull(expressionBase);
CsdlRecordExpression recordExp = Assert.IsType <CsdlRecordExpression>(expressionBase);
Assert.NotNull(recordExp.Type);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(recordExp.Type);
Assert.Equal("org.example.person.Manager", namedType.FullName);
Assert.NotNull(recordExp.PropertyValues);
Assert.Equal(4, recordExp.PropertyValues.Count());
// GivenName
CsdlPropertyValue propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "GivenName");
Assert.NotNull(propertyValue);
Assert.IsType <CsdlPathExpression>(propertyValue.Expression);
// Surname
propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "Surname");
Assert.NotNull(propertyValue);
Assert.IsType <CsdlPathExpression>(propertyValue.Expression);
// DirectSupervisor
propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "DirectSupervisor");
Assert.NotNull(propertyValue);
Assert.IsType <CsdlPathExpression>(propertyValue.Expression);
// DirectSupervisor
propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "CostCenter");
Assert.NotNull(propertyValue);
Assert.IsType <CsdlConstantExpression>(propertyValue.Expression);
}
[InlineData("1.7976931348623157E+308", EdmValueKind.Floating, "1.7976931348623157E+308")] // double.MaxValue
public void ParseConstantExpressionWorksAsExpected(string json, EdmValueKind kind, string expected)
{
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlConstantExpression constExp = Assert.IsType <CsdlConstantExpression>(expressionBase);
Assert.Equal(kind, constExp.ValueKind);
Assert.Equal(expected, constExp.Value);
}
private static CsdlExpressionBase AdjustStringConstantUsingTermType(CsdlExpressionBase expression, IEdmTypeReference termType)
{
if (expression == null || termType == null)
{
return(expression);
}
switch (expression.ExpressionKind)
{
case EdmExpressionKind.Collection:
if (termType.IsCollection())
{
IEdmTypeReference elementType = termType.AsCollection().ElementType();
IList <CsdlExpressionBase> newElements = new List <CsdlExpressionBase>();
CsdlCollectionExpression collectionExp = (CsdlCollectionExpression)expression;
foreach (CsdlExpressionBase exp in collectionExp.ElementValues)
{
if (exp != null && exp.ExpressionKind == EdmExpressionKind.StringConstant)
{
newElements.Add(AdjustStringConstantUsingTermType(exp, elementType));
}
else
{
newElements.Add(exp);
}
}
return(new CsdlCollectionExpression(collectionExp.Type, newElements, collectionExp.Location as CsdlLocation));
}
break;
case EdmExpressionKind.StringConstant:
CsdlConstantExpression constantExp = (CsdlConstantExpression)expression;
switch (termType.TypeKind())
{
case EdmTypeKind.Primitive:
IEdmPrimitiveTypeReference primitiveTypeReference = (IEdmPrimitiveTypeReference)termType;
return(BuildPrimitiveExpression(primitiveTypeReference, constantExp));
case EdmTypeKind.Path:
IEdmPathType pathType = (IEdmPathType)termType.Definition;
return(BuildPathExpression(pathType, constantExp));
case EdmTypeKind.Enum:
IEdmEnumType enumType = (IEdmEnumType)termType.Definition;
return(BuildEnumExpression(enumType, constantExp));
}
break;
}
return(expression);
}
public void ParseValuePathExpressionWorksAsExpected()
{
string json = @" { ""$Path"": ""@vCard.Address#work/FullName"" }";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(expressionBase);
Assert.Equal("@vCard.Address#work/FullName", pathExp.Path);
}
public void ParseLabeledElementReferenceExpressionWorksAsExpected()
{
string json = @" { ""$LabeledElementReference"": ""self.CustomerFirstName"" }";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlLabeledExpressionReferenceExpression labeledRefExp = Assert.IsType <CsdlLabeledExpressionReferenceExpression>(expressionBase);
Assert.Equal("self.CustomerFirstName", labeledRefExp.Label);
}
/// <summary>
/// Parse the record expression expression using <see cref="JsonElement"/>.
/// </summary>
/// <param name="element">The input JSON element.</param>
/// <param name="context">The parser context.</param>
/// <returns>the built record expression.</returns>
private static CsdlRecordExpression ParseRecordExpression(JsonElement element, JsonParserContext context)
{
Debug.Assert(context != null);
// A record expression MAY specify the structured type of its result, which MUST be an entity type or complex type in scope.
// If not explicitly specified, the type is derived from the expression’s context
// The type of a record expression is represented as the @type control information
// for example: "@type": "https://example.org/vocabs/person#org.example.person.Manager",
// So far, ODL doesn't support the type "@type" with relative path, only supports like "#Model.VipCustomer", or without #
// for 4.0, this name MUST be prefixed with the hash symbol (#);
// or non-OData 4.0 payloads, built-in primitive type values SHOULD be represented without the hash symbol,
// but consumers of 4.01 or greater payloads MUST support values with or without the hash symbol.
CsdlTypeReference typeReference = null;
if (element.TryGetProperty("@type", out JsonElement typeValue))
{
// Try to build the type. The type should be "Complex type" or "Entity Type".
string typeName = typeValue.ProcessProperty("@type", context, (e, c) => e.ParseAsString(c));
int index = typeName.IndexOf('#');
if (index >= 0)
{
typeName = typeName.Substring(index + 1); // remove the "#"
}
typeReference = new CsdlNamedTypeReference(typeName, true, context.Location());
}
IList <CsdlPropertyValue> propertyValues = new List <CsdlPropertyValue>();
element.ParseAsObject(context, (propertyName, propertyValue) =>
{
// skips the @type, because it's processed above.
if (propertyName == "@type")
{
return;
}
// It MAY contain annotations for itself and its members. Annotations for record members are prefixed with the member name.
// So far, it's not supported. So report non-fatal error for all the annotations on record.
if (propertyName.IndexOf('@') != -1)
{
context.ReportError(EdmErrorCode.UnsupportedElement, Strings.CsdlJsonParser_UnsupportedJsonMember(context.Path));
return;
}
CsdlExpressionBase propertyValueExpression = ParseExpression(propertyValue, context);
propertyValues.Add(new CsdlPropertyValue(propertyName, propertyValueExpression, context.Location()));
});
return(new CsdlRecordExpression(typeReference, propertyValues, context.Location()));
}
public void ParseLabeledElementExpressionWorksAsExpected()
{
string json = @" { ""$LabeledElement"": {
""$Path"": ""FirstName""
},
""$Name"": ""CustomerFirstName""
}";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlLabeledExpression labeledExp = Assert.IsType <CsdlLabeledExpression>(expressionBase);
Assert.Equal("CustomerFirstName", labeledExp.Label);
Assert.NotNull(labeledExp.Element);
Assert.IsType <CsdlPathExpression>(labeledExp.Element);
}
public void ParseCollectionExpressionWorksAsExpected()
{
string json = @" [
""Product"",
""Supplier"",
""Customer""
]";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlCollectionExpression collectionExp = Assert.IsType <CsdlCollectionExpression>(expressionBase);
Assert.Equal(3, collectionExp.ElementValues.Count());
Assert.Equal(new[] { "Product", "Supplier", "Customer" },
collectionExp.ElementValues.Select(e => ((CsdlConstantExpression)e).Value));
}
/// <summary>
/// Parse the Labeled Element expression using <see cref="JsonElement"/>.
/// </summary>
/// <param name="element">The input JSON element.</param>
/// <param name="context">The parser context.</param>
/// <param name="labeledExp">The built labeled element expression.</param>
/// <returns>true/false</returns>
private static bool TryParseLabeledElementExpression(JsonElement element, JsonParserContext context, out CsdlLabeledExpression labeledExp)
{
Debug.Assert(context != null);
labeledExp = null;
// Labeled element expressions are represented as an object with a member $LabeledElement whose value is an annotation expression
JsonElement propertyValue;
if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$LabeledElement", out propertyValue))
{
return(false);
}
CsdlExpressionBase expression = propertyValue.ProcessProperty("$LabeledElement", context, ParseExpression);
// a member $Name whose value is a string containing the labeled element’s name.
string label = element.ProcessRequiredProperty("$Name", context, (v, p) => v.ParseAsString(p));
labeledExp = new CsdlLabeledExpression(label, expression, context.Location());
return(true);
}
/// <summary>
/// Parse the Cast expression using <see cref="JsonElement"/>.
/// </summary>
/// <param name="element">The input JSON element.</param>
/// <param name="context">The parser context.</param>
/// <param name="castExp">The built cast expression.</param>
/// <returns>true/false.</returns>
private static bool TryParseCastExpression(JsonElement element, JsonParserContext context, out CsdlCastExpression castExp)
{
Debug.Assert(context != null);
castExp = null;
// Cast expressions are represented as an object with a member $Cast
JsonElement propertyValue;
if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$Cast", out propertyValue))
{
return(false);
}
// with a member $Cast whose value is an annotation expression
CsdlExpressionBase expression = propertyValue.ProcessProperty("$Cast", context, ParseExpression);
// a member $Type whose value is a string containing the qualified type name, and optionally a member $Collection with a value of true.
CsdlTypeReference typeReference = CsdlJsonParseHelper.ParseCsdlTypeReference(element, context);
castExp = new CsdlCastExpression(typeReference, expression, context.Location());
return(true);
}
/// <summary>
/// Try to parse the input json value <see cref="JsonElement"/> to <see cref="CsdlAnnotation"/>.
/// </summary>
/// <param name="annotionName">The input annotation name, annotation name should start with '@'.</param>
/// <param name="element">The JSON value to parse.</param>
/// <param name="context">The parser context.</param>
/// <param name="csdlAnnotation">The built CSDL annotation.</param>
/// <returns>true/false.</returns>
public static bool TryParseCsdlAnnotation(string annotionName, JsonElement element, JsonParserContext context, out CsdlAnnotation csdlAnnotation)
{
EdmUtil.CheckArgumentNull(context, nameof(context));
csdlAnnotation = null;
// An annotation is represented as a member whose name consists of an at (@) character,
// followed by the qualified name of a term, optionally followed by a hash (#) and a qualifier.
if (!ParseAnnotationName(annotionName, out string termName, out string qualifier))
{
return(false);
}
context.EnterScope(annotionName);
CsdlExpressionBase expression = ParseExpression(element, context);
context.LeaveScope(annotionName);
csdlAnnotation = new CsdlAnnotation(termName, qualifier, expression, context.Location());
return(true);
}
public void ParseIsOfExpressionWorksAsExpected()
{
string json = @" { ""$IsOf"": {
""$Path"": ""FirstName""
},
""$Type"": ""self.PreferredCustomer"",
""$Collection"": true
}";
CsdlExpressionBase expressionBase = ParseExpression(json);
Assert.NotNull(expressionBase);
CsdlIsTypeExpression isTypeExp = Assert.IsType <CsdlIsTypeExpression>(expressionBase);
Assert.NotNull(isTypeExp.Type);
CsdlExpressionTypeReference expTypeReference = Assert.IsType <CsdlExpressionTypeReference>(isTypeExp.Type);
CsdlCollectionType collectionType = Assert.IsType <CsdlCollectionType>(expTypeReference.TypeExpression);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(collectionType.ElementType);
Assert.Equal("self.PreferredCustomer", namedType.FullName);
Assert.NotNull(isTypeExp.Operand);
Assert.IsType <CsdlPathExpression>(isTypeExp.Operand);
}
protected CsdlSemanticsExpression(CsdlSemanticsSchema schema, CsdlExpressionBase element)
: base(element)
{
this.schema = schema;
}
public CsdlPropertyValue(string property, CsdlExpressionBase expression, CsdlLocation location)
: base(location)
{
this.property = property;
this.expression = expression;
}
public CsdlLabeledExpression(string label, CsdlExpressionBase element, CsdlLocation location)
: base(location)
{
this.label = label;
this.element = element;
}
public CsdlIsTypeExpression(CsdlTypeReference type, CsdlExpressionBase operand, CsdlLocation location)
: base(location)
{
this.type = type;
this.operand = operand;
}
public CsdlPropertyReferenceExpression(string property, CsdlExpressionBase baseExpression, CsdlLocation location)
: base(location)
{
this.property = property;
this.baseExpression = baseExpression;
}
internal static IEdmExpression WrapExpression(CsdlExpressionBase expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
{
if (expression != null)
{
switch (expression.ExpressionKind)
{
case EdmExpressionKind.Cast:
return(new CsdlSemanticsCastExpression((CsdlCastExpression)expression, bindingContext, schema));
case EdmExpressionKind.BinaryConstant:
return(new CsdlSemanticsBinaryConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.BooleanConstant:
return(new CsdlSemanticsBooleanConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.Collection:
return(new CsdlSemanticsCollectionExpression((CsdlCollectionExpression)expression, bindingContext, schema));
case EdmExpressionKind.DateTimeOffsetConstant:
return(new CsdlSemanticsDateTimeOffsetConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DecimalConstant:
return(new CsdlSemanticsDecimalConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.EnumMember:
return(new CsdlSemanticsEnumMemberExpression((CsdlEnumMemberExpression)expression, bindingContext, schema));
case EdmExpressionKind.FloatingConstant:
return(new CsdlSemanticsFloatingConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.Null:
return(new CsdlSemanticsNullExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.FunctionApplication:
return(new CsdlSemanticsApplyExpression((CsdlApplyExpression)expression, bindingContext, schema));
case EdmExpressionKind.GuidConstant:
return(new CsdlSemanticsGuidConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.If:
return(new CsdlSemanticsIfExpression((CsdlIfExpression)expression, bindingContext, schema));
case EdmExpressionKind.IntegerConstant:
return(new CsdlSemanticsIntConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.IsType:
return(new CsdlSemanticsIsTypeExpression((CsdlIsTypeExpression)expression, bindingContext, schema));
case EdmExpressionKind.LabeledExpressionReference:
return(new CsdlSemanticsLabeledExpressionReferenceExpression((CsdlLabeledExpressionReferenceExpression)expression, bindingContext, schema));
case EdmExpressionKind.Labeled:
return(schema.WrapLabeledElement((CsdlLabeledExpression)expression, bindingContext));
case EdmExpressionKind.Path:
return(new CsdlSemanticsPathExpression((CsdlPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.PropertyPath:
return(new CsdlSemanticsPropertyPathExpression((CsdlPropertyPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.NavigationPropertyPath:
return(new CsdlSemanticsNavigationPropertyPathExpression((CsdlNavigationPropertyPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.Record:
return(new CsdlSemanticsRecordExpression((CsdlRecordExpression)expression, bindingContext, schema));
case EdmExpressionKind.StringConstant:
return(new CsdlSemanticsStringConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DurationConstant:
return(new CsdlSemanticsDurationConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DateConstant:
return(new CsdlSemanticsDateConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.TimeOfDayConstant:
return(new CsdlSemanticsTimeOfDayConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.AnnotationPath:
return(new CsdlSemanticsAnnotationPathExpression((CsdlAnnotationPathExpression)expression, bindingContext, schema));
}
}
return(null);
}
public CsdlPropertyValue(string property, CsdlExpressionBase expression, CsdlLocation location)
: base(location)
{
this.property = property;
this.expression = expression;
}
private static void AddLabeledExpressions(CsdlExpressionBase expression, Dictionary <string, object> result)
{
if (expression == null)
{
return;
}
switch (expression.ExpressionKind)
{
case Expressions.EdmExpressionKind.Labeled:
{
CsdlLabeledExpression labeledElement = (CsdlLabeledExpression)expression;
string label = labeledElement.Label;
object duplicateLabeledElement;
if (result.TryGetValue(label, out duplicateLabeledElement))
{
// If the label has multiple definitions, store the duplicates as a list of labeled elements.
List <CsdlLabeledExpression> duplicates = duplicateLabeledElement as List <CsdlLabeledExpression>;
if (duplicates == null)
{
duplicates = new List <CsdlLabeledExpression>();
duplicates.Add((CsdlLabeledExpression)duplicateLabeledElement);
result[label] = duplicates;
}
duplicates.Add(labeledElement);
}
else
{
result[label] = labeledElement;
}
AddLabeledExpressions(labeledElement.Element, result);
break;
}
case Expressions.EdmExpressionKind.Collection:
foreach (CsdlExpressionBase element in ((CsdlCollectionExpression)expression).ElementValues)
{
AddLabeledExpressions(element, result);
}
break;
case Expressions.EdmExpressionKind.OperationApplication:
foreach (CsdlExpressionBase argument in ((CsdlApplyExpression)expression).Arguments)
{
AddLabeledExpressions(argument, result);
}
break;
case Expressions.EdmExpressionKind.Record:
foreach (CsdlPropertyValue property in ((CsdlRecordExpression)expression).PropertyValues)
{
AddLabeledExpressions(property.Expression, result);
}
break;
case Expressions.EdmExpressionKind.If:
{
CsdlIfExpression ifExpression = (CsdlIfExpression)expression;
AddLabeledExpressions(ifExpression.Test, result);
AddLabeledExpressions(ifExpression.IfTrue, result);
AddLabeledExpressions(ifExpression.IfFalse, result);
break;
}
case Expressions.EdmExpressionKind.IsType:
AddLabeledExpressions(((CsdlIsTypeExpression)expression).Operand, result);
break;
case Expressions.EdmExpressionKind.Cast:
AddLabeledExpressions(((CsdlCastExpression)expression).Operand, result);
break;
default:
break;
}
}
private static void AddLabeledExpressions(CsdlExpressionBase expression, Dictionary <string, object> result)
{
if (expression != null)
{
switch (expression.ExpressionKind)
{
case EdmExpressionKind.Record:
foreach (CsdlPropertyValue value2 in ((CsdlRecordExpression)expression).PropertyValues)
{
AddLabeledExpressions(value2.Expression, result);
}
return;
case EdmExpressionKind.Collection:
foreach (CsdlExpressionBase base2 in ((CsdlCollectionExpression)expression).ElementValues)
{
AddLabeledExpressions(base2, result);
}
return;
case EdmExpressionKind.If:
{
CsdlIfExpression expression3 = (CsdlIfExpression)expression;
AddLabeledExpressions(expression3.Test, result);
AddLabeledExpressions(expression3.IfTrue, result);
AddLabeledExpressions(expression3.IfFalse, result);
return;
}
case EdmExpressionKind.AssertType:
AddLabeledExpressions(((CsdlAssertTypeExpression)expression).Operand, result);
return;
case EdmExpressionKind.IsType:
AddLabeledExpressions(((CsdlIsTypeExpression)expression).Operand, result);
return;
case EdmExpressionKind.FunctionApplication:
foreach (CsdlExpressionBase base3 in ((CsdlApplyExpression)expression).Arguments)
{
AddLabeledExpressions(base3, result);
}
return;
case EdmExpressionKind.LabeledExpressionReference:
return;
case EdmExpressionKind.Labeled:
{
object obj2;
CsdlLabeledExpression item = (CsdlLabeledExpression)expression;
string label = item.Label;
if (!result.TryGetValue(label, out obj2))
{
result[label] = item;
}
else
{
List <CsdlLabeledExpression> list = obj2 as List <CsdlLabeledExpression>;
if (list == null)
{
list = new List <CsdlLabeledExpression> {
(CsdlLabeledExpression)obj2
};
result[label] = list;
}
list.Add(item);
}
AddLabeledExpressions(item.Element, result);
return;
}
}
}
}
public CsdlPropertyReferenceExpression(string property, CsdlExpressionBase baseExpression, CsdlLocation location)
: base(location)
{
this.property = property;
this.baseExpression = baseExpression;
}
public CsdlLabeledExpression(string label, CsdlExpressionBase element, CsdlLocation location)
: base(location)
{
this.label = label;
this.element = element;
}
public CsdlIsTypeExpression(CsdlTypeReference type, CsdlExpressionBase operand, CsdlLocation location)
: base(location)
{
this.type = type;
this.operand = operand;
}
public CsdlValueAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
: base(term, qualifier, location)
{
this.expression = expression;
}
