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, IfDslThenStepFluent.ForStatementsNested, IfFluent.ForElseStatementNested, IfFluent.ForStatementNested, LambdaFluent.ForStatementNested, SynchronizedFluent.ForBodyNested, 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.BinaryExpressionBodyNested<N>
class	ForFluent.BinaryExpressionCompareNested<N>
class	ForFluent.BinaryExpressionInitNested<N>
class	ForFluent.BinaryExpressionUpdateNested<N>
class	ForFluent.BitwiseAndBodyNested<N>
class	ForFluent.BitwiseAndCompareNested<N>
class	ForFluent.BitwiseAndInitNested<N>
class	ForFluent.BitwiseAndUpdateNested<N>
class	ForFluent.BitwiseOrBodyNested<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.ClassRefCompareNested<N>
class	ForFluent.ClassRefInitNested<N>
class	ForFluent.ClassRefUpdateNested<N>
class	ForFluent.ConstructBodyNested<N>
class	ForFluent.ConstructCompareNested<N>
class	ForFluent.ConstructInitNested<N>
class	ForFluent.ConstructUpdateNested<N>
class	ForFluent.ContextRefCompareNested<N>
class	ForFluent.ContextRefInitNested<N>
class	ForFluent.ContextRefUpdateNested<N>
class	ForFluent.ContinueBodyNested<N>
class	ForFluent.DeclareBodyNested<N>
class	ForFluent.DeclareCompareNested<N>
class	ForFluent.DeclareInitNested<N>
class	ForFluent.DeclareUpdateNested<N>
class	ForFluent.DivideBodyNested<N>
class	ForFluent.DivideCompareNested<N>
class	ForFluent.DivideInitNested<N>
class	ForFluent.DivideUpdateNested<N>
class	ForFluent.DoBodyNested<N>
class	ForFluent.DotClassCompareNested<N>
class	ForFluent.DotClassInitNested<N>
class	ForFluent.DotClassUpdateNested<N>
class	ForFluent.EmptyBodyNested<N>
class	ForFluent.EmptyCompareNested<N>
class	ForFluent.EmptyInitNested<N>
class	ForFluent.EmptyUpdateNested<N>
class	ForFluent.EnclosedCompareNested<N>
class	ForFluent.EnclosedInitNested<N>
class	ForFluent.EnclosedUpdateNested<N>
class	ForFluent.EqualsBodyNested<N>
class	ForFluent.EqualsCompareNested<N>
class	ForFluent.EqualsInitNested<N>
class	ForFluent.EqualsUpdateNested<N>
class	ForFluent.ForBodyNested<N>
class	ForFluent.ForeachBodyNested<N>
class	ForFluent.GreaterThanBodyNested<N>
class	ForFluent.GreaterThanCompareNested<N>
class	ForFluent.GreaterThanInitNested<N>
class	ForFluent.GreaterThanOrEqualBodyNested<N>
class	ForFluent.GreaterThanOrEqualCompareNested<N>
class	ForFluent.GreaterThanOrEqualInitNested<N>
class	ForFluent.GreaterThanOrEqualUpdateNested<N>
class	ForFluent.GreaterThanUpdateNested<N>
class	ForFluent.IfBodyNested<N>
class	ForFluent.IfDslThenStepBodyNested<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.LeftShiftBodyNested<N>
class	ForFluent.LeftShiftCompareNested<N>
class	ForFluent.LeftShiftInitNested<N>
class	ForFluent.LeftShiftUpdateNested<N>
class	ForFluent.LessThanBodyNested<N>
class	ForFluent.LessThanCompareNested<N>
class	ForFluent.LessThanInitNested<N>
class	ForFluent.LessThanOrEqualBodyNested<N>
class	ForFluent.LessThanOrEqualCompareNested<N>
class	ForFluent.LessThanOrEqualInitNested<N>
class	ForFluent.LessThanOrEqualUpdateNested<N>
class	ForFluent.LessThanUpdateNested<N>
class	ForFluent.LogicalAndBodyNested<N>
class	ForFluent.LogicalAndCompareNested<N>
class	ForFluent.LogicalAndInitNested<N>
class	ForFluent.LogicalAndUpdateNested<N>
class	ForFluent.LogicalOrBodyNested<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.MinusBodyNested<N>
class	ForFluent.MinusCompareNested<N>
class	ForFluent.MinusInitNested<N>
class	ForFluent.MinusUpdateNested<N>
class	ForFluent.ModuloBodyNested<N>
class	ForFluent.ModuloCompareNested<N>
class	ForFluent.ModuloInitNested<N>
class	ForFluent.ModuloUpdateNested<N>
class	ForFluent.MultiplyBodyNested<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.NotEqualsBodyNested<N>
class	ForFluent.NotEqualsCompareNested<N>
class	ForFluent.NotEqualsInitNested<N>
class	ForFluent.NotEqualsUpdateNested<N>
class	ForFluent.NotInitNested<N>
class	ForFluent.NotUpdateNested<N>
class	ForFluent.PlusBodyNested<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.PostDecrementBodyNested<N>
class	ForFluent.PostDecrementCompareNested<N>
class	ForFluent.PostDecrementInitNested<N>
class	ForFluent.PostDecrementUpdateNested<N>
class	ForFluent.PostIncrementBodyNested<N>
class	ForFluent.PostIncrementCompareNested<N>
class	ForFluent.PostIncrementInitNested<N>
class	ForFluent.PostIncrementUpdateNested<N>
class	ForFluent.PreDecrementBodyNested<N>
class	ForFluent.PreDecrementCompareNested<N>
class	ForFluent.PreDecrementInitNested<N>
class	ForFluent.PreDecrementUpdateNested<N>
class	ForFluent.PreIncrementBodyNested<N>
class	ForFluent.PreIncrementCompareNested<N>
class	ForFluent.PreIncrementInitNested<N>
class	ForFluent.PreIncrementUpdateNested<N>
class	ForFluent.PropertyCompareNested<N>
class	ForFluent.PropertyInitNested<N>
class	ForFluent.PropertyRefBodyNested<N>
class	ForFluent.PropertyRefCompareNested<N>
class	ForFluent.PropertyRefInitNested<N>
class	ForFluent.PropertyRefUpdateNested<N>
class	ForFluent.PropertyUpdateNested<N>
class	ForFluent.ReturnBodyNested<N>
class	ForFluent.ReturnDslThisStepBodyNested<N>
class	ForFluent.ReturnDslVariableStepBodyNested<N>
class	ForFluent.RightShiftBodyNested<N>
class	ForFluent.RightShiftCompareNested<N>
class	ForFluent.RightShiftInitNested<N>
class	ForFluent.RightShiftUpdateNested<N>
class	ForFluent.RightUnsignedShiftBodyNested<N>
class	ForFluent.RightUnsignedShiftCompareNested<N>
class	ForFluent.RightUnsignedShiftInitNested<N>
class	ForFluent.RightUnsignedShiftUpdateNested<N>
class	ForFluent.StringStatementBodyNested<N>
class	ForFluent.SuperCompareNested<N>
class	ForFluent.SuperInitNested<N>
class	ForFluent.SuperUpdateNested<N>
class	ForFluent.SwitchBodyNested<N>
class	ForFluent.SynchronizedBodyNested<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.ThrowBodyNested<N>
class	ForFluent.TryBodyNested<N>
class	ForFluent.ValueRefCompareNested<N>
class	ForFluent.ValueRefInitNested<N>
class	ForFluent.ValueRefUpdateNested<N>
class	ForFluent.WhileBodyNested<N>
class	ForFluent.XorBodyNested<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>.ClassRefInitNested<A>	addNewClassRefInit()
ForFluent<A>.ClassRefInitNested<A>	addNewClassRefInitLike(ClassRef item)
ForFluent<A>.ClassRefUpdateNested<A>	addNewClassRefUpdate()
ForFluent<A>.ClassRefUpdateNested<A>	addNewClassRefUpdateLike(ClassRef 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>.ContextRefInitNested<A>	addNewContextRefInit()
A	addNewContextRefInit(String name)
ForFluent<A>.ContextRefInitNested<A>	addNewContextRefInitLike(ContextRef item)
ForFluent<A>.ContextRefUpdateNested<A>	addNewContextRefUpdate()
A	addNewContextRefUpdate(String name)
ForFluent<A>.ContextRefUpdateNested<A>	addNewContextRefUpdateLike(ContextRef 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>.DotClassInitNested<A>	addNewDotClassInit()
ForFluent<A>.DotClassInitNested<A>	addNewDotClassInitLike(DotClass item)
ForFluent<A>.DotClassUpdateNested<A>	addNewDotClassUpdate()
ForFluent<A>.DotClassUpdateNested<A>	addNewDotClassUpdateLike(DotClass item)
ForFluent<A>.EmptyInitNested<A>	addNewEmptyInit()
ForFluent<A>.EmptyInitNested<A>	addNewEmptyInitLike(Empty item)
ForFluent<A>.EmptyUpdateNested<A>	addNewEmptyUpdate()
ForFluent<A>.EmptyUpdateNested<A>	addNewEmptyUpdateLike(Empty 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>.PropertyInitNested<A>	addNewPropertyInit()
ForFluent<A>.PropertyInitNested<A>	addNewPropertyInitLike(Property 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>.PropertyUpdateNested<A>	addNewPropertyUpdate()
ForFluent<A>.PropertyUpdateNested<A>	addNewPropertyUpdateLike(Property 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>.SuperInitNested<A>	addNewSuperInit()
ForFluent<A>.SuperInitNested<A>	addNewSuperInitLike(Super item)
ForFluent<A>.SuperUpdateNested<A>	addNewSuperUpdate()
ForFluent<A>.SuperUpdateNested<A>	addNewSuperUpdateLike(Super 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>.ClassRefInitNested<A>	setNewClassRefInitLike(int index, ClassRef item)
ForFluent<A>.ClassRefUpdateNested<A>	setNewClassRefUpdateLike(int index, ClassRef item)
ForFluent<A>.ConstructInitNested<A>	setNewConstructInitLike(int index, Construct item)
ForFluent<A>.ConstructUpdateNested<A>	setNewConstructUpdateLike(int index, Construct item)
ForFluent<A>.ContextRefInitNested<A>	setNewContextRefInitLike(int index, ContextRef item)
ForFluent<A>.ContextRefUpdateNested<A>	setNewContextRefUpdateLike(int index, ContextRef 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>.DotClassInitNested<A>	setNewDotClassInitLike(int index, DotClass item)
ForFluent<A>.DotClassUpdateNested<A>	setNewDotClassUpdateLike(int index, DotClass item)
ForFluent<A>.EmptyInitNested<A>	setNewEmptyInitLike(int index, Empty item)
ForFluent<A>.EmptyUpdateNested<A>	setNewEmptyUpdateLike(int index, Empty 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>.PropertyInitNested<A>	setNewPropertyInitLike(int index, Property item)
ForFluent<A>.PropertyRefInitNested<A>	setNewPropertyRefInitLike(int index, PropertyRef item)
ForFluent<A>.PropertyRefUpdateNested<A>	setNewPropertyRefUpdateLike(int index, PropertyRef item)
ForFluent<A>.PropertyUpdateNested<A>	setNewPropertyUpdateLike(int index, Property 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>.SuperInitNested<A>	setNewSuperInitLike(int index, Super item)
ForFluent<A>.SuperUpdateNested<A>	setNewSuperUpdateLike(int index, Super 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>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBody()
ForFluent<A>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBodyLike(BinaryExpression item)
ForFluent<A>.BinaryExpressionCompareNested<A>	withNewBinaryExpressionCompare()
ForFluent<A>.BinaryExpressionCompareNested<A>	withNewBinaryExpressionCompareLike(BinaryExpression item)
ForFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBody()
A	withNewBitwiseAndBody(Object left, Object right)
ForFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBodyLike(BitwiseAnd item)
ForFluent<A>.BitwiseAndCompareNested<A>	withNewBitwiseAndCompare()
A	withNewBitwiseAndCompare(Object left, Object right)
ForFluent<A>.BitwiseAndCompareNested<A>	withNewBitwiseAndCompareLike(BitwiseAnd item)
ForFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBody()
A	withNewBitwiseOrBody(Object left, Object right)
ForFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBodyLike(BitwiseOr 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>.ClassRefCompareNested<A>	withNewClassRefCompare()
ForFluent<A>.ClassRefCompareNested<A>	withNewClassRefCompareLike(ClassRef item)
ForFluent<A>.ConstructBodyNested<A>	withNewConstructBody()
ForFluent<A>.ConstructBodyNested<A>	withNewConstructBodyLike(Construct item)
ForFluent<A>.ConstructCompareNested<A>	withNewConstructCompare()
ForFluent<A>.ConstructCompareNested<A>	withNewConstructCompareLike(Construct item)
ForFluent<A>.ContextRefCompareNested<A>	withNewContextRefCompare()
A	withNewContextRefCompare(String name)
ForFluent<A>.ContextRefCompareNested<A>	withNewContextRefCompareLike(ContextRef 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>.DivideBodyNested<A>	withNewDivideBody()
A	withNewDivideBody(Object left, Object right)
ForFluent<A>.DivideBodyNested<A>	withNewDivideBodyLike(Divide 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>.DotClassCompareNested<A>	withNewDotClassCompare()
ForFluent<A>.DotClassCompareNested<A>	withNewDotClassCompareLike(DotClass item)
ForFluent<A>.EmptyBodyNested<A>	withNewEmptyBody()
ForFluent<A>.EmptyBodyNested<A>	withNewEmptyBodyLike(Empty item)
ForFluent<A>.EmptyCompareNested<A>	withNewEmptyCompare()
ForFluent<A>.EmptyCompareNested<A>	withNewEmptyCompareLike(Empty item)
ForFluent<A>.EnclosedCompareNested<A>	withNewEnclosedCompare()
ForFluent<A>.EnclosedCompareNested<A>	withNewEnclosedCompareLike(Enclosed item)
ForFluent<A>.EqualsBodyNested<A>	withNewEqualsBody()
A	withNewEqualsBody(Object left, Object right)
ForFluent<A>.EqualsBodyNested<A>	withNewEqualsBodyLike(Equals 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>.GreaterThanBodyNested<A>	withNewGreaterThanBody()
A	withNewGreaterThanBody(Object left, Object right)
ForFluent<A>.GreaterThanBodyNested<A>	withNewGreaterThanBodyLike(GreaterThan item)
ForFluent<A>.GreaterThanCompareNested<A>	withNewGreaterThanCompare()
A	withNewGreaterThanCompare(Object left, Object right)
ForFluent<A>.GreaterThanCompareNested<A>	withNewGreaterThanCompareLike(GreaterThan item)
ForFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBody()
A	withNewGreaterThanOrEqualBody(Object left, Object right)
ForFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBodyLike(GreaterThanOrEqual 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>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBody()
ForFluent<A>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBodyLike(IfDslThenStep 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>.LeftShiftBodyNested<A>	withNewLeftShiftBody()
A	withNewLeftShiftBody(Object left, Object right)
ForFluent<A>.LeftShiftBodyNested<A>	withNewLeftShiftBodyLike(LeftShift item)
ForFluent<A>.LeftShiftCompareNested<A>	withNewLeftShiftCompare()
A	withNewLeftShiftCompare(Object left, Object right)
ForFluent<A>.LeftShiftCompareNested<A>	withNewLeftShiftCompareLike(LeftShift item)
ForFluent<A>.LessThanBodyNested<A>	withNewLessThanBody()
A	withNewLessThanBody(Object left, Object right)
ForFluent<A>.LessThanBodyNested<A>	withNewLessThanBodyLike(LessThan item)
ForFluent<A>.LessThanCompareNested<A>	withNewLessThanCompare()
A	withNewLessThanCompare(Object left, Object right)
ForFluent<A>.LessThanCompareNested<A>	withNewLessThanCompareLike(LessThan item)
ForFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBody()
A	withNewLessThanOrEqualBody(Object left, Object right)
ForFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBodyLike(LessThanOrEqual item)
ForFluent<A>.LessThanOrEqualCompareNested<A>	withNewLessThanOrEqualCompare()
A	withNewLessThanOrEqualCompare(Object left, Object right)
ForFluent<A>.LessThanOrEqualCompareNested<A>	withNewLessThanOrEqualCompareLike(LessThanOrEqual item)
ForFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBody()
A	withNewLogicalAndBody(Object left, Object right)
ForFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBodyLike(LogicalAnd item)
ForFluent<A>.LogicalAndCompareNested<A>	withNewLogicalAndCompare()
A	withNewLogicalAndCompare(Object left, Object right)
ForFluent<A>.LogicalAndCompareNested<A>	withNewLogicalAndCompareLike(LogicalAnd item)
ForFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBody()
A	withNewLogicalOrBody(Object left, Object right)
ForFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBodyLike(LogicalOr 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>.MinusBodyNested<A>	withNewMinusBody()
A	withNewMinusBody(Object left, Object right)
ForFluent<A>.MinusBodyNested<A>	withNewMinusBodyLike(Minus item)
ForFluent<A>.MinusCompareNested<A>	withNewMinusCompare()
A	withNewMinusCompare(Object left, Object right)
ForFluent<A>.MinusCompareNested<A>	withNewMinusCompareLike(Minus item)
ForFluent<A>.ModuloBodyNested<A>	withNewModuloBody()
A	withNewModuloBody(Object left, Object right)
ForFluent<A>.ModuloBodyNested<A>	withNewModuloBodyLike(Modulo item)
ForFluent<A>.ModuloCompareNested<A>	withNewModuloCompare()
A	withNewModuloCompare(Object left, Object right)
ForFluent<A>.ModuloCompareNested<A>	withNewModuloCompareLike(Modulo item)
ForFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBody()
A	withNewMultiplyBody(Object left, Object right)
ForFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBodyLike(Multiply 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>.NotEqualsBodyNested<A>	withNewNotEqualsBody()
A	withNewNotEqualsBody(Object left, Object right)
ForFluent<A>.NotEqualsBodyNested<A>	withNewNotEqualsBodyLike(NotEquals item)
ForFluent<A>.NotEqualsCompareNested<A>	withNewNotEqualsCompare()
A	withNewNotEqualsCompare(Object left, Object right)
ForFluent<A>.NotEqualsCompareNested<A>	withNewNotEqualsCompareLike(NotEquals item)
ForFluent<A>.PlusBodyNested<A>	withNewPlusBody()
A	withNewPlusBody(Object left, Object right)
ForFluent<A>.PlusBodyNested<A>	withNewPlusBodyLike(Plus 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>.PostDecrementBodyNested<A>	withNewPostDecrementBody()
ForFluent<A>.PostDecrementBodyNested<A>	withNewPostDecrementBodyLike(PostDecrement item)
ForFluent<A>.PostDecrementCompareNested<A>	withNewPostDecrementCompare()
ForFluent<A>.PostDecrementCompareNested<A>	withNewPostDecrementCompareLike(PostDecrement item)
ForFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBody()
ForFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBodyLike(PostIncrement item)
ForFluent<A>.PostIncrementCompareNested<A>	withNewPostIncrementCompare()
ForFluent<A>.PostIncrementCompareNested<A>	withNewPostIncrementCompareLike(PostIncrement item)
ForFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBody()
ForFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBodyLike(PreDecrement item)
ForFluent<A>.PreDecrementCompareNested<A>	withNewPreDecrementCompare()
ForFluent<A>.PreDecrementCompareNested<A>	withNewPreDecrementCompareLike(PreDecrement item)
ForFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBody()
ForFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBodyLike(PreIncrement item)
ForFluent<A>.PreIncrementCompareNested<A>	withNewPreIncrementCompare()
ForFluent<A>.PreIncrementCompareNested<A>	withNewPreIncrementCompareLike(PreIncrement item)
ForFluent<A>.PropertyCompareNested<A>	withNewPropertyCompare()
ForFluent<A>.PropertyCompareNested<A>	withNewPropertyCompareLike(Property item)
ForFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBody()
ForFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBodyLike(PropertyRef 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>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBody()
ForFluent<A>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBodyLike(ReturnDslThisStep item)
ForFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBody()
A	withNewReturnDslVariableStepBody(String name)
ForFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBodyLike(ReturnDslVariableStep item)
ForFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBody()
A	withNewRightShiftBody(Object left, Object right)
ForFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBodyLike(RightShift item)
ForFluent<A>.RightShiftCompareNested<A>	withNewRightShiftCompare()
A	withNewRightShiftCompare(Object left, Object right)
ForFluent<A>.RightShiftCompareNested<A>	withNewRightShiftCompareLike(RightShift item)
ForFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBody()
A	withNewRightUnsignedShiftBody(Object left, Object right)
ForFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBodyLike(RightUnsignedShift 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>.SuperCompareNested<A>	withNewSuperCompare()
ForFluent<A>.SuperCompareNested<A>	withNewSuperCompareLike(Super item)
ForFluent<A>.SwitchBodyNested<A>	withNewSwitchBody()
ForFluent<A>.SwitchBodyNested<A>	withNewSwitchBodyLike(Switch item)
ForFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBody()
ForFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBodyLike(Synchronized 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>.ThrowBodyNested<A>	withNewThrowBody()
ForFluent<A>.ThrowBodyNested<A>	withNewThrowBodyLike(Throw item)
ForFluent<A>.TryBodyNested<A>	withNewTryBody()
ForFluent<A>.TryBodyNested<A>	withNewTryBodyLike(Try 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>.XorBodyNested<A>	withNewXorBody()
A	withNewXorBody(Object left, Object right)
ForFluent<A>.XorBodyNested<A>	withNewXorBodyLike(Xor 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

addAllToInit

public A addAllToInit(Collection<Expression> items)

addAllToUpdate

public A addAllToUpdate(Collection<Expression> items)

addNewAssignInit

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

addNewAssignInitLike

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

addNewAssignUpdate

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

addNewAssignUpdateLike

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

addNewBinaryExpressionInit

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

addNewBinaryExpressionInitLike

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

addNewBinaryExpressionUpdate

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

addNewBinaryExpressionUpdateLike

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

addNewBitwiseAndInit

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

addNewBitwiseAndInit

public A addNewBitwiseAndInit(Object left,
 Object right)

addNewBitwiseAndInitLike

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

addNewBitwiseAndUpdate

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

addNewBitwiseAndUpdate

public A addNewBitwiseAndUpdate(Object left,
 Object right)

addNewBitwiseAndUpdateLike

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

addNewBitwiseOrInit

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

addNewBitwiseOrInit

public A addNewBitwiseOrInit(Object left,
 Object right)

addNewBitwiseOrInitLike

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

addNewBitwiseOrUpdate

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

addNewBitwiseOrUpdate

public A addNewBitwiseOrUpdate(Object left,
 Object right)

addNewBitwiseOrUpdateLike

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

addNewCastInit

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

addNewCastInitLike

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

addNewCastUpdate

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

addNewCastUpdateLike

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

addNewClassRefInit

public ForFluent<A>.ClassRefInitNested<A> addNewClassRefInit()

addNewClassRefInitLike

public ForFluent<A>.ClassRefInitNested<A> addNewClassRefInitLike(ClassRef item)

addNewClassRefUpdate

public ForFluent<A>.ClassRefUpdateNested<A> addNewClassRefUpdate()

addNewClassRefUpdateLike

public ForFluent<A>.ClassRefUpdateNested<A> addNewClassRefUpdateLike(ClassRef item)

addNewConstructInit

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

addNewConstructInitLike

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

addNewConstructUpdate

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

addNewConstructUpdateLike

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

addNewContextRefInit

public ForFluent<A>.ContextRefInitNested<A> addNewContextRefInit()

addNewContextRefInit

public A addNewContextRefInit(String name)

addNewContextRefInitLike

public ForFluent<A>.ContextRefInitNested<A> addNewContextRefInitLike(ContextRef item)

addNewContextRefUpdate

public ForFluent<A>.ContextRefUpdateNested<A> addNewContextRefUpdate()

addNewContextRefUpdate

public A addNewContextRefUpdate(String name)

addNewContextRefUpdateLike

public ForFluent<A>.ContextRefUpdateNested<A> addNewContextRefUpdateLike(ContextRef item)

addNewDeclareInit

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

addNewDeclareInit

public A addNewDeclareInit(Class type,
 String name)

addNewDeclareInit

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

addNewDeclareInitLike

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

addNewDeclareUpdate

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

addNewDeclareUpdate

public A addNewDeclareUpdate(Class type,
 String name)

addNewDeclareUpdate

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

addNewDeclareUpdateLike

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

addNewDivideInit

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

addNewDivideInit

public A addNewDivideInit(Object left,
 Object right)

addNewDivideInitLike

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

addNewDivideUpdate

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

addNewDivideUpdate

public A addNewDivideUpdate(Object left,
 Object right)

addNewDivideUpdateLike

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

addNewDotClassInit

public ForFluent<A>.DotClassInitNested<A> addNewDotClassInit()

addNewDotClassInitLike

public ForFluent<A>.DotClassInitNested<A> addNewDotClassInitLike(DotClass item)

addNewDotClassUpdate

public ForFluent<A>.DotClassUpdateNested<A> addNewDotClassUpdate()

addNewDotClassUpdateLike

public ForFluent<A>.DotClassUpdateNested<A> addNewDotClassUpdateLike(DotClass item)

addNewEmptyInit

public ForFluent<A>.EmptyInitNested<A> addNewEmptyInit()

addNewEmptyInitLike

public ForFluent<A>.EmptyInitNested<A> addNewEmptyInitLike(Empty item)

addNewEmptyUpdate

public ForFluent<A>.EmptyUpdateNested<A> addNewEmptyUpdate()

addNewEmptyUpdateLike

public ForFluent<A>.EmptyUpdateNested<A> addNewEmptyUpdateLike(Empty item)

addNewEnclosedInit

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

addNewEnclosedInitLike

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

addNewEnclosedUpdate

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

addNewEnclosedUpdateLike

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

addNewEqualsInit

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

addNewEqualsInit

public A addNewEqualsInit(Object left,
 Object right)

addNewEqualsInitLike

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

addNewEqualsUpdate

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

addNewEqualsUpdate

public A addNewEqualsUpdate(Object left,
 Object right)

addNewEqualsUpdateLike

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

addNewGreaterThanInit

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

addNewGreaterThanInit

public A addNewGreaterThanInit(Object left,
 Object right)

addNewGreaterThanInitLike

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

addNewGreaterThanOrEqualInit

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

addNewGreaterThanOrEqualInit

public A addNewGreaterThanOrEqualInit(Object left,
 Object right)

addNewGreaterThanOrEqualInitLike

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

addNewGreaterThanOrEqualUpdate

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

addNewGreaterThanOrEqualUpdate

public A addNewGreaterThanOrEqualUpdate(Object left,
 Object right)

addNewGreaterThanOrEqualUpdateLike

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

addNewGreaterThanUpdate

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

addNewGreaterThanUpdate

public A addNewGreaterThanUpdate(Object left,
 Object right)

addNewGreaterThanUpdateLike

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

addNewIndexInit

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

addNewIndexInitLike

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

addNewIndexUpdate

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

addNewIndexUpdateLike

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

addNewInstanceOfInit

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

addNewInstanceOfInitLike

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

addNewInstanceOfUpdate

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

addNewInstanceOfUpdateLike

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

addNewInverseInit

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

addNewInverseInitLike

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

addNewInverseUpdate

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

addNewInverseUpdateLike

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

addNewLambdaInit

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

addNewLambdaInitLike

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

addNewLambdaUpdate

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

addNewLambdaUpdateLike

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

addNewLeftShiftInit

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

addNewLeftShiftInit

public A addNewLeftShiftInit(Object left,
 Object right)

addNewLeftShiftInitLike

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

addNewLeftShiftUpdate

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

addNewLeftShiftUpdate

public A addNewLeftShiftUpdate(Object left,
 Object right)

addNewLeftShiftUpdateLike

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

addNewLessThanInit

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

addNewLessThanInit

public A addNewLessThanInit(Object left,
 Object right)

addNewLessThanInitLike

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

addNewLessThanOrEqualInit

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

addNewLessThanOrEqualInit

public A addNewLessThanOrEqualInit(Object left,
 Object right)

addNewLessThanOrEqualInitLike

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

addNewLessThanOrEqualUpdate

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

addNewLessThanOrEqualUpdate

public A addNewLessThanOrEqualUpdate(Object left,
 Object right)

addNewLessThanOrEqualUpdateLike

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

addNewLessThanUpdate

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

addNewLessThanUpdate

public A addNewLessThanUpdate(Object left,
 Object right)

addNewLessThanUpdateLike

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

addNewLogicalAndInit

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

addNewLogicalAndInit

public A addNewLogicalAndInit(Object left,
 Object right)

addNewLogicalAndInitLike

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

addNewLogicalAndUpdate

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

addNewLogicalAndUpdate

public A addNewLogicalAndUpdate(Object left,
 Object right)

addNewLogicalAndUpdateLike

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

addNewLogicalOrInit

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

addNewLogicalOrInit

public A addNewLogicalOrInit(Object left,
 Object right)

addNewLogicalOrInitLike

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

addNewLogicalOrUpdate

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

addNewLogicalOrUpdate

public A addNewLogicalOrUpdate(Object left,
 Object right)

addNewLogicalOrUpdateLike

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

addNewMethodCallInit

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

addNewMethodCallInitLike

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

addNewMethodCallUpdate

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

addNewMethodCallUpdateLike

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

addNewMinusInit

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

addNewMinusInit

public A addNewMinusInit(Object left,
 Object right)

addNewMinusInitLike

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

addNewMinusUpdate

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

addNewMinusUpdate

public A addNewMinusUpdate(Object left,
 Object right)

addNewMinusUpdateLike

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

addNewModuloInit

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

addNewModuloInit

public A addNewModuloInit(Object left,
 Object right)

addNewModuloInitLike

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

addNewModuloUpdate

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

addNewModuloUpdate

public A addNewModuloUpdate(Object left,
 Object right)

addNewModuloUpdateLike

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

addNewMultiplyInit

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

addNewMultiplyInit

public A addNewMultiplyInit(Object left,
 Object right)

addNewMultiplyInitLike

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

addNewMultiplyUpdate

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

addNewMultiplyUpdate

public A addNewMultiplyUpdate(Object left,
 Object right)

addNewMultiplyUpdateLike

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

addNewNegativeInit

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

addNewNegativeInitLike

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

addNewNegativeUpdate

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

addNewNegativeUpdateLike

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

addNewNewArrayInit

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

addNewNewArrayInit

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

addNewNewArrayInitLike

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

addNewNewArrayUpdate

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

addNewNewArrayUpdate

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

addNewNewArrayUpdateLike

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

addNewNotEqualsInit

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

addNewNotEqualsInit

public A addNewNotEqualsInit(Object left,
 Object right)

addNewNotEqualsInitLike

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

addNewNotEqualsUpdate

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

addNewNotEqualsUpdate

public A addNewNotEqualsUpdate(Object left,
 Object right)

addNewNotEqualsUpdateLike

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

addNewNotInit

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

addNewNotInitLike

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

addNewNotUpdate

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

addNewNotUpdateLike

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

addNewPlusInit

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

addNewPlusInit

public A addNewPlusInit(Object left,
 Object right)

addNewPlusInitLike

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

addNewPlusUpdate

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

addNewPlusUpdate

public A addNewPlusUpdate(Object left,
 Object right)

addNewPlusUpdateLike

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

addNewPositiveInit

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

addNewPositiveInitLike

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

addNewPositiveUpdate

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

addNewPositiveUpdateLike

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

addNewPostDecrementInit

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

addNewPostDecrementInitLike

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

addNewPostDecrementUpdate

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

addNewPostDecrementUpdateLike

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

addNewPostIncrementInit

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

addNewPostIncrementInitLike

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

addNewPostIncrementUpdate

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

addNewPostIncrementUpdateLike

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

addNewPreDecrementInit

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

addNewPreDecrementInitLike

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

addNewPreDecrementUpdate

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

addNewPreDecrementUpdateLike

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

addNewPreIncrementInit

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

addNewPreIncrementInitLike

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

addNewPreIncrementUpdate

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

addNewPreIncrementUpdateLike

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

addNewPropertyInit

public ForFluent<A>.PropertyInitNested<A> addNewPropertyInit()

addNewPropertyInitLike

public ForFluent<A>.PropertyInitNested<A> addNewPropertyInitLike(Property item)

addNewPropertyRefInit

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

addNewPropertyRefInitLike

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

addNewPropertyRefUpdate

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

addNewPropertyRefUpdateLike

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

addNewPropertyUpdate

public ForFluent<A>.PropertyUpdateNested<A> addNewPropertyUpdate()

addNewPropertyUpdateLike

public ForFluent<A>.PropertyUpdateNested<A> addNewPropertyUpdateLike(Property item)

addNewRightShiftInit

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

addNewRightShiftInit

public A addNewRightShiftInit(Object left,
 Object right)

addNewRightShiftInitLike

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

addNewRightShiftUpdate

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

addNewRightShiftUpdate

public A addNewRightShiftUpdate(Object left,
 Object right)

addNewRightShiftUpdateLike

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

addNewRightUnsignedShiftInit

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

addNewRightUnsignedShiftInit

public A addNewRightUnsignedShiftInit(Object left,
 Object right)

addNewRightUnsignedShiftInitLike

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

addNewRightUnsignedShiftUpdate

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

addNewRightUnsignedShiftUpdate

public A addNewRightUnsignedShiftUpdate(Object left,
 Object right)

addNewRightUnsignedShiftUpdateLike

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

addNewSuperInit

public ForFluent<A>.SuperInitNested<A> addNewSuperInit()

addNewSuperInitLike

public ForFluent<A>.SuperInitNested<A> addNewSuperInitLike(Super item)

addNewSuperUpdate

public ForFluent<A>.SuperUpdateNested<A> addNewSuperUpdate()

addNewSuperUpdateLike

public ForFluent<A>.SuperUpdateNested<A> addNewSuperUpdateLike(Super item)

addNewTernaryInit

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

addNewTernaryInitLike

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

addNewTernaryUpdate

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

addNewTernaryUpdateLike

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

addNewThisInit

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

addNewThisInitLike

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

addNewThisUpdate

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

addNewThisUpdateLike

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

addNewValueRefInit

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

addNewValueRefInit

public A addNewValueRefInit(Object value)

addNewValueRefInitLike

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

addNewValueRefUpdate

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

addNewValueRefUpdate

public A addNewValueRefUpdate(Object value)

addNewValueRefUpdateLike

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

addNewXorInit

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

addNewXorInit

public A addNewXorInit(Object left,
 Object right)

addNewXorInitLike

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

addNewXorUpdate

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

addNewXorUpdate

public A addNewXorUpdate(Object left,
 Object right)

addNewXorUpdateLike

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

addToInit

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

addToInit

public A addToInit(Expression... items)

addToInit

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

addToInit

public A addToInit(int index,
 Expression item)

addToUpdate

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

addToUpdate

public A addToUpdate(Expression... items)

addToUpdate

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

addToUpdate

public A addToUpdate(int index,
 Expression item)

buildBody

public Statement buildBody()

buildCompare

public Expression buildCompare()

buildFirstInit

public Expression buildFirstInit()

buildFirstUpdate

public Expression buildFirstUpdate()

buildInit

public List<Expression> buildInit()

buildInit

public Expression buildInit(int index)

buildLastInit

public Expression buildLastInit()

buildLastUpdate

public Expression buildLastUpdate()

buildMatchingInit

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

buildMatchingUpdate

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

buildUpdate

public List<Expression> buildUpdate()

buildUpdate

public Expression buildUpdate(int index)

builder

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

copyInstance

protected void copyInstance(For instance)

equals

public boolean equals(Object o)

Overrides:

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

hasBody

public boolean hasBody()

hasCompare

public boolean hasCompare()

hasInit

public boolean hasInit()

hasMatchingInit

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

hasMatchingUpdate

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

hasUpdate

public boolean hasUpdate()

hashCode

public int hashCode()

Overrides:

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

removeAllFromInit

public A removeAllFromInit(Collection<Expression> items)

removeAllFromUpdate

public A removeAllFromUpdate(Collection<Expression> items)

removeFromInit

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

removeFromInit

public A removeFromInit(Expression... items)

removeFromUpdate

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

removeFromUpdate

public A removeFromUpdate(Expression... items)

removeMatchingFromInit

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

removeMatchingFromUpdate

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

setNewAssignInitLike

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

setNewAssignUpdateLike

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

setNewBinaryExpressionInitLike

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

setNewBinaryExpressionUpdateLike

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

setNewBitwiseAndInitLike

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

setNewBitwiseAndUpdateLike

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

setNewBitwiseOrInitLike

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

setNewBitwiseOrUpdateLike

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

setNewCastInitLike

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

setNewCastUpdateLike

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

setNewClassRefInitLike

public ForFluent<A>.ClassRefInitNested<A> setNewClassRefInitLike(int index,
 ClassRef item)

setNewClassRefUpdateLike

public ForFluent<A>.ClassRefUpdateNested<A> setNewClassRefUpdateLike(int index,
 ClassRef item)

setNewConstructInitLike

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

setNewConstructUpdateLike

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

setNewContextRefInitLike

public ForFluent<A>.ContextRefInitNested<A> setNewContextRefInitLike(int index,
 ContextRef item)

setNewContextRefUpdateLike

public ForFluent<A>.ContextRefUpdateNested<A> setNewContextRefUpdateLike(int index,
 ContextRef item)

setNewDeclareInitLike

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

setNewDeclareUpdateLike

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

setNewDivideInitLike

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

setNewDivideUpdateLike

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

setNewDotClassInitLike

public ForFluent<A>.DotClassInitNested<A> setNewDotClassInitLike(int index,
 DotClass item)

setNewDotClassUpdateLike

public ForFluent<A>.DotClassUpdateNested<A> setNewDotClassUpdateLike(int index,
 DotClass item)

setNewEmptyInitLike

public ForFluent<A>.EmptyInitNested<A> setNewEmptyInitLike(int index,
 Empty item)

setNewEmptyUpdateLike

public ForFluent<A>.EmptyUpdateNested<A> setNewEmptyUpdateLike(int index,
 Empty item)

setNewEnclosedInitLike

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

setNewEnclosedUpdateLike

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

setNewEqualsInitLike

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

setNewEqualsUpdateLike

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

setNewGreaterThanInitLike

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

setNewGreaterThanOrEqualInitLike

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

setNewGreaterThanOrEqualUpdateLike

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

setNewGreaterThanUpdateLike

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

setNewIndexInitLike

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

setNewIndexUpdateLike

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

setNewInstanceOfInitLike

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

setNewInstanceOfUpdateLike

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

setNewInverseInitLike

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

setNewInverseUpdateLike

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

setNewLambdaInitLike

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

setNewLambdaUpdateLike

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

setNewLeftShiftInitLike

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

setNewLeftShiftUpdateLike

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

setNewLessThanInitLike

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

setNewLessThanOrEqualInitLike

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

setNewLessThanOrEqualUpdateLike

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

setNewLessThanUpdateLike

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

setNewLogicalAndInitLike

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

setNewLogicalAndUpdateLike

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

setNewLogicalOrInitLike

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

setNewLogicalOrUpdateLike

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

setNewMethodCallInitLike

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

setNewMethodCallUpdateLike

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

setNewMinusInitLike

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

setNewMinusUpdateLike

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

setNewModuloInitLike

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

setNewModuloUpdateLike

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

setNewMultiplyInitLike

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

setNewMultiplyUpdateLike

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

setNewNegativeInitLike

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

setNewNegativeUpdateLike

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

setNewNewArrayInitLike

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

setNewNewArrayUpdateLike

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

setNewNotEqualsInitLike

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

setNewNotEqualsUpdateLike

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

setNewNotInitLike

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

setNewNotUpdateLike

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

setNewPlusInitLike

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

setNewPlusUpdateLike

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

setNewPositiveInitLike

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

setNewPositiveUpdateLike

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

setNewPostDecrementInitLike

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

setNewPostDecrementUpdateLike

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

setNewPostIncrementInitLike

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

setNewPostIncrementUpdateLike

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

setNewPreDecrementInitLike

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

setNewPreDecrementUpdateLike

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

setNewPreIncrementInitLike

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

setNewPreIncrementUpdateLike

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

setNewPropertyInitLike

public ForFluent<A>.PropertyInitNested<A> setNewPropertyInitLike(int index,
 Property item)

setNewPropertyRefInitLike

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

setNewPropertyRefUpdateLike

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

setNewPropertyUpdateLike

public ForFluent<A>.PropertyUpdateNested<A> setNewPropertyUpdateLike(int index,
 Property item)

setNewRightShiftInitLike

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

setNewRightShiftUpdateLike

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

setNewRightUnsignedShiftInitLike

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

setNewRightUnsignedShiftUpdateLike

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

setNewSuperInitLike

public ForFluent<A>.SuperInitNested<A> setNewSuperInitLike(int index,
 Super item)

setNewSuperUpdateLike

public ForFluent<A>.SuperUpdateNested<A> setNewSuperUpdateLike(int index,
 Super item)

setNewTernaryInitLike

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

setNewTernaryUpdateLike

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

setNewThisInitLike

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

setNewThisUpdateLike

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

setNewValueRefInitLike

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

setNewValueRefUpdateLike

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

setNewXorInitLike

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

setNewXorUpdateLike

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

setToInit

public A setToInit(int index,
 Expression item)

setToUpdate

public A setToUpdate(int index,
 Expression item)

toString

public String toString()

Overrides:

toString in class Object

withBody

public A withBody(Statement body)

withCompare

public A withCompare(Expression compare)

withInit

public A withInit(List<Expression> init)

withInit

public A withInit(Expression... init)

withNewAssignBody

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

withNewAssignBodyLike

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

withNewAssignCompare

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

withNewAssignCompareLike

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

withNewBinaryExpressionBody

public ForFluent<A>.BinaryExpressionBodyNested<A> withNewBinaryExpressionBody()

withNewBinaryExpressionBodyLike

public ForFluent<A>.BinaryExpressionBodyNested<A> withNewBinaryExpressionBodyLike(BinaryExpression item)

withNewBinaryExpressionCompare

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

withNewBinaryExpressionCompareLike

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

withNewBitwiseAndBody

public ForFluent<A>.BitwiseAndBodyNested<A> withNewBitwiseAndBody()

withNewBitwiseAndBody

public A withNewBitwiseAndBody(Object left,
 Object right)

withNewBitwiseAndBodyLike

public ForFluent<A>.BitwiseAndBodyNested<A> withNewBitwiseAndBodyLike(BitwiseAnd item)

withNewBitwiseAndCompare

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

withNewBitwiseAndCompare

public A withNewBitwiseAndCompare(Object left,
 Object right)

withNewBitwiseAndCompareLike

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

withNewBitwiseOrBody

public ForFluent<A>.BitwiseOrBodyNested<A> withNewBitwiseOrBody()

withNewBitwiseOrBody

public A withNewBitwiseOrBody(Object left,
 Object right)

withNewBitwiseOrBodyLike

public ForFluent<A>.BitwiseOrBodyNested<A> withNewBitwiseOrBodyLike(BitwiseOr item)

withNewBitwiseOrCompare

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

withNewBitwiseOrCompare

public A withNewBitwiseOrCompare(Object left,
 Object right)

withNewBitwiseOrCompareLike

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

withNewBlockBody

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

withNewBlockBodyLike

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

withNewBreakBody

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

withNewBreakBodyLike

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

withNewCastCompare

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

withNewCastCompareLike

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

withNewClassRefCompare

public ForFluent<A>.ClassRefCompareNested<A> withNewClassRefCompare()

withNewClassRefCompareLike

public ForFluent<A>.ClassRefCompareNested<A> withNewClassRefCompareLike(ClassRef item)

withNewConstructBody

public ForFluent<A>.ConstructBodyNested<A> withNewConstructBody()

withNewConstructBodyLike

public ForFluent<A>.ConstructBodyNested<A> withNewConstructBodyLike(Construct item)

withNewConstructCompare

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

withNewConstructCompareLike

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

withNewContextRefCompare

public ForFluent<A>.ContextRefCompareNested<A> withNewContextRefCompare()

withNewContextRefCompare

public A withNewContextRefCompare(String name)

withNewContextRefCompareLike

public ForFluent<A>.ContextRefCompareNested<A> withNewContextRefCompareLike(ContextRef item)

withNewContinueBody

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

withNewContinueBodyLike

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

withNewDeclareBody

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

withNewDeclareBody

public A withNewDeclareBody(Class type,
 String name)

withNewDeclareBody

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

withNewDeclareBodyLike

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

withNewDeclareCompare

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

withNewDeclareCompare

public A withNewDeclareCompare(Class type,
 String name)

withNewDeclareCompare

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

withNewDeclareCompareLike

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

withNewDivideBody

public ForFluent<A>.DivideBodyNested<A> withNewDivideBody()

withNewDivideBody

public A withNewDivideBody(Object left,
 Object right)

withNewDivideBodyLike

public ForFluent<A>.DivideBodyNested<A> withNewDivideBodyLike(Divide item)

withNewDivideCompare

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

withNewDivideCompare

public A withNewDivideCompare(Object left,
 Object right)

withNewDivideCompareLike

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

withNewDoBody

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

withNewDoBodyLike

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

withNewDotClassCompare

public ForFluent<A>.DotClassCompareNested<A> withNewDotClassCompare()

withNewDotClassCompareLike

public ForFluent<A>.DotClassCompareNested<A> withNewDotClassCompareLike(DotClass item)

withNewEmptyBody

public ForFluent<A>.EmptyBodyNested<A> withNewEmptyBody()

withNewEmptyBodyLike

public ForFluent<A>.EmptyBodyNested<A> withNewEmptyBodyLike(Empty item)

withNewEmptyCompare

public ForFluent<A>.EmptyCompareNested<A> withNewEmptyCompare()

withNewEmptyCompareLike

public ForFluent<A>.EmptyCompareNested<A> withNewEmptyCompareLike(Empty item)

withNewEnclosedCompare

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

withNewEnclosedCompareLike

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

withNewEqualsBody

public ForFluent<A>.EqualsBodyNested<A> withNewEqualsBody()

withNewEqualsBody

public A withNewEqualsBody(Object left,
 Object right)

withNewEqualsBodyLike

public ForFluent<A>.EqualsBodyNested<A> withNewEqualsBodyLike(Equals item)

withNewEqualsCompare

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

withNewEqualsCompare

public A withNewEqualsCompare(Object left,
 Object right)

withNewEqualsCompareLike

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

withNewForBody

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

withNewForBodyLike

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

withNewForeachBody

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

withNewForeachBodyLike

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

withNewGreaterThanBody

public ForFluent<A>.GreaterThanBodyNested<A> withNewGreaterThanBody()

withNewGreaterThanBody

public A withNewGreaterThanBody(Object left,
 Object right)

withNewGreaterThanBodyLike

public ForFluent<A>.GreaterThanBodyNested<A> withNewGreaterThanBodyLike(GreaterThan item)

withNewGreaterThanCompare

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

withNewGreaterThanCompare

public A withNewGreaterThanCompare(Object left,
 Object right)

withNewGreaterThanCompareLike

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

withNewGreaterThanOrEqualBody

public ForFluent<A>.GreaterThanOrEqualBodyNested<A> withNewGreaterThanOrEqualBody()

withNewGreaterThanOrEqualBody

public A withNewGreaterThanOrEqualBody(Object left,
 Object right)

withNewGreaterThanOrEqualBodyLike

public ForFluent<A>.GreaterThanOrEqualBodyNested<A> withNewGreaterThanOrEqualBodyLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualCompare

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

withNewGreaterThanOrEqualCompare

public A withNewGreaterThanOrEqualCompare(Object left,
 Object right)

withNewGreaterThanOrEqualCompareLike

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

withNewIfBody

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

withNewIfBodyLike

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

withNewIfDslThenStepBody

public ForFluent<A>.IfDslThenStepBodyNested<A> withNewIfDslThenStepBody()

withNewIfDslThenStepBodyLike

public ForFluent<A>.IfDslThenStepBodyNested<A> withNewIfDslThenStepBodyLike(IfDslThenStep item)

withNewIndexCompare

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

withNewIndexCompareLike

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

withNewInstanceOfCompare

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

withNewInstanceOfCompareLike

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

withNewInverseCompare

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

withNewInverseCompareLike

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

withNewLambdaBody

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

withNewLambdaBodyLike

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

withNewLambdaCompare

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

withNewLambdaCompareLike

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

withNewLeftShiftBody

public ForFluent<A>.LeftShiftBodyNested<A> withNewLeftShiftBody()

withNewLeftShiftBody

public A withNewLeftShiftBody(Object left,
 Object right)

withNewLeftShiftBodyLike

public ForFluent<A>.LeftShiftBodyNested<A> withNewLeftShiftBodyLike(LeftShift item)

withNewLeftShiftCompare

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

withNewLeftShiftCompare

public A withNewLeftShiftCompare(Object left,
 Object right)

withNewLeftShiftCompareLike

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

withNewLessThanBody

public ForFluent<A>.LessThanBodyNested<A> withNewLessThanBody()

withNewLessThanBody

public A withNewLessThanBody(Object left,
 Object right)

withNewLessThanBodyLike

public ForFluent<A>.LessThanBodyNested<A> withNewLessThanBodyLike(LessThan item)

withNewLessThanCompare

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

withNewLessThanCompare

public A withNewLessThanCompare(Object left,
 Object right)

withNewLessThanCompareLike

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

withNewLessThanOrEqualBody

public ForFluent<A>.LessThanOrEqualBodyNested<A> withNewLessThanOrEqualBody()

withNewLessThanOrEqualBody

public A withNewLessThanOrEqualBody(Object left,
 Object right)

withNewLessThanOrEqualBodyLike

public ForFluent<A>.LessThanOrEqualBodyNested<A> withNewLessThanOrEqualBodyLike(LessThanOrEqual item)

withNewLessThanOrEqualCompare

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

withNewLessThanOrEqualCompare

public A withNewLessThanOrEqualCompare(Object left,
 Object right)

withNewLessThanOrEqualCompareLike

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

withNewLogicalAndBody

public ForFluent<A>.LogicalAndBodyNested<A> withNewLogicalAndBody()

withNewLogicalAndBody

public A withNewLogicalAndBody(Object left,
 Object right)

withNewLogicalAndBodyLike

public ForFluent<A>.LogicalAndBodyNested<A> withNewLogicalAndBodyLike(LogicalAnd item)

withNewLogicalAndCompare

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

withNewLogicalAndCompare

public A withNewLogicalAndCompare(Object left,
 Object right)

withNewLogicalAndCompareLike

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

withNewLogicalOrBody

public ForFluent<A>.LogicalOrBodyNested<A> withNewLogicalOrBody()

withNewLogicalOrBody

public A withNewLogicalOrBody(Object left,
 Object right)

withNewLogicalOrBodyLike

public ForFluent<A>.LogicalOrBodyNested<A> withNewLogicalOrBodyLike(LogicalOr item)

withNewLogicalOrCompare

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

withNewLogicalOrCompare

public A withNewLogicalOrCompare(Object left,
 Object right)

withNewLogicalOrCompareLike

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

withNewMethodCallBody

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

withNewMethodCallBodyLike

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

withNewMethodCallCompare

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

withNewMethodCallCompareLike

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

withNewMinusBody

public ForFluent<A>.MinusBodyNested<A> withNewMinusBody()

withNewMinusBody

public A withNewMinusBody(Object left,
 Object right)

withNewMinusBodyLike

public ForFluent<A>.MinusBodyNested<A> withNewMinusBodyLike(Minus item)

withNewMinusCompare

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

withNewMinusCompare

public A withNewMinusCompare(Object left,
 Object right)

withNewMinusCompareLike

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

withNewModuloBody

public ForFluent<A>.ModuloBodyNested<A> withNewModuloBody()

withNewModuloBody

public A withNewModuloBody(Object left,
 Object right)

withNewModuloBodyLike

public ForFluent<A>.ModuloBodyNested<A> withNewModuloBodyLike(Modulo item)

withNewModuloCompare

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

withNewModuloCompare

public A withNewModuloCompare(Object left,
 Object right)

withNewModuloCompareLike

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

withNewMultiplyBody

public ForFluent<A>.MultiplyBodyNested<A> withNewMultiplyBody()

withNewMultiplyBody

public A withNewMultiplyBody(Object left,
 Object right)

withNewMultiplyBodyLike

public ForFluent<A>.MultiplyBodyNested<A> withNewMultiplyBodyLike(Multiply item)

withNewMultiplyCompare

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

withNewMultiplyCompare

public A withNewMultiplyCompare(Object left,
 Object right)

withNewMultiplyCompareLike

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

withNewNegativeCompare

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

withNewNegativeCompareLike

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

withNewNewArrayCompare

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

withNewNewArrayCompare

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

withNewNewArrayCompareLike

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

withNewNotCompare

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

withNewNotCompareLike

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

withNewNotEqualsBody

public ForFluent<A>.NotEqualsBodyNested<A> withNewNotEqualsBody()

withNewNotEqualsBody

public A withNewNotEqualsBody(Object left,
 Object right)

withNewNotEqualsBodyLike

public ForFluent<A>.NotEqualsBodyNested<A> withNewNotEqualsBodyLike(NotEquals item)

withNewNotEqualsCompare

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

withNewNotEqualsCompare

public A withNewNotEqualsCompare(Object left,
 Object right)

withNewNotEqualsCompareLike

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

withNewPlusBody

public ForFluent<A>.PlusBodyNested<A> withNewPlusBody()

withNewPlusBody

public A withNewPlusBody(Object left,
 Object right)

withNewPlusBodyLike

public ForFluent<A>.PlusBodyNested<A> withNewPlusBodyLike(Plus item)

withNewPlusCompare

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

withNewPlusCompare

public A withNewPlusCompare(Object left,
 Object right)

withNewPlusCompareLike

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

withNewPositiveCompare

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

withNewPositiveCompareLike

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

withNewPostDecrementBody

public ForFluent<A>.PostDecrementBodyNested<A> withNewPostDecrementBody()

withNewPostDecrementBodyLike

public ForFluent<A>.PostDecrementBodyNested<A> withNewPostDecrementBodyLike(PostDecrement item)

withNewPostDecrementCompare

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

withNewPostDecrementCompareLike

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

withNewPostIncrementBody

public ForFluent<A>.PostIncrementBodyNested<A> withNewPostIncrementBody()

withNewPostIncrementBodyLike

public ForFluent<A>.PostIncrementBodyNested<A> withNewPostIncrementBodyLike(PostIncrement item)

withNewPostIncrementCompare

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

withNewPostIncrementCompareLike

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

withNewPreDecrementBody

public ForFluent<A>.PreDecrementBodyNested<A> withNewPreDecrementBody()

withNewPreDecrementBodyLike

public ForFluent<A>.PreDecrementBodyNested<A> withNewPreDecrementBodyLike(PreDecrement item)

withNewPreDecrementCompare

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

withNewPreDecrementCompareLike

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

withNewPreIncrementBody

public ForFluent<A>.PreIncrementBodyNested<A> withNewPreIncrementBody()

withNewPreIncrementBodyLike

public ForFluent<A>.PreIncrementBodyNested<A> withNewPreIncrementBodyLike(PreIncrement item)

withNewPreIncrementCompare

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

withNewPreIncrementCompareLike

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

withNewPropertyCompare

public ForFluent<A>.PropertyCompareNested<A> withNewPropertyCompare()

withNewPropertyCompareLike

public ForFluent<A>.PropertyCompareNested<A> withNewPropertyCompareLike(Property item)

withNewPropertyRefBody

public ForFluent<A>.PropertyRefBodyNested<A> withNewPropertyRefBody()

withNewPropertyRefBodyLike

public ForFluent<A>.PropertyRefBodyNested<A> withNewPropertyRefBodyLike(PropertyRef item)

withNewPropertyRefCompare

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

withNewPropertyRefCompareLike

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

withNewReturnBody

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

withNewReturnBody

public A withNewReturnBody(Object object)

withNewReturnBodyLike

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

withNewReturnDslThisStepBody

public ForFluent<A>.ReturnDslThisStepBodyNested<A> withNewReturnDslThisStepBody()

withNewReturnDslThisStepBodyLike

public ForFluent<A>.ReturnDslThisStepBodyNested<A> withNewReturnDslThisStepBodyLike(ReturnDslThisStep item)

withNewReturnDslVariableStepBody

public ForFluent<A>.ReturnDslVariableStepBodyNested<A> withNewReturnDslVariableStepBody()

withNewReturnDslVariableStepBody

public A withNewReturnDslVariableStepBody(String name)

withNewReturnDslVariableStepBodyLike

public ForFluent<A>.ReturnDslVariableStepBodyNested<A> withNewReturnDslVariableStepBodyLike(ReturnDslVariableStep item)

withNewRightShiftBody

public ForFluent<A>.RightShiftBodyNested<A> withNewRightShiftBody()

withNewRightShiftBody

public A withNewRightShiftBody(Object left,
 Object right)

withNewRightShiftBodyLike

public ForFluent<A>.RightShiftBodyNested<A> withNewRightShiftBodyLike(RightShift item)

withNewRightShiftCompare

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

withNewRightShiftCompare

public A withNewRightShiftCompare(Object left,
 Object right)

withNewRightShiftCompareLike

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

withNewRightUnsignedShiftBody

public ForFluent<A>.RightUnsignedShiftBodyNested<A> withNewRightUnsignedShiftBody()

withNewRightUnsignedShiftBody

public A withNewRightUnsignedShiftBody(Object left,
 Object right)

withNewRightUnsignedShiftBodyLike

public ForFluent<A>.RightUnsignedShiftBodyNested<A> withNewRightUnsignedShiftBodyLike(RightUnsignedShift item)

withNewRightUnsignedShiftCompare

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

withNewRightUnsignedShiftCompare

public A withNewRightUnsignedShiftCompare(Object left,
 Object right)

withNewRightUnsignedShiftCompareLike

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

withNewStringStatementBody

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

withNewStringStatementBody

public A withNewStringStatementBody(String data)

withNewStringStatementBody

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

withNewStringStatementBodyLike

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

withNewSuperCompare

public ForFluent<A>.SuperCompareNested<A> withNewSuperCompare()

withNewSuperCompareLike

public ForFluent<A>.SuperCompareNested<A> withNewSuperCompareLike(Super item)

withNewSwitchBody

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

withNewSwitchBodyLike

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

withNewSynchronizedBody

public ForFluent<A>.SynchronizedBodyNested<A> withNewSynchronizedBody()

withNewSynchronizedBodyLike

public ForFluent<A>.SynchronizedBodyNested<A> withNewSynchronizedBodyLike(Synchronized item)

withNewTernaryCompare

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

withNewTernaryCompareLike

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

withNewThisCompare

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

withNewThisCompareLike

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

withNewThrowBody

public ForFluent<A>.ThrowBodyNested<A> withNewThrowBody()

withNewThrowBodyLike

public ForFluent<A>.ThrowBodyNested<A> withNewThrowBodyLike(Throw item)

withNewTryBody

public ForFluent<A>.TryBodyNested<A> withNewTryBody()

withNewTryBodyLike

public ForFluent<A>.TryBodyNested<A> withNewTryBodyLike(Try item)

withNewValueRefCompare

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

withNewValueRefCompare

public A withNewValueRefCompare(Object value)

withNewValueRefCompareLike

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

withNewWhileBody

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

withNewWhileBodyLike

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

withNewXorBody

public ForFluent<A>.XorBodyNested<A> withNewXorBody()

withNewXorBody

public A withNewXorBody(Object left,
 Object right)

withNewXorBodyLike

public ForFluent<A>.XorBodyNested<A> withNewXorBodyLike(Xor item)

withNewXorCompare

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

withNewXorCompare

public A withNewXorCompare(Object left,
 Object right)

withNewXorCompareLike

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

withUpdate

public A withUpdate(List<Expression> update)

withUpdate

public A withUpdate(Expression... update)