Package io.sundr.model

Class ForFluent<A extends ForFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.ForFluent<A>

Direct Known Subclasses:

BlockFluent.ForStatementsNested, DoFluent.ForStatementNested, ForBuilder, ForeachFluent.ForBodyNested, ForFluent.ForBodyNested, IfFluent.ForStatementNested, LambdaFluent.ForStatementNested, WhileFluent.ForStatementNested

public class ForFluent<A extends ForFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	ForFluent.AssignBodyNested<N>
class	ForFluent.AssignCompareNested<N>
class	ForFluent.AssignInitNested<N>
class	ForFluent.AssignUpdateNested<N>
class	ForFluent.BinaryExpressionCompareNested<N>
class	ForFluent.BinaryExpressionInitNested<N>
class	ForFluent.BinaryExpressionUpdateNested<N>
class	ForFluent.BitwiseAndCompareNested<N>
class	ForFluent.BitwiseAndInitNested<N>
class	ForFluent.BitwiseAndUpdateNested<N>
class	ForFluent.BitwiseOrCompareNested<N>
class	ForFluent.BitwiseOrInitNested<N>
class	ForFluent.BitwiseOrUpdateNested<N>
class	ForFluent.BlockBodyNested<N>
class	ForFluent.BreakBodyNested<N>
class	ForFluent.CastCompareNested<N>
class	ForFluent.CastInitNested<N>
class	ForFluent.CastUpdateNested<N>
class	ForFluent.ConstructCompareNested<N>
class	ForFluent.ConstructInitNested<N>
class	ForFluent.ConstructUpdateNested<N>
class	ForFluent.ContinueBodyNested<N>
class	ForFluent.DeclareBodyNested<N>
class	ForFluent.DeclareCompareNested<N>
class	ForFluent.DeclareInitNested<N>
class	ForFluent.DeclareUpdateNested<N>
class	ForFluent.DivideCompareNested<N>
class	ForFluent.DivideInitNested<N>
class	ForFluent.DivideUpdateNested<N>
class	ForFluent.DoBodyNested<N>
class	ForFluent.EnclosedCompareNested<N>
class	ForFluent.EnclosedInitNested<N>
class	ForFluent.EnclosedUpdateNested<N>
class	ForFluent.EqualsCompareNested<N>
class	ForFluent.EqualsInitNested<N>
class	ForFluent.EqualsUpdateNested<N>
class	ForFluent.ForBodyNested<N>
class	ForFluent.ForeachBodyNested<N>
class	ForFluent.GreaterThanCompareNested<N>
class	ForFluent.GreaterThanInitNested<N>
class	ForFluent.GreaterThanOrEqualCompareNested<N>
class	ForFluent.GreaterThanOrEqualInitNested<N>
class	ForFluent.GreaterThanOrEqualUpdateNested<N>
class	ForFluent.GreaterThanUpdateNested<N>
class	ForFluent.IfBodyNested<N>
class	ForFluent.IndexCompareNested<N>
class	ForFluent.IndexInitNested<N>
class	ForFluent.IndexUpdateNested<N>
class	ForFluent.InstanceOfCompareNested<N>
class	ForFluent.InstanceOfInitNested<N>
class	ForFluent.InstanceOfUpdateNested<N>
class	ForFluent.InverseCompareNested<N>
class	ForFluent.InverseInitNested<N>
class	ForFluent.InverseUpdateNested<N>
class	ForFluent.LambdaBodyNested<N>
class	ForFluent.LambdaCompareNested<N>
class	ForFluent.LambdaInitNested<N>
class	ForFluent.LambdaUpdateNested<N>
class	ForFluent.LeftShiftCompareNested<N>
class	ForFluent.LeftShiftInitNested<N>
class	ForFluent.LeftShiftUpdateNested<N>
class	ForFluent.LessThanCompareNested<N>
class	ForFluent.LessThanInitNested<N>
class	ForFluent.LessThanOrEqualCompareNested<N>
class	ForFluent.LessThanOrEqualInitNested<N>
class	ForFluent.LessThanOrEqualUpdateNested<N>
class	ForFluent.LessThanUpdateNested<N>
class	ForFluent.LogicalAndCompareNested<N>
class	ForFluent.LogicalAndInitNested<N>
class	ForFluent.LogicalAndUpdateNested<N>
class	ForFluent.LogicalOrCompareNested<N>
class	ForFluent.LogicalOrInitNested<N>
class	ForFluent.LogicalOrUpdateNested<N>
class	ForFluent.MethodCallBodyNested<N>
class	ForFluent.MethodCallCompareNested<N>
class	ForFluent.MethodCallInitNested<N>
class	ForFluent.MethodCallUpdateNested<N>
class	ForFluent.MinusCompareNested<N>
class	ForFluent.MinusInitNested<N>
class	ForFluent.MinusUpdateNested<N>
class	ForFluent.ModuloCompareNested<N>
class	ForFluent.ModuloInitNested<N>
class	ForFluent.ModuloUpdateNested<N>
class	ForFluent.MultiplyCompareNested<N>
class	ForFluent.MultiplyInitNested<N>
class	ForFluent.MultiplyUpdateNested<N>
class	ForFluent.NegativeCompareNested<N>
class	ForFluent.NegativeInitNested<N>
class	ForFluent.NegativeUpdateNested<N>
class	ForFluent.NewArrayCompareNested<N>
class	ForFluent.NewArrayInitNested<N>
class	ForFluent.NewArrayUpdateNested<N>
class	ForFluent.NotCompareNested<N>
class	ForFluent.NotEqualsCompareNested<N>
class	ForFluent.NotEqualsInitNested<N>
class	ForFluent.NotEqualsUpdateNested<N>
class	ForFluent.NotInitNested<N>
class	ForFluent.NotUpdateNested<N>
class	ForFluent.PlusCompareNested<N>
class	ForFluent.PlusInitNested<N>
class	ForFluent.PlusUpdateNested<N>
class	ForFluent.PositiveCompareNested<N>
class	ForFluent.PositiveInitNested<N>
class	ForFluent.PositiveUpdateNested<N>
class	ForFluent.PostDecrementCompareNested<N>
class	ForFluent.PostDecrementInitNested<N>
class	ForFluent.PostDecrementUpdateNested<N>
class	ForFluent.PostIncrementCompareNested<N>
class	ForFluent.PostIncrementInitNested<N>
class	ForFluent.PostIncrementUpdateNested<N>
class	ForFluent.PreDecrementCompareNested<N>
class	ForFluent.PreDecrementInitNested<N>
class	ForFluent.PreDecrementUpdateNested<N>
class	ForFluent.PreIncrementCompareNested<N>
class	ForFluent.PreIncrementInitNested<N>
class	ForFluent.PreIncrementUpdateNested<N>
class	ForFluent.PropertyRefCompareNested<N>
class	ForFluent.PropertyRefInitNested<N>
class	ForFluent.PropertyRefUpdateNested<N>
class	ForFluent.ReturnBodyNested<N>
class	ForFluent.RightShiftCompareNested<N>
class	ForFluent.RightShiftInitNested<N>
class	ForFluent.RightShiftUpdateNested<N>
class	ForFluent.RightUnsignedShiftCompareNested<N>
class	ForFluent.RightUnsignedShiftInitNested<N>
class	ForFluent.RightUnsignedShiftUpdateNested<N>
class	ForFluent.StringStatementBodyNested<N>
class	ForFluent.SwitchBodyNested<N>
class	ForFluent.TernaryCompareNested<N>
class	ForFluent.TernaryInitNested<N>
class	ForFluent.TernaryUpdateNested<N>
class	ForFluent.ThisCompareNested<N>
class	ForFluent.ThisInitNested<N>
class	ForFluent.ThisUpdateNested<N>
class	ForFluent.ValueRefCompareNested<N>
class	ForFluent.ValueRefInitNested<N>
class	ForFluent.ValueRefUpdateNested<N>
class	ForFluent.WhileBodyNested<N>
class	ForFluent.XorCompareNested<N>
class	ForFluent.XorInitNested<N>
class	ForFluent.XorUpdateNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
ForFluent()
ForFluent(For instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToInit(Collection<Expression> items)
A	addAllToUpdate(Collection<Expression> items)
ForFluent<A>.AssignInitNested<A>	addNewAssignInit()
ForFluent<A>.AssignInitNested<A>	addNewAssignInitLike(Assign item)
ForFluent<A>.AssignUpdateNested<A>	addNewAssignUpdate()
ForFluent<A>.AssignUpdateNested<A>	addNewAssignUpdateLike(Assign item)
ForFluent<A>.BinaryExpressionInitNested<A>	addNewBinaryExpressionInit()
ForFluent<A>.BinaryExpressionInitNested<A>	addNewBinaryExpressionInitLike(BinaryExpression item)
ForFluent<A>.BinaryExpressionUpdateNested<A>	addNewBinaryExpressionUpdate()
ForFluent<A>.BinaryExpressionUpdateNested<A>	addNewBinaryExpressionUpdateLike(BinaryExpression item)
ForFluent<A>.BitwiseAndInitNested<A>	addNewBitwiseAndInit()
A	addNewBitwiseAndInit(Object left, Object right)
ForFluent<A>.BitwiseAndInitNested<A>	addNewBitwiseAndInitLike(BitwiseAnd item)
ForFluent<A>.BitwiseAndUpdateNested<A>	addNewBitwiseAndUpdate()
A	addNewBitwiseAndUpdate(Object left, Object right)
ForFluent<A>.BitwiseAndUpdateNested<A>	addNewBitwiseAndUpdateLike(BitwiseAnd item)
ForFluent<A>.BitwiseOrInitNested<A>	addNewBitwiseOrInit()
A	addNewBitwiseOrInit(Object left, Object right)
ForFluent<A>.BitwiseOrInitNested<A>	addNewBitwiseOrInitLike(BitwiseOr item)
ForFluent<A>.BitwiseOrUpdateNested<A>	addNewBitwiseOrUpdate()
A	addNewBitwiseOrUpdate(Object left, Object right)
ForFluent<A>.BitwiseOrUpdateNested<A>	addNewBitwiseOrUpdateLike(BitwiseOr item)
ForFluent<A>.CastInitNested<A>	addNewCastInit()
ForFluent<A>.CastInitNested<A>	addNewCastInitLike(Cast item)
ForFluent<A>.CastUpdateNested<A>	addNewCastUpdate()
ForFluent<A>.CastUpdateNested<A>	addNewCastUpdateLike(Cast item)
ForFluent<A>.ConstructInitNested<A>	addNewConstructInit()
ForFluent<A>.ConstructInitNested<A>	addNewConstructInitLike(Construct item)
ForFluent<A>.ConstructUpdateNested<A>	addNewConstructUpdate()
ForFluent<A>.ConstructUpdateNested<A>	addNewConstructUpdateLike(Construct item)
ForFluent<A>.DeclareInitNested<A>	addNewDeclareInit()
A	addNewDeclareInit(Class type, String name)
A	addNewDeclareInit(Class type, String name, Object value)
ForFluent<A>.DeclareInitNested<A>	addNewDeclareInitLike(Declare item)
ForFluent<A>.DeclareUpdateNested<A>	addNewDeclareUpdate()
A	addNewDeclareUpdate(Class type, String name)
A	addNewDeclareUpdate(Class type, String name, Object value)
ForFluent<A>.DeclareUpdateNested<A>	addNewDeclareUpdateLike(Declare item)
ForFluent<A>.DivideInitNested<A>	addNewDivideInit()
A	addNewDivideInit(Object left, Object right)
ForFluent<A>.DivideInitNested<A>	addNewDivideInitLike(Divide item)
ForFluent<A>.DivideUpdateNested<A>	addNewDivideUpdate()
A	addNewDivideUpdate(Object left, Object right)
ForFluent<A>.DivideUpdateNested<A>	addNewDivideUpdateLike(Divide item)
ForFluent<A>.EnclosedInitNested<A>	addNewEnclosedInit()
ForFluent<A>.EnclosedInitNested<A>	addNewEnclosedInitLike(Enclosed item)
ForFluent<A>.EnclosedUpdateNested<A>	addNewEnclosedUpdate()
ForFluent<A>.EnclosedUpdateNested<A>	addNewEnclosedUpdateLike(Enclosed item)
ForFluent<A>.EqualsInitNested<A>	addNewEqualsInit()
A	addNewEqualsInit(Object left, Object right)
ForFluent<A>.EqualsInitNested<A>	addNewEqualsInitLike(Equals item)
ForFluent<A>.EqualsUpdateNested<A>	addNewEqualsUpdate()
A	addNewEqualsUpdate(Object left, Object right)
ForFluent<A>.EqualsUpdateNested<A>	addNewEqualsUpdateLike(Equals item)
ForFluent<A>.GreaterThanInitNested<A>	addNewGreaterThanInit()
A	addNewGreaterThanInit(Object left, Object right)
ForFluent<A>.GreaterThanInitNested<A>	addNewGreaterThanInitLike(GreaterThan item)
ForFluent<A>.GreaterThanOrEqualInitNested<A>	addNewGreaterThanOrEqualInit()
A	addNewGreaterThanOrEqualInit(Object left, Object right)
ForFluent<A>.GreaterThanOrEqualInitNested<A>	addNewGreaterThanOrEqualInitLike(GreaterThanOrEqual item)
ForFluent<A>.GreaterThanOrEqualUpdateNested<A>	addNewGreaterThanOrEqualUpdate()
A	addNewGreaterThanOrEqualUpdate(Object left, Object right)
ForFluent<A>.GreaterThanOrEqualUpdateNested<A>	addNewGreaterThanOrEqualUpdateLike(GreaterThanOrEqual item)
ForFluent<A>.GreaterThanUpdateNested<A>	addNewGreaterThanUpdate()
A	addNewGreaterThanUpdate(Object left, Object right)
ForFluent<A>.GreaterThanUpdateNested<A>	addNewGreaterThanUpdateLike(GreaterThan item)
ForFluent<A>.IndexInitNested<A>	addNewIndexInit()
ForFluent<A>.IndexInitNested<A>	addNewIndexInitLike(Index item)
ForFluent<A>.IndexUpdateNested<A>	addNewIndexUpdate()
ForFluent<A>.IndexUpdateNested<A>	addNewIndexUpdateLike(Index item)
ForFluent<A>.InstanceOfInitNested<A>	addNewInstanceOfInit()
ForFluent<A>.InstanceOfInitNested<A>	addNewInstanceOfInitLike(InstanceOf item)
ForFluent<A>.InstanceOfUpdateNested<A>	addNewInstanceOfUpdate()
ForFluent<A>.InstanceOfUpdateNested<A>	addNewInstanceOfUpdateLike(InstanceOf item)
ForFluent<A>.InverseInitNested<A>	addNewInverseInit()
ForFluent<A>.InverseInitNested<A>	addNewInverseInitLike(Inverse item)
ForFluent<A>.InverseUpdateNested<A>	addNewInverseUpdate()
ForFluent<A>.InverseUpdateNested<A>	addNewInverseUpdateLike(Inverse item)
ForFluent<A>.LambdaInitNested<A>	addNewLambdaInit()
ForFluent<A>.LambdaInitNested<A>	addNewLambdaInitLike(Lambda item)
ForFluent<A>.LambdaUpdateNested<A>	addNewLambdaUpdate()
ForFluent<A>.LambdaUpdateNested<A>	addNewLambdaUpdateLike(Lambda item)
ForFluent<A>.LeftShiftInitNested<A>	addNewLeftShiftInit()
A	addNewLeftShiftInit(Object left, Object right)
ForFluent<A>.LeftShiftInitNested<A>	addNewLeftShiftInitLike(LeftShift item)
ForFluent<A>.LeftShiftUpdateNested<A>	addNewLeftShiftUpdate()
A	addNewLeftShiftUpdate(Object left, Object right)
ForFluent<A>.LeftShiftUpdateNested<A>	addNewLeftShiftUpdateLike(LeftShift item)
ForFluent<A>.LessThanInitNested<A>	addNewLessThanInit()
A	addNewLessThanInit(Object left, Object right)
ForFluent<A>.LessThanInitNested<A>	addNewLessThanInitLike(LessThan item)
ForFluent<A>.LessThanOrEqualInitNested<A>	addNewLessThanOrEqualInit()
A	addNewLessThanOrEqualInit(Object left, Object right)
ForFluent<A>.LessThanOrEqualInitNested<A>	addNewLessThanOrEqualInitLike(LessThanOrEqual item)
ForFluent<A>.LessThanOrEqualUpdateNested<A>	addNewLessThanOrEqualUpdate()
A	addNewLessThanOrEqualUpdate(Object left, Object right)
ForFluent<A>.LessThanOrEqualUpdateNested<A>	addNewLessThanOrEqualUpdateLike(LessThanOrEqual item)
ForFluent<A>.LessThanUpdateNested<A>	addNewLessThanUpdate()
A	addNewLessThanUpdate(Object left, Object right)
ForFluent<A>.LessThanUpdateNested<A>	addNewLessThanUpdateLike(LessThan item)
ForFluent<A>.LogicalAndInitNested<A>	addNewLogicalAndInit()
A	addNewLogicalAndInit(Object left, Object right)
ForFluent<A>.LogicalAndInitNested<A>	addNewLogicalAndInitLike(LogicalAnd item)
ForFluent<A>.LogicalAndUpdateNested<A>	addNewLogicalAndUpdate()
A	addNewLogicalAndUpdate(Object left, Object right)
ForFluent<A>.LogicalAndUpdateNested<A>	addNewLogicalAndUpdateLike(LogicalAnd item)
ForFluent<A>.LogicalOrInitNested<A>	addNewLogicalOrInit()
A	addNewLogicalOrInit(Object left, Object right)
ForFluent<A>.LogicalOrInitNested<A>	addNewLogicalOrInitLike(LogicalOr item)
ForFluent<A>.LogicalOrUpdateNested<A>	addNewLogicalOrUpdate()
A	addNewLogicalOrUpdate(Object left, Object right)
ForFluent<A>.LogicalOrUpdateNested<A>	addNewLogicalOrUpdateLike(LogicalOr item)
ForFluent<A>.MethodCallInitNested<A>	addNewMethodCallInit()
ForFluent<A>.MethodCallInitNested<A>	addNewMethodCallInitLike(MethodCall item)
ForFluent<A>.MethodCallUpdateNested<A>	addNewMethodCallUpdate()
ForFluent<A>.MethodCallUpdateNested<A>	addNewMethodCallUpdateLike(MethodCall item)
ForFluent<A>.MinusInitNested<A>	addNewMinusInit()
A	addNewMinusInit(Object left, Object right)
ForFluent<A>.MinusInitNested<A>	addNewMinusInitLike(Minus item)
ForFluent<A>.MinusUpdateNested<A>	addNewMinusUpdate()
A	addNewMinusUpdate(Object left, Object right)
ForFluent<A>.MinusUpdateNested<A>	addNewMinusUpdateLike(Minus item)
ForFluent<A>.ModuloInitNested<A>	addNewModuloInit()
A	addNewModuloInit(Object left, Object right)
ForFluent<A>.ModuloInitNested<A>	addNewModuloInitLike(Modulo item)
ForFluent<A>.ModuloUpdateNested<A>	addNewModuloUpdate()
A	addNewModuloUpdate(Object left, Object right)
ForFluent<A>.ModuloUpdateNested<A>	addNewModuloUpdateLike(Modulo item)
ForFluent<A>.MultiplyInitNested<A>	addNewMultiplyInit()
A	addNewMultiplyInit(Object left, Object right)
ForFluent<A>.MultiplyInitNested<A>	addNewMultiplyInitLike(Multiply item)
ForFluent<A>.MultiplyUpdateNested<A>	addNewMultiplyUpdate()
A	addNewMultiplyUpdate(Object left, Object right)
ForFluent<A>.MultiplyUpdateNested<A>	addNewMultiplyUpdateLike(Multiply item)
ForFluent<A>.NegativeInitNested<A>	addNewNegativeInit()
ForFluent<A>.NegativeInitNested<A>	addNewNegativeInitLike(Negative item)
ForFluent<A>.NegativeUpdateNested<A>	addNewNegativeUpdate()
ForFluent<A>.NegativeUpdateNested<A>	addNewNegativeUpdateLike(Negative item)
ForFluent<A>.NewArrayInitNested<A>	addNewNewArrayInit()
A	addNewNewArrayInit(Class type, Integer[] sizes)
ForFluent<A>.NewArrayInitNested<A>	addNewNewArrayInitLike(NewArray item)
ForFluent<A>.NewArrayUpdateNested<A>	addNewNewArrayUpdate()
A	addNewNewArrayUpdate(Class type, Integer[] sizes)
ForFluent<A>.NewArrayUpdateNested<A>	addNewNewArrayUpdateLike(NewArray item)
ForFluent<A>.NotEqualsInitNested<A>	addNewNotEqualsInit()
A	addNewNotEqualsInit(Object left, Object right)
ForFluent<A>.NotEqualsInitNested<A>	addNewNotEqualsInitLike(NotEquals item)
ForFluent<A>.NotEqualsUpdateNested<A>	addNewNotEqualsUpdate()
A	addNewNotEqualsUpdate(Object left, Object right)
ForFluent<A>.NotEqualsUpdateNested<A>	addNewNotEqualsUpdateLike(NotEquals item)
ForFluent<A>.NotInitNested<A>	addNewNotInit()
ForFluent<A>.NotInitNested<A>	addNewNotInitLike(Not item)
ForFluent<A>.NotUpdateNested<A>	addNewNotUpdate()
ForFluent<A>.NotUpdateNested<A>	addNewNotUpdateLike(Not item)
ForFluent<A>.PlusInitNested<A>	addNewPlusInit()
A	addNewPlusInit(Object left, Object right)
ForFluent<A>.PlusInitNested<A>	addNewPlusInitLike(Plus item)
ForFluent<A>.PlusUpdateNested<A>	addNewPlusUpdate()
A	addNewPlusUpdate(Object left, Object right)
ForFluent<A>.PlusUpdateNested<A>	addNewPlusUpdateLike(Plus item)
ForFluent<A>.PositiveInitNested<A>	addNewPositiveInit()
ForFluent<A>.PositiveInitNested<A>	addNewPositiveInitLike(Positive item)
ForFluent<A>.PositiveUpdateNested<A>	addNewPositiveUpdate()
ForFluent<A>.PositiveUpdateNested<A>	addNewPositiveUpdateLike(Positive item)
ForFluent<A>.PostDecrementInitNested<A>	addNewPostDecrementInit()
ForFluent<A>.PostDecrementInitNested<A>	addNewPostDecrementInitLike(PostDecrement item)
ForFluent<A>.PostDecrementUpdateNested<A>	addNewPostDecrementUpdate()
ForFluent<A>.PostDecrementUpdateNested<A>	addNewPostDecrementUpdateLike(PostDecrement item)
ForFluent<A>.PostIncrementInitNested<A>	addNewPostIncrementInit()
ForFluent<A>.PostIncrementInitNested<A>	addNewPostIncrementInitLike(PostIncrement item)
ForFluent<A>.PostIncrementUpdateNested<A>	addNewPostIncrementUpdate()
ForFluent<A>.PostIncrementUpdateNested<A>	addNewPostIncrementUpdateLike(PostIncrement item)
ForFluent<A>.PreDecrementInitNested<A>	addNewPreDecrementInit()
ForFluent<A>.PreDecrementInitNested<A>	addNewPreDecrementInitLike(PreDecrement item)
ForFluent<A>.PreDecrementUpdateNested<A>	addNewPreDecrementUpdate()
ForFluent<A>.PreDecrementUpdateNested<A>	addNewPreDecrementUpdateLike(PreDecrement item)
ForFluent<A>.PreIncrementInitNested<A>	addNewPreIncrementInit()
ForFluent<A>.PreIncrementInitNested<A>	addNewPreIncrementInitLike(PreIncrement item)
ForFluent<A>.PreIncrementUpdateNested<A>	addNewPreIncrementUpdate()
ForFluent<A>.PreIncrementUpdateNested<A>	addNewPreIncrementUpdateLike(PreIncrement item)
ForFluent<A>.PropertyRefInitNested<A>	addNewPropertyRefInit()
ForFluent<A>.PropertyRefInitNested<A>	addNewPropertyRefInitLike(PropertyRef item)
ForFluent<A>.PropertyRefUpdateNested<A>	addNewPropertyRefUpdate()
ForFluent<A>.PropertyRefUpdateNested<A>	addNewPropertyRefUpdateLike(PropertyRef item)
ForFluent<A>.RightShiftInitNested<A>	addNewRightShiftInit()
A	addNewRightShiftInit(Object left, Object right)
ForFluent<A>.RightShiftInitNested<A>	addNewRightShiftInitLike(RightShift item)
ForFluent<A>.RightShiftUpdateNested<A>	addNewRightShiftUpdate()
A	addNewRightShiftUpdate(Object left, Object right)
ForFluent<A>.RightShiftUpdateNested<A>	addNewRightShiftUpdateLike(RightShift item)
ForFluent<A>.RightUnsignedShiftInitNested<A>	addNewRightUnsignedShiftInit()
A	addNewRightUnsignedShiftInit(Object left, Object right)
ForFluent<A>.RightUnsignedShiftInitNested<A>	addNewRightUnsignedShiftInitLike(RightUnsignedShift item)
ForFluent<A>.RightUnsignedShiftUpdateNested<A>	addNewRightUnsignedShiftUpdate()
A	addNewRightUnsignedShiftUpdate(Object left, Object right)
ForFluent<A>.RightUnsignedShiftUpdateNested<A>	addNewRightUnsignedShiftUpdateLike(RightUnsignedShift item)
ForFluent<A>.TernaryInitNested<A>	addNewTernaryInit()
ForFluent<A>.TernaryInitNested<A>	addNewTernaryInitLike(Ternary item)
ForFluent<A>.TernaryUpdateNested<A>	addNewTernaryUpdate()
ForFluent<A>.TernaryUpdateNested<A>	addNewTernaryUpdateLike(Ternary item)
ForFluent<A>.ThisInitNested<A>	addNewThisInit()
ForFluent<A>.ThisInitNested<A>	addNewThisInitLike(This item)
ForFluent<A>.ThisUpdateNested<A>	addNewThisUpdate()
ForFluent<A>.ThisUpdateNested<A>	addNewThisUpdateLike(This item)
ForFluent<A>.ValueRefInitNested<A>	addNewValueRefInit()
A	addNewValueRefInit(Object value)
ForFluent<A>.ValueRefInitNested<A>	addNewValueRefInitLike(ValueRef item)
ForFluent<A>.ValueRefUpdateNested<A>	addNewValueRefUpdate()
A	addNewValueRefUpdate(Object value)
ForFluent<A>.ValueRefUpdateNested<A>	addNewValueRefUpdateLike(ValueRef item)
ForFluent<A>.XorInitNested<A>	addNewXorInit()
A	addNewXorInit(Object left, Object right)
ForFluent<A>.XorInitNested<A>	addNewXorInitLike(Xor item)
ForFluent<A>.XorUpdateNested<A>	addNewXorUpdate()
A	addNewXorUpdate(Object left, Object right)
ForFluent<A>.XorUpdateNested<A>	addNewXorUpdateLike(Xor item)
A	addToInit(int index, VisitableBuilder<? extends Expression,?> builder)
A	addToInit(int index, Expression item)
A	addToInit(VisitableBuilder<? extends Expression,?> builder)
A	addToInit(Expression... items)
A	addToUpdate(int index, VisitableBuilder<? extends Expression,?> builder)
A	addToUpdate(int index, Expression item)
A	addToUpdate(VisitableBuilder<? extends Expression,?> builder)
A	addToUpdate(Expression... items)
Statement	buildBody()
Expression	buildCompare()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildFirstInit()
Expression	buildFirstUpdate()
List<Expression>	buildInit()
Expression	buildInit(int index)
Expression	buildLastInit()
Expression	buildLastUpdate()
Expression	buildMatchingInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
Expression	buildMatchingUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
List<Expression>	buildUpdate()
Expression	buildUpdate(int index)
protected void	copyInstance(For instance)
boolean	equals(Object o)
boolean	hasBody()
boolean	hasCompare()
int	hashCode()
boolean	hasInit()
boolean	hasMatchingInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
boolean	hasMatchingUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
boolean	hasUpdate()
A	removeAllFromInit(Collection<Expression> items)
A	removeAllFromUpdate(Collection<Expression> items)
A	removeFromInit(VisitableBuilder<? extends Expression,?> builder)
A	removeFromInit(Expression... items)
A	removeFromUpdate(VisitableBuilder<? extends Expression,?> builder)
A	removeFromUpdate(Expression... items)
A	removeMatchingFromInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
A	removeMatchingFromUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
ForFluent<A>.AssignInitNested<A>	setNewAssignInitLike(int index, Assign item)
ForFluent<A>.AssignUpdateNested<A>	setNewAssignUpdateLike(int index, Assign item)
ForFluent<A>.BinaryExpressionInitNested<A>	setNewBinaryExpressionInitLike(int index, BinaryExpression item)
ForFluent<A>.BinaryExpressionUpdateNested<A>	setNewBinaryExpressionUpdateLike(int index, BinaryExpression item)
ForFluent<A>.BitwiseAndInitNested<A>	setNewBitwiseAndInitLike(int index, BitwiseAnd item)
ForFluent<A>.BitwiseAndUpdateNested<A>	setNewBitwiseAndUpdateLike(int index, BitwiseAnd item)
ForFluent<A>.BitwiseOrInitNested<A>	setNewBitwiseOrInitLike(int index, BitwiseOr item)
ForFluent<A>.BitwiseOrUpdateNested<A>	setNewBitwiseOrUpdateLike(int index, BitwiseOr item)
ForFluent<A>.CastInitNested<A>	setNewCastInitLike(int index, Cast item)
ForFluent<A>.CastUpdateNested<A>	setNewCastUpdateLike(int index, Cast item)
ForFluent<A>.ConstructInitNested<A>	setNewConstructInitLike(int index, Construct item)
ForFluent<A>.ConstructUpdateNested<A>	setNewConstructUpdateLike(int index, Construct item)
ForFluent<A>.DeclareInitNested<A>	setNewDeclareInitLike(int index, Declare item)
ForFluent<A>.DeclareUpdateNested<A>	setNewDeclareUpdateLike(int index, Declare item)
ForFluent<A>.DivideInitNested<A>	setNewDivideInitLike(int index, Divide item)
ForFluent<A>.DivideUpdateNested<A>	setNewDivideUpdateLike(int index, Divide item)
ForFluent<A>.EnclosedInitNested<A>	setNewEnclosedInitLike(int index, Enclosed item)
ForFluent<A>.EnclosedUpdateNested<A>	setNewEnclosedUpdateLike(int index, Enclosed item)
ForFluent<A>.EqualsInitNested<A>	setNewEqualsInitLike(int index, Equals item)
ForFluent<A>.EqualsUpdateNested<A>	setNewEqualsUpdateLike(int index, Equals item)
ForFluent<A>.GreaterThanInitNested<A>	setNewGreaterThanInitLike(int index, GreaterThan item)
ForFluent<A>.GreaterThanOrEqualInitNested<A>	setNewGreaterThanOrEqualInitLike(int index, GreaterThanOrEqual item)
ForFluent<A>.GreaterThanOrEqualUpdateNested<A>	setNewGreaterThanOrEqualUpdateLike(int index, GreaterThanOrEqual item)
ForFluent<A>.GreaterThanUpdateNested<A>	setNewGreaterThanUpdateLike(int index, GreaterThan item)
ForFluent<A>.IndexInitNested<A>	setNewIndexInitLike(int index, Index item)
ForFluent<A>.IndexUpdateNested<A>	setNewIndexUpdateLike(int index, Index item)
ForFluent<A>.InstanceOfInitNested<A>	setNewInstanceOfInitLike(int index, InstanceOf item)
ForFluent<A>.InstanceOfUpdateNested<A>	setNewInstanceOfUpdateLike(int index, InstanceOf item)
ForFluent<A>.InverseInitNested<A>	setNewInverseInitLike(int index, Inverse item)
ForFluent<A>.InverseUpdateNested<A>	setNewInverseUpdateLike(int index, Inverse item)
ForFluent<A>.LambdaInitNested<A>	setNewLambdaInitLike(int index, Lambda item)
ForFluent<A>.LambdaUpdateNested<A>	setNewLambdaUpdateLike(int index, Lambda item)
ForFluent<A>.LeftShiftInitNested<A>	setNewLeftShiftInitLike(int index, LeftShift item)
ForFluent<A>.LeftShiftUpdateNested<A>	setNewLeftShiftUpdateLike(int index, LeftShift item)
ForFluent<A>.LessThanInitNested<A>	setNewLessThanInitLike(int index, LessThan item)
ForFluent<A>.LessThanOrEqualInitNested<A>	setNewLessThanOrEqualInitLike(int index, LessThanOrEqual item)
ForFluent<A>.LessThanOrEqualUpdateNested<A>	setNewLessThanOrEqualUpdateLike(int index, LessThanOrEqual item)
ForFluent<A>.LessThanUpdateNested<A>	setNewLessThanUpdateLike(int index, LessThan item)
ForFluent<A>.LogicalAndInitNested<A>	setNewLogicalAndInitLike(int index, LogicalAnd item)
ForFluent<A>.LogicalAndUpdateNested<A>	setNewLogicalAndUpdateLike(int index, LogicalAnd item)
ForFluent<A>.LogicalOrInitNested<A>	setNewLogicalOrInitLike(int index, LogicalOr item)
ForFluent<A>.LogicalOrUpdateNested<A>	setNewLogicalOrUpdateLike(int index, LogicalOr item)
ForFluent<A>.MethodCallInitNested<A>	setNewMethodCallInitLike(int index, MethodCall item)
ForFluent<A>.MethodCallUpdateNested<A>	setNewMethodCallUpdateLike(int index, MethodCall item)
ForFluent<A>.MinusInitNested<A>	setNewMinusInitLike(int index, Minus item)
ForFluent<A>.MinusUpdateNested<A>	setNewMinusUpdateLike(int index, Minus item)
ForFluent<A>.ModuloInitNested<A>	setNewModuloInitLike(int index, Modulo item)
ForFluent<A>.ModuloUpdateNested<A>	setNewModuloUpdateLike(int index, Modulo item)
ForFluent<A>.MultiplyInitNested<A>	setNewMultiplyInitLike(int index, Multiply item)
ForFluent<A>.MultiplyUpdateNested<A>	setNewMultiplyUpdateLike(int index, Multiply item)
ForFluent<A>.NegativeInitNested<A>	setNewNegativeInitLike(int index, Negative item)
ForFluent<A>.NegativeUpdateNested<A>	setNewNegativeUpdateLike(int index, Negative item)
ForFluent<A>.NewArrayInitNested<A>	setNewNewArrayInitLike(int index, NewArray item)
ForFluent<A>.NewArrayUpdateNested<A>	setNewNewArrayUpdateLike(int index, NewArray item)
ForFluent<A>.NotEqualsInitNested<A>	setNewNotEqualsInitLike(int index, NotEquals item)
ForFluent<A>.NotEqualsUpdateNested<A>	setNewNotEqualsUpdateLike(int index, NotEquals item)
ForFluent<A>.NotInitNested<A>	setNewNotInitLike(int index, Not item)
ForFluent<A>.NotUpdateNested<A>	setNewNotUpdateLike(int index, Not item)
ForFluent<A>.PlusInitNested<A>	setNewPlusInitLike(int index, Plus item)
ForFluent<A>.PlusUpdateNested<A>	setNewPlusUpdateLike(int index, Plus item)
ForFluent<A>.PositiveInitNested<A>	setNewPositiveInitLike(int index, Positive item)
ForFluent<A>.PositiveUpdateNested<A>	setNewPositiveUpdateLike(int index, Positive item)
ForFluent<A>.PostDecrementInitNested<A>	setNewPostDecrementInitLike(int index, PostDecrement item)
ForFluent<A>.PostDecrementUpdateNested<A>	setNewPostDecrementUpdateLike(int index, PostDecrement item)
ForFluent<A>.PostIncrementInitNested<A>	setNewPostIncrementInitLike(int index, PostIncrement item)
ForFluent<A>.PostIncrementUpdateNested<A>	setNewPostIncrementUpdateLike(int index, PostIncrement item)
ForFluent<A>.PreDecrementInitNested<A>	setNewPreDecrementInitLike(int index, PreDecrement item)
ForFluent<A>.PreDecrementUpdateNested<A>	setNewPreDecrementUpdateLike(int index, PreDecrement item)
ForFluent<A>.PreIncrementInitNested<A>	setNewPreIncrementInitLike(int index, PreIncrement item)
ForFluent<A>.PreIncrementUpdateNested<A>	setNewPreIncrementUpdateLike(int index, PreIncrement item)
ForFluent<A>.PropertyRefInitNested<A>	setNewPropertyRefInitLike(int index, PropertyRef item)
ForFluent<A>.PropertyRefUpdateNested<A>	setNewPropertyRefUpdateLike(int index, PropertyRef item)
ForFluent<A>.RightShiftInitNested<A>	setNewRightShiftInitLike(int index, RightShift item)
ForFluent<A>.RightShiftUpdateNested<A>	setNewRightShiftUpdateLike(int index, RightShift item)
ForFluent<A>.RightUnsignedShiftInitNested<A>	setNewRightUnsignedShiftInitLike(int index, RightUnsignedShift item)
ForFluent<A>.RightUnsignedShiftUpdateNested<A>	setNewRightUnsignedShiftUpdateLike(int index, RightUnsignedShift item)
ForFluent<A>.TernaryInitNested<A>	setNewTernaryInitLike(int index, Ternary item)
ForFluent<A>.TernaryUpdateNested<A>	setNewTernaryUpdateLike(int index, Ternary item)
ForFluent<A>.ThisInitNested<A>	setNewThisInitLike(int index, This item)
ForFluent<A>.ThisUpdateNested<A>	setNewThisUpdateLike(int index, This item)
ForFluent<A>.ValueRefInitNested<A>	setNewValueRefInitLike(int index, ValueRef item)
ForFluent<A>.ValueRefUpdateNested<A>	setNewValueRefUpdateLike(int index, ValueRef item)
ForFluent<A>.XorInitNested<A>	setNewXorInitLike(int index, Xor item)
ForFluent<A>.XorUpdateNested<A>	setNewXorUpdateLike(int index, Xor item)
A	setToInit(int index, Expression item)
A	setToUpdate(int index, Expression item)
String	toString()
A	withBody(Statement body)
A	withCompare(Expression compare)
A	withInit(Expression... init)
A	withInit(List<Expression> init)
ForFluent<A>.AssignBodyNested<A>	withNewAssignBody()
ForFluent<A>.AssignBodyNested<A>	withNewAssignBodyLike(Assign item)
ForFluent<A>.AssignCompareNested<A>	withNewAssignCompare()
ForFluent<A>.AssignCompareNested<A>	withNewAssignCompareLike(Assign item)
ForFluent<A>.BinaryExpressionCompareNested<A>	withNewBinaryExpressionCompare()
ForFluent<A>.BinaryExpressionCompareNested<A>	withNewBinaryExpressionCompareLike(BinaryExpression item)
ForFluent<A>.BitwiseAndCompareNested<A>	withNewBitwiseAndCompare()
A	withNewBitwiseAndCompare(Object left, Object right)
ForFluent<A>.BitwiseAndCompareNested<A>	withNewBitwiseAndCompareLike(BitwiseAnd item)
ForFluent<A>.BitwiseOrCompareNested<A>	withNewBitwiseOrCompare()
A	withNewBitwiseOrCompare(Object left, Object right)
ForFluent<A>.BitwiseOrCompareNested<A>	withNewBitwiseOrCompareLike(BitwiseOr item)
ForFluent<A>.BlockBodyNested<A>	withNewBlockBody()
ForFluent<A>.BlockBodyNested<A>	withNewBlockBodyLike(Block item)
ForFluent<A>.BreakBodyNested<A>	withNewBreakBody()
ForFluent<A>.BreakBodyNested<A>	withNewBreakBodyLike(Break item)
ForFluent<A>.CastCompareNested<A>	withNewCastCompare()
ForFluent<A>.CastCompareNested<A>	withNewCastCompareLike(Cast item)
ForFluent<A>.ConstructCompareNested<A>	withNewConstructCompare()
ForFluent<A>.ConstructCompareNested<A>	withNewConstructCompareLike(Construct item)
ForFluent<A>.ContinueBodyNested<A>	withNewContinueBody()
ForFluent<A>.ContinueBodyNested<A>	withNewContinueBodyLike(Continue item)
ForFluent<A>.DeclareBodyNested<A>	withNewDeclareBody()
A	withNewDeclareBody(Class type, String name)
A	withNewDeclareBody(Class type, String name, Object value)
ForFluent<A>.DeclareBodyNested<A>	withNewDeclareBodyLike(Declare item)
ForFluent<A>.DeclareCompareNested<A>	withNewDeclareCompare()
A	withNewDeclareCompare(Class type, String name)
A	withNewDeclareCompare(Class type, String name, Object value)
ForFluent<A>.DeclareCompareNested<A>	withNewDeclareCompareLike(Declare item)
ForFluent<A>.DivideCompareNested<A>	withNewDivideCompare()
A	withNewDivideCompare(Object left, Object right)
ForFluent<A>.DivideCompareNested<A>	withNewDivideCompareLike(Divide item)
ForFluent<A>.DoBodyNested<A>	withNewDoBody()
ForFluent<A>.DoBodyNested<A>	withNewDoBodyLike(Do item)
ForFluent<A>.EnclosedCompareNested<A>	withNewEnclosedCompare()
ForFluent<A>.EnclosedCompareNested<A>	withNewEnclosedCompareLike(Enclosed item)
ForFluent<A>.EqualsCompareNested<A>	withNewEqualsCompare()
A	withNewEqualsCompare(Object left, Object right)
ForFluent<A>.EqualsCompareNested<A>	withNewEqualsCompareLike(Equals item)
ForFluent<A>.ForBodyNested<A>	withNewForBody()
ForFluent<A>.ForBodyNested<A>	withNewForBodyLike(For item)
ForFluent<A>.ForeachBodyNested<A>	withNewForeachBody()
ForFluent<A>.ForeachBodyNested<A>	withNewForeachBodyLike(Foreach item)
ForFluent<A>.GreaterThanCompareNested<A>	withNewGreaterThanCompare()
A	withNewGreaterThanCompare(Object left, Object right)
ForFluent<A>.GreaterThanCompareNested<A>	withNewGreaterThanCompareLike(GreaterThan item)
ForFluent<A>.GreaterThanOrEqualCompareNested<A>	withNewGreaterThanOrEqualCompare()
A	withNewGreaterThanOrEqualCompare(Object left, Object right)
ForFluent<A>.GreaterThanOrEqualCompareNested<A>	withNewGreaterThanOrEqualCompareLike(GreaterThanOrEqual item)
ForFluent<A>.IfBodyNested<A>	withNewIfBody()
ForFluent<A>.IfBodyNested<A>	withNewIfBodyLike(If item)
ForFluent<A>.IndexCompareNested<A>	withNewIndexCompare()
ForFluent<A>.IndexCompareNested<A>	withNewIndexCompareLike(Index item)
ForFluent<A>.InstanceOfCompareNested<A>	withNewInstanceOfCompare()
ForFluent<A>.InstanceOfCompareNested<A>	withNewInstanceOfCompareLike(InstanceOf item)
ForFluent<A>.InverseCompareNested<A>	withNewInverseCompare()
ForFluent<A>.InverseCompareNested<A>	withNewInverseCompareLike(Inverse item)
ForFluent<A>.LambdaBodyNested<A>	withNewLambdaBody()
ForFluent<A>.LambdaBodyNested<A>	withNewLambdaBodyLike(Lambda item)
ForFluent<A>.LambdaCompareNested<A>	withNewLambdaCompare()
ForFluent<A>.LambdaCompareNested<A>	withNewLambdaCompareLike(Lambda item)
ForFluent<A>.LeftShiftCompareNested<A>	withNewLeftShiftCompare()
A	withNewLeftShiftCompare(Object left, Object right)
ForFluent<A>.LeftShiftCompareNested<A>	withNewLeftShiftCompareLike(LeftShift item)
ForFluent<A>.LessThanCompareNested<A>	withNewLessThanCompare()
A	withNewLessThanCompare(Object left, Object right)
ForFluent<A>.LessThanCompareNested<A>	withNewLessThanCompareLike(LessThan item)
ForFluent<A>.LessThanOrEqualCompareNested<A>	withNewLessThanOrEqualCompare()
A	withNewLessThanOrEqualCompare(Object left, Object right)
ForFluent<A>.LessThanOrEqualCompareNested<A>	withNewLessThanOrEqualCompareLike(LessThanOrEqual item)
ForFluent<A>.LogicalAndCompareNested<A>	withNewLogicalAndCompare()
A	withNewLogicalAndCompare(Object left, Object right)
ForFluent<A>.LogicalAndCompareNested<A>	withNewLogicalAndCompareLike(LogicalAnd item)
ForFluent<A>.LogicalOrCompareNested<A>	withNewLogicalOrCompare()
A	withNewLogicalOrCompare(Object left, Object right)
ForFluent<A>.LogicalOrCompareNested<A>	withNewLogicalOrCompareLike(LogicalOr item)
ForFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBody()
ForFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBodyLike(MethodCall item)
ForFluent<A>.MethodCallCompareNested<A>	withNewMethodCallCompare()
ForFluent<A>.MethodCallCompareNested<A>	withNewMethodCallCompareLike(MethodCall item)
ForFluent<A>.MinusCompareNested<A>	withNewMinusCompare()
A	withNewMinusCompare(Object left, Object right)
ForFluent<A>.MinusCompareNested<A>	withNewMinusCompareLike(Minus item)
ForFluent<A>.ModuloCompareNested<A>	withNewModuloCompare()
A	withNewModuloCompare(Object left, Object right)
ForFluent<A>.ModuloCompareNested<A>	withNewModuloCompareLike(Modulo item)
ForFluent<A>.MultiplyCompareNested<A>	withNewMultiplyCompare()
A	withNewMultiplyCompare(Object left, Object right)
ForFluent<A>.MultiplyCompareNested<A>	withNewMultiplyCompareLike(Multiply item)
ForFluent<A>.NegativeCompareNested<A>	withNewNegativeCompare()
ForFluent<A>.NegativeCompareNested<A>	withNewNegativeCompareLike(Negative item)
ForFluent<A>.NewArrayCompareNested<A>	withNewNewArrayCompare()
A	withNewNewArrayCompare(Class type, Integer[] sizes)
ForFluent<A>.NewArrayCompareNested<A>	withNewNewArrayCompareLike(NewArray item)
ForFluent<A>.NotCompareNested<A>	withNewNotCompare()
ForFluent<A>.NotCompareNested<A>	withNewNotCompareLike(Not item)
ForFluent<A>.NotEqualsCompareNested<A>	withNewNotEqualsCompare()
A	withNewNotEqualsCompare(Object left, Object right)
ForFluent<A>.NotEqualsCompareNested<A>	withNewNotEqualsCompareLike(NotEquals item)
ForFluent<A>.PlusCompareNested<A>	withNewPlusCompare()
A	withNewPlusCompare(Object left, Object right)
ForFluent<A>.PlusCompareNested<A>	withNewPlusCompareLike(Plus item)
ForFluent<A>.PositiveCompareNested<A>	withNewPositiveCompare()
ForFluent<A>.PositiveCompareNested<A>	withNewPositiveCompareLike(Positive item)
ForFluent<A>.PostDecrementCompareNested<A>	withNewPostDecrementCompare()
ForFluent<A>.PostDecrementCompareNested<A>	withNewPostDecrementCompareLike(PostDecrement item)
ForFluent<A>.PostIncrementCompareNested<A>	withNewPostIncrementCompare()
ForFluent<A>.PostIncrementCompareNested<A>	withNewPostIncrementCompareLike(PostIncrement item)
ForFluent<A>.PreDecrementCompareNested<A>	withNewPreDecrementCompare()
ForFluent<A>.PreDecrementCompareNested<A>	withNewPreDecrementCompareLike(PreDecrement item)
ForFluent<A>.PreIncrementCompareNested<A>	withNewPreIncrementCompare()
ForFluent<A>.PreIncrementCompareNested<A>	withNewPreIncrementCompareLike(PreIncrement item)
ForFluent<A>.PropertyRefCompareNested<A>	withNewPropertyRefCompare()
ForFluent<A>.PropertyRefCompareNested<A>	withNewPropertyRefCompareLike(PropertyRef item)
ForFluent<A>.ReturnBodyNested<A>	withNewReturnBody()
A	withNewReturnBody(Object object)
ForFluent<A>.ReturnBodyNested<A>	withNewReturnBodyLike(Return item)
ForFluent<A>.RightShiftCompareNested<A>	withNewRightShiftCompare()
A	withNewRightShiftCompare(Object left, Object right)
ForFluent<A>.RightShiftCompareNested<A>	withNewRightShiftCompareLike(RightShift item)
ForFluent<A>.RightUnsignedShiftCompareNested<A>	withNewRightUnsignedShiftCompare()
A	withNewRightUnsignedShiftCompare(Object left, Object right)
ForFluent<A>.RightUnsignedShiftCompareNested<A>	withNewRightUnsignedShiftCompareLike(RightUnsignedShift item)
ForFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBody()
A	withNewStringStatementBody(String data)
A	withNewStringStatementBody(String data, Object[] parameters)
ForFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBodyLike(StringStatement item)
ForFluent<A>.SwitchBodyNested<A>	withNewSwitchBody()
ForFluent<A>.SwitchBodyNested<A>	withNewSwitchBodyLike(Switch item)
ForFluent<A>.TernaryCompareNested<A>	withNewTernaryCompare()
ForFluent<A>.TernaryCompareNested<A>	withNewTernaryCompareLike(Ternary item)
ForFluent<A>.ThisCompareNested<A>	withNewThisCompare()
ForFluent<A>.ThisCompareNested<A>	withNewThisCompareLike(This item)
ForFluent<A>.ValueRefCompareNested<A>	withNewValueRefCompare()
A	withNewValueRefCompare(Object value)
ForFluent<A>.ValueRefCompareNested<A>	withNewValueRefCompareLike(ValueRef item)
ForFluent<A>.WhileBodyNested<A>	withNewWhileBody()
ForFluent<A>.WhileBodyNested<A>	withNewWhileBodyLike(While item)
ForFluent<A>.XorCompareNested<A>	withNewXorCompare()
A	withNewXorCompare(Object left, Object right)
ForFluent<A>.XorCompareNested<A>	withNewXorCompareLike(Xor item)
A	withUpdate(Expression... update)
A	withUpdate(List<Expression> update)

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

ForFluent

public ForFluent()

ForFluent

public ForFluent(For instance)

Method Details

copyInstance

protected void copyInstance(For instance)

addToInit

public A addToInit(VisitableBuilder<? extends Expression,?> builder)

addToInit

public A addToInit(int index,
 VisitableBuilder<? extends Expression,?> builder)

addToInit

public A addToInit(int index,
 Expression item)

setToInit

public A setToInit(int index,
 Expression item)

addToInit

public A addToInit(Expression... items)

addAllToInit

public A addAllToInit(Collection<Expression> items)

removeFromInit

public A removeFromInit(VisitableBuilder<? extends Expression,?> builder)

removeFromInit

public A removeFromInit(Expression... items)

removeAllFromInit

public A removeAllFromInit(Collection<Expression> items)

removeMatchingFromInit

public A removeMatchingFromInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

buildInit

public List<Expression> buildInit()

buildInit

public Expression buildInit(int index)

buildFirstInit

public Expression buildFirstInit()

buildLastInit

public Expression buildLastInit()

buildMatchingInit

public Expression buildMatchingInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

hasMatchingInit

public boolean hasMatchingInit(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

withInit

public A withInit(List<Expression> init)

withInit

public A withInit(Expression... init)

hasInit

public boolean hasInit()

addNewMultiplyInit

public ForFluent<A>.MultiplyInitNested<A> addNewMultiplyInit()

addNewMultiplyInitLike

public ForFluent<A>.MultiplyInitNested<A> addNewMultiplyInitLike(Multiply item)

addNewMultiplyInit

public A addNewMultiplyInit(Object left,
 Object right)

setNewMultiplyInitLike

public ForFluent<A>.MultiplyInitNested<A> setNewMultiplyInitLike(int index,
 Multiply item)

addNewNewArrayInit

public ForFluent<A>.NewArrayInitNested<A> addNewNewArrayInit()

addNewNewArrayInitLike

public ForFluent<A>.NewArrayInitNested<A> addNewNewArrayInitLike(NewArray item)

addNewNewArrayInit

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

setNewNewArrayInitLike

public ForFluent<A>.NewArrayInitNested<A> setNewNewArrayInitLike(int index,
 NewArray item)

addNewInstanceOfInit

public ForFluent<A>.InstanceOfInitNested<A> addNewInstanceOfInit()

addNewInstanceOfInitLike

public ForFluent<A>.InstanceOfInitNested<A> addNewInstanceOfInitLike(InstanceOf item)

setNewInstanceOfInitLike

public ForFluent<A>.InstanceOfInitNested<A> setNewInstanceOfInitLike(int index,
 InstanceOf item)

addNewMethodCallInit

public ForFluent<A>.MethodCallInitNested<A> addNewMethodCallInit()

addNewMethodCallInitLike

public ForFluent<A>.MethodCallInitNested<A> addNewMethodCallInitLike(MethodCall item)

setNewMethodCallInitLike

public ForFluent<A>.MethodCallInitNested<A> setNewMethodCallInitLike(int index,
 MethodCall item)

addNewInverseInit

public ForFluent<A>.InverseInitNested<A> addNewInverseInit()

addNewInverseInitLike

public ForFluent<A>.InverseInitNested<A> addNewInverseInitLike(Inverse item)

setNewInverseInitLike

public ForFluent<A>.InverseInitNested<A> setNewInverseInitLike(int index,
 Inverse item)

addNewIndexInit

public ForFluent<A>.IndexInitNested<A> addNewIndexInit()

addNewIndexInitLike

public ForFluent<A>.IndexInitNested<A> addNewIndexInitLike(Index item)

setNewIndexInitLike

public ForFluent<A>.IndexInitNested<A> setNewIndexInitLike(int index,
 Index item)

addNewGreaterThanOrEqualInit

public ForFluent<A>.GreaterThanOrEqualInitNested<A> addNewGreaterThanOrEqualInit()

addNewGreaterThanOrEqualInitLike

public ForFluent<A>.GreaterThanOrEqualInitNested<A> addNewGreaterThanOrEqualInitLike(GreaterThanOrEqual item)

addNewGreaterThanOrEqualInit

public A addNewGreaterThanOrEqualInit(Object left,
 Object right)

setNewGreaterThanOrEqualInitLike

public ForFluent<A>.GreaterThanOrEqualInitNested<A> setNewGreaterThanOrEqualInitLike(int index,
 GreaterThanOrEqual item)

addNewBitwiseAndInit

public ForFluent<A>.BitwiseAndInitNested<A> addNewBitwiseAndInit()

addNewBitwiseAndInitLike

public ForFluent<A>.BitwiseAndInitNested<A> addNewBitwiseAndInitLike(BitwiseAnd item)

addNewBitwiseAndInit

public A addNewBitwiseAndInit(Object left,
 Object right)

setNewBitwiseAndInitLike

public ForFluent<A>.BitwiseAndInitNested<A> setNewBitwiseAndInitLike(int index,
 BitwiseAnd item)

addNewMinusInit

public ForFluent<A>.MinusInitNested<A> addNewMinusInit()

addNewMinusInitLike

public ForFluent<A>.MinusInitNested<A> addNewMinusInitLike(Minus item)

addNewMinusInit

public A addNewMinusInit(Object left,
 Object right)

setNewMinusInitLike

public ForFluent<A>.MinusInitNested<A> setNewMinusInitLike(int index,
 Minus item)

addNewLogicalOrInit

public ForFluent<A>.LogicalOrInitNested<A> addNewLogicalOrInit()

addNewLogicalOrInitLike

public ForFluent<A>.LogicalOrInitNested<A> addNewLogicalOrInitLike(LogicalOr item)

addNewLogicalOrInit

public A addNewLogicalOrInit(Object left,
 Object right)

setNewLogicalOrInitLike

public ForFluent<A>.LogicalOrInitNested<A> setNewLogicalOrInitLike(int index,
 LogicalOr item)

addNewNotEqualsInit

public ForFluent<A>.NotEqualsInitNested<A> addNewNotEqualsInit()

addNewNotEqualsInitLike

public ForFluent<A>.NotEqualsInitNested<A> addNewNotEqualsInitLike(NotEquals item)

addNewNotEqualsInit

public A addNewNotEqualsInit(Object left,
 Object right)

setNewNotEqualsInitLike

public ForFluent<A>.NotEqualsInitNested<A> setNewNotEqualsInitLike(int index,
 NotEquals item)

addNewDivideInit

public ForFluent<A>.DivideInitNested<A> addNewDivideInit()

addNewDivideInitLike

public ForFluent<A>.DivideInitNested<A> addNewDivideInitLike(Divide item)

addNewDivideInit

public A addNewDivideInit(Object left,
 Object right)

setNewDivideInitLike

public ForFluent<A>.DivideInitNested<A> setNewDivideInitLike(int index,
 Divide item)

addNewLessThanInit

public ForFluent<A>.LessThanInitNested<A> addNewLessThanInit()

addNewLessThanInitLike

public ForFluent<A>.LessThanInitNested<A> addNewLessThanInitLike(LessThan item)

addNewLessThanInit

public A addNewLessThanInit(Object left,
 Object right)

setNewLessThanInitLike

public ForFluent<A>.LessThanInitNested<A> setNewLessThanInitLike(int index,
 LessThan item)

addNewBitwiseOrInit

public ForFluent<A>.BitwiseOrInitNested<A> addNewBitwiseOrInit()

addNewBitwiseOrInitLike

public ForFluent<A>.BitwiseOrInitNested<A> addNewBitwiseOrInitLike(BitwiseOr item)

addNewBitwiseOrInit

public A addNewBitwiseOrInit(Object left,
 Object right)

setNewBitwiseOrInitLike

public ForFluent<A>.BitwiseOrInitNested<A> setNewBitwiseOrInitLike(int index,
 BitwiseOr item)

addNewPropertyRefInit

public ForFluent<A>.PropertyRefInitNested<A> addNewPropertyRefInit()

addNewPropertyRefInitLike

public ForFluent<A>.PropertyRefInitNested<A> addNewPropertyRefInitLike(PropertyRef item)

setNewPropertyRefInitLike

public ForFluent<A>.PropertyRefInitNested<A> setNewPropertyRefInitLike(int index,
 PropertyRef item)

addNewRightShiftInit

public ForFluent<A>.RightShiftInitNested<A> addNewRightShiftInit()

addNewRightShiftInitLike

public ForFluent<A>.RightShiftInitNested<A> addNewRightShiftInitLike(RightShift item)

addNewRightShiftInit

public A addNewRightShiftInit(Object left,
 Object right)

setNewRightShiftInitLike

public ForFluent<A>.RightShiftInitNested<A> setNewRightShiftInitLike(int index,
 RightShift item)

addNewGreaterThanInit

public ForFluent<A>.GreaterThanInitNested<A> addNewGreaterThanInit()

addNewGreaterThanInitLike

public ForFluent<A>.GreaterThanInitNested<A> addNewGreaterThanInitLike(GreaterThan item)

addNewGreaterThanInit

public A addNewGreaterThanInit(Object left,
 Object right)

setNewGreaterThanInitLike

public ForFluent<A>.GreaterThanInitNested<A> setNewGreaterThanInitLike(int index,
 GreaterThan item)

addNewDeclareInit

public ForFluent<A>.DeclareInitNested<A> addNewDeclareInit()

addNewDeclareInitLike

public ForFluent<A>.DeclareInitNested<A> addNewDeclareInitLike(Declare item)

addNewDeclareInit

public A addNewDeclareInit(Class type,
 String name)

addNewDeclareInit

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

setNewDeclareInitLike

public ForFluent<A>.DeclareInitNested<A> setNewDeclareInitLike(int index,
 Declare item)

addNewCastInit

public ForFluent<A>.CastInitNested<A> addNewCastInit()

addNewCastInitLike

public ForFluent<A>.CastInitNested<A> addNewCastInitLike(Cast item)

setNewCastInitLike

public ForFluent<A>.CastInitNested<A> setNewCastInitLike(int index,
 Cast item)

addNewModuloInit

public ForFluent<A>.ModuloInitNested<A> addNewModuloInit()

addNewModuloInitLike

public ForFluent<A>.ModuloInitNested<A> addNewModuloInitLike(Modulo item)

addNewModuloInit

public A addNewModuloInit(Object left,
 Object right)

setNewModuloInitLike

public ForFluent<A>.ModuloInitNested<A> setNewModuloInitLike(int index,
 Modulo item)

addNewValueRefInit

public ForFluent<A>.ValueRefInitNested<A> addNewValueRefInit()

addNewValueRefInitLike

public ForFluent<A>.ValueRefInitNested<A> addNewValueRefInitLike(ValueRef item)

addNewValueRefInit

public A addNewValueRefInit(Object value)

setNewValueRefInitLike

public ForFluent<A>.ValueRefInitNested<A> setNewValueRefInitLike(int index,
 ValueRef item)

addNewLeftShiftInit

public ForFluent<A>.LeftShiftInitNested<A> addNewLeftShiftInit()

addNewLeftShiftInitLike

public ForFluent<A>.LeftShiftInitNested<A> addNewLeftShiftInitLike(LeftShift item)

addNewLeftShiftInit

public A addNewLeftShiftInit(Object left,
 Object right)

setNewLeftShiftInitLike

public ForFluent<A>.LeftShiftInitNested<A> setNewLeftShiftInitLike(int index,
 LeftShift item)

addNewTernaryInit

public ForFluent<A>.TernaryInitNested<A> addNewTernaryInit()

addNewTernaryInitLike

public ForFluent<A>.TernaryInitNested<A> addNewTernaryInitLike(Ternary item)

setNewTernaryInitLike

public ForFluent<A>.TernaryInitNested<A> setNewTernaryInitLike(int index,
 Ternary item)

addNewBinaryExpressionInit

public ForFluent<A>.BinaryExpressionInitNested<A> addNewBinaryExpressionInit()

addNewBinaryExpressionInitLike

public ForFluent<A>.BinaryExpressionInitNested<A> addNewBinaryExpressionInitLike(BinaryExpression item)

setNewBinaryExpressionInitLike

public ForFluent<A>.BinaryExpressionInitNested<A> setNewBinaryExpressionInitLike(int index,
 BinaryExpression item)

addNewEqualsInit

public ForFluent<A>.EqualsInitNested<A> addNewEqualsInit()

addNewEqualsInitLike

public ForFluent<A>.EqualsInitNested<A> addNewEqualsInitLike(Equals item)

addNewEqualsInit

public A addNewEqualsInit(Object left,
 Object right)

setNewEqualsInitLike

public ForFluent<A>.EqualsInitNested<A> setNewEqualsInitLike(int index,
 Equals item)

addNewEnclosedInit

public ForFluent<A>.EnclosedInitNested<A> addNewEnclosedInit()

addNewEnclosedInitLike

public ForFluent<A>.EnclosedInitNested<A> addNewEnclosedInitLike(Enclosed item)

setNewEnclosedInitLike

public ForFluent<A>.EnclosedInitNested<A> setNewEnclosedInitLike(int index,
 Enclosed item)

addNewPreDecrementInit

public ForFluent<A>.PreDecrementInitNested<A> addNewPreDecrementInit()

addNewPreDecrementInitLike

public ForFluent<A>.PreDecrementInitNested<A> addNewPreDecrementInitLike(PreDecrement item)

setNewPreDecrementInitLike

public ForFluent<A>.PreDecrementInitNested<A> setNewPreDecrementInitLike(int index,
 PreDecrement item)

addNewPostDecrementInit

public ForFluent<A>.PostDecrementInitNested<A> addNewPostDecrementInit()

addNewPostDecrementInitLike

public ForFluent<A>.PostDecrementInitNested<A> addNewPostDecrementInitLike(PostDecrement item)

setNewPostDecrementInitLike

public ForFluent<A>.PostDecrementInitNested<A> setNewPostDecrementInitLike(int index,
 PostDecrement item)

addNewLambdaInit

public ForFluent<A>.LambdaInitNested<A> addNewLambdaInit()

addNewLambdaInitLike

public ForFluent<A>.LambdaInitNested<A> addNewLambdaInitLike(Lambda item)

setNewLambdaInitLike

public ForFluent<A>.LambdaInitNested<A> setNewLambdaInitLike(int index,
 Lambda item)

addNewNotInit

public ForFluent<A>.NotInitNested<A> addNewNotInit()

addNewNotInitLike

public ForFluent<A>.NotInitNested<A> addNewNotInitLike(Not item)

setNewNotInitLike

public ForFluent<A>.NotInitNested<A> setNewNotInitLike(int index,
 Not item)

addNewAssignInit

public ForFluent<A>.AssignInitNested<A> addNewAssignInit()

addNewAssignInitLike

public ForFluent<A>.AssignInitNested<A> addNewAssignInitLike(Assign item)

setNewAssignInitLike

public ForFluent<A>.AssignInitNested<A> setNewAssignInitLike(int index,
 Assign item)

addNewNegativeInit

public ForFluent<A>.NegativeInitNested<A> addNewNegativeInit()

addNewNegativeInitLike

public ForFluent<A>.NegativeInitNested<A> addNewNegativeInitLike(Negative item)

setNewNegativeInitLike

public ForFluent<A>.NegativeInitNested<A> setNewNegativeInitLike(int index,
 Negative item)

addNewThisInit

public ForFluent<A>.ThisInitNested<A> addNewThisInit()

addNewThisInitLike

public ForFluent<A>.ThisInitNested<A> addNewThisInitLike(This item)

setNewThisInitLike

public ForFluent<A>.ThisInitNested<A> setNewThisInitLike(int index,
 This item)

addNewLogicalAndInit

public ForFluent<A>.LogicalAndInitNested<A> addNewLogicalAndInit()

addNewLogicalAndInitLike

public ForFluent<A>.LogicalAndInitNested<A> addNewLogicalAndInitLike(LogicalAnd item)

addNewLogicalAndInit

public A addNewLogicalAndInit(Object left,
 Object right)

setNewLogicalAndInitLike

public ForFluent<A>.LogicalAndInitNested<A> setNewLogicalAndInitLike(int index,
 LogicalAnd item)

addNewPostIncrementInit

public ForFluent<A>.PostIncrementInitNested<A> addNewPostIncrementInit()

addNewPostIncrementInitLike

public ForFluent<A>.PostIncrementInitNested<A> addNewPostIncrementInitLike(PostIncrement item)

setNewPostIncrementInitLike

public ForFluent<A>.PostIncrementInitNested<A> setNewPostIncrementInitLike(int index,
 PostIncrement item)

addNewRightUnsignedShiftInit

public ForFluent<A>.RightUnsignedShiftInitNested<A> addNewRightUnsignedShiftInit()

addNewRightUnsignedShiftInitLike

public ForFluent<A>.RightUnsignedShiftInitNested<A> addNewRightUnsignedShiftInitLike(RightUnsignedShift item)

addNewRightUnsignedShiftInit

public A addNewRightUnsignedShiftInit(Object left,
 Object right)

setNewRightUnsignedShiftInitLike

public ForFluent<A>.RightUnsignedShiftInitNested<A> setNewRightUnsignedShiftInitLike(int index,
 RightUnsignedShift item)

addNewPlusInit

public ForFluent<A>.PlusInitNested<A> addNewPlusInit()

addNewPlusInitLike

public ForFluent<A>.PlusInitNested<A> addNewPlusInitLike(Plus item)

addNewPlusInit

public A addNewPlusInit(Object left,
 Object right)

setNewPlusInitLike

public ForFluent<A>.PlusInitNested<A> setNewPlusInitLike(int index,
 Plus item)

addNewConstructInit

public ForFluent<A>.ConstructInitNested<A> addNewConstructInit()

addNewConstructInitLike

public ForFluent<A>.ConstructInitNested<A> addNewConstructInitLike(Construct item)

setNewConstructInitLike

public ForFluent<A>.ConstructInitNested<A> setNewConstructInitLike(int index,
 Construct item)

addNewXorInit

public ForFluent<A>.XorInitNested<A> addNewXorInit()

addNewXorInitLike

public ForFluent<A>.XorInitNested<A> addNewXorInitLike(Xor item)

addNewXorInit

public A addNewXorInit(Object left,
 Object right)

setNewXorInitLike

public ForFluent<A>.XorInitNested<A> setNewXorInitLike(int index,
 Xor item)

addNewPreIncrementInit

public ForFluent<A>.PreIncrementInitNested<A> addNewPreIncrementInit()

addNewPreIncrementInitLike

public ForFluent<A>.PreIncrementInitNested<A> addNewPreIncrementInitLike(PreIncrement item)

setNewPreIncrementInitLike

public ForFluent<A>.PreIncrementInitNested<A> setNewPreIncrementInitLike(int index,
 PreIncrement item)

addNewLessThanOrEqualInit

public ForFluent<A>.LessThanOrEqualInitNested<A> addNewLessThanOrEqualInit()

addNewLessThanOrEqualInitLike

public ForFluent<A>.LessThanOrEqualInitNested<A> addNewLessThanOrEqualInitLike(LessThanOrEqual item)

addNewLessThanOrEqualInit

public A addNewLessThanOrEqualInit(Object left,
 Object right)

setNewLessThanOrEqualInitLike

public ForFluent<A>.LessThanOrEqualInitNested<A> setNewLessThanOrEqualInitLike(int index,
 LessThanOrEqual item)

addNewPositiveInit

public ForFluent<A>.PositiveInitNested<A> addNewPositiveInit()

addNewPositiveInitLike

public ForFluent<A>.PositiveInitNested<A> addNewPositiveInitLike(Positive item)

setNewPositiveInitLike

public ForFluent<A>.PositiveInitNested<A> setNewPositiveInitLike(int index,
 Positive item)

buildCompare

public Expression buildCompare()

withCompare

public A withCompare(Expression compare)

hasCompare

public boolean hasCompare()

withNewMultiplyCompare

public ForFluent<A>.MultiplyCompareNested<A> withNewMultiplyCompare()

withNewMultiplyCompareLike

public ForFluent<A>.MultiplyCompareNested<A> withNewMultiplyCompareLike(Multiply item)

withNewMultiplyCompare

public A withNewMultiplyCompare(Object left,
 Object right)

withNewNewArrayCompare

public ForFluent<A>.NewArrayCompareNested<A> withNewNewArrayCompare()

withNewNewArrayCompareLike

public ForFluent<A>.NewArrayCompareNested<A> withNewNewArrayCompareLike(NewArray item)

withNewNewArrayCompare

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

withNewInstanceOfCompare

public ForFluent<A>.InstanceOfCompareNested<A> withNewInstanceOfCompare()

withNewInstanceOfCompareLike

public ForFluent<A>.InstanceOfCompareNested<A> withNewInstanceOfCompareLike(InstanceOf item)

withNewMethodCallCompare

public ForFluent<A>.MethodCallCompareNested<A> withNewMethodCallCompare()

withNewMethodCallCompareLike

public ForFluent<A>.MethodCallCompareNested<A> withNewMethodCallCompareLike(MethodCall item)

withNewInverseCompare

public ForFluent<A>.InverseCompareNested<A> withNewInverseCompare()

withNewInverseCompareLike

public ForFluent<A>.InverseCompareNested<A> withNewInverseCompareLike(Inverse item)

withNewIndexCompare

public ForFluent<A>.IndexCompareNested<A> withNewIndexCompare()

withNewIndexCompareLike

public ForFluent<A>.IndexCompareNested<A> withNewIndexCompareLike(Index item)

withNewGreaterThanOrEqualCompare

public ForFluent<A>.GreaterThanOrEqualCompareNested<A> withNewGreaterThanOrEqualCompare()

withNewGreaterThanOrEqualCompareLike

public ForFluent<A>.GreaterThanOrEqualCompareNested<A> withNewGreaterThanOrEqualCompareLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualCompare

public A withNewGreaterThanOrEqualCompare(Object left,
 Object right)

withNewBitwiseAndCompare

public ForFluent<A>.BitwiseAndCompareNested<A> withNewBitwiseAndCompare()

withNewBitwiseAndCompareLike

public ForFluent<A>.BitwiseAndCompareNested<A> withNewBitwiseAndCompareLike(BitwiseAnd item)

withNewBitwiseAndCompare

public A withNewBitwiseAndCompare(Object left,
 Object right)

withNewMinusCompare

public ForFluent<A>.MinusCompareNested<A> withNewMinusCompare()

withNewMinusCompareLike

public ForFluent<A>.MinusCompareNested<A> withNewMinusCompareLike(Minus item)

withNewMinusCompare

public A withNewMinusCompare(Object left,
 Object right)

withNewLogicalOrCompare

public ForFluent<A>.LogicalOrCompareNested<A> withNewLogicalOrCompare()

withNewLogicalOrCompareLike

public ForFluent<A>.LogicalOrCompareNested<A> withNewLogicalOrCompareLike(LogicalOr item)

withNewLogicalOrCompare

public A withNewLogicalOrCompare(Object left,
 Object right)

withNewNotEqualsCompare

public ForFluent<A>.NotEqualsCompareNested<A> withNewNotEqualsCompare()

withNewNotEqualsCompareLike

public ForFluent<A>.NotEqualsCompareNested<A> withNewNotEqualsCompareLike(NotEquals item)

withNewNotEqualsCompare

public A withNewNotEqualsCompare(Object left,
 Object right)

withNewDivideCompare

public ForFluent<A>.DivideCompareNested<A> withNewDivideCompare()

withNewDivideCompareLike

public ForFluent<A>.DivideCompareNested<A> withNewDivideCompareLike(Divide item)

withNewDivideCompare

public A withNewDivideCompare(Object left,
 Object right)

withNewLessThanCompare

public ForFluent<A>.LessThanCompareNested<A> withNewLessThanCompare()

withNewLessThanCompareLike

public ForFluent<A>.LessThanCompareNested<A> withNewLessThanCompareLike(LessThan item)

withNewLessThanCompare

public A withNewLessThanCompare(Object left,
 Object right)

withNewBitwiseOrCompare

public ForFluent<A>.BitwiseOrCompareNested<A> withNewBitwiseOrCompare()

withNewBitwiseOrCompareLike

public ForFluent<A>.BitwiseOrCompareNested<A> withNewBitwiseOrCompareLike(BitwiseOr item)

withNewBitwiseOrCompare

public A withNewBitwiseOrCompare(Object left,
 Object right)

withNewPropertyRefCompare

public ForFluent<A>.PropertyRefCompareNested<A> withNewPropertyRefCompare()

withNewPropertyRefCompareLike

public ForFluent<A>.PropertyRefCompareNested<A> withNewPropertyRefCompareLike(PropertyRef item)

withNewRightShiftCompare

public ForFluent<A>.RightShiftCompareNested<A> withNewRightShiftCompare()

withNewRightShiftCompareLike

public ForFluent<A>.RightShiftCompareNested<A> withNewRightShiftCompareLike(RightShift item)

withNewRightShiftCompare

public A withNewRightShiftCompare(Object left,
 Object right)

withNewGreaterThanCompare

public ForFluent<A>.GreaterThanCompareNested<A> withNewGreaterThanCompare()

withNewGreaterThanCompareLike

public ForFluent<A>.GreaterThanCompareNested<A> withNewGreaterThanCompareLike(GreaterThan item)

withNewGreaterThanCompare

public A withNewGreaterThanCompare(Object left,
 Object right)

withNewDeclareCompare

public ForFluent<A>.DeclareCompareNested<A> withNewDeclareCompare()

withNewDeclareCompareLike

public ForFluent<A>.DeclareCompareNested<A> withNewDeclareCompareLike(Declare item)

withNewDeclareCompare

public A withNewDeclareCompare(Class type,
 String name)

withNewDeclareCompare

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

withNewCastCompare

public ForFluent<A>.CastCompareNested<A> withNewCastCompare()

withNewCastCompareLike

public ForFluent<A>.CastCompareNested<A> withNewCastCompareLike(Cast item)

withNewModuloCompare

public ForFluent<A>.ModuloCompareNested<A> withNewModuloCompare()

withNewModuloCompareLike

public ForFluent<A>.ModuloCompareNested<A> withNewModuloCompareLike(Modulo item)

withNewModuloCompare

public A withNewModuloCompare(Object left,
 Object right)

withNewValueRefCompare

public ForFluent<A>.ValueRefCompareNested<A> withNewValueRefCompare()

withNewValueRefCompareLike

public ForFluent<A>.ValueRefCompareNested<A> withNewValueRefCompareLike(ValueRef item)

withNewValueRefCompare

public A withNewValueRefCompare(Object value)

withNewLeftShiftCompare

public ForFluent<A>.LeftShiftCompareNested<A> withNewLeftShiftCompare()

withNewLeftShiftCompareLike

public ForFluent<A>.LeftShiftCompareNested<A> withNewLeftShiftCompareLike(LeftShift item)

withNewLeftShiftCompare

public A withNewLeftShiftCompare(Object left,
 Object right)

withNewTernaryCompare

public ForFluent<A>.TernaryCompareNested<A> withNewTernaryCompare()

withNewTernaryCompareLike

public ForFluent<A>.TernaryCompareNested<A> withNewTernaryCompareLike(Ternary item)

withNewBinaryExpressionCompare

public ForFluent<A>.BinaryExpressionCompareNested<A> withNewBinaryExpressionCompare()

withNewBinaryExpressionCompareLike

public ForFluent<A>.BinaryExpressionCompareNested<A> withNewBinaryExpressionCompareLike(BinaryExpression item)

withNewEqualsCompare

public ForFluent<A>.EqualsCompareNested<A> withNewEqualsCompare()

withNewEqualsCompareLike

public ForFluent<A>.EqualsCompareNested<A> withNewEqualsCompareLike(Equals item)

withNewEqualsCompare

public A withNewEqualsCompare(Object left,
 Object right)

withNewEnclosedCompare

public ForFluent<A>.EnclosedCompareNested<A> withNewEnclosedCompare()

withNewEnclosedCompareLike

public ForFluent<A>.EnclosedCompareNested<A> withNewEnclosedCompareLike(Enclosed item)

withNewPreDecrementCompare

public ForFluent<A>.PreDecrementCompareNested<A> withNewPreDecrementCompare()

withNewPreDecrementCompareLike

public ForFluent<A>.PreDecrementCompareNested<A> withNewPreDecrementCompareLike(PreDecrement item)

withNewPostDecrementCompare

public ForFluent<A>.PostDecrementCompareNested<A> withNewPostDecrementCompare()

withNewPostDecrementCompareLike

public ForFluent<A>.PostDecrementCompareNested<A> withNewPostDecrementCompareLike(PostDecrement item)

withNewLambdaCompare

public ForFluent<A>.LambdaCompareNested<A> withNewLambdaCompare()

withNewLambdaCompareLike

public ForFluent<A>.LambdaCompareNested<A> withNewLambdaCompareLike(Lambda item)

withNewNotCompare

public ForFluent<A>.NotCompareNested<A> withNewNotCompare()

withNewNotCompareLike

public ForFluent<A>.NotCompareNested<A> withNewNotCompareLike(Not item)

withNewAssignCompare

public ForFluent<A>.AssignCompareNested<A> withNewAssignCompare()

withNewAssignCompareLike

public ForFluent<A>.AssignCompareNested<A> withNewAssignCompareLike(Assign item)

withNewNegativeCompare

public ForFluent<A>.NegativeCompareNested<A> withNewNegativeCompare()

withNewNegativeCompareLike

public ForFluent<A>.NegativeCompareNested<A> withNewNegativeCompareLike(Negative item)

withNewThisCompare

public ForFluent<A>.ThisCompareNested<A> withNewThisCompare()

withNewThisCompareLike

public ForFluent<A>.ThisCompareNested<A> withNewThisCompareLike(This item)

withNewLogicalAndCompare

public ForFluent<A>.LogicalAndCompareNested<A> withNewLogicalAndCompare()

withNewLogicalAndCompareLike

public ForFluent<A>.LogicalAndCompareNested<A> withNewLogicalAndCompareLike(LogicalAnd item)

withNewLogicalAndCompare

public A withNewLogicalAndCompare(Object left,
 Object right)

withNewPostIncrementCompare

public ForFluent<A>.PostIncrementCompareNested<A> withNewPostIncrementCompare()

withNewPostIncrementCompareLike

public ForFluent<A>.PostIncrementCompareNested<A> withNewPostIncrementCompareLike(PostIncrement item)

withNewRightUnsignedShiftCompare

public ForFluent<A>.RightUnsignedShiftCompareNested<A> withNewRightUnsignedShiftCompare()

withNewRightUnsignedShiftCompareLike

public ForFluent<A>.RightUnsignedShiftCompareNested<A> withNewRightUnsignedShiftCompareLike(RightUnsignedShift item)

withNewRightUnsignedShiftCompare

public A withNewRightUnsignedShiftCompare(Object left,
 Object right)

withNewPlusCompare

public ForFluent<A>.PlusCompareNested<A> withNewPlusCompare()

withNewPlusCompareLike

public ForFluent<A>.PlusCompareNested<A> withNewPlusCompareLike(Plus item)

withNewPlusCompare

public A withNewPlusCompare(Object left,
 Object right)

withNewConstructCompare

public ForFluent<A>.ConstructCompareNested<A> withNewConstructCompare()

withNewConstructCompareLike

public ForFluent<A>.ConstructCompareNested<A> withNewConstructCompareLike(Construct item)

withNewXorCompare

public ForFluent<A>.XorCompareNested<A> withNewXorCompare()

withNewXorCompareLike

public ForFluent<A>.XorCompareNested<A> withNewXorCompareLike(Xor item)

withNewXorCompare

public A withNewXorCompare(Object left,
 Object right)

withNewPreIncrementCompare

public ForFluent<A>.PreIncrementCompareNested<A> withNewPreIncrementCompare()

withNewPreIncrementCompareLike

public ForFluent<A>.PreIncrementCompareNested<A> withNewPreIncrementCompareLike(PreIncrement item)

withNewLessThanOrEqualCompare

public ForFluent<A>.LessThanOrEqualCompareNested<A> withNewLessThanOrEqualCompare()

withNewLessThanOrEqualCompareLike

public ForFluent<A>.LessThanOrEqualCompareNested<A> withNewLessThanOrEqualCompareLike(LessThanOrEqual item)

withNewLessThanOrEqualCompare

public A withNewLessThanOrEqualCompare(Object left,
 Object right)

withNewPositiveCompare

public ForFluent<A>.PositiveCompareNested<A> withNewPositiveCompare()

withNewPositiveCompareLike

public ForFluent<A>.PositiveCompareNested<A> withNewPositiveCompareLike(Positive item)

addToUpdate

public A addToUpdate(VisitableBuilder<? extends Expression,?> builder)

addToUpdate

public A addToUpdate(int index,
 VisitableBuilder<? extends Expression,?> builder)

addToUpdate

public A addToUpdate(int index,
 Expression item)

setToUpdate

public A setToUpdate(int index,
 Expression item)

addToUpdate

public A addToUpdate(Expression... items)

addAllToUpdate

public A addAllToUpdate(Collection<Expression> items)

removeFromUpdate

public A removeFromUpdate(VisitableBuilder<? extends Expression,?> builder)

removeFromUpdate

public A removeFromUpdate(Expression... items)

removeAllFromUpdate

public A removeAllFromUpdate(Collection<Expression> items)

removeMatchingFromUpdate

public A removeMatchingFromUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

buildUpdate

public List<Expression> buildUpdate()

buildUpdate

public Expression buildUpdate(int index)

buildFirstUpdate

public Expression buildFirstUpdate()

buildLastUpdate

public Expression buildLastUpdate()

buildMatchingUpdate

public Expression buildMatchingUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

hasMatchingUpdate

public boolean hasMatchingUpdate(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

withUpdate

public A withUpdate(List<Expression> update)

withUpdate

public A withUpdate(Expression... update)

hasUpdate

public boolean hasUpdate()

addNewMultiplyUpdate

public ForFluent<A>.MultiplyUpdateNested<A> addNewMultiplyUpdate()

addNewMultiplyUpdateLike

public ForFluent<A>.MultiplyUpdateNested<A> addNewMultiplyUpdateLike(Multiply item)

addNewMultiplyUpdate

public A addNewMultiplyUpdate(Object left,
 Object right)

setNewMultiplyUpdateLike

public ForFluent<A>.MultiplyUpdateNested<A> setNewMultiplyUpdateLike(int index,
 Multiply item)

addNewNewArrayUpdate

public ForFluent<A>.NewArrayUpdateNested<A> addNewNewArrayUpdate()

addNewNewArrayUpdateLike

public ForFluent<A>.NewArrayUpdateNested<A> addNewNewArrayUpdateLike(NewArray item)

addNewNewArrayUpdate

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

setNewNewArrayUpdateLike

public ForFluent<A>.NewArrayUpdateNested<A> setNewNewArrayUpdateLike(int index,
 NewArray item)

addNewInstanceOfUpdate

public ForFluent<A>.InstanceOfUpdateNested<A> addNewInstanceOfUpdate()

addNewInstanceOfUpdateLike

public ForFluent<A>.InstanceOfUpdateNested<A> addNewInstanceOfUpdateLike(InstanceOf item)

setNewInstanceOfUpdateLike

public ForFluent<A>.InstanceOfUpdateNested<A> setNewInstanceOfUpdateLike(int index,
 InstanceOf item)

addNewMethodCallUpdate

public ForFluent<A>.MethodCallUpdateNested<A> addNewMethodCallUpdate()

addNewMethodCallUpdateLike

public ForFluent<A>.MethodCallUpdateNested<A> addNewMethodCallUpdateLike(MethodCall item)

setNewMethodCallUpdateLike

public ForFluent<A>.MethodCallUpdateNested<A> setNewMethodCallUpdateLike(int index,
 MethodCall item)

addNewInverseUpdate

public ForFluent<A>.InverseUpdateNested<A> addNewInverseUpdate()

addNewInverseUpdateLike

public ForFluent<A>.InverseUpdateNested<A> addNewInverseUpdateLike(Inverse item)

setNewInverseUpdateLike

public ForFluent<A>.InverseUpdateNested<A> setNewInverseUpdateLike(int index,
 Inverse item)

addNewIndexUpdate

public ForFluent<A>.IndexUpdateNested<A> addNewIndexUpdate()

addNewIndexUpdateLike

public ForFluent<A>.IndexUpdateNested<A> addNewIndexUpdateLike(Index item)

setNewIndexUpdateLike

public ForFluent<A>.IndexUpdateNested<A> setNewIndexUpdateLike(int index,
 Index item)

addNewGreaterThanOrEqualUpdate

public ForFluent<A>.GreaterThanOrEqualUpdateNested<A> addNewGreaterThanOrEqualUpdate()

addNewGreaterThanOrEqualUpdateLike

public ForFluent<A>.GreaterThanOrEqualUpdateNested<A> addNewGreaterThanOrEqualUpdateLike(GreaterThanOrEqual item)

addNewGreaterThanOrEqualUpdate

public A addNewGreaterThanOrEqualUpdate(Object left,
 Object right)

setNewGreaterThanOrEqualUpdateLike

public ForFluent<A>.GreaterThanOrEqualUpdateNested<A> setNewGreaterThanOrEqualUpdateLike(int index,
 GreaterThanOrEqual item)

addNewBitwiseAndUpdate

public ForFluent<A>.BitwiseAndUpdateNested<A> addNewBitwiseAndUpdate()

addNewBitwiseAndUpdateLike

public ForFluent<A>.BitwiseAndUpdateNested<A> addNewBitwiseAndUpdateLike(BitwiseAnd item)

addNewBitwiseAndUpdate

public A addNewBitwiseAndUpdate(Object left,
 Object right)

setNewBitwiseAndUpdateLike

public ForFluent<A>.BitwiseAndUpdateNested<A> setNewBitwiseAndUpdateLike(int index,
 BitwiseAnd item)

addNewMinusUpdate

public ForFluent<A>.MinusUpdateNested<A> addNewMinusUpdate()

addNewMinusUpdateLike

public ForFluent<A>.MinusUpdateNested<A> addNewMinusUpdateLike(Minus item)

addNewMinusUpdate

public A addNewMinusUpdate(Object left,
 Object right)

setNewMinusUpdateLike

public ForFluent<A>.MinusUpdateNested<A> setNewMinusUpdateLike(int index,
 Minus item)

addNewLogicalOrUpdate

public ForFluent<A>.LogicalOrUpdateNested<A> addNewLogicalOrUpdate()

addNewLogicalOrUpdateLike

public ForFluent<A>.LogicalOrUpdateNested<A> addNewLogicalOrUpdateLike(LogicalOr item)

addNewLogicalOrUpdate

public A addNewLogicalOrUpdate(Object left,
 Object right)

setNewLogicalOrUpdateLike

public ForFluent<A>.LogicalOrUpdateNested<A> setNewLogicalOrUpdateLike(int index,
 LogicalOr item)

addNewNotEqualsUpdate

public ForFluent<A>.NotEqualsUpdateNested<A> addNewNotEqualsUpdate()

addNewNotEqualsUpdateLike

public ForFluent<A>.NotEqualsUpdateNested<A> addNewNotEqualsUpdateLike(NotEquals item)

addNewNotEqualsUpdate

public A addNewNotEqualsUpdate(Object left,
 Object right)

setNewNotEqualsUpdateLike

public ForFluent<A>.NotEqualsUpdateNested<A> setNewNotEqualsUpdateLike(int index,
 NotEquals item)

addNewDivideUpdate

public ForFluent<A>.DivideUpdateNested<A> addNewDivideUpdate()

addNewDivideUpdateLike

public ForFluent<A>.DivideUpdateNested<A> addNewDivideUpdateLike(Divide item)

addNewDivideUpdate

public A addNewDivideUpdate(Object left,
 Object right)

setNewDivideUpdateLike

public ForFluent<A>.DivideUpdateNested<A> setNewDivideUpdateLike(int index,
 Divide item)

addNewLessThanUpdate

public ForFluent<A>.LessThanUpdateNested<A> addNewLessThanUpdate()

addNewLessThanUpdateLike

public ForFluent<A>.LessThanUpdateNested<A> addNewLessThanUpdateLike(LessThan item)

addNewLessThanUpdate

public A addNewLessThanUpdate(Object left,
 Object right)

setNewLessThanUpdateLike

public ForFluent<A>.LessThanUpdateNested<A> setNewLessThanUpdateLike(int index,
 LessThan item)

addNewBitwiseOrUpdate

public ForFluent<A>.BitwiseOrUpdateNested<A> addNewBitwiseOrUpdate()

addNewBitwiseOrUpdateLike

public ForFluent<A>.BitwiseOrUpdateNested<A> addNewBitwiseOrUpdateLike(BitwiseOr item)

addNewBitwiseOrUpdate

public A addNewBitwiseOrUpdate(Object left,
 Object right)

setNewBitwiseOrUpdateLike

public ForFluent<A>.BitwiseOrUpdateNested<A> setNewBitwiseOrUpdateLike(int index,
 BitwiseOr item)

addNewPropertyRefUpdate

public ForFluent<A>.PropertyRefUpdateNested<A> addNewPropertyRefUpdate()

addNewPropertyRefUpdateLike

public ForFluent<A>.PropertyRefUpdateNested<A> addNewPropertyRefUpdateLike(PropertyRef item)

setNewPropertyRefUpdateLike

public ForFluent<A>.PropertyRefUpdateNested<A> setNewPropertyRefUpdateLike(int index,
 PropertyRef item)

addNewRightShiftUpdate

public ForFluent<A>.RightShiftUpdateNested<A> addNewRightShiftUpdate()

addNewRightShiftUpdateLike

public ForFluent<A>.RightShiftUpdateNested<A> addNewRightShiftUpdateLike(RightShift item)

addNewRightShiftUpdate

public A addNewRightShiftUpdate(Object left,
 Object right)

setNewRightShiftUpdateLike

public ForFluent<A>.RightShiftUpdateNested<A> setNewRightShiftUpdateLike(int index,
 RightShift item)

addNewGreaterThanUpdate

public ForFluent<A>.GreaterThanUpdateNested<A> addNewGreaterThanUpdate()

addNewGreaterThanUpdateLike

public ForFluent<A>.GreaterThanUpdateNested<A> addNewGreaterThanUpdateLike(GreaterThan item)

addNewGreaterThanUpdate

public A addNewGreaterThanUpdate(Object left,
 Object right)

setNewGreaterThanUpdateLike

public ForFluent<A>.GreaterThanUpdateNested<A> setNewGreaterThanUpdateLike(int index,
 GreaterThan item)

addNewDeclareUpdate

public ForFluent<A>.DeclareUpdateNested<A> addNewDeclareUpdate()

addNewDeclareUpdateLike

public ForFluent<A>.DeclareUpdateNested<A> addNewDeclareUpdateLike(Declare item)

addNewDeclareUpdate

public A addNewDeclareUpdate(Class type,
 String name)

addNewDeclareUpdate

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

setNewDeclareUpdateLike

public ForFluent<A>.DeclareUpdateNested<A> setNewDeclareUpdateLike(int index,
 Declare item)

addNewCastUpdate

public ForFluent<A>.CastUpdateNested<A> addNewCastUpdate()

addNewCastUpdateLike

public ForFluent<A>.CastUpdateNested<A> addNewCastUpdateLike(Cast item)

setNewCastUpdateLike

public ForFluent<A>.CastUpdateNested<A> setNewCastUpdateLike(int index,
 Cast item)

addNewModuloUpdate

public ForFluent<A>.ModuloUpdateNested<A> addNewModuloUpdate()

addNewModuloUpdateLike

public ForFluent<A>.ModuloUpdateNested<A> addNewModuloUpdateLike(Modulo item)

addNewModuloUpdate

public A addNewModuloUpdate(Object left,
 Object right)

setNewModuloUpdateLike

public ForFluent<A>.ModuloUpdateNested<A> setNewModuloUpdateLike(int index,
 Modulo item)

addNewValueRefUpdate

public ForFluent<A>.ValueRefUpdateNested<A> addNewValueRefUpdate()

addNewValueRefUpdateLike

public ForFluent<A>.ValueRefUpdateNested<A> addNewValueRefUpdateLike(ValueRef item)

addNewValueRefUpdate

public A addNewValueRefUpdate(Object value)

setNewValueRefUpdateLike

public ForFluent<A>.ValueRefUpdateNested<A> setNewValueRefUpdateLike(int index,
 ValueRef item)

addNewLeftShiftUpdate

public ForFluent<A>.LeftShiftUpdateNested<A> addNewLeftShiftUpdate()

addNewLeftShiftUpdateLike

public ForFluent<A>.LeftShiftUpdateNested<A> addNewLeftShiftUpdateLike(LeftShift item)

addNewLeftShiftUpdate

public A addNewLeftShiftUpdate(Object left,
 Object right)

setNewLeftShiftUpdateLike

public ForFluent<A>.LeftShiftUpdateNested<A> setNewLeftShiftUpdateLike(int index,
 LeftShift item)

addNewTernaryUpdate

public ForFluent<A>.TernaryUpdateNested<A> addNewTernaryUpdate()

addNewTernaryUpdateLike

public ForFluent<A>.TernaryUpdateNested<A> addNewTernaryUpdateLike(Ternary item)

setNewTernaryUpdateLike

public ForFluent<A>.TernaryUpdateNested<A> setNewTernaryUpdateLike(int index,
 Ternary item)

addNewBinaryExpressionUpdate

public ForFluent<A>.BinaryExpressionUpdateNested<A> addNewBinaryExpressionUpdate()

addNewBinaryExpressionUpdateLike

public ForFluent<A>.BinaryExpressionUpdateNested<A> addNewBinaryExpressionUpdateLike(BinaryExpression item)

setNewBinaryExpressionUpdateLike

public ForFluent<A>.BinaryExpressionUpdateNested<A> setNewBinaryExpressionUpdateLike(int index,
 BinaryExpression item)

addNewEqualsUpdate

public ForFluent<A>.EqualsUpdateNested<A> addNewEqualsUpdate()

addNewEqualsUpdateLike

public ForFluent<A>.EqualsUpdateNested<A> addNewEqualsUpdateLike(Equals item)

addNewEqualsUpdate

public A addNewEqualsUpdate(Object left,
 Object right)

setNewEqualsUpdateLike

public ForFluent<A>.EqualsUpdateNested<A> setNewEqualsUpdateLike(int index,
 Equals item)

addNewEnclosedUpdate

public ForFluent<A>.EnclosedUpdateNested<A> addNewEnclosedUpdate()

addNewEnclosedUpdateLike

public ForFluent<A>.EnclosedUpdateNested<A> addNewEnclosedUpdateLike(Enclosed item)

setNewEnclosedUpdateLike

public ForFluent<A>.EnclosedUpdateNested<A> setNewEnclosedUpdateLike(int index,
 Enclosed item)

addNewPreDecrementUpdate

public ForFluent<A>.PreDecrementUpdateNested<A> addNewPreDecrementUpdate()

addNewPreDecrementUpdateLike

public ForFluent<A>.PreDecrementUpdateNested<A> addNewPreDecrementUpdateLike(PreDecrement item)

setNewPreDecrementUpdateLike

public ForFluent<A>.PreDecrementUpdateNested<A> setNewPreDecrementUpdateLike(int index,
 PreDecrement item)

addNewPostDecrementUpdate

public ForFluent<A>.PostDecrementUpdateNested<A> addNewPostDecrementUpdate()

addNewPostDecrementUpdateLike

public ForFluent<A>.PostDecrementUpdateNested<A> addNewPostDecrementUpdateLike(PostDecrement item)

setNewPostDecrementUpdateLike

public ForFluent<A>.PostDecrementUpdateNested<A> setNewPostDecrementUpdateLike(int index,
 PostDecrement item)

addNewLambdaUpdate

public ForFluent<A>.LambdaUpdateNested<A> addNewLambdaUpdate()

addNewLambdaUpdateLike

public ForFluent<A>.LambdaUpdateNested<A> addNewLambdaUpdateLike(Lambda item)

setNewLambdaUpdateLike

public ForFluent<A>.LambdaUpdateNested<A> setNewLambdaUpdateLike(int index,
 Lambda item)

addNewNotUpdate

public ForFluent<A>.NotUpdateNested<A> addNewNotUpdate()

addNewNotUpdateLike

public ForFluent<A>.NotUpdateNested<A> addNewNotUpdateLike(Not item)

setNewNotUpdateLike

public ForFluent<A>.NotUpdateNested<A> setNewNotUpdateLike(int index,
 Not item)

addNewAssignUpdate

public ForFluent<A>.AssignUpdateNested<A> addNewAssignUpdate()

addNewAssignUpdateLike

public ForFluent<A>.AssignUpdateNested<A> addNewAssignUpdateLike(Assign item)

setNewAssignUpdateLike

public ForFluent<A>.AssignUpdateNested<A> setNewAssignUpdateLike(int index,
 Assign item)

addNewNegativeUpdate

public ForFluent<A>.NegativeUpdateNested<A> addNewNegativeUpdate()

addNewNegativeUpdateLike

public ForFluent<A>.NegativeUpdateNested<A> addNewNegativeUpdateLike(Negative item)

setNewNegativeUpdateLike

public ForFluent<A>.NegativeUpdateNested<A> setNewNegativeUpdateLike(int index,
 Negative item)

addNewThisUpdate

public ForFluent<A>.ThisUpdateNested<A> addNewThisUpdate()

addNewThisUpdateLike

public ForFluent<A>.ThisUpdateNested<A> addNewThisUpdateLike(This item)

setNewThisUpdateLike

public ForFluent<A>.ThisUpdateNested<A> setNewThisUpdateLike(int index,
 This item)

addNewLogicalAndUpdate

public ForFluent<A>.LogicalAndUpdateNested<A> addNewLogicalAndUpdate()

addNewLogicalAndUpdateLike

public ForFluent<A>.LogicalAndUpdateNested<A> addNewLogicalAndUpdateLike(LogicalAnd item)

addNewLogicalAndUpdate

public A addNewLogicalAndUpdate(Object left,
 Object right)

setNewLogicalAndUpdateLike

public ForFluent<A>.LogicalAndUpdateNested<A> setNewLogicalAndUpdateLike(int index,
 LogicalAnd item)

addNewPostIncrementUpdate

public ForFluent<A>.PostIncrementUpdateNested<A> addNewPostIncrementUpdate()

addNewPostIncrementUpdateLike

public ForFluent<A>.PostIncrementUpdateNested<A> addNewPostIncrementUpdateLike(PostIncrement item)

setNewPostIncrementUpdateLike

public ForFluent<A>.PostIncrementUpdateNested<A> setNewPostIncrementUpdateLike(int index,
 PostIncrement item)

addNewRightUnsignedShiftUpdate

public ForFluent<A>.RightUnsignedShiftUpdateNested<A> addNewRightUnsignedShiftUpdate()

addNewRightUnsignedShiftUpdateLike

public ForFluent<A>.RightUnsignedShiftUpdateNested<A> addNewRightUnsignedShiftUpdateLike(RightUnsignedShift item)

addNewRightUnsignedShiftUpdate

public A addNewRightUnsignedShiftUpdate(Object left,
 Object right)

setNewRightUnsignedShiftUpdateLike

public ForFluent<A>.RightUnsignedShiftUpdateNested<A> setNewRightUnsignedShiftUpdateLike(int index,
 RightUnsignedShift item)

addNewPlusUpdate

public ForFluent<A>.PlusUpdateNested<A> addNewPlusUpdate()

addNewPlusUpdateLike

public ForFluent<A>.PlusUpdateNested<A> addNewPlusUpdateLike(Plus item)

addNewPlusUpdate

public A addNewPlusUpdate(Object left,
 Object right)

setNewPlusUpdateLike

public ForFluent<A>.PlusUpdateNested<A> setNewPlusUpdateLike(int index,
 Plus item)

addNewConstructUpdate

public ForFluent<A>.ConstructUpdateNested<A> addNewConstructUpdate()

addNewConstructUpdateLike

public ForFluent<A>.ConstructUpdateNested<A> addNewConstructUpdateLike(Construct item)

setNewConstructUpdateLike

public ForFluent<A>.ConstructUpdateNested<A> setNewConstructUpdateLike(int index,
 Construct item)

addNewXorUpdate

public ForFluent<A>.XorUpdateNested<A> addNewXorUpdate()

addNewXorUpdateLike

public ForFluent<A>.XorUpdateNested<A> addNewXorUpdateLike(Xor item)

addNewXorUpdate

public A addNewXorUpdate(Object left,
 Object right)

setNewXorUpdateLike

public ForFluent<A>.XorUpdateNested<A> setNewXorUpdateLike(int index,
 Xor item)

addNewPreIncrementUpdate

public ForFluent<A>.PreIncrementUpdateNested<A> addNewPreIncrementUpdate()

addNewPreIncrementUpdateLike

public ForFluent<A>.PreIncrementUpdateNested<A> addNewPreIncrementUpdateLike(PreIncrement item)

setNewPreIncrementUpdateLike

public ForFluent<A>.PreIncrementUpdateNested<A> setNewPreIncrementUpdateLike(int index,
 PreIncrement item)

addNewLessThanOrEqualUpdate

public ForFluent<A>.LessThanOrEqualUpdateNested<A> addNewLessThanOrEqualUpdate()

addNewLessThanOrEqualUpdateLike

public ForFluent<A>.LessThanOrEqualUpdateNested<A> addNewLessThanOrEqualUpdateLike(LessThanOrEqual item)

addNewLessThanOrEqualUpdate

public A addNewLessThanOrEqualUpdate(Object left,
 Object right)

setNewLessThanOrEqualUpdateLike

public ForFluent<A>.LessThanOrEqualUpdateNested<A> setNewLessThanOrEqualUpdateLike(int index,
 LessThanOrEqual item)

addNewPositiveUpdate

public ForFluent<A>.PositiveUpdateNested<A> addNewPositiveUpdate()

addNewPositiveUpdateLike

public ForFluent<A>.PositiveUpdateNested<A> addNewPositiveUpdateLike(Positive item)

setNewPositiveUpdateLike

public ForFluent<A>.PositiveUpdateNested<A> setNewPositiveUpdateLike(int index,
 Positive item)

buildBody

public Statement buildBody()

withBody

public A withBody(Statement body)

hasBody

public boolean hasBody()

withNewMethodCallBody

public ForFluent<A>.MethodCallBodyNested<A> withNewMethodCallBody()

withNewMethodCallBodyLike

public ForFluent<A>.MethodCallBodyNested<A> withNewMethodCallBodyLike(MethodCall item)

withNewSwitchBody

public ForFluent<A>.SwitchBodyNested<A> withNewSwitchBody()

withNewSwitchBodyLike

public ForFluent<A>.SwitchBodyNested<A> withNewSwitchBodyLike(Switch item)

withNewBreakBody

public ForFluent<A>.BreakBodyNested<A> withNewBreakBody()

withNewBreakBodyLike

public ForFluent<A>.BreakBodyNested<A> withNewBreakBodyLike(Break item)

withNewDeclareBody

public ForFluent<A>.DeclareBodyNested<A> withNewDeclareBody()

withNewDeclareBodyLike

public ForFluent<A>.DeclareBodyNested<A> withNewDeclareBodyLike(Declare item)

withNewDeclareBody

public A withNewDeclareBody(Class type,
 String name)

withNewDeclareBody

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

withNewWhileBody

public ForFluent<A>.WhileBodyNested<A> withNewWhileBody()

withNewWhileBodyLike

public ForFluent<A>.WhileBodyNested<A> withNewWhileBodyLike(While item)

withNewContinueBody

public ForFluent<A>.ContinueBodyNested<A> withNewContinueBody()

withNewContinueBodyLike

public ForFluent<A>.ContinueBodyNested<A> withNewContinueBodyLike(Continue item)

withNewStringStatementBody

public ForFluent<A>.StringStatementBodyNested<A> withNewStringStatementBody()

withNewStringStatementBodyLike

public ForFluent<A>.StringStatementBodyNested<A> withNewStringStatementBodyLike(StringStatement item)

withNewStringStatementBody

public A withNewStringStatementBody(String data)

withNewStringStatementBody

public A withNewStringStatementBody(String data,
 Object[] parameters)

withNewDoBody

public ForFluent<A>.DoBodyNested<A> withNewDoBody()

withNewDoBodyLike

public ForFluent<A>.DoBodyNested<A> withNewDoBodyLike(Do item)

withNewForeachBody

public ForFluent<A>.ForeachBodyNested<A> withNewForeachBody()

withNewForeachBodyLike

public ForFluent<A>.ForeachBodyNested<A> withNewForeachBodyLike(Foreach item)

withNewBlockBody

public ForFluent<A>.BlockBodyNested<A> withNewBlockBody()

withNewBlockBodyLike

public ForFluent<A>.BlockBodyNested<A> withNewBlockBodyLike(Block item)

withNewIfBody

public ForFluent<A>.IfBodyNested<A> withNewIfBody()

withNewIfBodyLike

public ForFluent<A>.IfBodyNested<A> withNewIfBodyLike(If item)

withNewLambdaBody

public ForFluent<A>.LambdaBodyNested<A> withNewLambdaBody()

withNewLambdaBodyLike

public ForFluent<A>.LambdaBodyNested<A> withNewLambdaBodyLike(Lambda item)

withNewReturnBody

public ForFluent<A>.ReturnBodyNested<A> withNewReturnBody()

withNewReturnBodyLike

public ForFluent<A>.ReturnBodyNested<A> withNewReturnBodyLike(Return item)

withNewReturnBody

public A withNewReturnBody(Object object)

withNewAssignBody

public ForFluent<A>.AssignBodyNested<A> withNewAssignBody()

withNewAssignBodyLike

public ForFluent<A>.AssignBodyNested<A> withNewAssignBodyLike(Assign item)

withNewForBody

public ForFluent<A>.ForBodyNested<A> withNewForBody()

withNewForBodyLike

public ForFluent<A>.ForBodyNested<A> withNewForBodyLike(For item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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