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, IfFluent.ForeachStatementNested, LambdaFluent.ForeachStatementNested, 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.BinaryExpressionNested<N>
class	ForeachFluent.BitwiseAndExpressionNested<N>
class	ForeachFluent.BitwiseOrExpressionNested<N>
class	ForeachFluent.BlockBodyNested<N>
class	ForeachFluent.BreakBodyNested<N>
class	ForeachFluent.CastExpressionNested<N>
class	ForeachFluent.ConstructExpressionNested<N>
class	ForeachFluent.ContinueBodyNested<N>
class	ForeachFluent.DeclareBodyNested<N>
class	ForeachFluent.DeclareExpressionNested<N>
class	ForeachFluent.DeclareNested<N>
class	ForeachFluent.DivideExpressionNested<N>
class	ForeachFluent.DoBodyNested<N>
class	ForeachFluent.EnclosedExpressionNested<N>
class	ForeachFluent.EqualsExpressionNested<N>
class	ForeachFluent.ForBodyNested<N>
class	ForeachFluent.ForeachBodyNested<N>
class	ForeachFluent.GreaterThanExpressionNested<N>
class	ForeachFluent.GreaterThanOrEqualExpressionNested<N>
class	ForeachFluent.IfBodyNested<N>
class	ForeachFluent.IndexExpressionNested<N>
class	ForeachFluent.InstanceOfExpressionNested<N>
class	ForeachFluent.InverseExpressionNested<N>
class	ForeachFluent.LambdaBodyNested<N>
class	ForeachFluent.LambdaExpressionNested<N>
class	ForeachFluent.LeftShiftExpressionNested<N>
class	ForeachFluent.LessThanExpressionNested<N>
class	ForeachFluent.LessThanOrEqualExpressionNested<N>
class	ForeachFluent.LogicalAndExpressionNested<N>
class	ForeachFluent.LogicalOrExpressionNested<N>
class	ForeachFluent.MethodCallBodyNested<N>
class	ForeachFluent.MethodCallExpressionNested<N>
class	ForeachFluent.MinusExpressionNested<N>
class	ForeachFluent.ModuloExpressionNested<N>
class	ForeachFluent.MultiplyExpressionNested<N>
class	ForeachFluent.NegativeExpressionNested<N>
class	ForeachFluent.NewArrayExpressionNested<N>
class	ForeachFluent.NotEqualsExpressionNested<N>
class	ForeachFluent.NotExpressionNested<N>
class	ForeachFluent.PlusExpressionNested<N>
class	ForeachFluent.PositiveExpressionNested<N>
class	ForeachFluent.PostDecrementExpressionNested<N>
class	ForeachFluent.PostIncrementExpressionNested<N>
class	ForeachFluent.PreDecrementExpressionNested<N>
class	ForeachFluent.PreIncrementExpressionNested<N>
class	ForeachFluent.PropertyRefExpressionNested<N>
class	ForeachFluent.ReturnBodyNested<N>
class	ForeachFluent.RightShiftExpressionNested<N>
class	ForeachFluent.RightUnsignedShiftExpressionNested<N>
class	ForeachFluent.StringStatementBodyNested<N>
class	ForeachFluent.SwitchBodyNested<N>
class	ForeachFluent.TernaryExpressionNested<N>
class	ForeachFluent.ThisExpressionNested<N>
class	ForeachFluent.ValueRefExpressionNested<N>
class	ForeachFluent.WhileBodyNested<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.DeclareNested<A>	editDeclare()
ForeachFluent.DeclareNested<A>	editOrNewDeclare()
ForeachFluent.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.AssignBodyNested<A>	withNewAssignBody()
ForeachFluent.AssignBodyNested<A>	withNewAssignBodyLike(Assign item)
ForeachFluent.AssignExpressionNested<A>	withNewAssignExpression()
ForeachFluent.AssignExpressionNested<A>	withNewAssignExpressionLike(Assign item)
ForeachFluent.BinaryExpressionNested<A>	withNewBinaryExpression()
ForeachFluent.BinaryExpressionNested<A>	withNewBinaryExpressionLike(BinaryExpression item)
ForeachFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpression()
A	withNewBitwiseAndExpression(Object left, Object right)
ForeachFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpressionLike(BitwiseAnd item)
ForeachFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpression()
A	withNewBitwiseOrExpression(Object left, Object right)
ForeachFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpressionLike(BitwiseOr item)
ForeachFluent.BlockBodyNested<A>	withNewBlockBody()
ForeachFluent.BlockBodyNested<A>	withNewBlockBodyLike(Block item)
ForeachFluent.BreakBodyNested<A>	withNewBreakBody()
ForeachFluent.BreakBodyNested<A>	withNewBreakBodyLike(Break item)
ForeachFluent.CastExpressionNested<A>	withNewCastExpression()
ForeachFluent.CastExpressionNested<A>	withNewCastExpressionLike(Cast item)
ForeachFluent.ConstructExpressionNested<A>	withNewConstructExpression()
ForeachFluent.ConstructExpressionNested<A>	withNewConstructExpressionLike(Construct item)
ForeachFluent.ContinueBodyNested<A>	withNewContinueBody()
ForeachFluent.ContinueBodyNested<A>	withNewContinueBodyLike(Continue item)
ForeachFluent.DeclareNested<A>	withNewDeclare()
A	withNewDeclare(Class type, String name)
A	withNewDeclare(Class type, String name, Object value)
ForeachFluent.DeclareBodyNested<A>	withNewDeclareBody()
A	withNewDeclareBody(Class type, String name)
A	withNewDeclareBody(Class type, String name, Object value)
ForeachFluent.DeclareBodyNested<A>	withNewDeclareBodyLike(Declare item)
ForeachFluent.DeclareExpressionNested<A>	withNewDeclareExpression()
A	withNewDeclareExpression(Class type, String name)
A	withNewDeclareExpression(Class type, String name, Object value)
ForeachFluent.DeclareExpressionNested<A>	withNewDeclareExpressionLike(Declare item)
ForeachFluent.DeclareNested<A>	withNewDeclareLike(Declare item)
ForeachFluent.DivideExpressionNested<A>	withNewDivideExpression()
A	withNewDivideExpression(Object left, Object right)
ForeachFluent.DivideExpressionNested<A>	withNewDivideExpressionLike(Divide item)
ForeachFluent.DoBodyNested<A>	withNewDoBody()
ForeachFluent.DoBodyNested<A>	withNewDoBodyLike(Do item)
ForeachFluent.EnclosedExpressionNested<A>	withNewEnclosedExpression()
ForeachFluent.EnclosedExpressionNested<A>	withNewEnclosedExpressionLike(Enclosed item)
ForeachFluent.EqualsExpressionNested<A>	withNewEqualsExpression()
A	withNewEqualsExpression(Object left, Object right)
ForeachFluent.EqualsExpressionNested<A>	withNewEqualsExpressionLike(Equals item)
ForeachFluent.ForBodyNested<A>	withNewForBody()
ForeachFluent.ForBodyNested<A>	withNewForBodyLike(For item)
ForeachFluent.ForeachBodyNested<A>	withNewForeachBody()
ForeachFluent.ForeachBodyNested<A>	withNewForeachBodyLike(Foreach item)
ForeachFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpression()
A	withNewGreaterThanExpression(Object left, Object right)
ForeachFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpressionLike(GreaterThan item)
ForeachFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpression()
A	withNewGreaterThanOrEqualExpression(Object left, Object right)
ForeachFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
ForeachFluent.IfBodyNested<A>	withNewIfBody()
ForeachFluent.IfBodyNested<A>	withNewIfBodyLike(If item)
ForeachFluent.IndexExpressionNested<A>	withNewIndexExpression()
ForeachFluent.IndexExpressionNested<A>	withNewIndexExpressionLike(Index item)
ForeachFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpression()
ForeachFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpressionLike(InstanceOf item)
ForeachFluent.InverseExpressionNested<A>	withNewInverseExpression()
ForeachFluent.InverseExpressionNested<A>	withNewInverseExpressionLike(Inverse item)
ForeachFluent.LambdaBodyNested<A>	withNewLambdaBody()
ForeachFluent.LambdaBodyNested<A>	withNewLambdaBodyLike(Lambda item)
ForeachFluent.LambdaExpressionNested<A>	withNewLambdaExpression()
ForeachFluent.LambdaExpressionNested<A>	withNewLambdaExpressionLike(Lambda item)
ForeachFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpression()
A	withNewLeftShiftExpression(Object left, Object right)
ForeachFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpressionLike(LeftShift item)
ForeachFluent.LessThanExpressionNested<A>	withNewLessThanExpression()
A	withNewLessThanExpression(Object left, Object right)
ForeachFluent.LessThanExpressionNested<A>	withNewLessThanExpressionLike(LessThan item)
ForeachFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpression()
A	withNewLessThanOrEqualExpression(Object left, Object right)
ForeachFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
ForeachFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpression()
A	withNewLogicalAndExpression(Object left, Object right)
ForeachFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpressionLike(LogicalAnd item)
ForeachFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpression()
A	withNewLogicalOrExpression(Object left, Object right)
ForeachFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpressionLike(LogicalOr item)
ForeachFluent.MethodCallBodyNested<A>	withNewMethodCallBody()
ForeachFluent.MethodCallBodyNested<A>	withNewMethodCallBodyLike(MethodCall item)
ForeachFluent.MethodCallExpressionNested<A>	withNewMethodCallExpression()
ForeachFluent.MethodCallExpressionNested<A>	withNewMethodCallExpressionLike(MethodCall item)
ForeachFluent.MinusExpressionNested<A>	withNewMinusExpression()
A	withNewMinusExpression(Object left, Object right)
ForeachFluent.MinusExpressionNested<A>	withNewMinusExpressionLike(Minus item)
ForeachFluent.ModuloExpressionNested<A>	withNewModuloExpression()
A	withNewModuloExpression(Object left, Object right)
ForeachFluent.ModuloExpressionNested<A>	withNewModuloExpressionLike(Modulo item)
ForeachFluent.MultiplyExpressionNested<A>	withNewMultiplyExpression()
A	withNewMultiplyExpression(Object left, Object right)
ForeachFluent.MultiplyExpressionNested<A>	withNewMultiplyExpressionLike(Multiply item)
ForeachFluent.NegativeExpressionNested<A>	withNewNegativeExpression()
ForeachFluent.NegativeExpressionNested<A>	withNewNegativeExpressionLike(Negative item)
ForeachFluent.NewArrayExpressionNested<A>	withNewNewArrayExpression()
A	withNewNewArrayExpression(Class type, Integer[] sizes)
ForeachFluent.NewArrayExpressionNested<A>	withNewNewArrayExpressionLike(NewArray item)
ForeachFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpression()
A	withNewNotEqualsExpression(Object left, Object right)
ForeachFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpressionLike(NotEquals item)
ForeachFluent.NotExpressionNested<A>	withNewNotExpression()
ForeachFluent.NotExpressionNested<A>	withNewNotExpressionLike(Not item)
ForeachFluent.PlusExpressionNested<A>	withNewPlusExpression()
A	withNewPlusExpression(Object left, Object right)
ForeachFluent.PlusExpressionNested<A>	withNewPlusExpressionLike(Plus item)
ForeachFluent.PositiveExpressionNested<A>	withNewPositiveExpression()
ForeachFluent.PositiveExpressionNested<A>	withNewPositiveExpressionLike(Positive item)
ForeachFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpression()
ForeachFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpressionLike(PostDecrement item)
ForeachFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpression()
ForeachFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpressionLike(PostIncrement item)
ForeachFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpression()
ForeachFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpressionLike(PreDecrement item)
ForeachFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpression()
ForeachFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpressionLike(PreIncrement item)
ForeachFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpression()
ForeachFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpressionLike(PropertyRef item)
ForeachFluent.ReturnBodyNested<A>	withNewReturnBody()
A	withNewReturnBody(Object object)
ForeachFluent.ReturnBodyNested<A>	withNewReturnBodyLike(Return item)
ForeachFluent.RightShiftExpressionNested<A>	withNewRightShiftExpression()
A	withNewRightShiftExpression(Object left, Object right)
ForeachFluent.RightShiftExpressionNested<A>	withNewRightShiftExpressionLike(RightShift item)
ForeachFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpression()
A	withNewRightUnsignedShiftExpression(Object left, Object right)
ForeachFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
ForeachFluent.StringStatementBodyNested<A>	withNewStringStatementBody()
A	withNewStringStatementBody(String data)
A	withNewStringStatementBody(String data, Object[] parameters)
ForeachFluent.StringStatementBodyNested<A>	withNewStringStatementBodyLike(StringStatement item)
ForeachFluent.SwitchBodyNested<A>	withNewSwitchBody()
ForeachFluent.SwitchBodyNested<A>	withNewSwitchBodyLike(Switch item)
ForeachFluent.TernaryExpressionNested<A>	withNewTernaryExpression()
ForeachFluent.TernaryExpressionNested<A>	withNewTernaryExpressionLike(Ternary item)
ForeachFluent.ThisExpressionNested<A>	withNewThisExpression()
ForeachFluent.ThisExpressionNested<A>	withNewThisExpressionLike(This item)
ForeachFluent.ValueRefExpressionNested<A>	withNewValueRefExpression()
A	withNewValueRefExpression(Object value)
ForeachFluent.ValueRefExpressionNested<A>	withNewValueRefExpressionLike(ValueRef item)
ForeachFluent.WhileBodyNested<A>	withNewWhileBody()
ForeachFluent.WhileBodyNested<A>	withNewWhileBodyLike(While item)
ForeachFluent.XorExpressionNested<A>	withNewXorExpression()
A	withNewXorExpression(Object left, Object right)
ForeachFluent.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 Detail

ForeachFluent

public ForeachFluent()

ForeachFluent

public ForeachFluent(Foreach instance)

Method Detail

copyInstance

protected void copyInstance(Foreach instance)

buildDeclare

public Declare buildDeclare()

withDeclare

public A withDeclare(Declare declare)

hasDeclare

public boolean hasDeclare()

withNewDeclare

public A withNewDeclare(Class type,
                        String name)

withNewDeclare

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

withNewDeclare

public ForeachFluent.DeclareNested<A> withNewDeclare()

withNewDeclareLike

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

editDeclare

public ForeachFluent.DeclareNested<A> editDeclare()

editOrNewDeclare

public ForeachFluent.DeclareNested<A> editOrNewDeclare()

editOrNewDeclareLike

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

buildExpression

public Expression buildExpression()

withExpression

public A withExpression(Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public ForeachFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public ForeachFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public ForeachFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public ForeachFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public ForeachFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public ForeachFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public ForeachFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public ForeachFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public ForeachFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public ForeachFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public ForeachFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public ForeachFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public ForeachFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public ForeachFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public ForeachFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public ForeachFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public ForeachFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public ForeachFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

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

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
                                  String name)

withNewDeclareExpression

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

withNewCastExpression

public ForeachFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewModuloExpression

public ForeachFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public ForeachFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public ForeachFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public ForeachFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public ForeachFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public ForeachFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public ForeachFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public ForeachFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public ForeachFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public ForeachFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public ForeachFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public ForeachFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public ForeachFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public ForeachFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public ForeachFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public ForeachFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public ForeachFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public ForeachFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public ForeachFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public ForeachFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public ForeachFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public ForeachFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public ForeachFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

buildBody

public Statement buildBody()

withBody

public A withBody(Statement body)

hasBody

public boolean hasBody()

withNewMethodCallBody

public ForeachFluent.MethodCallBodyNested<A> withNewMethodCallBody()

withNewMethodCallBodyLike

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

withNewSwitchBody

public ForeachFluent.SwitchBodyNested<A> withNewSwitchBody()

withNewSwitchBodyLike

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

withNewBreakBody

public ForeachFluent.BreakBodyNested<A> withNewBreakBody()

withNewBreakBodyLike

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

withNewDeclareBody

public ForeachFluent.DeclareBodyNested<A> withNewDeclareBody()

withNewDeclareBodyLike

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

withNewDeclareBody

public A withNewDeclareBody(Class type,
                            String name)

withNewDeclareBody

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

withNewWhileBody

public ForeachFluent.WhileBodyNested<A> withNewWhileBody()

withNewWhileBodyLike

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

withNewContinueBody

public ForeachFluent.ContinueBodyNested<A> withNewContinueBody()

withNewContinueBodyLike

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

withNewStringStatementBody

public ForeachFluent.StringStatementBodyNested<A> withNewStringStatementBody()

withNewStringStatementBodyLike

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

withNewStringStatementBody

public A withNewStringStatementBody(String data)

withNewStringStatementBody

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

withNewDoBody

public ForeachFluent.DoBodyNested<A> withNewDoBody()

withNewDoBodyLike

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

withNewForeachBody

public ForeachFluent.ForeachBodyNested<A> withNewForeachBody()

withNewForeachBodyLike

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

withNewBlockBody

public ForeachFluent.BlockBodyNested<A> withNewBlockBody()

withNewBlockBodyLike

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

withNewIfBody

public ForeachFluent.IfBodyNested<A> withNewIfBody()

withNewIfBodyLike

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

withNewLambdaBody

public ForeachFluent.LambdaBodyNested<A> withNewLambdaBody()

withNewLambdaBodyLike

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

withNewReturnBody

public ForeachFluent.ReturnBodyNested<A> withNewReturnBody()

withNewReturnBodyLike

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

withNewReturnBody

public A withNewReturnBody(Object object)

withNewAssignBody

public ForeachFluent.AssignBodyNested<A> withNewAssignBody()

withNewAssignBodyLike

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

withNewForBody

public ForeachFluent.ForBodyNested<A> withNewForBody()

withNewForBodyLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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