Package io.sundr.model

Class ForeachFluent<A extends ForeachFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.ForeachFluent<A>

Direct Known Subclasses:

BlockFluent.ForeachStatementsNested, DoFluent.ForeachStatementNested, ForeachBuilder, ForeachFluent.ForeachBodyNested, ForFluent.ForeachBodyNested, IfDslThenStepFluent.ForeachStatementsNested, IfFluent.ForeachElseStatementNested, IfFluent.ForeachStatementNested, LambdaFluent.ForeachStatementNested, SynchronizedFluent.ForeachBodyNested, WhileFluent.ForeachStatementNested

public class ForeachFluent<A extends ForeachFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	ForeachFluent.AssignBodyNested<N>
class	ForeachFluent.AssignExpressionNested<N>
class	ForeachFluent.BinaryExpressionBodyNested<N>
class	ForeachFluent.BinaryExpressionNested<N>
class	ForeachFluent.BitwiseAndBodyNested<N>
class	ForeachFluent.BitwiseAndExpressionNested<N>
class	ForeachFluent.BitwiseOrBodyNested<N>
class	ForeachFluent.BitwiseOrExpressionNested<N>
class	ForeachFluent.BlockBodyNested<N>
class	ForeachFluent.BreakBodyNested<N>
class	ForeachFluent.CastExpressionNested<N>
class	ForeachFluent.ClassRefExpressionNested<N>
class	ForeachFluent.ConstructBodyNested<N>
class	ForeachFluent.ConstructExpressionNested<N>
class	ForeachFluent.ContextRefExpressionNested<N>
class	ForeachFluent.ContinueBodyNested<N>
class	ForeachFluent.DeclareBodyNested<N>
class	ForeachFluent.DeclareExpressionNested<N>
class	ForeachFluent.DeclareNested<N>
class	ForeachFluent.DivideBodyNested<N>
class	ForeachFluent.DivideExpressionNested<N>
class	ForeachFluent.DoBodyNested<N>
class	ForeachFluent.DotClassExpressionNested<N>
class	ForeachFluent.EmptyBodyNested<N>
class	ForeachFluent.EmptyExpressionNested<N>
class	ForeachFluent.EnclosedExpressionNested<N>
class	ForeachFluent.EqualsBodyNested<N>
class	ForeachFluent.EqualsExpressionNested<N>
class	ForeachFluent.ForBodyNested<N>
class	ForeachFluent.ForeachBodyNested<N>
class	ForeachFluent.GreaterThanBodyNested<N>
class	ForeachFluent.GreaterThanExpressionNested<N>
class	ForeachFluent.GreaterThanOrEqualBodyNested<N>
class	ForeachFluent.GreaterThanOrEqualExpressionNested<N>
class	ForeachFluent.IfBodyNested<N>
class	ForeachFluent.IfDslThenStepBodyNested<N>
class	ForeachFluent.IndexExpressionNested<N>
class	ForeachFluent.InstanceOfExpressionNested<N>
class	ForeachFluent.InverseExpressionNested<N>
class	ForeachFluent.LambdaBodyNested<N>
class	ForeachFluent.LambdaExpressionNested<N>
class	ForeachFluent.LeftShiftBodyNested<N>
class	ForeachFluent.LeftShiftExpressionNested<N>
class	ForeachFluent.LessThanBodyNested<N>
class	ForeachFluent.LessThanExpressionNested<N>
class	ForeachFluent.LessThanOrEqualBodyNested<N>
class	ForeachFluent.LessThanOrEqualExpressionNested<N>
class	ForeachFluent.LogicalAndBodyNested<N>
class	ForeachFluent.LogicalAndExpressionNested<N>
class	ForeachFluent.LogicalOrBodyNested<N>
class	ForeachFluent.LogicalOrExpressionNested<N>
class	ForeachFluent.MethodCallBodyNested<N>
class	ForeachFluent.MethodCallExpressionNested<N>
class	ForeachFluent.MinusBodyNested<N>
class	ForeachFluent.MinusExpressionNested<N>
class	ForeachFluent.ModuloBodyNested<N>
class	ForeachFluent.ModuloExpressionNested<N>
class	ForeachFluent.MultiplyBodyNested<N>
class	ForeachFluent.MultiplyExpressionNested<N>
class	ForeachFluent.NegativeExpressionNested<N>
class	ForeachFluent.NewArrayExpressionNested<N>
class	ForeachFluent.NotEqualsBodyNested<N>
class	ForeachFluent.NotEqualsExpressionNested<N>
class	ForeachFluent.NotExpressionNested<N>
class	ForeachFluent.PlusBodyNested<N>
class	ForeachFluent.PlusExpressionNested<N>
class	ForeachFluent.PositiveExpressionNested<N>
class	ForeachFluent.PostDecrementBodyNested<N>
class	ForeachFluent.PostDecrementExpressionNested<N>
class	ForeachFluent.PostIncrementBodyNested<N>
class	ForeachFluent.PostIncrementExpressionNested<N>
class	ForeachFluent.PreDecrementBodyNested<N>
class	ForeachFluent.PreDecrementExpressionNested<N>
class	ForeachFluent.PreIncrementBodyNested<N>
class	ForeachFluent.PreIncrementExpressionNested<N>
class	ForeachFluent.PropertyExpressionNested<N>
class	ForeachFluent.PropertyRefBodyNested<N>
class	ForeachFluent.PropertyRefExpressionNested<N>
class	ForeachFluent.ReturnBodyNested<N>
class	ForeachFluent.ReturnDslThisStepBodyNested<N>
class	ForeachFluent.ReturnDslVariableStepBodyNested<N>
class	ForeachFluent.RightShiftBodyNested<N>
class	ForeachFluent.RightShiftExpressionNested<N>
class	ForeachFluent.RightUnsignedShiftBodyNested<N>
class	ForeachFluent.RightUnsignedShiftExpressionNested<N>
class	ForeachFluent.StringStatementBodyNested<N>
class	ForeachFluent.SuperExpressionNested<N>
class	ForeachFluent.SwitchBodyNested<N>
class	ForeachFluent.SynchronizedBodyNested<N>
class	ForeachFluent.TernaryExpressionNested<N>
class	ForeachFluent.ThisExpressionNested<N>
class	ForeachFluent.ThrowBodyNested<N>
class	ForeachFluent.TryBodyNested<N>
class	ForeachFluent.ValueRefExpressionNested<N>
class	ForeachFluent.WhileBodyNested<N>
class	ForeachFluent.XorBodyNested<N>
class	ForeachFluent.XorExpressionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
ForeachFluent()
ForeachFluent(Foreach instance)

Method Summary

Modifier and Type	Method	Description
Statement	buildBody()
Declare	buildDeclare()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildExpression()
protected void	copyInstance(Foreach instance)
ForeachFluent<A>.DeclareNested<A>	editDeclare()
ForeachFluent<A>.DeclareNested<A>	editOrNewDeclare()
ForeachFluent<A>.DeclareNested<A>	editOrNewDeclareLike(Declare item)
boolean	equals(Object o)
boolean	hasBody()
boolean	hasDeclare()
boolean	hasExpression()
int	hashCode()
String	toString()
A	withBody(Statement body)
A	withDeclare(Declare declare)
A	withExpression(Expression expression)
ForeachFluent<A>.AssignBodyNested<A>	withNewAssignBody()
ForeachFluent<A>.AssignBodyNested<A>	withNewAssignBodyLike(Assign item)
ForeachFluent<A>.AssignExpressionNested<A>	withNewAssignExpression()
ForeachFluent<A>.AssignExpressionNested<A>	withNewAssignExpressionLike(Assign item)
ForeachFluent<A>.BinaryExpressionNested<A>	withNewBinaryExpression()
ForeachFluent<A>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBody()
ForeachFluent<A>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBodyLike(BinaryExpression item)
ForeachFluent<A>.BinaryExpressionNested<A>	withNewBinaryExpressionLike(BinaryExpression item)
ForeachFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBody()
A	withNewBitwiseAndBody(Object left, Object right)
ForeachFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBodyLike(BitwiseAnd item)
ForeachFluent<A>.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpression()
A	withNewBitwiseAndExpression(Object left, Object right)
ForeachFluent<A>.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpressionLike(BitwiseAnd item)
ForeachFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBody()
A	withNewBitwiseOrBody(Object left, Object right)
ForeachFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBodyLike(BitwiseOr item)
ForeachFluent<A>.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpression()
A	withNewBitwiseOrExpression(Object left, Object right)
ForeachFluent<A>.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpressionLike(BitwiseOr item)
ForeachFluent<A>.BlockBodyNested<A>	withNewBlockBody()
ForeachFluent<A>.BlockBodyNested<A>	withNewBlockBodyLike(Block item)
ForeachFluent<A>.BreakBodyNested<A>	withNewBreakBody()
ForeachFluent<A>.BreakBodyNested<A>	withNewBreakBodyLike(Break item)
ForeachFluent<A>.CastExpressionNested<A>	withNewCastExpression()
ForeachFluent<A>.CastExpressionNested<A>	withNewCastExpressionLike(Cast item)
ForeachFluent<A>.ClassRefExpressionNested<A>	withNewClassRefExpression()
ForeachFluent<A>.ClassRefExpressionNested<A>	withNewClassRefExpressionLike(ClassRef item)
ForeachFluent<A>.ConstructBodyNested<A>	withNewConstructBody()
ForeachFluent<A>.ConstructBodyNested<A>	withNewConstructBodyLike(Construct item)
ForeachFluent<A>.ConstructExpressionNested<A>	withNewConstructExpression()
ForeachFluent<A>.ConstructExpressionNested<A>	withNewConstructExpressionLike(Construct item)
ForeachFluent<A>.ContextRefExpressionNested<A>	withNewContextRefExpression()
A	withNewContextRefExpression(String name)
ForeachFluent<A>.ContextRefExpressionNested<A>	withNewContextRefExpressionLike(ContextRef item)
ForeachFluent<A>.ContinueBodyNested<A>	withNewContinueBody()
ForeachFluent<A>.ContinueBodyNested<A>	withNewContinueBodyLike(Continue item)
ForeachFluent<A>.DeclareNested<A>	withNewDeclare()
A	withNewDeclare(Class type, String name)
A	withNewDeclare(Class type, String name, Object value)
ForeachFluent<A>.DeclareBodyNested<A>	withNewDeclareBody()
A	withNewDeclareBody(Class type, String name)
A	withNewDeclareBody(Class type, String name, Object value)
ForeachFluent<A>.DeclareBodyNested<A>	withNewDeclareBodyLike(Declare item)
ForeachFluent<A>.DeclareExpressionNested<A>	withNewDeclareExpression()
A	withNewDeclareExpression(Class type, String name)
A	withNewDeclareExpression(Class type, String name, Object value)
ForeachFluent<A>.DeclareExpressionNested<A>	withNewDeclareExpressionLike(Declare item)
ForeachFluent<A>.DeclareNested<A>	withNewDeclareLike(Declare item)
ForeachFluent<A>.DivideBodyNested<A>	withNewDivideBody()
A	withNewDivideBody(Object left, Object right)
ForeachFluent<A>.DivideBodyNested<A>	withNewDivideBodyLike(Divide item)
ForeachFluent<A>.DivideExpressionNested<A>	withNewDivideExpression()
A	withNewDivideExpression(Object left, Object right)
ForeachFluent<A>.DivideExpressionNested<A>	withNewDivideExpressionLike(Divide item)
ForeachFluent<A>.DoBodyNested<A>	withNewDoBody()
ForeachFluent<A>.DoBodyNested<A>	withNewDoBodyLike(Do item)
ForeachFluent<A>.DotClassExpressionNested<A>	withNewDotClassExpression()
ForeachFluent<A>.DotClassExpressionNested<A>	withNewDotClassExpressionLike(DotClass item)
ForeachFluent<A>.EmptyBodyNested<A>	withNewEmptyBody()
ForeachFluent<A>.EmptyBodyNested<A>	withNewEmptyBodyLike(Empty item)
ForeachFluent<A>.EmptyExpressionNested<A>	withNewEmptyExpression()
ForeachFluent<A>.EmptyExpressionNested<A>	withNewEmptyExpressionLike(Empty item)
ForeachFluent<A>.EnclosedExpressionNested<A>	withNewEnclosedExpression()
ForeachFluent<A>.EnclosedExpressionNested<A>	withNewEnclosedExpressionLike(Enclosed item)
ForeachFluent<A>.EqualsBodyNested<A>	withNewEqualsBody()
A	withNewEqualsBody(Object left, Object right)
ForeachFluent<A>.EqualsBodyNested<A>	withNewEqualsBodyLike(Equals item)
ForeachFluent<A>.EqualsExpressionNested<A>	withNewEqualsExpression()
A	withNewEqualsExpression(Object left, Object right)
ForeachFluent<A>.EqualsExpressionNested<A>	withNewEqualsExpressionLike(Equals item)
ForeachFluent<A>.ForBodyNested<A>	withNewForBody()
ForeachFluent<A>.ForBodyNested<A>	withNewForBodyLike(For item)
ForeachFluent<A>.ForeachBodyNested<A>	withNewForeachBody()
ForeachFluent<A>.ForeachBodyNested<A>	withNewForeachBodyLike(Foreach item)
ForeachFluent<A>.GreaterThanBodyNested<A>	withNewGreaterThanBody()
A	withNewGreaterThanBody(Object left, Object right)
ForeachFluent<A>.GreaterThanBodyNested<A>	withNewGreaterThanBodyLike(GreaterThan item)
ForeachFluent<A>.GreaterThanExpressionNested<A>	withNewGreaterThanExpression()
A	withNewGreaterThanExpression(Object left, Object right)
ForeachFluent<A>.GreaterThanExpressionNested<A>	withNewGreaterThanExpressionLike(GreaterThan item)
ForeachFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBody()
A	withNewGreaterThanOrEqualBody(Object left, Object right)
ForeachFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBodyLike(GreaterThanOrEqual item)
ForeachFluent<A>.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpression()
A	withNewGreaterThanOrEqualExpression(Object left, Object right)
ForeachFluent<A>.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
ForeachFluent<A>.IfBodyNested<A>	withNewIfBody()
ForeachFluent<A>.IfBodyNested<A>	withNewIfBodyLike(If item)
ForeachFluent<A>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBody()
ForeachFluent<A>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBodyLike(IfDslThenStep item)
ForeachFluent<A>.IndexExpressionNested<A>	withNewIndexExpression()
ForeachFluent<A>.IndexExpressionNested<A>	withNewIndexExpressionLike(Index item)
ForeachFluent<A>.InstanceOfExpressionNested<A>	withNewInstanceOfExpression()
ForeachFluent<A>.InstanceOfExpressionNested<A>	withNewInstanceOfExpressionLike(InstanceOf item)
ForeachFluent<A>.InverseExpressionNested<A>	withNewInverseExpression()
ForeachFluent<A>.InverseExpressionNested<A>	withNewInverseExpressionLike(Inverse item)
ForeachFluent<A>.LambdaBodyNested<A>	withNewLambdaBody()
ForeachFluent<A>.LambdaBodyNested<A>	withNewLambdaBodyLike(Lambda item)
ForeachFluent<A>.LambdaExpressionNested<A>	withNewLambdaExpression()
ForeachFluent<A>.LambdaExpressionNested<A>	withNewLambdaExpressionLike(Lambda item)
ForeachFluent<A>.LeftShiftBodyNested<A>	withNewLeftShiftBody()
A	withNewLeftShiftBody(Object left, Object right)
ForeachFluent<A>.LeftShiftBodyNested<A>	withNewLeftShiftBodyLike(LeftShift item)
ForeachFluent<A>.LeftShiftExpressionNested<A>	withNewLeftShiftExpression()
A	withNewLeftShiftExpression(Object left, Object right)
ForeachFluent<A>.LeftShiftExpressionNested<A>	withNewLeftShiftExpressionLike(LeftShift item)
ForeachFluent<A>.LessThanBodyNested<A>	withNewLessThanBody()
A	withNewLessThanBody(Object left, Object right)
ForeachFluent<A>.LessThanBodyNested<A>	withNewLessThanBodyLike(LessThan item)
ForeachFluent<A>.LessThanExpressionNested<A>	withNewLessThanExpression()
A	withNewLessThanExpression(Object left, Object right)
ForeachFluent<A>.LessThanExpressionNested<A>	withNewLessThanExpressionLike(LessThan item)
ForeachFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBody()
A	withNewLessThanOrEqualBody(Object left, Object right)
ForeachFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBodyLike(LessThanOrEqual item)
ForeachFluent<A>.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpression()
A	withNewLessThanOrEqualExpression(Object left, Object right)
ForeachFluent<A>.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
ForeachFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBody()
A	withNewLogicalAndBody(Object left, Object right)
ForeachFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBodyLike(LogicalAnd item)
ForeachFluent<A>.LogicalAndExpressionNested<A>	withNewLogicalAndExpression()
A	withNewLogicalAndExpression(Object left, Object right)
ForeachFluent<A>.LogicalAndExpressionNested<A>	withNewLogicalAndExpressionLike(LogicalAnd item)
ForeachFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBody()
A	withNewLogicalOrBody(Object left, Object right)
ForeachFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBodyLike(LogicalOr item)
ForeachFluent<A>.LogicalOrExpressionNested<A>	withNewLogicalOrExpression()
A	withNewLogicalOrExpression(Object left, Object right)
ForeachFluent<A>.LogicalOrExpressionNested<A>	withNewLogicalOrExpressionLike(LogicalOr item)
ForeachFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBody()
ForeachFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBodyLike(MethodCall item)
ForeachFluent<A>.MethodCallExpressionNested<A>	withNewMethodCallExpression()
ForeachFluent<A>.MethodCallExpressionNested<A>	withNewMethodCallExpressionLike(MethodCall item)
ForeachFluent<A>.MinusBodyNested<A>	withNewMinusBody()
A	withNewMinusBody(Object left, Object right)
ForeachFluent<A>.MinusBodyNested<A>	withNewMinusBodyLike(Minus item)
ForeachFluent<A>.MinusExpressionNested<A>	withNewMinusExpression()
A	withNewMinusExpression(Object left, Object right)
ForeachFluent<A>.MinusExpressionNested<A>	withNewMinusExpressionLike(Minus item)
ForeachFluent<A>.ModuloBodyNested<A>	withNewModuloBody()
A	withNewModuloBody(Object left, Object right)
ForeachFluent<A>.ModuloBodyNested<A>	withNewModuloBodyLike(Modulo item)
ForeachFluent<A>.ModuloExpressionNested<A>	withNewModuloExpression()
A	withNewModuloExpression(Object left, Object right)
ForeachFluent<A>.ModuloExpressionNested<A>	withNewModuloExpressionLike(Modulo item)
ForeachFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBody()
A	withNewMultiplyBody(Object left, Object right)
ForeachFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBodyLike(Multiply item)
ForeachFluent<A>.MultiplyExpressionNested<A>	withNewMultiplyExpression()
A	withNewMultiplyExpression(Object left, Object right)
ForeachFluent<A>.MultiplyExpressionNested<A>	withNewMultiplyExpressionLike(Multiply item)
ForeachFluent<A>.NegativeExpressionNested<A>	withNewNegativeExpression()
ForeachFluent<A>.NegativeExpressionNested<A>	withNewNegativeExpressionLike(Negative item)
ForeachFluent<A>.NewArrayExpressionNested<A>	withNewNewArrayExpression()
A	withNewNewArrayExpression(Class type, Integer[] sizes)
ForeachFluent<A>.NewArrayExpressionNested<A>	withNewNewArrayExpressionLike(NewArray item)
ForeachFluent<A>.NotEqualsBodyNested<A>	withNewNotEqualsBody()
A	withNewNotEqualsBody(Object left, Object right)
ForeachFluent<A>.NotEqualsBodyNested<A>	withNewNotEqualsBodyLike(NotEquals item)
ForeachFluent<A>.NotEqualsExpressionNested<A>	withNewNotEqualsExpression()
A	withNewNotEqualsExpression(Object left, Object right)
ForeachFluent<A>.NotEqualsExpressionNested<A>	withNewNotEqualsExpressionLike(NotEquals item)
ForeachFluent<A>.NotExpressionNested<A>	withNewNotExpression()
ForeachFluent<A>.NotExpressionNested<A>	withNewNotExpressionLike(Not item)
ForeachFluent<A>.PlusBodyNested<A>	withNewPlusBody()
A	withNewPlusBody(Object left, Object right)
ForeachFluent<A>.PlusBodyNested<A>	withNewPlusBodyLike(Plus item)
ForeachFluent<A>.PlusExpressionNested<A>	withNewPlusExpression()
A	withNewPlusExpression(Object left, Object right)
ForeachFluent<A>.PlusExpressionNested<A>	withNewPlusExpressionLike(Plus item)
ForeachFluent<A>.PositiveExpressionNested<A>	withNewPositiveExpression()
ForeachFluent<A>.PositiveExpressionNested<A>	withNewPositiveExpressionLike(Positive item)
ForeachFluent<A>.PostDecrementBodyNested<A>	withNewPostDecrementBody()
ForeachFluent<A>.PostDecrementBodyNested<A>	withNewPostDecrementBodyLike(PostDecrement item)
ForeachFluent<A>.PostDecrementExpressionNested<A>	withNewPostDecrementExpression()
ForeachFluent<A>.PostDecrementExpressionNested<A>	withNewPostDecrementExpressionLike(PostDecrement item)
ForeachFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBody()
ForeachFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBodyLike(PostIncrement item)
ForeachFluent<A>.PostIncrementExpressionNested<A>	withNewPostIncrementExpression()
ForeachFluent<A>.PostIncrementExpressionNested<A>	withNewPostIncrementExpressionLike(PostIncrement item)
ForeachFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBody()
ForeachFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBodyLike(PreDecrement item)
ForeachFluent<A>.PreDecrementExpressionNested<A>	withNewPreDecrementExpression()
ForeachFluent<A>.PreDecrementExpressionNested<A>	withNewPreDecrementExpressionLike(PreDecrement item)
ForeachFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBody()
ForeachFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBodyLike(PreIncrement item)
ForeachFluent<A>.PreIncrementExpressionNested<A>	withNewPreIncrementExpression()
ForeachFluent<A>.PreIncrementExpressionNested<A>	withNewPreIncrementExpressionLike(PreIncrement item)
ForeachFluent<A>.PropertyExpressionNested<A>	withNewPropertyExpression()
ForeachFluent<A>.PropertyExpressionNested<A>	withNewPropertyExpressionLike(Property item)
ForeachFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBody()
ForeachFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBodyLike(PropertyRef item)
ForeachFluent<A>.PropertyRefExpressionNested<A>	withNewPropertyRefExpression()
ForeachFluent<A>.PropertyRefExpressionNested<A>	withNewPropertyRefExpressionLike(PropertyRef item)
ForeachFluent<A>.ReturnBodyNested<A>	withNewReturnBody()
A	withNewReturnBody(Object object)
ForeachFluent<A>.ReturnBodyNested<A>	withNewReturnBodyLike(Return item)
ForeachFluent<A>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBody()
ForeachFluent<A>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBodyLike(ReturnDslThisStep item)
ForeachFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBody()
A	withNewReturnDslVariableStepBody(String name)
ForeachFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBodyLike(ReturnDslVariableStep item)
ForeachFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBody()
A	withNewRightShiftBody(Object left, Object right)
ForeachFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBodyLike(RightShift item)
ForeachFluent<A>.RightShiftExpressionNested<A>	withNewRightShiftExpression()
A	withNewRightShiftExpression(Object left, Object right)
ForeachFluent<A>.RightShiftExpressionNested<A>	withNewRightShiftExpressionLike(RightShift item)
ForeachFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBody()
A	withNewRightUnsignedShiftBody(Object left, Object right)
ForeachFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBodyLike(RightUnsignedShift item)
ForeachFluent<A>.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpression()
A	withNewRightUnsignedShiftExpression(Object left, Object right)
ForeachFluent<A>.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
ForeachFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBody()
A	withNewStringStatementBody(String data)
A	withNewStringStatementBody(String data, Object[] parameters)
ForeachFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBodyLike(StringStatement item)
ForeachFluent<A>.SuperExpressionNested<A>	withNewSuperExpression()
ForeachFluent<A>.SuperExpressionNested<A>	withNewSuperExpressionLike(Super item)
ForeachFluent<A>.SwitchBodyNested<A>	withNewSwitchBody()
ForeachFluent<A>.SwitchBodyNested<A>	withNewSwitchBodyLike(Switch item)
ForeachFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBody()
ForeachFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBodyLike(Synchronized item)
ForeachFluent<A>.TernaryExpressionNested<A>	withNewTernaryExpression()
ForeachFluent<A>.TernaryExpressionNested<A>	withNewTernaryExpressionLike(Ternary item)
ForeachFluent<A>.ThisExpressionNested<A>	withNewThisExpression()
ForeachFluent<A>.ThisExpressionNested<A>	withNewThisExpressionLike(This item)
ForeachFluent<A>.ThrowBodyNested<A>	withNewThrowBody()
ForeachFluent<A>.ThrowBodyNested<A>	withNewThrowBodyLike(Throw item)
ForeachFluent<A>.TryBodyNested<A>	withNewTryBody()
ForeachFluent<A>.TryBodyNested<A>	withNewTryBodyLike(Try item)
ForeachFluent<A>.ValueRefExpressionNested<A>	withNewValueRefExpression()
A	withNewValueRefExpression(Object value)
ForeachFluent<A>.ValueRefExpressionNested<A>	withNewValueRefExpressionLike(ValueRef item)
ForeachFluent<A>.WhileBodyNested<A>	withNewWhileBody()
ForeachFluent<A>.WhileBodyNested<A>	withNewWhileBodyLike(While item)
ForeachFluent<A>.XorBodyNested<A>	withNewXorBody()
A	withNewXorBody(Object left, Object right)
ForeachFluent<A>.XorBodyNested<A>	withNewXorBodyLike(Xor item)
ForeachFluent<A>.XorExpressionNested<A>	withNewXorExpression()
A	withNewXorExpression(Object left, Object right)
ForeachFluent<A>.XorExpressionNested<A>	withNewXorExpressionLike(Xor item)

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

ForeachFluent

public ForeachFluent()

ForeachFluent

public ForeachFluent(Foreach instance)

Method Details

buildBody

public Statement buildBody()

buildDeclare

public Declare buildDeclare()

buildExpression

public Expression buildExpression()

builder

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

copyInstance

protected void copyInstance(Foreach instance)

editDeclare

public ForeachFluent<A>.DeclareNested<A> editDeclare()

editOrNewDeclare

public ForeachFluent<A>.DeclareNested<A> editOrNewDeclare()

editOrNewDeclareLike

public ForeachFluent<A>.DeclareNested<A> editOrNewDeclareLike(Declare item)

equals

public boolean equals(Object o)

Overrides:

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

hasBody

public boolean hasBody()

hasDeclare

public boolean hasDeclare()

hasExpression

public boolean hasExpression()

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

withBody

public A withBody(Statement body)

withDeclare

public A withDeclare(Declare declare)

withExpression

public A withExpression(Expression expression)

withNewAssignBody

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

withNewAssignBodyLike

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

withNewAssignExpression

public ForeachFluent<A>.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

public ForeachFluent<A>.AssignExpressionNested<A> withNewAssignExpressionLike(Assign item)

withNewBinaryExpression

public ForeachFluent<A>.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionBody

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

withNewBinaryExpressionBodyLike

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

withNewBinaryExpressionLike

public ForeachFluent<A>.BinaryExpressionNested<A> withNewBinaryExpressionLike(BinaryExpression item)

withNewBitwiseAndBody

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

withNewBitwiseAndBody

public A withNewBitwiseAndBody(Object left,
 Object right)

withNewBitwiseAndBodyLike

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

withNewBitwiseAndExpression

public ForeachFluent<A>.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
 Object right)

withNewBitwiseAndExpressionLike

public ForeachFluent<A>.BitwiseAndExpressionNested<A> withNewBitwiseAndExpressionLike(BitwiseAnd item)

withNewBitwiseOrBody

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

withNewBitwiseOrBody

public A withNewBitwiseOrBody(Object left,
 Object right)

withNewBitwiseOrBodyLike

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

withNewBitwiseOrExpression

public ForeachFluent<A>.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
 Object right)

withNewBitwiseOrExpressionLike

public ForeachFluent<A>.BitwiseOrExpressionNested<A> withNewBitwiseOrExpressionLike(BitwiseOr item)

withNewBlockBody

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

withNewBlockBodyLike

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

withNewBreakBody

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

withNewBreakBodyLike

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

withNewCastExpression

public ForeachFluent<A>.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

public ForeachFluent<A>.CastExpressionNested<A> withNewCastExpressionLike(Cast item)

withNewClassRefExpression

public ForeachFluent<A>.ClassRefExpressionNested<A> withNewClassRefExpression()

withNewClassRefExpressionLike

public ForeachFluent<A>.ClassRefExpressionNested<A> withNewClassRefExpressionLike(ClassRef item)

withNewConstructBody

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

withNewConstructBodyLike

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

withNewConstructExpression

public ForeachFluent<A>.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

public ForeachFluent<A>.ConstructExpressionNested<A> withNewConstructExpressionLike(Construct item)

withNewContextRefExpression

public ForeachFluent<A>.ContextRefExpressionNested<A> withNewContextRefExpression()

withNewContextRefExpression

public A withNewContextRefExpression(String name)

withNewContextRefExpressionLike

public ForeachFluent<A>.ContextRefExpressionNested<A> withNewContextRefExpressionLike(ContextRef item)

withNewContinueBody

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

withNewContinueBodyLike

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

withNewDeclare

public ForeachFluent<A>.DeclareNested<A> withNewDeclare()

withNewDeclare

public A withNewDeclare(Class type,
 String name)

withNewDeclare

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

withNewDeclareBody

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

withNewDeclareBody

public A withNewDeclareBody(Class type,
 String name)

withNewDeclareBody

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

withNewDeclareBodyLike

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

withNewDeclareExpression

public ForeachFluent<A>.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
 String name)

withNewDeclareExpression

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

withNewDeclareExpressionLike

public ForeachFluent<A>.DeclareExpressionNested<A> withNewDeclareExpressionLike(Declare item)

withNewDeclareLike

public ForeachFluent<A>.DeclareNested<A> withNewDeclareLike(Declare item)

withNewDivideBody

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

withNewDivideBody

public A withNewDivideBody(Object left,
 Object right)

withNewDivideBodyLike

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

withNewDivideExpression

public ForeachFluent<A>.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpression

public A withNewDivideExpression(Object left,
 Object right)

withNewDivideExpressionLike

public ForeachFluent<A>.DivideExpressionNested<A> withNewDivideExpressionLike(Divide item)

withNewDoBody

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

withNewDoBodyLike

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

withNewDotClassExpression

public ForeachFluent<A>.DotClassExpressionNested<A> withNewDotClassExpression()

withNewDotClassExpressionLike

public ForeachFluent<A>.DotClassExpressionNested<A> withNewDotClassExpressionLike(DotClass item)

withNewEmptyBody

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

withNewEmptyBodyLike

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

withNewEmptyExpression

public ForeachFluent<A>.EmptyExpressionNested<A> withNewEmptyExpression()

withNewEmptyExpressionLike

public ForeachFluent<A>.EmptyExpressionNested<A> withNewEmptyExpressionLike(Empty item)

withNewEnclosedExpression

public ForeachFluent<A>.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

public ForeachFluent<A>.EnclosedExpressionNested<A> withNewEnclosedExpressionLike(Enclosed item)

withNewEqualsBody

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

withNewEqualsBody

public A withNewEqualsBody(Object left,
 Object right)

withNewEqualsBodyLike

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

withNewEqualsExpression

public ForeachFluent<A>.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
 Object right)

withNewEqualsExpressionLike

public ForeachFluent<A>.EqualsExpressionNested<A> withNewEqualsExpressionLike(Equals item)

withNewForBody

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

withNewForBodyLike

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

withNewForeachBody

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

withNewForeachBodyLike

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

withNewGreaterThanBody

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

withNewGreaterThanBody

public A withNewGreaterThanBody(Object left,
 Object right)

withNewGreaterThanBodyLike

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

withNewGreaterThanExpression

public ForeachFluent<A>.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
 Object right)

withNewGreaterThanExpressionLike

public ForeachFluent<A>.GreaterThanExpressionNested<A> withNewGreaterThanExpressionLike(GreaterThan item)

withNewGreaterThanOrEqualBody

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

withNewGreaterThanOrEqualBody

public A withNewGreaterThanOrEqualBody(Object left,
 Object right)

withNewGreaterThanOrEqualBodyLike

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

withNewGreaterThanOrEqualExpression

public ForeachFluent<A>.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
 Object right)

withNewGreaterThanOrEqualExpressionLike

public ForeachFluent<A>.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)

withNewIfBody

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

withNewIfBodyLike

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

withNewIfDslThenStepBody

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

withNewIfDslThenStepBodyLike

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

withNewIndexExpression

public ForeachFluent<A>.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

public ForeachFluent<A>.IndexExpressionNested<A> withNewIndexExpressionLike(Index item)

withNewInstanceOfExpression

public ForeachFluent<A>.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

public ForeachFluent<A>.InstanceOfExpressionNested<A> withNewInstanceOfExpressionLike(InstanceOf item)

withNewInverseExpression

public ForeachFluent<A>.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

public ForeachFluent<A>.InverseExpressionNested<A> withNewInverseExpressionLike(Inverse item)

withNewLambdaBody

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

withNewLambdaBodyLike

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

withNewLambdaExpression

public ForeachFluent<A>.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

public ForeachFluent<A>.LambdaExpressionNested<A> withNewLambdaExpressionLike(Lambda item)

withNewLeftShiftBody

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

withNewLeftShiftBody

public A withNewLeftShiftBody(Object left,
 Object right)

withNewLeftShiftBodyLike

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

withNewLeftShiftExpression

public ForeachFluent<A>.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
 Object right)

withNewLeftShiftExpressionLike

public ForeachFluent<A>.LeftShiftExpressionNested<A> withNewLeftShiftExpressionLike(LeftShift item)

withNewLessThanBody

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

withNewLessThanBody

public A withNewLessThanBody(Object left,
 Object right)

withNewLessThanBodyLike

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

withNewLessThanExpression

public ForeachFluent<A>.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
 Object right)

withNewLessThanExpressionLike

public ForeachFluent<A>.LessThanExpressionNested<A> withNewLessThanExpressionLike(LessThan item)

withNewLessThanOrEqualBody

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

withNewLessThanOrEqualBody

public A withNewLessThanOrEqualBody(Object left,
 Object right)

withNewLessThanOrEqualBodyLike

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

withNewLessThanOrEqualExpression

public ForeachFluent<A>.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
 Object right)

withNewLessThanOrEqualExpressionLike

public ForeachFluent<A>.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)

withNewLogicalAndBody

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

withNewLogicalAndBody

public A withNewLogicalAndBody(Object left,
 Object right)

withNewLogicalAndBodyLike

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

withNewLogicalAndExpression

public ForeachFluent<A>.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
 Object right)

withNewLogicalAndExpressionLike

public ForeachFluent<A>.LogicalAndExpressionNested<A> withNewLogicalAndExpressionLike(LogicalAnd item)

withNewLogicalOrBody

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

withNewLogicalOrBody

public A withNewLogicalOrBody(Object left,
 Object right)

withNewLogicalOrBodyLike

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

withNewLogicalOrExpression

public ForeachFluent<A>.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
 Object right)

withNewLogicalOrExpressionLike

public ForeachFluent<A>.LogicalOrExpressionNested<A> withNewLogicalOrExpressionLike(LogicalOr item)

withNewMethodCallBody

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

withNewMethodCallBodyLike

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

withNewMethodCallExpression

public ForeachFluent<A>.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

public ForeachFluent<A>.MethodCallExpressionNested<A> withNewMethodCallExpressionLike(MethodCall item)

withNewMinusBody

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

withNewMinusBody

public A withNewMinusBody(Object left,
 Object right)

withNewMinusBodyLike

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

withNewMinusExpression

public ForeachFluent<A>.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpression

public A withNewMinusExpression(Object left,
 Object right)

withNewMinusExpressionLike

public ForeachFluent<A>.MinusExpressionNested<A> withNewMinusExpressionLike(Minus item)

withNewModuloBody

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

withNewModuloBody

public A withNewModuloBody(Object left,
 Object right)

withNewModuloBodyLike

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

withNewModuloExpression

public ForeachFluent<A>.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpression

public A withNewModuloExpression(Object left,
 Object right)

withNewModuloExpressionLike

public ForeachFluent<A>.ModuloExpressionNested<A> withNewModuloExpressionLike(Modulo item)

withNewMultiplyBody

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

withNewMultiplyBody

public A withNewMultiplyBody(Object left,
 Object right)

withNewMultiplyBodyLike

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

withNewMultiplyExpression

public ForeachFluent<A>.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
 Object right)

withNewMultiplyExpressionLike

public ForeachFluent<A>.MultiplyExpressionNested<A> withNewMultiplyExpressionLike(Multiply item)

withNewNegativeExpression

public ForeachFluent<A>.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

public ForeachFluent<A>.NegativeExpressionNested<A> withNewNegativeExpressionLike(Negative item)

withNewNewArrayExpression

public ForeachFluent<A>.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpression

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

withNewNewArrayExpressionLike

public ForeachFluent<A>.NewArrayExpressionNested<A> withNewNewArrayExpressionLike(NewArray item)

withNewNotEqualsBody

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

withNewNotEqualsBody

public A withNewNotEqualsBody(Object left,
 Object right)

withNewNotEqualsBodyLike

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

withNewNotEqualsExpression

public ForeachFluent<A>.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
 Object right)

withNewNotEqualsExpressionLike

public ForeachFluent<A>.NotEqualsExpressionNested<A> withNewNotEqualsExpressionLike(NotEquals item)

withNewNotExpression

public ForeachFluent<A>.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

public ForeachFluent<A>.NotExpressionNested<A> withNewNotExpressionLike(Not item)

withNewPlusBody

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

withNewPlusBody

public A withNewPlusBody(Object left,
 Object right)

withNewPlusBodyLike

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

withNewPlusExpression

public ForeachFluent<A>.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpression

public A withNewPlusExpression(Object left,
 Object right)

withNewPlusExpressionLike

public ForeachFluent<A>.PlusExpressionNested<A> withNewPlusExpressionLike(Plus item)

withNewPositiveExpression

public ForeachFluent<A>.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

public ForeachFluent<A>.PositiveExpressionNested<A> withNewPositiveExpressionLike(Positive item)

withNewPostDecrementBody

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

withNewPostDecrementBodyLike

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

withNewPostDecrementExpression

public ForeachFluent<A>.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

public ForeachFluent<A>.PostDecrementExpressionNested<A> withNewPostDecrementExpressionLike(PostDecrement item)

withNewPostIncrementBody

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

withNewPostIncrementBodyLike

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

withNewPostIncrementExpression

public ForeachFluent<A>.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

public ForeachFluent<A>.PostIncrementExpressionNested<A> withNewPostIncrementExpressionLike(PostIncrement item)

withNewPreDecrementBody

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

withNewPreDecrementBodyLike

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

withNewPreDecrementExpression

public ForeachFluent<A>.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

public ForeachFluent<A>.PreDecrementExpressionNested<A> withNewPreDecrementExpressionLike(PreDecrement item)

withNewPreIncrementBody

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

withNewPreIncrementBodyLike

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

withNewPreIncrementExpression

public ForeachFluent<A>.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

public ForeachFluent<A>.PreIncrementExpressionNested<A> withNewPreIncrementExpressionLike(PreIncrement item)

withNewPropertyExpression

public ForeachFluent<A>.PropertyExpressionNested<A> withNewPropertyExpression()

withNewPropertyExpressionLike

public ForeachFluent<A>.PropertyExpressionNested<A> withNewPropertyExpressionLike(Property item)

withNewPropertyRefBody

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

withNewPropertyRefBodyLike

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

withNewPropertyRefExpression

public ForeachFluent<A>.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

public ForeachFluent<A>.PropertyRefExpressionNested<A> withNewPropertyRefExpressionLike(PropertyRef item)

withNewReturnBody

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

withNewReturnBody

public A withNewReturnBody(Object object)

withNewReturnBodyLike

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

withNewReturnDslThisStepBody

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

withNewReturnDslThisStepBodyLike

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

withNewReturnDslVariableStepBody

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

withNewReturnDslVariableStepBody

public A withNewReturnDslVariableStepBody(String name)

withNewReturnDslVariableStepBodyLike

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

withNewRightShiftBody

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

withNewRightShiftBody

public A withNewRightShiftBody(Object left,
 Object right)

withNewRightShiftBodyLike

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

withNewRightShiftExpression

public ForeachFluent<A>.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
 Object right)

withNewRightShiftExpressionLike

public ForeachFluent<A>.RightShiftExpressionNested<A> withNewRightShiftExpressionLike(RightShift item)

withNewRightUnsignedShiftBody

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

withNewRightUnsignedShiftBody

public A withNewRightUnsignedShiftBody(Object left,
 Object right)

withNewRightUnsignedShiftBodyLike

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

withNewRightUnsignedShiftExpression

public ForeachFluent<A>.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
 Object right)

withNewRightUnsignedShiftExpressionLike

public ForeachFluent<A>.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)

withNewStringStatementBody

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

withNewStringStatementBody

public A withNewStringStatementBody(String data)

withNewStringStatementBody

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

withNewStringStatementBodyLike

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

withNewSuperExpression

public ForeachFluent<A>.SuperExpressionNested<A> withNewSuperExpression()

withNewSuperExpressionLike

public ForeachFluent<A>.SuperExpressionNested<A> withNewSuperExpressionLike(Super item)

withNewSwitchBody

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

withNewSwitchBodyLike

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

withNewSynchronizedBody

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

withNewSynchronizedBodyLike

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

withNewTernaryExpression

public ForeachFluent<A>.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

public ForeachFluent<A>.TernaryExpressionNested<A> withNewTernaryExpressionLike(Ternary item)

withNewThisExpression

public ForeachFluent<A>.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

public ForeachFluent<A>.ThisExpressionNested<A> withNewThisExpressionLike(This item)

withNewThrowBody

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

withNewThrowBodyLike

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

withNewTryBody

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

withNewTryBodyLike

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

withNewValueRefExpression

public ForeachFluent<A>.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewValueRefExpressionLike

public ForeachFluent<A>.ValueRefExpressionNested<A> withNewValueRefExpressionLike(ValueRef item)

withNewWhileBody

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

withNewWhileBodyLike

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

withNewXorBody

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

withNewXorBody

public A withNewXorBody(Object left,
 Object right)

withNewXorBodyLike

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

withNewXorExpression

public ForeachFluent<A>.XorExpressionNested<A> withNewXorExpression()

withNewXorExpression

public A withNewXorExpression(Object left,
 Object right)

withNewXorExpressionLike

public ForeachFluent<A>.XorExpressionNested<A> withNewXorExpressionLike(Xor item)