public override bool Visit(NotEqualNode node)
{
int nodeLeft = 0;
int nodeRight = 0;
if (node.Left is NumberNode)
{
nodeLeft = Visit(node.Left as NumberNode);
}
else if (node.Left is IdentifierNode)
{
nodeLeft = Visit(node.Left as IdentifierNode);
}
else
{
nodeLeft = Visit(node.Left as InfixExpressionNode);
}
if (node.Right is NumberNode)
{
nodeRight = Visit(node.Right as NumberNode);
}
else if (node.Right is IdentifierNode)
{
nodeRight = Visit(node.Right as IdentifierNode);
}
else
{
nodeRight = Visit(node.Right as InfixExpressionNode);
}
return(nodeLeft != nodeRight);
}
public void Init()
{
_testExpression = Expression.NotEqual(TestLeftExpression, TestRightExpression);
TestObject = new NotEqualNode(
MockNodeFactory.Object,
TestExpression);
}
public void NotEqualExpressionHasExpectedLeft()
{
IExpressionNode actual = TestObject.Build(TestNotEqualExpression);
NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>();
ConstantNode leftNode = actualNode.Left.VerifyIsActually <ConstantNode>();
Assert.AreSame(TestConstantZero, leftNode.SourceExpression);
}
public void NotEqualExpressionHasExpectedRight()
{
IExpressionNode actual = TestObject.Build(TestNotEqualExpression);
NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>();
ConstantNode rightNode = actualNode.Right.VerifyIsActually <ConstantNode>();
Assert.AreSame(TestConstantOne, rightNode.SourceExpression);
}
public void NotEqualExpressionIsExpected()
{
Expression testExpression = TestNotEqualExpression;
IExpressionNode actual = TestObject.Build(testExpression);
NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>();
Assert.AreSame(testExpression, actualNode.SourceExpression);
}
public void InvalidOperandstoOrOperation()
{
NotEqualNode node = new NotEqualNode("!=");
node.Left = new BoolNode(true);
node.Right = new IntNode(2);
SymbolTable symbolTable = new SymbolTable();
TypeCheckSymbolTableVisitor visitor = new TypeCheckSymbolTableVisitor(symbolTable);
Assert.ThrowsException <InvalidOperandsException>(() =>
{
visitor.Visit(node);
});
}
public override Node VisitInfixRelationalExpr(ML4DParser.InfixRelationalExprContext context)
{
InfixExpressionNode node;
switch (context.op.Type)
{
case ML4DLexer.LTHAN:
node = new LessThanNode(context.op.Text);
break;
case ML4DLexer.GTHAN:
node = new GreaterThanNode(context.op.Text);
break;
case ML4DLexer.LETHAN:
node = new LessEqualThanNode(context.op.Text);
break;
case ML4DLexer.GETHAN:
node = new GreaterEqualThanNode(context.op.Text);
break;
case ML4DLexer.EQUALS:
node = new EqualNode(context.op.Text);
break;
case ML4DLexer.NOTEQUALS:
node = new NotEqualNode(context.op.Text);
break;
default:
throw new NotSupportedException(
$"The operator {context.op.Text}, is not a valid relational operator.");
}
node.Left = (ExpressionNode)Visit(context.left);
node.Right = (ExpressionNode)Visit(context.right);
return(node);
}
private ExpressionNode ParseEquality()
{
var lhs = ParseRel();
while (true)
{
if (_reader.Peek() is Equal)
{
Match <Equal>();
lhs = new EqualNode(lhs, ParseRel());
}
else if (_reader.Peek() is NotEqual)
{
Match <NotEqual>();
lhs = new NotEqualNode(lhs, ParseRel());
}
else
{
break;
}
}
return(lhs);
}
protected virtual QueryNode VisitNotEqual(NotEqualNode node, AzureQueryOptimizerState state)
{
return(this.Visit((QueryNode) new NotNode((QueryNode) new EqualNode(node.LeftNode, node.RightNode, node.Boost)), state));
}
private bool TryExpression(ParserContext context, out IAstNode instr)
{
IAstNode value2;
if (context.Stream.Consume <IAstNode>(TryTerm, context, out var currInstr))
{
instr = currInstr;
while (!context.Stream.Eof)
{
if (context.Stream.Consume(TokenTypes.Plus))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new AddNode(currInstr, value2);
instr = currInstr;
}
else if (context.Stream.Consume(TokenTypes.Minus))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new SubNode(currInstr, value2);
instr = currInstr;
}
else if (context.Stream.Consume(TokenTypes.GreaterThan))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new GreaterThanNode(currInstr, value2);
instr = currInstr;
}
else if (context.Stream.Consume(TokenTypes.LessThan))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new LessThanNode(currInstr, value2);
instr = currInstr;
}
else if (context.Stream.Consume(TokenTypes.Equal))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new EqualNode(currInstr, value2);
instr = currInstr;
}
else if (context.Stream.Consume(TokenTypes.NotEqual))
{
if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2))
{
return(false);
}
currInstr = new NotEqualNode(currInstr, value2);
instr = currInstr;
}
else
{
return(true);
}
}
return(true);
}
instr = null;
return(false);
}
private TypeInfo Visit(NotEqualNode node, MethodBuilder builder, CodegenContext context)
{
return(BinaryOperatorVisit(node, builder, (x) => x.NEqual(), context));
}
public object Visit(NotEqualNode node)
{
return(!IsEqual(node.Value1, node.Value2));
}
private ValInfo Visit(NotEqualNode node)
{
return(BinaryOperator(node, (x, y) => x != y));
}
private TypeDescriptor Visit(NotEqualNode node, Context context)
{
return(RelationOperator(node, context));
}
protected virtual QueryNode VisitNotEqual(NotEqualNode node, ElasticSearchQueryOptimizerState state)
{
var node2 = new NotNode(new EqualNode(node.LeftNode, node.RightNode, node.Boost));
return(Visit(node2, state));
}
public virtual void VisitNotEqual(NotEqualNode notEqualNode) => throw new NotImplementedException();
public abstract U Visit(NotEqualNode node);