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, CastFluent.BinaryExpressionNested, ConstructFluent.BinaryExpressionArgumentsNested, DivideFluent, DoFluent.BinaryExpressionConditionNested, EnclosedFluent.BinaryExpressionExpresionNested, EqualsFluent, ForeachFluent.BinaryExpressionNested, ForFluent.BinaryExpressionCompareNested, ForFluent.BinaryExpressionInitNested, ForFluent.BinaryExpressionUpdateNested, GreaterThanFluent, GreaterThanOrEqualFluent, IfFluent.BinaryExpressionConditionNested, IndexFluent.BinaryExpressionNested, IndexFluent.BinaryExpressionScopeNested, InstanceOfFluent.BinaryExpressionNested, InverseFluent.BinaryExpressionExpresionNested, LeftShiftFluent, LessThanFluent, LessThanOrEqualFluent, LogicalAndFluent, LogicalOrFluent, MethodCallFluent.BinaryExpressionArgumentsNested, MethodCallFluent.BinaryExpressionScopeNested, MinusFluent, ModuloFluent, MultiplyFluent, NegativeFluent.BinaryExpressionExpresionNested, NewArrayFluent.BinaryExpressionExpressionsNested, NotEqualsFluent, NotFluent.BinaryExpressionExpresionNested, PlusFluent, PositiveFluent.BinaryExpressionExpresionNested, PostDecrementFluent.BinaryExpressionNested, PostIncrementFluent.BinaryExpressionNested, PreDecrementFluent.BinaryExpressionNested, PreIncrementFluent.BinaryExpressionNested, PropertyRefFluent.BinaryExpressionScopeNested, ReturnFluent.BinaryExpressionNested, RightShiftFluent, RightUnsignedShiftFluent, SwitchFluent.BinaryExpressionNested, TernaryFluent.BinaryExpressionAlternativeNested, TernaryFluent.BinaryExpressionConditionNested, TernaryFluent.BinaryExpressionResultNested, WhileFluent.BinaryExpressionConditionNested, XorFluent

public class BinaryExpressionFluent<A extends BinaryExpressionFluent<A>>
extends io.sundr.builder.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.ConstructLeftNested<N>
class	BinaryExpressionFluent.ConstructRightNested<N>
class	BinaryExpressionFluent.DeclareLeftNested<N>
class	BinaryExpressionFluent.DeclareRightNested<N>
class	BinaryExpressionFluent.DivideLeftNested<N>
class	BinaryExpressionFluent.DivideRightNested<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.PropertyRefLeftNested<N>
class	BinaryExpressionFluent.PropertyRefRightNested<N>
class	BinaryExpressionFluent.RightShiftLeftNested<N>
class	BinaryExpressionFluent.RightShiftRightNested<N>
class	BinaryExpressionFluent.RightUnsignedShiftLeftNested<N>
class	BinaryExpressionFluent.RightUnsignedShiftRightNested<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(io.sundr.model.BinaryExpression instance)

Method Summary

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

BinaryExpressionFluent

public BinaryExpressionFluent()

BinaryExpressionFluent

public BinaryExpressionFluent(io.sundr.model.BinaryExpression instance)

Method Detail

copyInstance

protected void copyInstance(io.sundr.model.BinaryExpression instance)

buildLeft

public io.sundr.model.Expression buildLeft()

withLeft

public A withLeft(io.sundr.model.Expression left)

hasLeft

public boolean hasLeft()

withNewMultiplyLeft

public BinaryExpressionFluent.MultiplyLeftNested<A> withNewMultiplyLeft()

withNewMultiplyLeftLike

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

withNewMultiplyLeft

public A withNewMultiplyLeft(Object left,
                             Object right)

withNewNewArrayLeft

public BinaryExpressionFluent.NewArrayLeftNested<A> withNewNewArrayLeft()

withNewNewArrayLeftLike

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

withNewNewArrayLeft

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

withNewInstanceOfLeft

public BinaryExpressionFluent.InstanceOfLeftNested<A> withNewInstanceOfLeft()

withNewInstanceOfLeftLike

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

withNewMethodCallLeft

public BinaryExpressionFluent.MethodCallLeftNested<A> withNewMethodCallLeft()

withNewMethodCallLeftLike

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

withNewInverseLeft

public BinaryExpressionFluent.InverseLeftNested<A> withNewInverseLeft()

withNewInverseLeftLike

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

withNewIndexLeft

public BinaryExpressionFluent.IndexLeftNested<A> withNewIndexLeft()

withNewIndexLeftLike

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

withNewGreaterThanOrEqualLeft

public BinaryExpressionFluent.GreaterThanOrEqualLeftNested<A> withNewGreaterThanOrEqualLeft()

withNewGreaterThanOrEqualLeftLike

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

withNewGreaterThanOrEqualLeft

public A withNewGreaterThanOrEqualLeft(Object left,
                                       Object right)

withNewBitwiseAndLeft

public BinaryExpressionFluent.BitwiseAndLeftNested<A> withNewBitwiseAndLeft()

withNewBitwiseAndLeftLike

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

withNewBitwiseAndLeft

public A withNewBitwiseAndLeft(Object left,
                               Object right)

withNewMinusLeft

public BinaryExpressionFluent.MinusLeftNested<A> withNewMinusLeft()

withNewMinusLeftLike

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

withNewMinusLeft

public A withNewMinusLeft(Object left,
                          Object right)

withNewLogicalOrLeft

public BinaryExpressionFluent.LogicalOrLeftNested<A> withNewLogicalOrLeft()

withNewLogicalOrLeftLike

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

withNewLogicalOrLeft

public A withNewLogicalOrLeft(Object left,
                              Object right)

withNewNotEqualsLeft

public BinaryExpressionFluent.NotEqualsLeftNested<A> withNewNotEqualsLeft()

withNewNotEqualsLeftLike

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

withNewNotEqualsLeft

public A withNewNotEqualsLeft(Object left,
                              Object right)

withNewDivideLeft

public BinaryExpressionFluent.DivideLeftNested<A> withNewDivideLeft()

withNewDivideLeftLike

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

withNewDivideLeft

public A withNewDivideLeft(Object left,
                           Object right)

withNewLessThanLeft

public BinaryExpressionFluent.LessThanLeftNested<A> withNewLessThanLeft()

withNewLessThanLeftLike

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

withNewLessThanLeft

public A withNewLessThanLeft(Object left,
                             Object right)

withNewBitwiseOrLeft

public BinaryExpressionFluent.BitwiseOrLeftNested<A> withNewBitwiseOrLeft()

withNewBitwiseOrLeftLike

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

withNewBitwiseOrLeft

public A withNewBitwiseOrLeft(Object left,
                              Object right)

withNewPropertyRefLeft

public BinaryExpressionFluent.PropertyRefLeftNested<A> withNewPropertyRefLeft()

withNewPropertyRefLeftLike

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

withNewRightShiftLeft

public BinaryExpressionFluent.RightShiftLeftNested<A> withNewRightShiftLeft()

withNewRightShiftLeftLike

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

withNewRightShiftLeft

public A withNewRightShiftLeft(Object left,
                               Object right)

withNewGreaterThanLeft

public BinaryExpressionFluent.GreaterThanLeftNested<A> withNewGreaterThanLeft()

withNewGreaterThanLeftLike

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

withNewGreaterThanLeft

public A withNewGreaterThanLeft(Object left,
                                Object right)

withNewDeclareLeft

public BinaryExpressionFluent.DeclareLeftNested<A> withNewDeclareLeft()

withNewDeclareLeftLike

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

withNewDeclareLeft

public A withNewDeclareLeft(Class type,
                            String name)

withNewDeclareLeft

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

withNewCastLeft

public BinaryExpressionFluent.CastLeftNested<A> withNewCastLeft()

withNewCastLeftLike

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

withNewModuloLeft

public BinaryExpressionFluent.ModuloLeftNested<A> withNewModuloLeft()

withNewModuloLeftLike

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

withNewModuloLeft

public A withNewModuloLeft(Object left,
                           Object right)

withNewValueRefLeft

public BinaryExpressionFluent.ValueRefLeftNested<A> withNewValueRefLeft()

withNewValueRefLeftLike

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

withNewValueRefLeft

public A withNewValueRefLeft(Object value)

withNewLeftShiftLeft

public BinaryExpressionFluent.LeftShiftLeftNested<A> withNewLeftShiftLeft()

withNewLeftShiftLeftLike

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

withNewLeftShiftLeft

public A withNewLeftShiftLeft(Object left,
                              Object right)

withNewTernaryLeft

public BinaryExpressionFluent.TernaryLeftNested<A> withNewTernaryLeft()

withNewTernaryLeftLike

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

withNewBinaryExpressionLeft

public BinaryExpressionFluent.BinaryExpressionLeftNested<A> withNewBinaryExpressionLeft()

withNewBinaryExpressionLeftLike

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

withNewEqualsLeft

public BinaryExpressionFluent.EqualsLeftNested<A> withNewEqualsLeft()

withNewEqualsLeftLike

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

withNewEqualsLeft

public A withNewEqualsLeft(Object left,
                           Object right)

withNewEnclosedLeft

public BinaryExpressionFluent.EnclosedLeftNested<A> withNewEnclosedLeft()

withNewEnclosedLeftLike

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

withNewPreDecrementLeft

public BinaryExpressionFluent.PreDecrementLeftNested<A> withNewPreDecrementLeft()

withNewPreDecrementLeftLike

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

withNewPostDecrementLeft

public BinaryExpressionFluent.PostDecrementLeftNested<A> withNewPostDecrementLeft()

withNewPostDecrementLeftLike

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

withNewLambdaLeft

public BinaryExpressionFluent.LambdaLeftNested<A> withNewLambdaLeft()

withNewLambdaLeftLike

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

withNewNotLeft

public BinaryExpressionFluent.NotLeftNested<A> withNewNotLeft()

withNewNotLeftLike

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

withNewAssignLeft

public BinaryExpressionFluent.AssignLeftNested<A> withNewAssignLeft()

withNewAssignLeftLike

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

withNewNegativeLeft

public BinaryExpressionFluent.NegativeLeftNested<A> withNewNegativeLeft()

withNewNegativeLeftLike

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

withNewThisLeft

public BinaryExpressionFluent.ThisLeftNested<A> withNewThisLeft()

withNewThisLeftLike

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

withNewLogicalAndLeft

public BinaryExpressionFluent.LogicalAndLeftNested<A> withNewLogicalAndLeft()

withNewLogicalAndLeftLike

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

withNewLogicalAndLeft

public A withNewLogicalAndLeft(Object left,
                               Object right)

withNewPostIncrementLeft

public BinaryExpressionFluent.PostIncrementLeftNested<A> withNewPostIncrementLeft()

withNewPostIncrementLeftLike

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

withNewRightUnsignedShiftLeft

public BinaryExpressionFluent.RightUnsignedShiftLeftNested<A> withNewRightUnsignedShiftLeft()

withNewRightUnsignedShiftLeftLike

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

withNewRightUnsignedShiftLeft

public A withNewRightUnsignedShiftLeft(Object left,
                                       Object right)

withNewPlusLeft

public BinaryExpressionFluent.PlusLeftNested<A> withNewPlusLeft()

withNewPlusLeftLike

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

withNewPlusLeft

public A withNewPlusLeft(Object left,
                         Object right)

withNewConstructLeft

public BinaryExpressionFluent.ConstructLeftNested<A> withNewConstructLeft()

withNewConstructLeftLike

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

withNewXorLeft

public BinaryExpressionFluent.XorLeftNested<A> withNewXorLeft()

withNewXorLeftLike

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

withNewXorLeft

public A withNewXorLeft(Object left,
                        Object right)

withNewPreIncrementLeft

public BinaryExpressionFluent.PreIncrementLeftNested<A> withNewPreIncrementLeft()

withNewPreIncrementLeftLike

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

withNewLessThanOrEqualLeft

public BinaryExpressionFluent.LessThanOrEqualLeftNested<A> withNewLessThanOrEqualLeft()

withNewLessThanOrEqualLeftLike

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

withNewLessThanOrEqualLeft

public A withNewLessThanOrEqualLeft(Object left,
                                    Object right)

withNewPositiveLeft

public BinaryExpressionFluent.PositiveLeftNested<A> withNewPositiveLeft()

withNewPositiveLeftLike

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

buildRight

public io.sundr.model.Expression buildRight()

withRight

public A withRight(io.sundr.model.Expression right)

hasRight

public boolean hasRight()

withNewMultiplyRight

public BinaryExpressionFluent.MultiplyRightNested<A> withNewMultiplyRight()

withNewMultiplyRightLike

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

withNewMultiplyRight

public A withNewMultiplyRight(Object left,
                              Object right)

withNewNewArrayRight

public BinaryExpressionFluent.NewArrayRightNested<A> withNewNewArrayRight()

withNewNewArrayRightLike

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

withNewNewArrayRight

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

withNewInstanceOfRight

public BinaryExpressionFluent.InstanceOfRightNested<A> withNewInstanceOfRight()

withNewInstanceOfRightLike

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

withNewMethodCallRight

public BinaryExpressionFluent.MethodCallRightNested<A> withNewMethodCallRight()

withNewMethodCallRightLike

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

withNewInverseRight

public BinaryExpressionFluent.InverseRightNested<A> withNewInverseRight()

withNewInverseRightLike

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

withNewIndexRight

public BinaryExpressionFluent.IndexRightNested<A> withNewIndexRight()

withNewIndexRightLike

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

withNewGreaterThanOrEqualRight

public BinaryExpressionFluent.GreaterThanOrEqualRightNested<A> withNewGreaterThanOrEqualRight()

withNewGreaterThanOrEqualRightLike

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

withNewGreaterThanOrEqualRight

public A withNewGreaterThanOrEqualRight(Object left,
                                        Object right)

withNewBitwiseAndRight

public BinaryExpressionFluent.BitwiseAndRightNested<A> withNewBitwiseAndRight()

withNewBitwiseAndRightLike

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

withNewBitwiseAndRight

public A withNewBitwiseAndRight(Object left,
                                Object right)

withNewMinusRight

public BinaryExpressionFluent.MinusRightNested<A> withNewMinusRight()

withNewMinusRightLike

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

withNewMinusRight

public A withNewMinusRight(Object left,
                           Object right)

withNewLogicalOrRight

public BinaryExpressionFluent.LogicalOrRightNested<A> withNewLogicalOrRight()

withNewLogicalOrRightLike

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

withNewLogicalOrRight

public A withNewLogicalOrRight(Object left,
                               Object right)

withNewNotEqualsRight

public BinaryExpressionFluent.NotEqualsRightNested<A> withNewNotEqualsRight()

withNewNotEqualsRightLike

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

withNewNotEqualsRight

public A withNewNotEqualsRight(Object left,
                               Object right)

withNewDivideRight

public BinaryExpressionFluent.DivideRightNested<A> withNewDivideRight()

withNewDivideRightLike

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

withNewDivideRight

public A withNewDivideRight(Object left,
                            Object right)

withNewLessThanRight

public BinaryExpressionFluent.LessThanRightNested<A> withNewLessThanRight()

withNewLessThanRightLike

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

withNewLessThanRight

public A withNewLessThanRight(Object left,
                              Object right)

withNewBitwiseOrRight

public BinaryExpressionFluent.BitwiseOrRightNested<A> withNewBitwiseOrRight()

withNewBitwiseOrRightLike

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

withNewBitwiseOrRight

public A withNewBitwiseOrRight(Object left,
                               Object right)

withNewPropertyRefRight

public BinaryExpressionFluent.PropertyRefRightNested<A> withNewPropertyRefRight()

withNewPropertyRefRightLike

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

withNewRightShiftRight

public BinaryExpressionFluent.RightShiftRightNested<A> withNewRightShiftRight()

withNewRightShiftRightLike

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

withNewRightShiftRight

public A withNewRightShiftRight(Object left,
                                Object right)

withNewGreaterThanRight

public BinaryExpressionFluent.GreaterThanRightNested<A> withNewGreaterThanRight()

withNewGreaterThanRightLike

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

withNewGreaterThanRight

public A withNewGreaterThanRight(Object left,
                                 Object right)

withNewDeclareRight

public BinaryExpressionFluent.DeclareRightNested<A> withNewDeclareRight()

withNewDeclareRightLike

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

withNewDeclareRight

public A withNewDeclareRight(Class type,
                             String name)

withNewDeclareRight

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

withNewCastRight

public BinaryExpressionFluent.CastRightNested<A> withNewCastRight()

withNewCastRightLike

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

withNewModuloRight

public BinaryExpressionFluent.ModuloRightNested<A> withNewModuloRight()

withNewModuloRightLike

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

withNewModuloRight

public A withNewModuloRight(Object left,
                            Object right)

withNewValueRefRight

public BinaryExpressionFluent.ValueRefRightNested<A> withNewValueRefRight()

withNewValueRefRightLike

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

withNewValueRefRight

public A withNewValueRefRight(Object value)

withNewLeftShiftRight

public BinaryExpressionFluent.LeftShiftRightNested<A> withNewLeftShiftRight()

withNewLeftShiftRightLike

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

withNewLeftShiftRight

public A withNewLeftShiftRight(Object left,
                               Object right)

withNewTernaryRight

public BinaryExpressionFluent.TernaryRightNested<A> withNewTernaryRight()

withNewTernaryRightLike

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

withNewBinaryExpressionRight

public BinaryExpressionFluent.BinaryExpressionRightNested<A> withNewBinaryExpressionRight()

withNewBinaryExpressionRightLike

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

withNewEqualsRight

public BinaryExpressionFluent.EqualsRightNested<A> withNewEqualsRight()

withNewEqualsRightLike

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

withNewEqualsRight

public A withNewEqualsRight(Object left,
                            Object right)

withNewEnclosedRight

public BinaryExpressionFluent.EnclosedRightNested<A> withNewEnclosedRight()

withNewEnclosedRightLike

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

withNewPreDecrementRight

public BinaryExpressionFluent.PreDecrementRightNested<A> withNewPreDecrementRight()

withNewPreDecrementRightLike

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

withNewPostDecrementRight

public BinaryExpressionFluent.PostDecrementRightNested<A> withNewPostDecrementRight()

withNewPostDecrementRightLike

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

withNewLambdaRight

public BinaryExpressionFluent.LambdaRightNested<A> withNewLambdaRight()

withNewLambdaRightLike

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

withNewNotRight

public BinaryExpressionFluent.NotRightNested<A> withNewNotRight()

withNewNotRightLike

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

withNewAssignRight

public BinaryExpressionFluent.AssignRightNested<A> withNewAssignRight()

withNewAssignRightLike

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

withNewNegativeRight

public BinaryExpressionFluent.NegativeRightNested<A> withNewNegativeRight()

withNewNegativeRightLike

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

withNewThisRight

public BinaryExpressionFluent.ThisRightNested<A> withNewThisRight()

withNewThisRightLike

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

withNewLogicalAndRight

public BinaryExpressionFluent.LogicalAndRightNested<A> withNewLogicalAndRight()

withNewLogicalAndRightLike

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

withNewLogicalAndRight

public A withNewLogicalAndRight(Object left,
                                Object right)

withNewPostIncrementRight

public BinaryExpressionFluent.PostIncrementRightNested<A> withNewPostIncrementRight()

withNewPostIncrementRightLike

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

withNewRightUnsignedShiftRight

public BinaryExpressionFluent.RightUnsignedShiftRightNested<A> withNewRightUnsignedShiftRight()

withNewRightUnsignedShiftRightLike

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

withNewRightUnsignedShiftRight

public A withNewRightUnsignedShiftRight(Object left,
                                        Object right)

withNewPlusRight

public BinaryExpressionFluent.PlusRightNested<A> withNewPlusRight()

withNewPlusRightLike

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

withNewPlusRight

public A withNewPlusRight(Object left,
                          Object right)

withNewConstructRight

public BinaryExpressionFluent.ConstructRightNested<A> withNewConstructRight()

withNewConstructRightLike

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

withNewXorRight

public BinaryExpressionFluent.XorRightNested<A> withNewXorRight()

withNewXorRightLike

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

withNewXorRight

public A withNewXorRight(Object left,
                         Object right)

withNewPreIncrementRight

public BinaryExpressionFluent.PreIncrementRightNested<A> withNewPreIncrementRight()

withNewPreIncrementRightLike

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

withNewLessThanOrEqualRight

public BinaryExpressionFluent.LessThanOrEqualRightNested<A> withNewLessThanOrEqualRight()

withNewLessThanOrEqualRightLike

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

withNewLessThanOrEqualRight

public A withNewLessThanOrEqualRight(Object left,
                                     Object right)

withNewPositiveRight

public BinaryExpressionFluent.PositiveRightNested<A> withNewPositiveRight()

withNewPositiveRightLike

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

equals

public boolean equals(Object o)

Overrides:

equals in class io.sundr.builder.BaseFluent<A extends BinaryExpressionFluent<A>>

hashCode

public int hashCode()

Overrides:

hashCode in class io.sundr.builder.BaseFluent<A extends BinaryExpressionFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

builder

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