public void Format_WhenWildcardWithNot_ExpectNotLikeSql()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var node = new EqualsOperator
{
Name = "ColumnName",
IsNot = true,
Value = @"*bob",
Statement = @"ColumnName:*bob",
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = equalsFormatter.Format(node, 0);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse.Sql, Is.EqualTo("ColumnName NOT LIKE @ColumnName0"));
Assert.That(sqlDataResponse.Params.First().Value, Is.EqualTo(@"%bob"));
}
public void Format_WhenIsWildcardSuffix_ExpectLikeSql()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var node = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Value = "bob*",
Statement = "ColumnName:bob*",
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = equalsFormatter.Format(node, 0);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse.Sql, Is.EqualTo("ColumnName LIKE @ColumnName0"));
Assert.That(sqlDataResponse.Params.First().Value, Is.EqualTo("bob%"));
}
public void Format_WhenSearchForWordNull_ExpectStandardEquals()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var node = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Value = "\"NULL\"",
Statement = "ColumnName:\"NULL\"",
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = equalsFormatter.Format(node, 0);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse.Sql, Is.EqualTo("ColumnName = @ColumnName0"));
Assert.That(sqlDataResponse.Params.First().Value, Is.EqualTo(@"NULL"));
}
public void Format_WhenStringNotComparison_ExpectCorrectSql()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var node = new EqualsOperator
{
Name = "ColumnName",
IsNot = true,
Value = "bob",
Statement = "ColumnName:bob",
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = equalsFormatter.Format(node, 0);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse.Sql, Is.EqualTo("ColumnName <> @ColumnName0"));
Assert.That(sqlDataResponse.Params.First().Value, Is.EqualTo("bob"));
}
public void Format_WhenSearchForNull_ExpectIsNullSql()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var node = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Value = @"NULL",
Statement = @"ColumnName:NULL",
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = equalsFormatter.Format(node, 0);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse.Sql, Is.EqualTo("ColumnName IS NULL"));
Assert.That(sqlDataResponse.Params.Any(), Is.False);
}
/// <summary>
/// Creates a <c>LeafExpression</c> capable of evaluating JSON using the operator specified in the JSON rule.
/// </summary>
/// <returns>The LeafExpression.</returns>
public override Expression ToExpression()
{
LeafExpressionOperator leafOperator = null;
if (this.Exists != null)
{
leafOperator = new ExistsOperator(Exists.Value, isNegative: false);
}
else if (this.HasValue != null)
{
leafOperator = new HasValueOperator(HasValue.Value, isNegative: false);
}
else if (this.Is != null || this.NotEquals != null)
{
leafOperator = new EqualsOperator(
specifiedValue: this.Is ?? this.NotEquals,
isNegative: this.NotEquals != null);
}
if (leafOperator != null)
{
return(new LeafExpression(this.ResourceType, this.Path, leafOperator));
}
throw new NotImplementedException();
}
public void NumberEqualsCanThrow()
{
Operator op = new EqualsOperator().NumberEquals;
MeVariable[] arr = { new MeStruct(""), new MeNumber(10) };
Assert.IsFalse(op.CanExecute(arr));
TestUtils.CustomExceptionTest(() => op.Execute(arr), typeof(MeContextException));
}
public void Visit(EqualsOperator node)
{
builder.AppendLine($"Equals");
builder.Indent();
node.Left.Accept(this);
node.Right.Accept(this);
builder.Outdent();
}
/// <summary>
/// Map if is equal to http header value specified name.
/// </summary>
/// <param name="leftOperand">Left operand.</param>
/// <param name="httpHeaderName">Http header name.</param>
public static ILogicOperator IsEqualToHttpHeader(this IOperand leftOperand, string httpHeaderName)
{
var op = new EqualsOperator(leftOperand, new HttpHeaderOperand(httpHeaderName));
leftOperand.Operator = op;
return(op);
}
public void Visit(EqualsOperator node)
{
VisitBinary(node);
ITerminalWrapper leftWrapper = ReferenceTables.GetValue(node.Left);
ITerminalWrapper rightWrapper = ReferenceTables.GetValue(node.Right);
ReferenceTables.SetValue(node, ((dynamic)leftWrapper) == ((dynamic)rightWrapper));
}
public void StringEqualsCanThrow()
{
Operator op = new EqualsOperator().NumberEquals;
string testString = "TEST";
MeVariable[] arr = { new MeStruct(testString), new MeString(testString) };
Assert.IsFalse(op.CanExecute(arr));
TestUtils.CustomExceptionTest(() => op.Execute(arr), typeof(MeContextException));
}
public void Format_WhenSingleNode_ExpectWhereStatement()
{
// Arrange
var mockEqualsFormatter = new Mock <IWhereOperatorFormatter <EqualsOperator> >();
var mockLessThanFormatter = new Mock <IWhereOperatorFormatter <LessThanOperator> >();
var mockGreaterThanFormatter = new Mock <IWhereOperatorFormatter <GreaterThanOperator> >();
var mockRangeFormatter = new Mock <IWhereOperatorFormatter <RangeOperator> >();
mockEqualsFormatter
.Setup(r => r.Format(It.IsAny <EqualsOperator>(), It.IsAny <int>()))
.Returns(new SqlDataResponse
{
Sql = "ColumnName = @ColumnName1",
LastSuffix = 1,
Params = new List <SqlWhereParam> {
new SqlWhereParam {
Value = "bob", VarName = "ColumnName1"
}
},
});
var whereFormatter = new WhereFormatter(
mockEqualsFormatter.Object,
mockLessThanFormatter.Object,
mockGreaterThanFormatter.Object,
mockRangeFormatter.Object);
var op = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Statement = "ColumnName:bob",
Value = "bob",
};
var whereNode = new WhereNode
{
Statement = new WhereStatement {
Value = op
},
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = whereFormatter.Format(whereNode);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse, Is.Not.Null);
Assert.That(sqlDataResponse.Sql, Is.EqualTo($"WHERE ColumnName = @ColumnName1{Environment.NewLine}"));
Assert.That(sqlDataResponse.Params.First(r => r.VarName == "ColumnName1").Value, Is.EqualTo("bob"));
}
public void StringEqualsCanCompare()
{
Operator op = new EqualsOperator().StringEquals;
string testString = "TEST_STR";
MeVariable[] arr = { new MeString(testString), new MeString(testString) };
Assert.IsTrue(op.CanExecute(arr));
bool result = op.Execute(arr).Get <bool>();
Assert.IsTrue(result);
}
public void NumberEqualsCanCompare()
{
Operator op = new EqualsOperator().NumberEquals;
float testNumber = 1337.0f;
MeVariable[] arr = { new MeNumber(testNumber), new MeNumber(testNumber) };
Assert.IsTrue(op.CanExecute(arr));
bool result = op.Execute(arr).Get <bool>();
Assert.IsTrue(result);
}
public void EqualityOperatorFullTest()
{
EqualsOperator eq = new EqualsOperator();
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Byte.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Int16.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Int32.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Int64.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Double.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Byte.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Int16.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Int32.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Int64.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Double.Parse("1")));
Assert.True((bool)eq.Evaluate(Single.Parse("1"), Single.Parse("1")));
Assert.True((bool)eq.Evaluate(null, null));
//Assert.True((bool)eq.Evaluate("C", 'C'));
}
public void EqualsOperator_ShouldPrint()
{
var ast = new EqualsOperator
(
position: 0,
left: new Identifier(0, "x"),
right: new Identifier(0, "y")
);
Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo(
@"Equals
Identifier(x)
Identifier(y)
"));
}
public void EvaluateExpression_PropertyIsNotEqual_EqualsExpressionIsFalse_NotEqualsExpressionIsTrue(object expectedValue, object actualValue)
{
var expectedValueJToken = ToJToken(expectedValue);
var actualValueJToken = ToJToken(actualValue);
// {"Equals": jTokenValue} is false
var equalsOperator = new EqualsOperator(expectedValueJToken, isNegative: false);
Assert.IsFalse(equalsOperator.EvaluateExpression(actualValueJToken));
// {"NotEquals": jTokenValue} is true
var notEqualsOperator = new EqualsOperator(expectedValueJToken, isNegative: true);
Assert.IsTrue(notEqualsOperator.EvaluateExpression(actualValueJToken));
}
public static Opcode GetCode(Expression expression, Opcode code, Type type)
{
var visitor = new LinqToSitecoreVisitor(code, type);
visitor.EvalOpcodeExpression(expression);
if (visitor.CodeTree == null)
{
var templateCode = new EqualsOperator(new FieldElement("@templatename"), new Literal(type.Name));
var root = new Root {
NextStep = new Descendant(new ItemElement("*", new Predicate(templateCode)))
};
return(root);
}
return(visitor.CodeTree);
}
public void Visit(EqualsOperator equals)
{
equals.Left.Accept(this);
var leftOperand = tacs.Last().Result;
equals.Right.Accept(this);
var rightOperand = tacs.Last().Result;
var result = MakeNewTemp();
var label1 = MakeNewLabel();
var label2 = MakeNewLabel();
tacs.Add(Tac.IfEqual(leftOperand, rightOperand, label1));
tacs.Add(Tac.Assign("0", result));
tacs.Add(Tac.Goto(label2));
tacs.Add(Tac.Label(label1, result));
tacs.Add(Tac.Assign("1", result));
tacs.Add(Tac.Label(label2, result));
}
public void Format_WhenSingleNode_ExpectWhereStatement()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var lessThanFormatter = new LessThanFormatter();
var greaterThanFormatter = new GreaterThanFormatter();
var rangeFormatter = new RangeFormatter();
var whereFormatter = new WhereFormatter(
equalsFormatter,
lessThanFormatter,
greaterThanFormatter,
rangeFormatter);
var op = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Statement = "ColumnName:bob",
Value = "bob",
};
var whereNode = new WhereNode
{
Statement = new WhereStatement {
Value = op
},
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = whereFormatter.Format(whereNode);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Console.WriteLine(sqlDataResponse.Sql);
}
public void CanDistinguishOperatorsBasedOnParameterType()
{
LanguageDefiner definer = new LanguageDefiner();
IOperatorDefiner equalsOp = new EqualsOperator();
equalsOp.AddOperator(definer);
string testStr = "test";
MeVariable[] strArr = { new MeString(testStr), new MeString(testStr) };
Operator strEquals = definer.GetOperator(LConstants.EQUAL_OP, strArr);
Assert.IsNotNull(strEquals);
Assert.IsTrue(strEquals.Execute(strArr).Get <bool>());
float number = 10.3f;
MeVariable[] numArr = { new MeNumber(number), new MeNumber(number) };
Operator numEquals = definer.GetOperator(LConstants.EQUAL_OP, numArr);
Assert.IsNotNull(numEquals);
Assert.IsTrue(numEquals.Execute(numArr).Get <bool>());
}
private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode)
{
//The current node is a variable / value token. Create a value node and return it back
if (!parsedNode.ChildNodes.Any())
{
switch (parsedNode.Term.Name)
{
case "variable":
{
var varName = parsedNode.FindTokenAndGetValue <string>();
return(new VariableValue(varName, parentExpNode));
}
case "boolean":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode));
case "integer":
case "decimal":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode));
case "SingleQuoteString":
case "DoubleQuoteString":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode));
default:
throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression");
}
}
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 1)
{
return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode));
}
//Ignore parenthesis, the middle non-terminal is what we want
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(")
{
return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode));
}
//Binary operator
else if (parsedNode.ChildNodes.Count == 3)
{
BinaryOperatorBase binaryOp;
var opStr = parsedNode.ChildNodes[1].FindToken().ValueString;
switch (opStr)
{
// Math
case "+":
binaryOp = new AdditionOperator(parentExpNode);
break;
case "-":
binaryOp = new SubtractionOperator(parentExpNode);
break;
case "*":
binaryOp = new MultiplacationOperator(parentExpNode);
break;
case "/":
binaryOp = new DivisionOperator(parentExpNode);
break;
case "%":
binaryOp = new ModulusOperator(parentExpNode);
break;
case "^":
binaryOp = new PowerOperator(parentExpNode);
break;
// Bool
case "~==":
binaryOp = new LooseEqualsOperator(parentExpNode);
break;
case "~!=":
binaryOp = new LooseNotEqualsOperator(parentExpNode);
break;
case "==":
binaryOp = new EqualsOperator(parentExpNode);
break;
case "!=":
binaryOp = new NotEqualsOperator(parentExpNode);
break;
case "like":
binaryOp = new LikeOperator(parentExpNode);
break;
case "match":
binaryOp = new MatchOperator(parentExpNode);
break;
case ">":
binaryOp = new GreaterThanOperator(parentExpNode);
break;
case ">=":
binaryOp = new GreaterThanOrEqualOperator(parentExpNode);
break;
case "<":
binaryOp = new LessThanOperator(parentExpNode);
break;
case "<=":
binaryOp = new LessThanOrEqualOperator(parentExpNode);
break;
case "&&":
binaryOp = new AndOperator(parentExpNode);
break;
case "||":
binaryOp = new OrOperator(parentExpNode);
break;
default:
throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'");
}
binaryOp.LeftOperand = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp);
binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp);
//Optimize
if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue)
{
return(new LiteralValue(binaryOp.Eval(), parentExpNode));
}
return(binaryOp);
}
// Unary operator
else if (parsedNode.ChildNodes.Count == 2)
{
var opVal = parsedNode.ChildNodes[0].FindToken().Value;
UnaryOperatorBase unaryOp;
if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType)
{
unaryOp = new TypeConversionOperator(convertType, parentExpNode);
}
else
{
var opStr = opVal.ToString();
switch (opStr)
{
case "!":
unaryOp = new NotOperator(parentExpNode);
break;
//Property Checking
case "lengthof":
unaryOp = new LengthOperator(parentExpNode);
break;
case "typeof":
unaryOp = new TypeOperator(parentExpNode);
break;
default:
unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode);
break;
}
}
unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp);
//Optimize
if (unaryOp.Operand is LiteralValue)
{
return(new LiteralValue(unaryOp.Eval(), parentExpNode));
}
return(unaryOp);
}
else
{
throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})");
}
}
public void Visit(EqualsOperator node)
{
}
public void Visit(EqualsOperator node)
{
VisitBinary(node);
CheckOperandsAreOfSameType(node);
}
public Opcode EvalOpcodeExpression(Expression node)
{
if (node is UnaryExpression)
{
var uNode = node.Cast <UnaryExpression>();
if (uNode.NodeType == ExpressionType.Not)
{
_isFuncUnariNot = true;
}
var opcode = EvalOpcodeExpression(uNode.Operand);
if (opcode is FieldElement)
{
if (uNode.NodeType == ExpressionType.Not)
{
return(new EqualsOperator(opcode, new BooleanValue(false)));
}
return(new EqualsOperator(opcode, new BooleanValue(true)));
}
}
if (node is MemberExpression)
{
var mNode = node.Cast <MemberExpression>();
var expression = EvalMember(mNode.Expression ?? mNode);
if (expression != null)
{
var value = GetValue(mNode);
if (value is bool)
{
return(new BooleanValue((bool)value));
}
if (value is DateTime)
{
return(new Literal(((DateTime)value).ToString("yyyyMMddThhmmss")));
}
if (value is int)
{
return(new Number((int)value));
}
return(new Literal(value?.ToString() ?? string.Empty));
}
return(new FieldElement(GetPropertyName(mNode.Member, mNode.Member.Name)));
}
if (node is MethodCallExpression)
{
var mNode = node.Cast <MethodCallExpression>();
if (mNode.Method.DeclaringType == typeof(Queryable) && mNode.Method.Name == "Where")
{
return(EvalOpcodeExpression(mNode.Arguments[1]));
}
var field = ((MemberExpression)mNode.Object).Member.Name;
var value = GetValue(mNode.Arguments[0]);
if (_isFuncUnariNot)
{
var func = new UnequalsOperator(EvalOpcodeExpression(mNode.Object),
new LinqToSitecoreFunction(mNode.Method.Name.ToLower(), field, value));
_isFuncUnariNot = false;
return(func);
}
var func2 = new EqualsOperator(EvalOpcodeExpression(mNode.Object),
new LinqToSitecoreFunction(mNode.Method.Name.ToLower(), field, value));
_isFuncUnariNot = false;
return(func2);
}
if (node is ConstantExpression)
{
var value = GetValue(node);
if (value is bool)
{
return(new BooleanValue((bool)value));
}
return(new Literal(value?.ToString() ?? string.Empty));
}
if (node is BinaryExpression)
{
_isFieldUnaryEqual = false;
var bnode = node.Cast <BinaryExpression>();
var left = EvalOpcodeExpression(bnode.Left);
var right = EvalOpcodeExpression(bnode.Right);
if (node.NodeType != ExpressionType.Equal &&
node.NodeType != ExpressionType.NotEqual &&
bnode.Left is MemberExpression &&
(bnode.Right is BinaryExpression || bnode.Right.NodeType == ExpressionType.Call))
{
if (bnode.Left.Cast <MemberExpression>().Type == typeof(bool))
{
left = new EqualsOperator(left, new BooleanValue(true));
}
}
if (node.NodeType != ExpressionType.Equal &&
node.NodeType != ExpressionType.NotEqual &&
bnode.Right is MemberExpression &&
(bnode.Left is BinaryExpression || bnode.Left.NodeType == ExpressionType.Call))
{
if (bnode.Right.Cast <MemberExpression>().Type == typeof(bool))
{
right = new EqualsOperator(right, new BooleanValue(true));
}
}
switch (node.NodeType)
{
case ExpressionType.And:
return(new AndOperator(left, right));
case ExpressionType.AndAlso:
return(new AndOperator(left, right));
case ExpressionType.Or:
return(new OrOperator(left, right));
case ExpressionType.OrElse:
return(new OrOperator(left, right));
case ExpressionType.NotEqual:
return(new UnequalsOperator(left, right));
case ExpressionType.Equal:
return(new EqualsOperator(left, right));
case ExpressionType.GreaterThanOrEqual:
return(new GreaterOrEqualsOperator(left, right));
case ExpressionType.GreaterThan:
return(new GreaterOperator(left, right));
case ExpressionType.LessThanOrEqual:
return(new SmallerOrEqualsOperator(left, right));
case ExpressionType.LessThan:
return(new SmallerOperator(left, right));
default:
throw new NotImplementedException($"{node.NodeType} is not supported.");
}
}
if (node is LambdaExpression)
{
var templateCode = new AndOperator(
new EqualsOperator(new FieldElement("@templatename"), new Literal(_type.Name)), EvalOpcodeExpression(node.Cast <LambdaExpression>().Body));
var root = new Root {
NextStep = new DescendantOrSelf(new ItemElement("*", new Predicate(templateCode)))
};
CodeTree = root;
}
return(CodeTree);
}
