/// <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 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 CsdlSemanticsIfExpression(CsdlIfExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.testCache = new Cache <CsdlSemanticsIfExpression, IEdmExpression>();
this.ifTrueCache = new Cache <CsdlSemanticsIfExpression, IEdmExpression>();
this.ifFalseCache = new Cache <CsdlSemanticsIfExpression, IEdmExpression>();
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsIfExpression(CsdlIfExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
this.bindingContext = bindingContext;
}
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;
}
}
}
}
