Package io.sundr.model

Class BinaryExpressionFluent<A extends BinaryExpressionFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.BinaryExpressionFluent<A>

Direct Known Subclasses:

AssignFluent.BinaryExpressionTargetNested, AssignFluent.BinaryExpressionValueNested, BinaryExpressionBuilder, BinaryExpressionFluent.BinaryExpressionLeftNested, BinaryExpressionFluent.BinaryExpressionRightNested, BitwiseAndFluent, BitwiseOrFluent, BlockFluent.BinaryExpressionStatementsNested, CastFluent.BinaryExpressionNested, ConstructFluent.BinaryExpressionArgumentsNested, DeclareFluent.BinaryExpressionValueNested, DivideFluent, DoFluent.BinaryExpressionConditionNested, DoFluent.BinaryExpressionStatementNested, EnclosedFluent.BinaryExpressionExpresionNested, EqualsFluent, ForeachFluent.BinaryExpressionBodyNested, ForeachFluent.BinaryExpressionNested, ForFluent.BinaryExpressionBodyNested, ForFluent.BinaryExpressionCompareNested, ForFluent.BinaryExpressionInitNested, ForFluent.BinaryExpressionUpdateNested, GreaterThanFluent, GreaterThanOrEqualFluent, IfDslConditionStepFluent.BinaryExpressionConditionNested, IfDslThenStepFluent.BinaryExpressionConditionNested, IfDslThenStepFluent.BinaryExpressionStatementsNested, IfFluent.BinaryExpressionConditionNested, IfFluent.BinaryExpressionElseStatementNested, IfFluent.BinaryExpressionStatementNested, IndexFluent.BinaryExpressionNested, InstanceOfFluent.BinaryExpressionNested, InverseFluent.BinaryExpressionExpresionNested, LambdaFluent.BinaryExpressionStatementNested, LeftShiftFluent, LessThanFluent, LessThanOrEqualFluent, LogicalAndFluent, LogicalOrFluent, MethodCallFluent.BinaryExpressionArgumentsNested, MinusFluent, ModuloFluent, MultiplyFluent, NegativeFluent.BinaryExpressionExpresionNested, NewArrayFluent.BinaryExpressionExpressionsNested, NotEqualsFluent, NotFluent.BinaryExpressionExpresionNested, PlusFluent, PositiveFluent.BinaryExpressionExpresionNested, PostDecrementFluent.BinaryExpressionNested, PostIncrementFluent.BinaryExpressionNested, PreDecrementFluent.BinaryExpressionNested, PreIncrementFluent.BinaryExpressionNested, PropertyFluent.BinaryExpressionInitialValueNested, ReturnFluent.BinaryExpressionNested, RightShiftFluent, RightUnsignedShiftFluent, SwitchFluent.BinaryExpressionNested, SynchronizedFluent.BinaryExpressionBodyNested, SynchronizedFluent.BinaryExpressionLockNested, TernaryFluent.BinaryExpressionAlternativeNested, TernaryFluent.BinaryExpressionConditionNested, TernaryFluent.BinaryExpressionResultNested, ThrowFluent.BinaryExpressionExceptionNested, WhileFluent.BinaryExpressionConditionNested, WhileFluent.BinaryExpressionStatementNested, WithScopeFluent.BinaryExpressionScopeNested, XorFluent

public class BinaryExpressionFluent<A extends BinaryExpressionFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	BinaryExpressionFluent.AssignLeftNested<N>
class	BinaryExpressionFluent.AssignRightNested<N>
class	BinaryExpressionFluent.BinaryExpressionLeftNested<N>
class	BinaryExpressionFluent.BinaryExpressionRightNested<N>
class	BinaryExpressionFluent.BitwiseAndLeftNested<N>
class	BinaryExpressionFluent.BitwiseAndRightNested<N>
class	BinaryExpressionFluent.BitwiseOrLeftNested<N>
class	BinaryExpressionFluent.BitwiseOrRightNested<N>
class	BinaryExpressionFluent.CastLeftNested<N>
class	BinaryExpressionFluent.CastRightNested<N>
class	BinaryExpressionFluent.ClassRefLeftNested<N>
class	BinaryExpressionFluent.ClassRefRightNested<N>
class	BinaryExpressionFluent.ConstructLeftNested<N>
class	BinaryExpressionFluent.ConstructRightNested<N>
class	BinaryExpressionFluent.ContextRefLeftNested<N>
class	BinaryExpressionFluent.ContextRefRightNested<N>
class	BinaryExpressionFluent.DeclareLeftNested<N>
class	BinaryExpressionFluent.DeclareRightNested<N>
class	BinaryExpressionFluent.DivideLeftNested<N>
class	BinaryExpressionFluent.DivideRightNested<N>
class	BinaryExpressionFluent.DotClassLeftNested<N>
class	BinaryExpressionFluent.DotClassRightNested<N>
class	BinaryExpressionFluent.EmptyLeftNested<N>
class	BinaryExpressionFluent.EmptyRightNested<N>
class	BinaryExpressionFluent.EnclosedLeftNested<N>
class	BinaryExpressionFluent.EnclosedRightNested<N>
class	BinaryExpressionFluent.EqualsLeftNested<N>
class	BinaryExpressionFluent.EqualsRightNested<N>
class	BinaryExpressionFluent.GreaterThanLeftNested<N>
class	BinaryExpressionFluent.GreaterThanOrEqualLeftNested<N>
class	BinaryExpressionFluent.GreaterThanOrEqualRightNested<N>
class	BinaryExpressionFluent.GreaterThanRightNested<N>
class	BinaryExpressionFluent.IndexLeftNested<N>
class	BinaryExpressionFluent.IndexRightNested<N>
class	BinaryExpressionFluent.InstanceOfLeftNested<N>
class	BinaryExpressionFluent.InstanceOfRightNested<N>
class	BinaryExpressionFluent.InverseLeftNested<N>
class	BinaryExpressionFluent.InverseRightNested<N>
class	BinaryExpressionFluent.LambdaLeftNested<N>
class	BinaryExpressionFluent.LambdaRightNested<N>
class	BinaryExpressionFluent.LeftShiftLeftNested<N>
class	BinaryExpressionFluent.LeftShiftRightNested<N>
class	BinaryExpressionFluent.LessThanLeftNested<N>
class	BinaryExpressionFluent.LessThanOrEqualLeftNested<N>
class	BinaryExpressionFluent.LessThanOrEqualRightNested<N>
class	BinaryExpressionFluent.LessThanRightNested<N>
class	BinaryExpressionFluent.LogicalAndLeftNested<N>
class	BinaryExpressionFluent.LogicalAndRightNested<N>
class	BinaryExpressionFluent.LogicalOrLeftNested<N>
class	BinaryExpressionFluent.LogicalOrRightNested<N>
class	BinaryExpressionFluent.MethodCallLeftNested<N>
class	BinaryExpressionFluent.MethodCallRightNested<N>
class	BinaryExpressionFluent.MinusLeftNested<N>
class	BinaryExpressionFluent.MinusRightNested<N>
class	BinaryExpressionFluent.ModuloLeftNested<N>
class	BinaryExpressionFluent.ModuloRightNested<N>
class	BinaryExpressionFluent.MultiplyLeftNested<N>
class	BinaryExpressionFluent.MultiplyRightNested<N>
class	BinaryExpressionFluent.NegativeLeftNested<N>
class	BinaryExpressionFluent.NegativeRightNested<N>
class	BinaryExpressionFluent.NewArrayLeftNested<N>
class	BinaryExpressionFluent.NewArrayRightNested<N>
class	BinaryExpressionFluent.NotEqualsLeftNested<N>
class	BinaryExpressionFluent.NotEqualsRightNested<N>
class	BinaryExpressionFluent.NotLeftNested<N>
class	BinaryExpressionFluent.NotRightNested<N>
class	BinaryExpressionFluent.PlusLeftNested<N>
class	BinaryExpressionFluent.PlusRightNested<N>
class	BinaryExpressionFluent.PositiveLeftNested<N>
class	BinaryExpressionFluent.PositiveRightNested<N>
class	BinaryExpressionFluent.PostDecrementLeftNested<N>
class	BinaryExpressionFluent.PostDecrementRightNested<N>
class	BinaryExpressionFluent.PostIncrementLeftNested<N>
class	BinaryExpressionFluent.PostIncrementRightNested<N>
class	BinaryExpressionFluent.PreDecrementLeftNested<N>
class	BinaryExpressionFluent.PreDecrementRightNested<N>
class	BinaryExpressionFluent.PreIncrementLeftNested<N>
class	BinaryExpressionFluent.PreIncrementRightNested<N>
class	BinaryExpressionFluent.PropertyLeftNested<N>
class	BinaryExpressionFluent.PropertyRefLeftNested<N>
class	BinaryExpressionFluent.PropertyRefRightNested<N>
class	BinaryExpressionFluent.PropertyRightNested<N>
class	BinaryExpressionFluent.RightShiftLeftNested<N>
class	BinaryExpressionFluent.RightShiftRightNested<N>
class	BinaryExpressionFluent.RightUnsignedShiftLeftNested<N>
class	BinaryExpressionFluent.RightUnsignedShiftRightNested<N>
class	BinaryExpressionFluent.SuperLeftNested<N>
class	BinaryExpressionFluent.SuperRightNested<N>
class	BinaryExpressionFluent.TernaryLeftNested<N>
class	BinaryExpressionFluent.TernaryRightNested<N>
class	BinaryExpressionFluent.ThisLeftNested<N>
class	BinaryExpressionFluent.ThisRightNested<N>
class	BinaryExpressionFluent.ValueRefLeftNested<N>
class	BinaryExpressionFluent.ValueRefRightNested<N>
class	BinaryExpressionFluent.XorLeftNested<N>
class	BinaryExpressionFluent.XorRightNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
BinaryExpressionFluent()
BinaryExpressionFluent(BinaryExpression instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildLeft()
Expression	buildRight()
protected void	copyInstance(BinaryExpression instance)
boolean	equals(Object o)
int	hashCode()
boolean	hasLeft()
boolean	hasRight()
String	toString()
A	withLeft(Expression left)
BinaryExpressionFluent<A>.AssignLeftNested<A>	withNewAssignLeft()
BinaryExpressionFluent<A>.AssignLeftNested<A>	withNewAssignLeftLike(Assign item)
BinaryExpressionFluent<A>.AssignRightNested<A>	withNewAssignRight()
BinaryExpressionFluent<A>.AssignRightNested<A>	withNewAssignRightLike(Assign item)
BinaryExpressionFluent<A>.BinaryExpressionLeftNested<A>	withNewBinaryExpressionLeft()
BinaryExpressionFluent<A>.BinaryExpressionLeftNested<A>	withNewBinaryExpressionLeftLike(BinaryExpression item)
BinaryExpressionFluent<A>.BinaryExpressionRightNested<A>	withNewBinaryExpressionRight()
BinaryExpressionFluent<A>.BinaryExpressionRightNested<A>	withNewBinaryExpressionRightLike(BinaryExpression item)
BinaryExpressionFluent<A>.BitwiseAndLeftNested<A>	withNewBitwiseAndLeft()
A	withNewBitwiseAndLeft(Object left, Object right)
BinaryExpressionFluent<A>.BitwiseAndLeftNested<A>	withNewBitwiseAndLeftLike(BitwiseAnd item)
BinaryExpressionFluent<A>.BitwiseAndRightNested<A>	withNewBitwiseAndRight()
A	withNewBitwiseAndRight(Object left, Object right)
BinaryExpressionFluent<A>.BitwiseAndRightNested<A>	withNewBitwiseAndRightLike(BitwiseAnd item)
BinaryExpressionFluent<A>.BitwiseOrLeftNested<A>	withNewBitwiseOrLeft()
A	withNewBitwiseOrLeft(Object left, Object right)
BinaryExpressionFluent<A>.BitwiseOrLeftNested<A>	withNewBitwiseOrLeftLike(BitwiseOr item)
BinaryExpressionFluent<A>.BitwiseOrRightNested<A>	withNewBitwiseOrRight()
A	withNewBitwiseOrRight(Object left, Object right)
BinaryExpressionFluent<A>.BitwiseOrRightNested<A>	withNewBitwiseOrRightLike(BitwiseOr item)
BinaryExpressionFluent<A>.CastLeftNested<A>	withNewCastLeft()
BinaryExpressionFluent<A>.CastLeftNested<A>	withNewCastLeftLike(Cast item)
BinaryExpressionFluent<A>.CastRightNested<A>	withNewCastRight()
BinaryExpressionFluent<A>.CastRightNested<A>	withNewCastRightLike(Cast item)
BinaryExpressionFluent<A>.ClassRefLeftNested<A>	withNewClassRefLeft()
BinaryExpressionFluent<A>.ClassRefLeftNested<A>	withNewClassRefLeftLike(ClassRef item)
BinaryExpressionFluent<A>.ClassRefRightNested<A>	withNewClassRefRight()
BinaryExpressionFluent<A>.ClassRefRightNested<A>	withNewClassRefRightLike(ClassRef item)
BinaryExpressionFluent<A>.ConstructLeftNested<A>	withNewConstructLeft()
BinaryExpressionFluent<A>.ConstructLeftNested<A>	withNewConstructLeftLike(Construct item)
BinaryExpressionFluent<A>.ConstructRightNested<A>	withNewConstructRight()
BinaryExpressionFluent<A>.ConstructRightNested<A>	withNewConstructRightLike(Construct item)
BinaryExpressionFluent<A>.ContextRefLeftNested<A>	withNewContextRefLeft()
A	withNewContextRefLeft(String name)
BinaryExpressionFluent<A>.ContextRefLeftNested<A>	withNewContextRefLeftLike(ContextRef item)
BinaryExpressionFluent<A>.ContextRefRightNested<A>	withNewContextRefRight()
A	withNewContextRefRight(String name)
BinaryExpressionFluent<A>.ContextRefRightNested<A>	withNewContextRefRightLike(ContextRef item)
BinaryExpressionFluent<A>.DeclareLeftNested<A>	withNewDeclareLeft()
A	withNewDeclareLeft(Class type, String name)
A	withNewDeclareLeft(Class type, String name, Object value)
BinaryExpressionFluent<A>.DeclareLeftNested<A>	withNewDeclareLeftLike(Declare item)
BinaryExpressionFluent<A>.DeclareRightNested<A>	withNewDeclareRight()
A	withNewDeclareRight(Class type, String name)
A	withNewDeclareRight(Class type, String name, Object value)
BinaryExpressionFluent<A>.DeclareRightNested<A>	withNewDeclareRightLike(Declare item)
BinaryExpressionFluent<A>.DivideLeftNested<A>	withNewDivideLeft()
A	withNewDivideLeft(Object left, Object right)
BinaryExpressionFluent<A>.DivideLeftNested<A>	withNewDivideLeftLike(Divide item)
BinaryExpressionFluent<A>.DivideRightNested<A>	withNewDivideRight()
A	withNewDivideRight(Object left, Object right)
BinaryExpressionFluent<A>.DivideRightNested<A>	withNewDivideRightLike(Divide item)
BinaryExpressionFluent<A>.DotClassLeftNested<A>	withNewDotClassLeft()
BinaryExpressionFluent<A>.DotClassLeftNested<A>	withNewDotClassLeftLike(DotClass item)
BinaryExpressionFluent<A>.DotClassRightNested<A>	withNewDotClassRight()
BinaryExpressionFluent<A>.DotClassRightNested<A>	withNewDotClassRightLike(DotClass item)
BinaryExpressionFluent<A>.EmptyLeftNested<A>	withNewEmptyLeft()
BinaryExpressionFluent<A>.EmptyLeftNested<A>	withNewEmptyLeftLike(Empty item)
BinaryExpressionFluent<A>.EmptyRightNested<A>	withNewEmptyRight()
BinaryExpressionFluent<A>.EmptyRightNested<A>	withNewEmptyRightLike(Empty item)
BinaryExpressionFluent<A>.EnclosedLeftNested<A>	withNewEnclosedLeft()
BinaryExpressionFluent<A>.EnclosedLeftNested<A>	withNewEnclosedLeftLike(Enclosed item)
BinaryExpressionFluent<A>.EnclosedRightNested<A>	withNewEnclosedRight()
BinaryExpressionFluent<A>.EnclosedRightNested<A>	withNewEnclosedRightLike(Enclosed item)
BinaryExpressionFluent<A>.EqualsLeftNested<A>	withNewEqualsLeft()
A	withNewEqualsLeft(Object left, Object right)
BinaryExpressionFluent<A>.EqualsLeftNested<A>	withNewEqualsLeftLike(Equals item)
BinaryExpressionFluent<A>.EqualsRightNested<A>	withNewEqualsRight()
A	withNewEqualsRight(Object left, Object right)
BinaryExpressionFluent<A>.EqualsRightNested<A>	withNewEqualsRightLike(Equals item)
BinaryExpressionFluent<A>.GreaterThanLeftNested<A>	withNewGreaterThanLeft()
A	withNewGreaterThanLeft(Object left, Object right)
BinaryExpressionFluent<A>.GreaterThanLeftNested<A>	withNewGreaterThanLeftLike(GreaterThan item)
BinaryExpressionFluent<A>.GreaterThanOrEqualLeftNested<A>	withNewGreaterThanOrEqualLeft()
A	withNewGreaterThanOrEqualLeft(Object left, Object right)
BinaryExpressionFluent<A>.GreaterThanOrEqualLeftNested<A>	withNewGreaterThanOrEqualLeftLike(GreaterThanOrEqual item)
BinaryExpressionFluent<A>.GreaterThanOrEqualRightNested<A>	withNewGreaterThanOrEqualRight()
A	withNewGreaterThanOrEqualRight(Object left, Object right)
BinaryExpressionFluent<A>.GreaterThanOrEqualRightNested<A>	withNewGreaterThanOrEqualRightLike(GreaterThanOrEqual item)
BinaryExpressionFluent<A>.GreaterThanRightNested<A>	withNewGreaterThanRight()
A	withNewGreaterThanRight(Object left, Object right)
BinaryExpressionFluent<A>.GreaterThanRightNested<A>	withNewGreaterThanRightLike(GreaterThan item)
BinaryExpressionFluent<A>.IndexLeftNested<A>	withNewIndexLeft()
BinaryExpressionFluent<A>.IndexLeftNested<A>	withNewIndexLeftLike(Index item)
BinaryExpressionFluent<A>.IndexRightNested<A>	withNewIndexRight()
BinaryExpressionFluent<A>.IndexRightNested<A>	withNewIndexRightLike(Index item)
BinaryExpressionFluent<A>.InstanceOfLeftNested<A>	withNewInstanceOfLeft()
BinaryExpressionFluent<A>.InstanceOfLeftNested<A>	withNewInstanceOfLeftLike(InstanceOf item)
BinaryExpressionFluent<A>.InstanceOfRightNested<A>	withNewInstanceOfRight()
BinaryExpressionFluent<A>.InstanceOfRightNested<A>	withNewInstanceOfRightLike(InstanceOf item)
BinaryExpressionFluent<A>.InverseLeftNested<A>	withNewInverseLeft()
BinaryExpressionFluent<A>.InverseLeftNested<A>	withNewInverseLeftLike(Inverse item)
BinaryExpressionFluent<A>.InverseRightNested<A>	withNewInverseRight()
BinaryExpressionFluent<A>.InverseRightNested<A>	withNewInverseRightLike(Inverse item)
BinaryExpressionFluent<A>.LambdaLeftNested<A>	withNewLambdaLeft()
BinaryExpressionFluent<A>.LambdaLeftNested<A>	withNewLambdaLeftLike(Lambda item)
BinaryExpressionFluent<A>.LambdaRightNested<A>	withNewLambdaRight()
BinaryExpressionFluent<A>.LambdaRightNested<A>	withNewLambdaRightLike(Lambda item)
BinaryExpressionFluent<A>.LeftShiftLeftNested<A>	withNewLeftShiftLeft()
A	withNewLeftShiftLeft(Object left, Object right)
BinaryExpressionFluent<A>.LeftShiftLeftNested<A>	withNewLeftShiftLeftLike(LeftShift item)
BinaryExpressionFluent<A>.LeftShiftRightNested<A>	withNewLeftShiftRight()
A	withNewLeftShiftRight(Object left, Object right)
BinaryExpressionFluent<A>.LeftShiftRightNested<A>	withNewLeftShiftRightLike(LeftShift item)
BinaryExpressionFluent<A>.LessThanLeftNested<A>	withNewLessThanLeft()
A	withNewLessThanLeft(Object left, Object right)
BinaryExpressionFluent<A>.LessThanLeftNested<A>	withNewLessThanLeftLike(LessThan item)
BinaryExpressionFluent<A>.LessThanOrEqualLeftNested<A>	withNewLessThanOrEqualLeft()
A	withNewLessThanOrEqualLeft(Object left, Object right)
BinaryExpressionFluent<A>.LessThanOrEqualLeftNested<A>	withNewLessThanOrEqualLeftLike(LessThanOrEqual item)
BinaryExpressionFluent<A>.LessThanOrEqualRightNested<A>	withNewLessThanOrEqualRight()
A	withNewLessThanOrEqualRight(Object left, Object right)
BinaryExpressionFluent<A>.LessThanOrEqualRightNested<A>	withNewLessThanOrEqualRightLike(LessThanOrEqual item)
BinaryExpressionFluent<A>.LessThanRightNested<A>	withNewLessThanRight()
A	withNewLessThanRight(Object left, Object right)
BinaryExpressionFluent<A>.LessThanRightNested<A>	withNewLessThanRightLike(LessThan item)
BinaryExpressionFluent<A>.LogicalAndLeftNested<A>	withNewLogicalAndLeft()
A	withNewLogicalAndLeft(Object left, Object right)
BinaryExpressionFluent<A>.LogicalAndLeftNested<A>	withNewLogicalAndLeftLike(LogicalAnd item)
BinaryExpressionFluent<A>.LogicalAndRightNested<A>	withNewLogicalAndRight()
A	withNewLogicalAndRight(Object left, Object right)
BinaryExpressionFluent<A>.LogicalAndRightNested<A>	withNewLogicalAndRightLike(LogicalAnd item)
BinaryExpressionFluent<A>.LogicalOrLeftNested<A>	withNewLogicalOrLeft()
A	withNewLogicalOrLeft(Object left, Object right)
BinaryExpressionFluent<A>.LogicalOrLeftNested<A>	withNewLogicalOrLeftLike(LogicalOr item)
BinaryExpressionFluent<A>.LogicalOrRightNested<A>	withNewLogicalOrRight()
A	withNewLogicalOrRight(Object left, Object right)
BinaryExpressionFluent<A>.LogicalOrRightNested<A>	withNewLogicalOrRightLike(LogicalOr item)
BinaryExpressionFluent<A>.MethodCallLeftNested<A>	withNewMethodCallLeft()
BinaryExpressionFluent<A>.MethodCallLeftNested<A>	withNewMethodCallLeftLike(MethodCall item)
BinaryExpressionFluent<A>.MethodCallRightNested<A>	withNewMethodCallRight()
BinaryExpressionFluent<A>.MethodCallRightNested<A>	withNewMethodCallRightLike(MethodCall item)
BinaryExpressionFluent<A>.MinusLeftNested<A>	withNewMinusLeft()
A	withNewMinusLeft(Object left, Object right)
BinaryExpressionFluent<A>.MinusLeftNested<A>	withNewMinusLeftLike(Minus item)
BinaryExpressionFluent<A>.MinusRightNested<A>	withNewMinusRight()
A	withNewMinusRight(Object left, Object right)
BinaryExpressionFluent<A>.MinusRightNested<A>	withNewMinusRightLike(Minus item)
BinaryExpressionFluent<A>.ModuloLeftNested<A>	withNewModuloLeft()
A	withNewModuloLeft(Object left, Object right)
BinaryExpressionFluent<A>.ModuloLeftNested<A>	withNewModuloLeftLike(Modulo item)
BinaryExpressionFluent<A>.ModuloRightNested<A>	withNewModuloRight()
A	withNewModuloRight(Object left, Object right)
BinaryExpressionFluent<A>.ModuloRightNested<A>	withNewModuloRightLike(Modulo item)
BinaryExpressionFluent<A>.MultiplyLeftNested<A>	withNewMultiplyLeft()
A	withNewMultiplyLeft(Object left, Object right)
BinaryExpressionFluent<A>.MultiplyLeftNested<A>	withNewMultiplyLeftLike(Multiply item)
BinaryExpressionFluent<A>.MultiplyRightNested<A>	withNewMultiplyRight()
A	withNewMultiplyRight(Object left, Object right)
BinaryExpressionFluent<A>.MultiplyRightNested<A>	withNewMultiplyRightLike(Multiply item)
BinaryExpressionFluent<A>.NegativeLeftNested<A>	withNewNegativeLeft()
BinaryExpressionFluent<A>.NegativeLeftNested<A>	withNewNegativeLeftLike(Negative item)
BinaryExpressionFluent<A>.NegativeRightNested<A>	withNewNegativeRight()
BinaryExpressionFluent<A>.NegativeRightNested<A>	withNewNegativeRightLike(Negative item)
BinaryExpressionFluent<A>.NewArrayLeftNested<A>	withNewNewArrayLeft()
A	withNewNewArrayLeft(Class type, Integer[] sizes)
BinaryExpressionFluent<A>.NewArrayLeftNested<A>	withNewNewArrayLeftLike(NewArray item)
BinaryExpressionFluent<A>.NewArrayRightNested<A>	withNewNewArrayRight()
A	withNewNewArrayRight(Class type, Integer[] sizes)
BinaryExpressionFluent<A>.NewArrayRightNested<A>	withNewNewArrayRightLike(NewArray item)
BinaryExpressionFluent<A>.NotEqualsLeftNested<A>	withNewNotEqualsLeft()
A	withNewNotEqualsLeft(Object left, Object right)
BinaryExpressionFluent<A>.NotEqualsLeftNested<A>	withNewNotEqualsLeftLike(NotEquals item)
BinaryExpressionFluent<A>.NotEqualsRightNested<A>	withNewNotEqualsRight()
A	withNewNotEqualsRight(Object left, Object right)
BinaryExpressionFluent<A>.NotEqualsRightNested<A>	withNewNotEqualsRightLike(NotEquals item)
BinaryExpressionFluent<A>.NotLeftNested<A>	withNewNotLeft()
BinaryExpressionFluent<A>.NotLeftNested<A>	withNewNotLeftLike(Not item)
BinaryExpressionFluent<A>.NotRightNested<A>	withNewNotRight()
BinaryExpressionFluent<A>.NotRightNested<A>	withNewNotRightLike(Not item)
BinaryExpressionFluent<A>.PlusLeftNested<A>	withNewPlusLeft()
A	withNewPlusLeft(Object left, Object right)
BinaryExpressionFluent<A>.PlusLeftNested<A>	withNewPlusLeftLike(Plus item)
BinaryExpressionFluent<A>.PlusRightNested<A>	withNewPlusRight()
A	withNewPlusRight(Object left, Object right)
BinaryExpressionFluent<A>.PlusRightNested<A>	withNewPlusRightLike(Plus item)
BinaryExpressionFluent<A>.PositiveLeftNested<A>	withNewPositiveLeft()
BinaryExpressionFluent<A>.PositiveLeftNested<A>	withNewPositiveLeftLike(Positive item)
BinaryExpressionFluent<A>.PositiveRightNested<A>	withNewPositiveRight()
BinaryExpressionFluent<A>.PositiveRightNested<A>	withNewPositiveRightLike(Positive item)
BinaryExpressionFluent<A>.PostDecrementLeftNested<A>	withNewPostDecrementLeft()
BinaryExpressionFluent<A>.PostDecrementLeftNested<A>	withNewPostDecrementLeftLike(PostDecrement item)
BinaryExpressionFluent<A>.PostDecrementRightNested<A>	withNewPostDecrementRight()
BinaryExpressionFluent<A>.PostDecrementRightNested<A>	withNewPostDecrementRightLike(PostDecrement item)
BinaryExpressionFluent<A>.PostIncrementLeftNested<A>	withNewPostIncrementLeft()
BinaryExpressionFluent<A>.PostIncrementLeftNested<A>	withNewPostIncrementLeftLike(PostIncrement item)
BinaryExpressionFluent<A>.PostIncrementRightNested<A>	withNewPostIncrementRight()
BinaryExpressionFluent<A>.PostIncrementRightNested<A>	withNewPostIncrementRightLike(PostIncrement item)
BinaryExpressionFluent<A>.PreDecrementLeftNested<A>	withNewPreDecrementLeft()
BinaryExpressionFluent<A>.PreDecrementLeftNested<A>	withNewPreDecrementLeftLike(PreDecrement item)
BinaryExpressionFluent<A>.PreDecrementRightNested<A>	withNewPreDecrementRight()
BinaryExpressionFluent<A>.PreDecrementRightNested<A>	withNewPreDecrementRightLike(PreDecrement item)
BinaryExpressionFluent<A>.PreIncrementLeftNested<A>	withNewPreIncrementLeft()
BinaryExpressionFluent<A>.PreIncrementLeftNested<A>	withNewPreIncrementLeftLike(PreIncrement item)
BinaryExpressionFluent<A>.PreIncrementRightNested<A>	withNewPreIncrementRight()
BinaryExpressionFluent<A>.PreIncrementRightNested<A>	withNewPreIncrementRightLike(PreIncrement item)
BinaryExpressionFluent<A>.PropertyLeftNested<A>	withNewPropertyLeft()
BinaryExpressionFluent<A>.PropertyLeftNested<A>	withNewPropertyLeftLike(Property item)
BinaryExpressionFluent<A>.PropertyRefLeftNested<A>	withNewPropertyRefLeft()
BinaryExpressionFluent<A>.PropertyRefLeftNested<A>	withNewPropertyRefLeftLike(PropertyRef item)
BinaryExpressionFluent<A>.PropertyRefRightNested<A>	withNewPropertyRefRight()
BinaryExpressionFluent<A>.PropertyRefRightNested<A>	withNewPropertyRefRightLike(PropertyRef item)
BinaryExpressionFluent<A>.PropertyRightNested<A>	withNewPropertyRight()
BinaryExpressionFluent<A>.PropertyRightNested<A>	withNewPropertyRightLike(Property item)
BinaryExpressionFluent<A>.RightShiftLeftNested<A>	withNewRightShiftLeft()
A	withNewRightShiftLeft(Object left, Object right)
BinaryExpressionFluent<A>.RightShiftLeftNested<A>	withNewRightShiftLeftLike(RightShift item)
BinaryExpressionFluent<A>.RightShiftRightNested<A>	withNewRightShiftRight()
A	withNewRightShiftRight(Object left, Object right)
BinaryExpressionFluent<A>.RightShiftRightNested<A>	withNewRightShiftRightLike(RightShift item)
BinaryExpressionFluent<A>.RightUnsignedShiftLeftNested<A>	withNewRightUnsignedShiftLeft()
A	withNewRightUnsignedShiftLeft(Object left, Object right)
BinaryExpressionFluent<A>.RightUnsignedShiftLeftNested<A>	withNewRightUnsignedShiftLeftLike(RightUnsignedShift item)
BinaryExpressionFluent<A>.RightUnsignedShiftRightNested<A>	withNewRightUnsignedShiftRight()
A	withNewRightUnsignedShiftRight(Object left, Object right)
BinaryExpressionFluent<A>.RightUnsignedShiftRightNested<A>	withNewRightUnsignedShiftRightLike(RightUnsignedShift item)
BinaryExpressionFluent<A>.SuperLeftNested<A>	withNewSuperLeft()
BinaryExpressionFluent<A>.SuperLeftNested<A>	withNewSuperLeftLike(Super item)
BinaryExpressionFluent<A>.SuperRightNested<A>	withNewSuperRight()
BinaryExpressionFluent<A>.SuperRightNested<A>	withNewSuperRightLike(Super item)
BinaryExpressionFluent<A>.TernaryLeftNested<A>	withNewTernaryLeft()
BinaryExpressionFluent<A>.TernaryLeftNested<A>	withNewTernaryLeftLike(Ternary item)
BinaryExpressionFluent<A>.TernaryRightNested<A>	withNewTernaryRight()
BinaryExpressionFluent<A>.TernaryRightNested<A>	withNewTernaryRightLike(Ternary item)
BinaryExpressionFluent<A>.ThisLeftNested<A>	withNewThisLeft()
BinaryExpressionFluent<A>.ThisLeftNested<A>	withNewThisLeftLike(This item)
BinaryExpressionFluent<A>.ThisRightNested<A>	withNewThisRight()
BinaryExpressionFluent<A>.ThisRightNested<A>	withNewThisRightLike(This item)
BinaryExpressionFluent<A>.ValueRefLeftNested<A>	withNewValueRefLeft()
A	withNewValueRefLeft(Object value)
BinaryExpressionFluent<A>.ValueRefLeftNested<A>	withNewValueRefLeftLike(ValueRef item)
BinaryExpressionFluent<A>.ValueRefRightNested<A>	withNewValueRefRight()
A	withNewValueRefRight(Object value)
BinaryExpressionFluent<A>.ValueRefRightNested<A>	withNewValueRefRightLike(ValueRef item)
BinaryExpressionFluent<A>.XorLeftNested<A>	withNewXorLeft()
A	withNewXorLeft(Object left, Object right)
BinaryExpressionFluent<A>.XorLeftNested<A>	withNewXorLeftLike(Xor item)
BinaryExpressionFluent<A>.XorRightNested<A>	withNewXorRight()
A	withNewXorRight(Object left, Object right)
BinaryExpressionFluent<A>.XorRightNested<A>	withNewXorRightLike(Xor item)
A	withRight(Expression right)

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Details

BinaryExpressionFluent

public BinaryExpressionFluent()

BinaryExpressionFluent

public BinaryExpressionFluent(BinaryExpression instance)

Method Details

buildLeft

public Expression buildLeft()

buildRight

public Expression buildRight()

builder

protected static <T> VisitableBuilder<T,?> builder(Object item)

copyInstance

protected void copyInstance(BinaryExpression instance)

equals

public boolean equals(Object o)

Overrides:

equals in class BaseFluent<A extends BinaryExpressionFluent<A>>

hasLeft

public boolean hasLeft()

hasRight

public boolean hasRight()

hashCode

public int hashCode()

Overrides:

hashCode in class BaseFluent<A extends BinaryExpressionFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

withLeft

public A withLeft(Expression left)

withNewAssignLeft

public BinaryExpressionFluent<A>.AssignLeftNested<A> withNewAssignLeft()

withNewAssignLeftLike

public BinaryExpressionFluent<A>.AssignLeftNested<A> withNewAssignLeftLike(Assign item)

withNewAssignRight

public BinaryExpressionFluent<A>.AssignRightNested<A> withNewAssignRight()

withNewAssignRightLike

public BinaryExpressionFluent<A>.AssignRightNested<A> withNewAssignRightLike(Assign item)

withNewBinaryExpressionLeft

public BinaryExpressionFluent<A>.BinaryExpressionLeftNested<A> withNewBinaryExpressionLeft()

withNewBinaryExpressionLeftLike

public BinaryExpressionFluent<A>.BinaryExpressionLeftNested<A> withNewBinaryExpressionLeftLike(BinaryExpression item)

withNewBinaryExpressionRight

public BinaryExpressionFluent<A>.BinaryExpressionRightNested<A> withNewBinaryExpressionRight()

withNewBinaryExpressionRightLike

public BinaryExpressionFluent<A>.BinaryExpressionRightNested<A> withNewBinaryExpressionRightLike(BinaryExpression item)

withNewBitwiseAndLeft

public BinaryExpressionFluent<A>.BitwiseAndLeftNested<A> withNewBitwiseAndLeft()

withNewBitwiseAndLeft

public A withNewBitwiseAndLeft(Object left,
 Object right)

withNewBitwiseAndLeftLike

public BinaryExpressionFluent<A>.BitwiseAndLeftNested<A> withNewBitwiseAndLeftLike(BitwiseAnd item)

withNewBitwiseAndRight

public BinaryExpressionFluent<A>.BitwiseAndRightNested<A> withNewBitwiseAndRight()

withNewBitwiseAndRight

public A withNewBitwiseAndRight(Object left,
 Object right)

withNewBitwiseAndRightLike

public BinaryExpressionFluent<A>.BitwiseAndRightNested<A> withNewBitwiseAndRightLike(BitwiseAnd item)

withNewBitwiseOrLeft

public BinaryExpressionFluent<A>.BitwiseOrLeftNested<A> withNewBitwiseOrLeft()

withNewBitwiseOrLeft

public A withNewBitwiseOrLeft(Object left,
 Object right)

withNewBitwiseOrLeftLike

public BinaryExpressionFluent<A>.BitwiseOrLeftNested<A> withNewBitwiseOrLeftLike(BitwiseOr item)

withNewBitwiseOrRight

public BinaryExpressionFluent<A>.BitwiseOrRightNested<A> withNewBitwiseOrRight()

withNewBitwiseOrRight

public A withNewBitwiseOrRight(Object left,
 Object right)

withNewBitwiseOrRightLike

public BinaryExpressionFluent<A>.BitwiseOrRightNested<A> withNewBitwiseOrRightLike(BitwiseOr item)

withNewCastLeft

public BinaryExpressionFluent<A>.CastLeftNested<A> withNewCastLeft()

withNewCastLeftLike

public BinaryExpressionFluent<A>.CastLeftNested<A> withNewCastLeftLike(Cast item)

withNewCastRight

public BinaryExpressionFluent<A>.CastRightNested<A> withNewCastRight()

withNewCastRightLike

public BinaryExpressionFluent<A>.CastRightNested<A> withNewCastRightLike(Cast item)

withNewClassRefLeft

public BinaryExpressionFluent<A>.ClassRefLeftNested<A> withNewClassRefLeft()

withNewClassRefLeftLike

public BinaryExpressionFluent<A>.ClassRefLeftNested<A> withNewClassRefLeftLike(ClassRef item)

withNewClassRefRight

public BinaryExpressionFluent<A>.ClassRefRightNested<A> withNewClassRefRight()

withNewClassRefRightLike

public BinaryExpressionFluent<A>.ClassRefRightNested<A> withNewClassRefRightLike(ClassRef item)

withNewConstructLeft

public BinaryExpressionFluent<A>.ConstructLeftNested<A> withNewConstructLeft()

withNewConstructLeftLike

public BinaryExpressionFluent<A>.ConstructLeftNested<A> withNewConstructLeftLike(Construct item)

withNewConstructRight

public BinaryExpressionFluent<A>.ConstructRightNested<A> withNewConstructRight()

withNewConstructRightLike

public BinaryExpressionFluent<A>.ConstructRightNested<A> withNewConstructRightLike(Construct item)

withNewContextRefLeft

public BinaryExpressionFluent<A>.ContextRefLeftNested<A> withNewContextRefLeft()

withNewContextRefLeft

public A withNewContextRefLeft(String name)

withNewContextRefLeftLike

public BinaryExpressionFluent<A>.ContextRefLeftNested<A> withNewContextRefLeftLike(ContextRef item)

withNewContextRefRight

public BinaryExpressionFluent<A>.ContextRefRightNested<A> withNewContextRefRight()

withNewContextRefRight

public A withNewContextRefRight(String name)

withNewContextRefRightLike

public BinaryExpressionFluent<A>.ContextRefRightNested<A> withNewContextRefRightLike(ContextRef item)

withNewDeclareLeft

public BinaryExpressionFluent<A>.DeclareLeftNested<A> withNewDeclareLeft()

withNewDeclareLeft

public A withNewDeclareLeft(Class type,
 String name)

withNewDeclareLeft

public A withNewDeclareLeft(Class type,
 String name,
 Object value)

withNewDeclareLeftLike

public BinaryExpressionFluent<A>.DeclareLeftNested<A> withNewDeclareLeftLike(Declare item)

withNewDeclareRight

public BinaryExpressionFluent<A>.DeclareRightNested<A> withNewDeclareRight()

withNewDeclareRight

public A withNewDeclareRight(Class type,
 String name)

withNewDeclareRight

public A withNewDeclareRight(Class type,
 String name,
 Object value)

withNewDeclareRightLike

public BinaryExpressionFluent<A>.DeclareRightNested<A> withNewDeclareRightLike(Declare item)

withNewDivideLeft

public BinaryExpressionFluent<A>.DivideLeftNested<A> withNewDivideLeft()

withNewDivideLeft

public A withNewDivideLeft(Object left,
 Object right)

withNewDivideLeftLike

public BinaryExpressionFluent<A>.DivideLeftNested<A> withNewDivideLeftLike(Divide item)

withNewDivideRight

public BinaryExpressionFluent<A>.DivideRightNested<A> withNewDivideRight()

withNewDivideRight

public A withNewDivideRight(Object left,
 Object right)

withNewDivideRightLike

public BinaryExpressionFluent<A>.DivideRightNested<A> withNewDivideRightLike(Divide item)

withNewDotClassLeft

public BinaryExpressionFluent<A>.DotClassLeftNested<A> withNewDotClassLeft()

withNewDotClassLeftLike

public BinaryExpressionFluent<A>.DotClassLeftNested<A> withNewDotClassLeftLike(DotClass item)

withNewDotClassRight

public BinaryExpressionFluent<A>.DotClassRightNested<A> withNewDotClassRight()

withNewDotClassRightLike

public BinaryExpressionFluent<A>.DotClassRightNested<A> withNewDotClassRightLike(DotClass item)

withNewEmptyLeft

public BinaryExpressionFluent<A>.EmptyLeftNested<A> withNewEmptyLeft()

withNewEmptyLeftLike

public BinaryExpressionFluent<A>.EmptyLeftNested<A> withNewEmptyLeftLike(Empty item)

withNewEmptyRight

public BinaryExpressionFluent<A>.EmptyRightNested<A> withNewEmptyRight()

withNewEmptyRightLike

public BinaryExpressionFluent<A>.EmptyRightNested<A> withNewEmptyRightLike(Empty item)

withNewEnclosedLeft

public BinaryExpressionFluent<A>.EnclosedLeftNested<A> withNewEnclosedLeft()

withNewEnclosedLeftLike

public BinaryExpressionFluent<A>.EnclosedLeftNested<A> withNewEnclosedLeftLike(Enclosed item)

withNewEnclosedRight

public BinaryExpressionFluent<A>.EnclosedRightNested<A> withNewEnclosedRight()

withNewEnclosedRightLike

public BinaryExpressionFluent<A>.EnclosedRightNested<A> withNewEnclosedRightLike(Enclosed item)

withNewEqualsLeft

public BinaryExpressionFluent<A>.EqualsLeftNested<A> withNewEqualsLeft()

withNewEqualsLeft

public A withNewEqualsLeft(Object left,
 Object right)

withNewEqualsLeftLike

public BinaryExpressionFluent<A>.EqualsLeftNested<A> withNewEqualsLeftLike(Equals item)

withNewEqualsRight

public BinaryExpressionFluent<A>.EqualsRightNested<A> withNewEqualsRight()

withNewEqualsRight

public A withNewEqualsRight(Object left,
 Object right)

withNewEqualsRightLike

public BinaryExpressionFluent<A>.EqualsRightNested<A> withNewEqualsRightLike(Equals item)

withNewGreaterThanLeft

public BinaryExpressionFluent<A>.GreaterThanLeftNested<A> withNewGreaterThanLeft()

withNewGreaterThanLeft

public A withNewGreaterThanLeft(Object left,
 Object right)

withNewGreaterThanLeftLike

public BinaryExpressionFluent<A>.GreaterThanLeftNested<A> withNewGreaterThanLeftLike(GreaterThan item)

withNewGreaterThanOrEqualLeft

public BinaryExpressionFluent<A>.GreaterThanOrEqualLeftNested<A> withNewGreaterThanOrEqualLeft()

withNewGreaterThanOrEqualLeft

public A withNewGreaterThanOrEqualLeft(Object left,
 Object right)

withNewGreaterThanOrEqualLeftLike

public BinaryExpressionFluent<A>.GreaterThanOrEqualLeftNested<A> withNewGreaterThanOrEqualLeftLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualRight

public BinaryExpressionFluent<A>.GreaterThanOrEqualRightNested<A> withNewGreaterThanOrEqualRight()

withNewGreaterThanOrEqualRight

public A withNewGreaterThanOrEqualRight(Object left,
 Object right)

withNewGreaterThanOrEqualRightLike

public BinaryExpressionFluent<A>.GreaterThanOrEqualRightNested<A> withNewGreaterThanOrEqualRightLike(GreaterThanOrEqual item)

withNewGreaterThanRight

public BinaryExpressionFluent<A>.GreaterThanRightNested<A> withNewGreaterThanRight()

withNewGreaterThanRight

public A withNewGreaterThanRight(Object left,
 Object right)

withNewGreaterThanRightLike

public BinaryExpressionFluent<A>.GreaterThanRightNested<A> withNewGreaterThanRightLike(GreaterThan item)

withNewIndexLeft

public BinaryExpressionFluent<A>.IndexLeftNested<A> withNewIndexLeft()

withNewIndexLeftLike

public BinaryExpressionFluent<A>.IndexLeftNested<A> withNewIndexLeftLike(Index item)

withNewIndexRight

public BinaryExpressionFluent<A>.IndexRightNested<A> withNewIndexRight()

withNewIndexRightLike

public BinaryExpressionFluent<A>.IndexRightNested<A> withNewIndexRightLike(Index item)

withNewInstanceOfLeft

public BinaryExpressionFluent<A>.InstanceOfLeftNested<A> withNewInstanceOfLeft()

withNewInstanceOfLeftLike

public BinaryExpressionFluent<A>.InstanceOfLeftNested<A> withNewInstanceOfLeftLike(InstanceOf item)

withNewInstanceOfRight

public BinaryExpressionFluent<A>.InstanceOfRightNested<A> withNewInstanceOfRight()

withNewInstanceOfRightLike

public BinaryExpressionFluent<A>.InstanceOfRightNested<A> withNewInstanceOfRightLike(InstanceOf item)

withNewInverseLeft

public BinaryExpressionFluent<A>.InverseLeftNested<A> withNewInverseLeft()

withNewInverseLeftLike

public BinaryExpressionFluent<A>.InverseLeftNested<A> withNewInverseLeftLike(Inverse item)

withNewInverseRight

public BinaryExpressionFluent<A>.InverseRightNested<A> withNewInverseRight()

withNewInverseRightLike

public BinaryExpressionFluent<A>.InverseRightNested<A> withNewInverseRightLike(Inverse item)

withNewLambdaLeft

public BinaryExpressionFluent<A>.LambdaLeftNested<A> withNewLambdaLeft()

withNewLambdaLeftLike

public BinaryExpressionFluent<A>.LambdaLeftNested<A> withNewLambdaLeftLike(Lambda item)

withNewLambdaRight

public BinaryExpressionFluent<A>.LambdaRightNested<A> withNewLambdaRight()

withNewLambdaRightLike

public BinaryExpressionFluent<A>.LambdaRightNested<A> withNewLambdaRightLike(Lambda item)

withNewLeftShiftLeft

public BinaryExpressionFluent<A>.LeftShiftLeftNested<A> withNewLeftShiftLeft()

withNewLeftShiftLeft

public A withNewLeftShiftLeft(Object left,
 Object right)

withNewLeftShiftLeftLike

public BinaryExpressionFluent<A>.LeftShiftLeftNested<A> withNewLeftShiftLeftLike(LeftShift item)

withNewLeftShiftRight

public BinaryExpressionFluent<A>.LeftShiftRightNested<A> withNewLeftShiftRight()

withNewLeftShiftRight

public A withNewLeftShiftRight(Object left,
 Object right)

withNewLeftShiftRightLike

public BinaryExpressionFluent<A>.LeftShiftRightNested<A> withNewLeftShiftRightLike(LeftShift item)

withNewLessThanLeft

public BinaryExpressionFluent<A>.LessThanLeftNested<A> withNewLessThanLeft()

withNewLessThanLeft

public A withNewLessThanLeft(Object left,
 Object right)

withNewLessThanLeftLike

public BinaryExpressionFluent<A>.LessThanLeftNested<A> withNewLessThanLeftLike(LessThan item)

withNewLessThanOrEqualLeft

public BinaryExpressionFluent<A>.LessThanOrEqualLeftNested<A> withNewLessThanOrEqualLeft()

withNewLessThanOrEqualLeft

public A withNewLessThanOrEqualLeft(Object left,
 Object right)

withNewLessThanOrEqualLeftLike

public BinaryExpressionFluent<A>.LessThanOrEqualLeftNested<A> withNewLessThanOrEqualLeftLike(LessThanOrEqual item)

withNewLessThanOrEqualRight

public BinaryExpressionFluent<A>.LessThanOrEqualRightNested<A> withNewLessThanOrEqualRight()

withNewLessThanOrEqualRight

public A withNewLessThanOrEqualRight(Object left,
 Object right)

withNewLessThanOrEqualRightLike

public BinaryExpressionFluent<A>.LessThanOrEqualRightNested<A> withNewLessThanOrEqualRightLike(LessThanOrEqual item)

withNewLessThanRight

public BinaryExpressionFluent<A>.LessThanRightNested<A> withNewLessThanRight()

withNewLessThanRight

public A withNewLessThanRight(Object left,
 Object right)

withNewLessThanRightLike

public BinaryExpressionFluent<A>.LessThanRightNested<A> withNewLessThanRightLike(LessThan item)

withNewLogicalAndLeft

public BinaryExpressionFluent<A>.LogicalAndLeftNested<A> withNewLogicalAndLeft()

withNewLogicalAndLeft

public A withNewLogicalAndLeft(Object left,
 Object right)

withNewLogicalAndLeftLike

public BinaryExpressionFluent<A>.LogicalAndLeftNested<A> withNewLogicalAndLeftLike(LogicalAnd item)

withNewLogicalAndRight

public BinaryExpressionFluent<A>.LogicalAndRightNested<A> withNewLogicalAndRight()

withNewLogicalAndRight

public A withNewLogicalAndRight(Object left,
 Object right)

withNewLogicalAndRightLike

public BinaryExpressionFluent<A>.LogicalAndRightNested<A> withNewLogicalAndRightLike(LogicalAnd item)

withNewLogicalOrLeft

public BinaryExpressionFluent<A>.LogicalOrLeftNested<A> withNewLogicalOrLeft()

withNewLogicalOrLeft

public A withNewLogicalOrLeft(Object left,
 Object right)

withNewLogicalOrLeftLike

public BinaryExpressionFluent<A>.LogicalOrLeftNested<A> withNewLogicalOrLeftLike(LogicalOr item)

withNewLogicalOrRight

public BinaryExpressionFluent<A>.LogicalOrRightNested<A> withNewLogicalOrRight()

withNewLogicalOrRight

public A withNewLogicalOrRight(Object left,
 Object right)

withNewLogicalOrRightLike

public BinaryExpressionFluent<A>.LogicalOrRightNested<A> withNewLogicalOrRightLike(LogicalOr item)

withNewMethodCallLeft

public BinaryExpressionFluent<A>.MethodCallLeftNested<A> withNewMethodCallLeft()

withNewMethodCallLeftLike

public BinaryExpressionFluent<A>.MethodCallLeftNested<A> withNewMethodCallLeftLike(MethodCall item)

withNewMethodCallRight

public BinaryExpressionFluent<A>.MethodCallRightNested<A> withNewMethodCallRight()

withNewMethodCallRightLike

public BinaryExpressionFluent<A>.MethodCallRightNested<A> withNewMethodCallRightLike(MethodCall item)

withNewMinusLeft

public BinaryExpressionFluent<A>.MinusLeftNested<A> withNewMinusLeft()

withNewMinusLeft

public A withNewMinusLeft(Object left,
 Object right)

withNewMinusLeftLike

public BinaryExpressionFluent<A>.MinusLeftNested<A> withNewMinusLeftLike(Minus item)

withNewMinusRight

public BinaryExpressionFluent<A>.MinusRightNested<A> withNewMinusRight()

withNewMinusRight

public A withNewMinusRight(Object left,
 Object right)

withNewMinusRightLike

public BinaryExpressionFluent<A>.MinusRightNested<A> withNewMinusRightLike(Minus item)

withNewModuloLeft

public BinaryExpressionFluent<A>.ModuloLeftNested<A> withNewModuloLeft()

withNewModuloLeft

public A withNewModuloLeft(Object left,
 Object right)

withNewModuloLeftLike

public BinaryExpressionFluent<A>.ModuloLeftNested<A> withNewModuloLeftLike(Modulo item)

withNewModuloRight

public BinaryExpressionFluent<A>.ModuloRightNested<A> withNewModuloRight()

withNewModuloRight

public A withNewModuloRight(Object left,
 Object right)

withNewModuloRightLike

public BinaryExpressionFluent<A>.ModuloRightNested<A> withNewModuloRightLike(Modulo item)

withNewMultiplyLeft

public BinaryExpressionFluent<A>.MultiplyLeftNested<A> withNewMultiplyLeft()

withNewMultiplyLeft

public A withNewMultiplyLeft(Object left,
 Object right)

withNewMultiplyLeftLike

public BinaryExpressionFluent<A>.MultiplyLeftNested<A> withNewMultiplyLeftLike(Multiply item)

withNewMultiplyRight

public BinaryExpressionFluent<A>.MultiplyRightNested<A> withNewMultiplyRight()

withNewMultiplyRight

public A withNewMultiplyRight(Object left,
 Object right)

withNewMultiplyRightLike

public BinaryExpressionFluent<A>.MultiplyRightNested<A> withNewMultiplyRightLike(Multiply item)

withNewNegativeLeft

public BinaryExpressionFluent<A>.NegativeLeftNested<A> withNewNegativeLeft()

withNewNegativeLeftLike

public BinaryExpressionFluent<A>.NegativeLeftNested<A> withNewNegativeLeftLike(Negative item)

withNewNegativeRight

public BinaryExpressionFluent<A>.NegativeRightNested<A> withNewNegativeRight()

withNewNegativeRightLike

public BinaryExpressionFluent<A>.NegativeRightNested<A> withNewNegativeRightLike(Negative item)

withNewNewArrayLeft

public BinaryExpressionFluent<A>.NewArrayLeftNested<A> withNewNewArrayLeft()

withNewNewArrayLeft

public A withNewNewArrayLeft(Class type,
 Integer[] sizes)

withNewNewArrayLeftLike

public BinaryExpressionFluent<A>.NewArrayLeftNested<A> withNewNewArrayLeftLike(NewArray item)

withNewNewArrayRight

public BinaryExpressionFluent<A>.NewArrayRightNested<A> withNewNewArrayRight()

withNewNewArrayRight

public A withNewNewArrayRight(Class type,
 Integer[] sizes)

withNewNewArrayRightLike

public BinaryExpressionFluent<A>.NewArrayRightNested<A> withNewNewArrayRightLike(NewArray item)

withNewNotEqualsLeft

public BinaryExpressionFluent<A>.NotEqualsLeftNested<A> withNewNotEqualsLeft()

withNewNotEqualsLeft

public A withNewNotEqualsLeft(Object left,
 Object right)

withNewNotEqualsLeftLike

public BinaryExpressionFluent<A>.NotEqualsLeftNested<A> withNewNotEqualsLeftLike(NotEquals item)

withNewNotEqualsRight

public BinaryExpressionFluent<A>.NotEqualsRightNested<A> withNewNotEqualsRight()

withNewNotEqualsRight

public A withNewNotEqualsRight(Object left,
 Object right)

withNewNotEqualsRightLike

public BinaryExpressionFluent<A>.NotEqualsRightNested<A> withNewNotEqualsRightLike(NotEquals item)

withNewNotLeft

public BinaryExpressionFluent<A>.NotLeftNested<A> withNewNotLeft()

withNewNotLeftLike

public BinaryExpressionFluent<A>.NotLeftNested<A> withNewNotLeftLike(Not item)

withNewNotRight

public BinaryExpressionFluent<A>.NotRightNested<A> withNewNotRight()

withNewNotRightLike

public BinaryExpressionFluent<A>.NotRightNested<A> withNewNotRightLike(Not item)

withNewPlusLeft

public BinaryExpressionFluent<A>.PlusLeftNested<A> withNewPlusLeft()

withNewPlusLeft

public A withNewPlusLeft(Object left,
 Object right)

withNewPlusLeftLike

public BinaryExpressionFluent<A>.PlusLeftNested<A> withNewPlusLeftLike(Plus item)

withNewPlusRight

public BinaryExpressionFluent<A>.PlusRightNested<A> withNewPlusRight()

withNewPlusRight

public A withNewPlusRight(Object left,
 Object right)

withNewPlusRightLike

public BinaryExpressionFluent<A>.PlusRightNested<A> withNewPlusRightLike(Plus item)

withNewPositiveLeft

public BinaryExpressionFluent<A>.PositiveLeftNested<A> withNewPositiveLeft()

withNewPositiveLeftLike

public BinaryExpressionFluent<A>.PositiveLeftNested<A> withNewPositiveLeftLike(Positive item)

withNewPositiveRight

public BinaryExpressionFluent<A>.PositiveRightNested<A> withNewPositiveRight()

withNewPositiveRightLike

public BinaryExpressionFluent<A>.PositiveRightNested<A> withNewPositiveRightLike(Positive item)

withNewPostDecrementLeft

public BinaryExpressionFluent<A>.PostDecrementLeftNested<A> withNewPostDecrementLeft()

withNewPostDecrementLeftLike

public BinaryExpressionFluent<A>.PostDecrementLeftNested<A> withNewPostDecrementLeftLike(PostDecrement item)

withNewPostDecrementRight

public BinaryExpressionFluent<A>.PostDecrementRightNested<A> withNewPostDecrementRight()

withNewPostDecrementRightLike

public BinaryExpressionFluent<A>.PostDecrementRightNested<A> withNewPostDecrementRightLike(PostDecrement item)

withNewPostIncrementLeft

public BinaryExpressionFluent<A>.PostIncrementLeftNested<A> withNewPostIncrementLeft()

withNewPostIncrementLeftLike

public BinaryExpressionFluent<A>.PostIncrementLeftNested<A> withNewPostIncrementLeftLike(PostIncrement item)

withNewPostIncrementRight

public BinaryExpressionFluent<A>.PostIncrementRightNested<A> withNewPostIncrementRight()

withNewPostIncrementRightLike

public BinaryExpressionFluent<A>.PostIncrementRightNested<A> withNewPostIncrementRightLike(PostIncrement item)

withNewPreDecrementLeft

public BinaryExpressionFluent<A>.PreDecrementLeftNested<A> withNewPreDecrementLeft()

withNewPreDecrementLeftLike

public BinaryExpressionFluent<A>.PreDecrementLeftNested<A> withNewPreDecrementLeftLike(PreDecrement item)

withNewPreDecrementRight

public BinaryExpressionFluent<A>.PreDecrementRightNested<A> withNewPreDecrementRight()

withNewPreDecrementRightLike

public BinaryExpressionFluent<A>.PreDecrementRightNested<A> withNewPreDecrementRightLike(PreDecrement item)

withNewPreIncrementLeft

public BinaryExpressionFluent<A>.PreIncrementLeftNested<A> withNewPreIncrementLeft()

withNewPreIncrementLeftLike

public BinaryExpressionFluent<A>.PreIncrementLeftNested<A> withNewPreIncrementLeftLike(PreIncrement item)

withNewPreIncrementRight

public BinaryExpressionFluent<A>.PreIncrementRightNested<A> withNewPreIncrementRight()

withNewPreIncrementRightLike

public BinaryExpressionFluent<A>.PreIncrementRightNested<A> withNewPreIncrementRightLike(PreIncrement item)

withNewPropertyLeft

public BinaryExpressionFluent<A>.PropertyLeftNested<A> withNewPropertyLeft()

withNewPropertyLeftLike

public BinaryExpressionFluent<A>.PropertyLeftNested<A> withNewPropertyLeftLike(Property item)

withNewPropertyRefLeft

public BinaryExpressionFluent<A>.PropertyRefLeftNested<A> withNewPropertyRefLeft()

withNewPropertyRefLeftLike

public BinaryExpressionFluent<A>.PropertyRefLeftNested<A> withNewPropertyRefLeftLike(PropertyRef item)

withNewPropertyRefRight

public BinaryExpressionFluent<A>.PropertyRefRightNested<A> withNewPropertyRefRight()

withNewPropertyRefRightLike

public BinaryExpressionFluent<A>.PropertyRefRightNested<A> withNewPropertyRefRightLike(PropertyRef item)

withNewPropertyRight

public BinaryExpressionFluent<A>.PropertyRightNested<A> withNewPropertyRight()

withNewPropertyRightLike

public BinaryExpressionFluent<A>.PropertyRightNested<A> withNewPropertyRightLike(Property item)

withNewRightShiftLeft

public BinaryExpressionFluent<A>.RightShiftLeftNested<A> withNewRightShiftLeft()

withNewRightShiftLeft

public A withNewRightShiftLeft(Object left,
 Object right)

withNewRightShiftLeftLike

public BinaryExpressionFluent<A>.RightShiftLeftNested<A> withNewRightShiftLeftLike(RightShift item)

withNewRightShiftRight

public BinaryExpressionFluent<A>.RightShiftRightNested<A> withNewRightShiftRight()

withNewRightShiftRight

public A withNewRightShiftRight(Object left,
 Object right)

withNewRightShiftRightLike

public BinaryExpressionFluent<A>.RightShiftRightNested<A> withNewRightShiftRightLike(RightShift item)

withNewRightUnsignedShiftLeft

public BinaryExpressionFluent<A>.RightUnsignedShiftLeftNested<A> withNewRightUnsignedShiftLeft()

withNewRightUnsignedShiftLeft

public A withNewRightUnsignedShiftLeft(Object left,
 Object right)

withNewRightUnsignedShiftLeftLike

public BinaryExpressionFluent<A>.RightUnsignedShiftLeftNested<A> withNewRightUnsignedShiftLeftLike(RightUnsignedShift item)

withNewRightUnsignedShiftRight

public BinaryExpressionFluent<A>.RightUnsignedShiftRightNested<A> withNewRightUnsignedShiftRight()

withNewRightUnsignedShiftRight

public A withNewRightUnsignedShiftRight(Object left,
 Object right)

withNewRightUnsignedShiftRightLike

public BinaryExpressionFluent<A>.RightUnsignedShiftRightNested<A> withNewRightUnsignedShiftRightLike(RightUnsignedShift item)

withNewSuperLeft

public BinaryExpressionFluent<A>.SuperLeftNested<A> withNewSuperLeft()

withNewSuperLeftLike

public BinaryExpressionFluent<A>.SuperLeftNested<A> withNewSuperLeftLike(Super item)

withNewSuperRight

public BinaryExpressionFluent<A>.SuperRightNested<A> withNewSuperRight()

withNewSuperRightLike

public BinaryExpressionFluent<A>.SuperRightNested<A> withNewSuperRightLike(Super item)

withNewTernaryLeft

public BinaryExpressionFluent<A>.TernaryLeftNested<A> withNewTernaryLeft()

withNewTernaryLeftLike

public BinaryExpressionFluent<A>.TernaryLeftNested<A> withNewTernaryLeftLike(Ternary item)

withNewTernaryRight

public BinaryExpressionFluent<A>.TernaryRightNested<A> withNewTernaryRight()

withNewTernaryRightLike

public BinaryExpressionFluent<A>.TernaryRightNested<A> withNewTernaryRightLike(Ternary item)

withNewThisLeft

public BinaryExpressionFluent<A>.ThisLeftNested<A> withNewThisLeft()

withNewThisLeftLike

public BinaryExpressionFluent<A>.ThisLeftNested<A> withNewThisLeftLike(This item)

withNewThisRight

public BinaryExpressionFluent<A>.ThisRightNested<A> withNewThisRight()

withNewThisRightLike

public BinaryExpressionFluent<A>.ThisRightNested<A> withNewThisRightLike(This item)

withNewValueRefLeft

public BinaryExpressionFluent<A>.ValueRefLeftNested<A> withNewValueRefLeft()

withNewValueRefLeft

public A withNewValueRefLeft(Object value)

withNewValueRefLeftLike

public BinaryExpressionFluent<A>.ValueRefLeftNested<A> withNewValueRefLeftLike(ValueRef item)

withNewValueRefRight

public BinaryExpressionFluent<A>.ValueRefRightNested<A> withNewValueRefRight()

withNewValueRefRight

public A withNewValueRefRight(Object value)

withNewValueRefRightLike

public BinaryExpressionFluent<A>.ValueRefRightNested<A> withNewValueRefRightLike(ValueRef item)

withNewXorLeft

public BinaryExpressionFluent<A>.XorLeftNested<A> withNewXorLeft()

withNewXorLeft

public A withNewXorLeft(Object left,
 Object right)

withNewXorLeftLike

public BinaryExpressionFluent<A>.XorLeftNested<A> withNewXorLeftLike(Xor item)

withNewXorRight

public BinaryExpressionFluent<A>.XorRightNested<A> withNewXorRight()

withNewXorRight

public A withNewXorRight(Object left,
 Object right)

withNewXorRightLike

public BinaryExpressionFluent<A>.XorRightNested<A> withNewXorRightLike(Xor item)

withRight

public A withRight(Expression right)