Package io.sundr.model

Class WhileFluent<A extends WhileFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.WhileFluent<A>

Direct Known Subclasses:

BlockFluent.WhileStatementsNested, DoFluent.WhileStatementNested, ForeachFluent.WhileBodyNested, ForFluent.WhileBodyNested, IfDslThenStepFluent.WhileStatementsNested, IfFluent.WhileElseStatementNested, IfFluent.WhileStatementNested, LambdaFluent.WhileStatementNested, SynchronizedFluent.WhileBodyNested, WhileBuilder, WhileFluent.WhileStatementNested

public class WhileFluent<A extends WhileFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	WhileFluent.AssignConditionNested<N>
class	WhileFluent.AssignStatementNested<N>
class	WhileFluent.BinaryExpressionConditionNested<N>
class	WhileFluent.BinaryExpressionStatementNested<N>
class	WhileFluent.BitwiseAndConditionNested<N>
class	WhileFluent.BitwiseAndStatementNested<N>
class	WhileFluent.BitwiseOrConditionNested<N>
class	WhileFluent.BitwiseOrStatementNested<N>
class	WhileFluent.BlockStatementNested<N>
class	WhileFluent.BreakStatementNested<N>
class	WhileFluent.CastConditionNested<N>
class	WhileFluent.ClassRefConditionNested<N>
class	WhileFluent.ConstructConditionNested<N>
class	WhileFluent.ConstructStatementNested<N>
class	WhileFluent.ContextRefConditionNested<N>
class	WhileFluent.ContinueStatementNested<N>
class	WhileFluent.DeclareConditionNested<N>
class	WhileFluent.DeclareStatementNested<N>
class	WhileFluent.DivideConditionNested<N>
class	WhileFluent.DivideStatementNested<N>
class	WhileFluent.DoStatementNested<N>
class	WhileFluent.DotClassConditionNested<N>
class	WhileFluent.EmptyConditionNested<N>
class	WhileFluent.EmptyStatementNested<N>
class	WhileFluent.EnclosedConditionNested<N>
class	WhileFluent.EqualsConditionNested<N>
class	WhileFluent.EqualsStatementNested<N>
class	WhileFluent.ForeachStatementNested<N>
class	WhileFluent.ForStatementNested<N>
class	WhileFluent.GreaterThanConditionNested<N>
class	WhileFluent.GreaterThanOrEqualConditionNested<N>
class	WhileFluent.GreaterThanOrEqualStatementNested<N>
class	WhileFluent.GreaterThanStatementNested<N>
class	WhileFluent.IfDslThenStepStatementNested<N>
class	WhileFluent.IfStatementNested<N>
class	WhileFluent.IndexConditionNested<N>
class	WhileFluent.InstanceOfConditionNested<N>
class	WhileFluent.InverseConditionNested<N>
class	WhileFluent.LambdaConditionNested<N>
class	WhileFluent.LambdaStatementNested<N>
class	WhileFluent.LeftShiftConditionNested<N>
class	WhileFluent.LeftShiftStatementNested<N>
class	WhileFluent.LessThanConditionNested<N>
class	WhileFluent.LessThanOrEqualConditionNested<N>
class	WhileFluent.LessThanOrEqualStatementNested<N>
class	WhileFluent.LessThanStatementNested<N>
class	WhileFluent.LogicalAndConditionNested<N>
class	WhileFluent.LogicalAndStatementNested<N>
class	WhileFluent.LogicalOrConditionNested<N>
class	WhileFluent.LogicalOrStatementNested<N>
class	WhileFluent.MethodCallConditionNested<N>
class	WhileFluent.MethodCallStatementNested<N>
class	WhileFluent.MinusConditionNested<N>
class	WhileFluent.MinusStatementNested<N>
class	WhileFluent.ModuloConditionNested<N>
class	WhileFluent.ModuloStatementNested<N>
class	WhileFluent.MultiplyConditionNested<N>
class	WhileFluent.MultiplyStatementNested<N>
class	WhileFluent.NegativeConditionNested<N>
class	WhileFluent.NewArrayConditionNested<N>
class	WhileFluent.NotConditionNested<N>
class	WhileFluent.NotEqualsConditionNested<N>
class	WhileFluent.NotEqualsStatementNested<N>
class	WhileFluent.PlusConditionNested<N>
class	WhileFluent.PlusStatementNested<N>
class	WhileFluent.PositiveConditionNested<N>
class	WhileFluent.PostDecrementConditionNested<N>
class	WhileFluent.PostDecrementStatementNested<N>
class	WhileFluent.PostIncrementConditionNested<N>
class	WhileFluent.PostIncrementStatementNested<N>
class	WhileFluent.PreDecrementConditionNested<N>
class	WhileFluent.PreDecrementStatementNested<N>
class	WhileFluent.PreIncrementConditionNested<N>
class	WhileFluent.PreIncrementStatementNested<N>
class	WhileFluent.PropertyConditionNested<N>
class	WhileFluent.PropertyRefConditionNested<N>
class	WhileFluent.PropertyRefStatementNested<N>
class	WhileFluent.ReturnDslThisStepStatementNested<N>
class	WhileFluent.ReturnDslVariableStepStatementNested<N>
class	WhileFluent.ReturnStatementNested<N>
class	WhileFluent.RightShiftConditionNested<N>
class	WhileFluent.RightShiftStatementNested<N>
class	WhileFluent.RightUnsignedShiftConditionNested<N>
class	WhileFluent.RightUnsignedShiftStatementNested<N>
class	WhileFluent.StringStatementNested<N>
class	WhileFluent.SuperConditionNested<N>
class	WhileFluent.SwitchStatementNested<N>
class	WhileFluent.SynchronizedStatementNested<N>
class	WhileFluent.TernaryConditionNested<N>
class	WhileFluent.ThisConditionNested<N>
class	WhileFluent.ThrowStatementNested<N>
class	WhileFluent.TryStatementNested<N>
class	WhileFluent.ValueRefConditionNested<N>
class	WhileFluent.WhileStatementNested<N>
class	WhileFluent.XorConditionNested<N>
class	WhileFluent.XorStatementNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
WhileFluent()
WhileFluent(While instance)

Method Summary

Modifier and Type	Method	Description
Expression	buildCondition()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Statement	buildStatement()
protected void	copyInstance(While instance)
boolean	equals(Object o)
boolean	hasCondition()
int	hashCode()
boolean	hasStatement()
String	toString()
A	withCondition(Expression condition)
WhileFluent<A>.AssignConditionNested<A>	withNewAssignCondition()
WhileFluent<A>.AssignConditionNested<A>	withNewAssignConditionLike(Assign item)
WhileFluent<A>.AssignStatementNested<A>	withNewAssignStatement()
WhileFluent<A>.AssignStatementNested<A>	withNewAssignStatementLike(Assign item)
WhileFluent<A>.BinaryExpressionConditionNested<A>	withNewBinaryExpressionCondition()
WhileFluent<A>.BinaryExpressionConditionNested<A>	withNewBinaryExpressionConditionLike(BinaryExpression item)
WhileFluent<A>.BinaryExpressionStatementNested<A>	withNewBinaryExpressionStatement()
WhileFluent<A>.BinaryExpressionStatementNested<A>	withNewBinaryExpressionStatementLike(BinaryExpression item)
WhileFluent<A>.BitwiseAndConditionNested<A>	withNewBitwiseAndCondition()
A	withNewBitwiseAndCondition(Object left, Object right)
WhileFluent<A>.BitwiseAndConditionNested<A>	withNewBitwiseAndConditionLike(BitwiseAnd item)
WhileFluent<A>.BitwiseAndStatementNested<A>	withNewBitwiseAndStatement()
A	withNewBitwiseAndStatement(Object left, Object right)
WhileFluent<A>.BitwiseAndStatementNested<A>	withNewBitwiseAndStatementLike(BitwiseAnd item)
WhileFluent<A>.BitwiseOrConditionNested<A>	withNewBitwiseOrCondition()
A	withNewBitwiseOrCondition(Object left, Object right)
WhileFluent<A>.BitwiseOrConditionNested<A>	withNewBitwiseOrConditionLike(BitwiseOr item)
WhileFluent<A>.BitwiseOrStatementNested<A>	withNewBitwiseOrStatement()
A	withNewBitwiseOrStatement(Object left, Object right)
WhileFluent<A>.BitwiseOrStatementNested<A>	withNewBitwiseOrStatementLike(BitwiseOr item)
WhileFluent<A>.BlockStatementNested<A>	withNewBlockStatement()
WhileFluent<A>.BlockStatementNested<A>	withNewBlockStatementLike(Block item)
WhileFluent<A>.BreakStatementNested<A>	withNewBreakStatement()
WhileFluent<A>.BreakStatementNested<A>	withNewBreakStatementLike(Break item)
WhileFluent<A>.CastConditionNested<A>	withNewCastCondition()
WhileFluent<A>.CastConditionNested<A>	withNewCastConditionLike(Cast item)
WhileFluent<A>.ClassRefConditionNested<A>	withNewClassRefCondition()
WhileFluent<A>.ClassRefConditionNested<A>	withNewClassRefConditionLike(ClassRef item)
WhileFluent<A>.ConstructConditionNested<A>	withNewConstructCondition()
WhileFluent<A>.ConstructConditionNested<A>	withNewConstructConditionLike(Construct item)
WhileFluent<A>.ConstructStatementNested<A>	withNewConstructStatement()
WhileFluent<A>.ConstructStatementNested<A>	withNewConstructStatementLike(Construct item)
WhileFluent<A>.ContextRefConditionNested<A>	withNewContextRefCondition()
A	withNewContextRefCondition(String name)
WhileFluent<A>.ContextRefConditionNested<A>	withNewContextRefConditionLike(ContextRef item)
WhileFluent<A>.ContinueStatementNested<A>	withNewContinueStatement()
WhileFluent<A>.ContinueStatementNested<A>	withNewContinueStatementLike(Continue item)
WhileFluent<A>.DeclareConditionNested<A>	withNewDeclareCondition()
A	withNewDeclareCondition(Class type, String name)
A	withNewDeclareCondition(Class type, String name, Object value)
WhileFluent<A>.DeclareConditionNested<A>	withNewDeclareConditionLike(Declare item)
WhileFluent<A>.DeclareStatementNested<A>	withNewDeclareStatement()
A	withNewDeclareStatement(Class type, String name)
A	withNewDeclareStatement(Class type, String name, Object value)
WhileFluent<A>.DeclareStatementNested<A>	withNewDeclareStatementLike(Declare item)
WhileFluent<A>.DivideConditionNested<A>	withNewDivideCondition()
A	withNewDivideCondition(Object left, Object right)
WhileFluent<A>.DivideConditionNested<A>	withNewDivideConditionLike(Divide item)
WhileFluent<A>.DivideStatementNested<A>	withNewDivideStatement()
A	withNewDivideStatement(Object left, Object right)
WhileFluent<A>.DivideStatementNested<A>	withNewDivideStatementLike(Divide item)
WhileFluent<A>.DoStatementNested<A>	withNewDoStatement()
WhileFluent<A>.DoStatementNested<A>	withNewDoStatementLike(Do item)
WhileFluent<A>.DotClassConditionNested<A>	withNewDotClassCondition()
WhileFluent<A>.DotClassConditionNested<A>	withNewDotClassConditionLike(DotClass item)
WhileFluent<A>.EmptyConditionNested<A>	withNewEmptyCondition()
WhileFluent<A>.EmptyConditionNested<A>	withNewEmptyConditionLike(Empty item)
WhileFluent<A>.EmptyStatementNested<A>	withNewEmptyStatement()
WhileFluent<A>.EmptyStatementNested<A>	withNewEmptyStatementLike(Empty item)
WhileFluent<A>.EnclosedConditionNested<A>	withNewEnclosedCondition()
WhileFluent<A>.EnclosedConditionNested<A>	withNewEnclosedConditionLike(Enclosed item)
WhileFluent<A>.EqualsConditionNested<A>	withNewEqualsCondition()
A	withNewEqualsCondition(Object left, Object right)
WhileFluent<A>.EqualsConditionNested<A>	withNewEqualsConditionLike(Equals item)
WhileFluent<A>.EqualsStatementNested<A>	withNewEqualsStatement()
A	withNewEqualsStatement(Object left, Object right)
WhileFluent<A>.EqualsStatementNested<A>	withNewEqualsStatementLike(Equals item)
WhileFluent<A>.ForeachStatementNested<A>	withNewForeachStatement()
WhileFluent<A>.ForeachStatementNested<A>	withNewForeachStatementLike(Foreach item)
WhileFluent<A>.ForStatementNested<A>	withNewForStatement()
WhileFluent<A>.ForStatementNested<A>	withNewForStatementLike(For item)
WhileFluent<A>.GreaterThanConditionNested<A>	withNewGreaterThanCondition()
A	withNewGreaterThanCondition(Object left, Object right)
WhileFluent<A>.GreaterThanConditionNested<A>	withNewGreaterThanConditionLike(GreaterThan item)
WhileFluent<A>.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualCondition()
A	withNewGreaterThanOrEqualCondition(Object left, Object right)
WhileFluent<A>.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualConditionLike(GreaterThanOrEqual item)
WhileFluent<A>.GreaterThanOrEqualStatementNested<A>	withNewGreaterThanOrEqualStatement()
A	withNewGreaterThanOrEqualStatement(Object left, Object right)
WhileFluent<A>.GreaterThanOrEqualStatementNested<A>	withNewGreaterThanOrEqualStatementLike(GreaterThanOrEqual item)
WhileFluent<A>.GreaterThanStatementNested<A>	withNewGreaterThanStatement()
A	withNewGreaterThanStatement(Object left, Object right)
WhileFluent<A>.GreaterThanStatementNested<A>	withNewGreaterThanStatementLike(GreaterThan item)
WhileFluent<A>.IfDslThenStepStatementNested<A>	withNewIfDslThenStepStatement()
WhileFluent<A>.IfDslThenStepStatementNested<A>	withNewIfDslThenStepStatementLike(IfDslThenStep item)
WhileFluent<A>.IfStatementNested<A>	withNewIfStatement()
WhileFluent<A>.IfStatementNested<A>	withNewIfStatementLike(If item)
WhileFluent<A>.IndexConditionNested<A>	withNewIndexCondition()
WhileFluent<A>.IndexConditionNested<A>	withNewIndexConditionLike(Index item)
WhileFluent<A>.InstanceOfConditionNested<A>	withNewInstanceOfCondition()
WhileFluent<A>.InstanceOfConditionNested<A>	withNewInstanceOfConditionLike(InstanceOf item)
WhileFluent<A>.InverseConditionNested<A>	withNewInverseCondition()
WhileFluent<A>.InverseConditionNested<A>	withNewInverseConditionLike(Inverse item)
WhileFluent<A>.LambdaConditionNested<A>	withNewLambdaCondition()
WhileFluent<A>.LambdaConditionNested<A>	withNewLambdaConditionLike(Lambda item)
WhileFluent<A>.LambdaStatementNested<A>	withNewLambdaStatement()
WhileFluent<A>.LambdaStatementNested<A>	withNewLambdaStatementLike(Lambda item)
WhileFluent<A>.LeftShiftConditionNested<A>	withNewLeftShiftCondition()
A	withNewLeftShiftCondition(Object left, Object right)
WhileFluent<A>.LeftShiftConditionNested<A>	withNewLeftShiftConditionLike(LeftShift item)
WhileFluent<A>.LeftShiftStatementNested<A>	withNewLeftShiftStatement()
A	withNewLeftShiftStatement(Object left, Object right)
WhileFluent<A>.LeftShiftStatementNested<A>	withNewLeftShiftStatementLike(LeftShift item)
WhileFluent<A>.LessThanConditionNested<A>	withNewLessThanCondition()
A	withNewLessThanCondition(Object left, Object right)
WhileFluent<A>.LessThanConditionNested<A>	withNewLessThanConditionLike(LessThan item)
WhileFluent<A>.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualCondition()
A	withNewLessThanOrEqualCondition(Object left, Object right)
WhileFluent<A>.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualConditionLike(LessThanOrEqual item)
WhileFluent<A>.LessThanOrEqualStatementNested<A>	withNewLessThanOrEqualStatement()
A	withNewLessThanOrEqualStatement(Object left, Object right)
WhileFluent<A>.LessThanOrEqualStatementNested<A>	withNewLessThanOrEqualStatementLike(LessThanOrEqual item)
WhileFluent<A>.LessThanStatementNested<A>	withNewLessThanStatement()
A	withNewLessThanStatement(Object left, Object right)
WhileFluent<A>.LessThanStatementNested<A>	withNewLessThanStatementLike(LessThan item)
WhileFluent<A>.LogicalAndConditionNested<A>	withNewLogicalAndCondition()
A	withNewLogicalAndCondition(Object left, Object right)
WhileFluent<A>.LogicalAndConditionNested<A>	withNewLogicalAndConditionLike(LogicalAnd item)
WhileFluent<A>.LogicalAndStatementNested<A>	withNewLogicalAndStatement()
A	withNewLogicalAndStatement(Object left, Object right)
WhileFluent<A>.LogicalAndStatementNested<A>	withNewLogicalAndStatementLike(LogicalAnd item)
WhileFluent<A>.LogicalOrConditionNested<A>	withNewLogicalOrCondition()
A	withNewLogicalOrCondition(Object left, Object right)
WhileFluent<A>.LogicalOrConditionNested<A>	withNewLogicalOrConditionLike(LogicalOr item)
WhileFluent<A>.LogicalOrStatementNested<A>	withNewLogicalOrStatement()
A	withNewLogicalOrStatement(Object left, Object right)
WhileFluent<A>.LogicalOrStatementNested<A>	withNewLogicalOrStatementLike(LogicalOr item)
WhileFluent<A>.MethodCallConditionNested<A>	withNewMethodCallCondition()
WhileFluent<A>.MethodCallConditionNested<A>	withNewMethodCallConditionLike(MethodCall item)
WhileFluent<A>.MethodCallStatementNested<A>	withNewMethodCallStatement()
WhileFluent<A>.MethodCallStatementNested<A>	withNewMethodCallStatementLike(MethodCall item)
WhileFluent<A>.MinusConditionNested<A>	withNewMinusCondition()
A	withNewMinusCondition(Object left, Object right)
WhileFluent<A>.MinusConditionNested<A>	withNewMinusConditionLike(Minus item)
WhileFluent<A>.MinusStatementNested<A>	withNewMinusStatement()
A	withNewMinusStatement(Object left, Object right)
WhileFluent<A>.MinusStatementNested<A>	withNewMinusStatementLike(Minus item)
WhileFluent<A>.ModuloConditionNested<A>	withNewModuloCondition()
A	withNewModuloCondition(Object left, Object right)
WhileFluent<A>.ModuloConditionNested<A>	withNewModuloConditionLike(Modulo item)
WhileFluent<A>.ModuloStatementNested<A>	withNewModuloStatement()
A	withNewModuloStatement(Object left, Object right)
WhileFluent<A>.ModuloStatementNested<A>	withNewModuloStatementLike(Modulo item)
WhileFluent<A>.MultiplyConditionNested<A>	withNewMultiplyCondition()
A	withNewMultiplyCondition(Object left, Object right)
WhileFluent<A>.MultiplyConditionNested<A>	withNewMultiplyConditionLike(Multiply item)
WhileFluent<A>.MultiplyStatementNested<A>	withNewMultiplyStatement()
A	withNewMultiplyStatement(Object left, Object right)
WhileFluent<A>.MultiplyStatementNested<A>	withNewMultiplyStatementLike(Multiply item)
WhileFluent<A>.NegativeConditionNested<A>	withNewNegativeCondition()
WhileFluent<A>.NegativeConditionNested<A>	withNewNegativeConditionLike(Negative item)
WhileFluent<A>.NewArrayConditionNested<A>	withNewNewArrayCondition()
A	withNewNewArrayCondition(Class type, Integer[] sizes)
WhileFluent<A>.NewArrayConditionNested<A>	withNewNewArrayConditionLike(NewArray item)
WhileFluent<A>.NotConditionNested<A>	withNewNotCondition()
WhileFluent<A>.NotConditionNested<A>	withNewNotConditionLike(Not item)
WhileFluent<A>.NotEqualsConditionNested<A>	withNewNotEqualsCondition()
A	withNewNotEqualsCondition(Object left, Object right)
WhileFluent<A>.NotEqualsConditionNested<A>	withNewNotEqualsConditionLike(NotEquals item)
WhileFluent<A>.NotEqualsStatementNested<A>	withNewNotEqualsStatement()
A	withNewNotEqualsStatement(Object left, Object right)
WhileFluent<A>.NotEqualsStatementNested<A>	withNewNotEqualsStatementLike(NotEquals item)
WhileFluent<A>.PlusConditionNested<A>	withNewPlusCondition()
A	withNewPlusCondition(Object left, Object right)
WhileFluent<A>.PlusConditionNested<A>	withNewPlusConditionLike(Plus item)
WhileFluent<A>.PlusStatementNested<A>	withNewPlusStatement()
A	withNewPlusStatement(Object left, Object right)
WhileFluent<A>.PlusStatementNested<A>	withNewPlusStatementLike(Plus item)
WhileFluent<A>.PositiveConditionNested<A>	withNewPositiveCondition()
WhileFluent<A>.PositiveConditionNested<A>	withNewPositiveConditionLike(Positive item)
WhileFluent<A>.PostDecrementConditionNested<A>	withNewPostDecrementCondition()
WhileFluent<A>.PostDecrementConditionNested<A>	withNewPostDecrementConditionLike(PostDecrement item)
WhileFluent<A>.PostDecrementStatementNested<A>	withNewPostDecrementStatement()
WhileFluent<A>.PostDecrementStatementNested<A>	withNewPostDecrementStatementLike(PostDecrement item)
WhileFluent<A>.PostIncrementConditionNested<A>	withNewPostIncrementCondition()
WhileFluent<A>.PostIncrementConditionNested<A>	withNewPostIncrementConditionLike(PostIncrement item)
WhileFluent<A>.PostIncrementStatementNested<A>	withNewPostIncrementStatement()
WhileFluent<A>.PostIncrementStatementNested<A>	withNewPostIncrementStatementLike(PostIncrement item)
WhileFluent<A>.PreDecrementConditionNested<A>	withNewPreDecrementCondition()
WhileFluent<A>.PreDecrementConditionNested<A>	withNewPreDecrementConditionLike(PreDecrement item)
WhileFluent<A>.PreDecrementStatementNested<A>	withNewPreDecrementStatement()
WhileFluent<A>.PreDecrementStatementNested<A>	withNewPreDecrementStatementLike(PreDecrement item)
WhileFluent<A>.PreIncrementConditionNested<A>	withNewPreIncrementCondition()
WhileFluent<A>.PreIncrementConditionNested<A>	withNewPreIncrementConditionLike(PreIncrement item)
WhileFluent<A>.PreIncrementStatementNested<A>	withNewPreIncrementStatement()
WhileFluent<A>.PreIncrementStatementNested<A>	withNewPreIncrementStatementLike(PreIncrement item)
WhileFluent<A>.PropertyConditionNested<A>	withNewPropertyCondition()
WhileFluent<A>.PropertyConditionNested<A>	withNewPropertyConditionLike(Property item)
WhileFluent<A>.PropertyRefConditionNested<A>	withNewPropertyRefCondition()
WhileFluent<A>.PropertyRefConditionNested<A>	withNewPropertyRefConditionLike(PropertyRef item)
WhileFluent<A>.PropertyRefStatementNested<A>	withNewPropertyRefStatement()
WhileFluent<A>.PropertyRefStatementNested<A>	withNewPropertyRefStatementLike(PropertyRef item)
WhileFluent<A>.ReturnDslThisStepStatementNested<A>	withNewReturnDslThisStepStatement()
WhileFluent<A>.ReturnDslThisStepStatementNested<A>	withNewReturnDslThisStepStatementLike(ReturnDslThisStep item)
WhileFluent<A>.ReturnDslVariableStepStatementNested<A>	withNewReturnDslVariableStepStatement()
A	withNewReturnDslVariableStepStatement(String name)
WhileFluent<A>.ReturnDslVariableStepStatementNested<A>	withNewReturnDslVariableStepStatementLike(ReturnDslVariableStep item)
WhileFluent<A>.ReturnStatementNested<A>	withNewReturnStatement()
A	withNewReturnStatement(Object object)
WhileFluent<A>.ReturnStatementNested<A>	withNewReturnStatementLike(Return item)
WhileFluent<A>.RightShiftConditionNested<A>	withNewRightShiftCondition()
A	withNewRightShiftCondition(Object left, Object right)
WhileFluent<A>.RightShiftConditionNested<A>	withNewRightShiftConditionLike(RightShift item)
WhileFluent<A>.RightShiftStatementNested<A>	withNewRightShiftStatement()
A	withNewRightShiftStatement(Object left, Object right)
WhileFluent<A>.RightShiftStatementNested<A>	withNewRightShiftStatementLike(RightShift item)
WhileFluent<A>.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftCondition()
A	withNewRightUnsignedShiftCondition(Object left, Object right)
WhileFluent<A>.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftConditionLike(RightUnsignedShift item)
WhileFluent<A>.RightUnsignedShiftStatementNested<A>	withNewRightUnsignedShiftStatement()
A	withNewRightUnsignedShiftStatement(Object left, Object right)
WhileFluent<A>.RightUnsignedShiftStatementNested<A>	withNewRightUnsignedShiftStatementLike(RightUnsignedShift item)
WhileFluent<A>.StringStatementNested<A>	withNewStringStatement()
A	withNewStringStatement(String data)
A	withNewStringStatement(String data, Object[] parameters)
WhileFluent<A>.StringStatementNested<A>	withNewStringStatementLike(StringStatement item)
WhileFluent<A>.SuperConditionNested<A>	withNewSuperCondition()
WhileFluent<A>.SuperConditionNested<A>	withNewSuperConditionLike(Super item)
WhileFluent<A>.SwitchStatementNested<A>	withNewSwitchStatement()
WhileFluent<A>.SwitchStatementNested<A>	withNewSwitchStatementLike(Switch item)
WhileFluent<A>.SynchronizedStatementNested<A>	withNewSynchronizedStatement()
WhileFluent<A>.SynchronizedStatementNested<A>	withNewSynchronizedStatementLike(Synchronized item)
WhileFluent<A>.TernaryConditionNested<A>	withNewTernaryCondition()
WhileFluent<A>.TernaryConditionNested<A>	withNewTernaryConditionLike(Ternary item)
WhileFluent<A>.ThisConditionNested<A>	withNewThisCondition()
WhileFluent<A>.ThisConditionNested<A>	withNewThisConditionLike(This item)
WhileFluent<A>.ThrowStatementNested<A>	withNewThrowStatement()
WhileFluent<A>.ThrowStatementNested<A>	withNewThrowStatementLike(Throw item)
WhileFluent<A>.TryStatementNested<A>	withNewTryStatement()
WhileFluent<A>.TryStatementNested<A>	withNewTryStatementLike(Try item)
WhileFluent<A>.ValueRefConditionNested<A>	withNewValueRefCondition()
A	withNewValueRefCondition(Object value)
WhileFluent<A>.ValueRefConditionNested<A>	withNewValueRefConditionLike(ValueRef item)
WhileFluent<A>.WhileStatementNested<A>	withNewWhileStatement()
WhileFluent<A>.WhileStatementNested<A>	withNewWhileStatementLike(While item)
WhileFluent<A>.XorConditionNested<A>	withNewXorCondition()
A	withNewXorCondition(Object left, Object right)
WhileFluent<A>.XorConditionNested<A>	withNewXorConditionLike(Xor item)
WhileFluent<A>.XorStatementNested<A>	withNewXorStatement()
A	withNewXorStatement(Object left, Object right)
WhileFluent<A>.XorStatementNested<A>	withNewXorStatementLike(Xor item)
A	withStatement(Statement statement)

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

WhileFluent

public WhileFluent()

WhileFluent

public WhileFluent(While instance)

Method Details

buildCondition

public Expression buildCondition()

buildStatement

public Statement buildStatement()

builder

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

copyInstance

protected void copyInstance(While instance)

equals

public boolean equals(Object o)

Overrides:

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

hasCondition

public boolean hasCondition()

hasStatement

public boolean hasStatement()

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

withCondition

public A withCondition(Expression condition)

withNewAssignCondition

public WhileFluent<A>.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

public WhileFluent<A>.AssignConditionNested<A> withNewAssignConditionLike(Assign item)

withNewAssignStatement

public WhileFluent<A>.AssignStatementNested<A> withNewAssignStatement()

withNewAssignStatementLike

public WhileFluent<A>.AssignStatementNested<A> withNewAssignStatementLike(Assign item)

withNewBinaryExpressionCondition

public WhileFluent<A>.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

public WhileFluent<A>.BinaryExpressionConditionNested<A> withNewBinaryExpressionConditionLike(BinaryExpression item)

withNewBinaryExpressionStatement

public WhileFluent<A>.BinaryExpressionStatementNested<A> withNewBinaryExpressionStatement()

withNewBinaryExpressionStatementLike

public WhileFluent<A>.BinaryExpressionStatementNested<A> withNewBinaryExpressionStatementLike(BinaryExpression item)

withNewBitwiseAndCondition

public WhileFluent<A>.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
 Object right)

withNewBitwiseAndConditionLike

public WhileFluent<A>.BitwiseAndConditionNested<A> withNewBitwiseAndConditionLike(BitwiseAnd item)

withNewBitwiseAndStatement

public WhileFluent<A>.BitwiseAndStatementNested<A> withNewBitwiseAndStatement()

withNewBitwiseAndStatement

public A withNewBitwiseAndStatement(Object left,
 Object right)

withNewBitwiseAndStatementLike

public WhileFluent<A>.BitwiseAndStatementNested<A> withNewBitwiseAndStatementLike(BitwiseAnd item)

withNewBitwiseOrCondition

public WhileFluent<A>.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
 Object right)

withNewBitwiseOrConditionLike

public WhileFluent<A>.BitwiseOrConditionNested<A> withNewBitwiseOrConditionLike(BitwiseOr item)

withNewBitwiseOrStatement

public WhileFluent<A>.BitwiseOrStatementNested<A> withNewBitwiseOrStatement()

withNewBitwiseOrStatement

public A withNewBitwiseOrStatement(Object left,
 Object right)

withNewBitwiseOrStatementLike

public WhileFluent<A>.BitwiseOrStatementNested<A> withNewBitwiseOrStatementLike(BitwiseOr item)

withNewBlockStatement

public WhileFluent<A>.BlockStatementNested<A> withNewBlockStatement()

withNewBlockStatementLike

public WhileFluent<A>.BlockStatementNested<A> withNewBlockStatementLike(Block item)

withNewBreakStatement

public WhileFluent<A>.BreakStatementNested<A> withNewBreakStatement()

withNewBreakStatementLike

public WhileFluent<A>.BreakStatementNested<A> withNewBreakStatementLike(Break item)

withNewCastCondition

public WhileFluent<A>.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

public WhileFluent<A>.CastConditionNested<A> withNewCastConditionLike(Cast item)

withNewClassRefCondition

public WhileFluent<A>.ClassRefConditionNested<A> withNewClassRefCondition()

withNewClassRefConditionLike

public WhileFluent<A>.ClassRefConditionNested<A> withNewClassRefConditionLike(ClassRef item)

withNewConstructCondition

public WhileFluent<A>.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

public WhileFluent<A>.ConstructConditionNested<A> withNewConstructConditionLike(Construct item)

withNewConstructStatement

public WhileFluent<A>.ConstructStatementNested<A> withNewConstructStatement()

withNewConstructStatementLike

public WhileFluent<A>.ConstructStatementNested<A> withNewConstructStatementLike(Construct item)

withNewContextRefCondition

public WhileFluent<A>.ContextRefConditionNested<A> withNewContextRefCondition()

withNewContextRefCondition

public A withNewContextRefCondition(String name)

withNewContextRefConditionLike

public WhileFluent<A>.ContextRefConditionNested<A> withNewContextRefConditionLike(ContextRef item)

withNewContinueStatement

public WhileFluent<A>.ContinueStatementNested<A> withNewContinueStatement()

withNewContinueStatementLike

public WhileFluent<A>.ContinueStatementNested<A> withNewContinueStatementLike(Continue item)

withNewDeclareCondition

public WhileFluent<A>.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
 String name)

withNewDeclareCondition

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

withNewDeclareConditionLike

public WhileFluent<A>.DeclareConditionNested<A> withNewDeclareConditionLike(Declare item)

withNewDeclareStatement

public WhileFluent<A>.DeclareStatementNested<A> withNewDeclareStatement()

withNewDeclareStatement

public A withNewDeclareStatement(Class type,
 String name)

withNewDeclareStatement

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

withNewDeclareStatementLike

public WhileFluent<A>.DeclareStatementNested<A> withNewDeclareStatementLike(Declare item)

withNewDivideCondition

public WhileFluent<A>.DivideConditionNested<A> withNewDivideCondition()

withNewDivideCondition

public A withNewDivideCondition(Object left,
 Object right)

withNewDivideConditionLike

public WhileFluent<A>.DivideConditionNested<A> withNewDivideConditionLike(Divide item)

withNewDivideStatement

public WhileFluent<A>.DivideStatementNested<A> withNewDivideStatement()

withNewDivideStatement

public A withNewDivideStatement(Object left,
 Object right)

withNewDivideStatementLike

public WhileFluent<A>.DivideStatementNested<A> withNewDivideStatementLike(Divide item)

withNewDoStatement

public WhileFluent<A>.DoStatementNested<A> withNewDoStatement()

withNewDoStatementLike

public WhileFluent<A>.DoStatementNested<A> withNewDoStatementLike(Do item)

withNewDotClassCondition

public WhileFluent<A>.DotClassConditionNested<A> withNewDotClassCondition()

withNewDotClassConditionLike

public WhileFluent<A>.DotClassConditionNested<A> withNewDotClassConditionLike(DotClass item)

withNewEmptyCondition

public WhileFluent<A>.EmptyConditionNested<A> withNewEmptyCondition()

withNewEmptyConditionLike

public WhileFluent<A>.EmptyConditionNested<A> withNewEmptyConditionLike(Empty item)

withNewEmptyStatement

public WhileFluent<A>.EmptyStatementNested<A> withNewEmptyStatement()

withNewEmptyStatementLike

public WhileFluent<A>.EmptyStatementNested<A> withNewEmptyStatementLike(Empty item)

withNewEnclosedCondition

public WhileFluent<A>.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

public WhileFluent<A>.EnclosedConditionNested<A> withNewEnclosedConditionLike(Enclosed item)

withNewEqualsCondition

public WhileFluent<A>.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
 Object right)

withNewEqualsConditionLike

public WhileFluent<A>.EqualsConditionNested<A> withNewEqualsConditionLike(Equals item)

withNewEqualsStatement

public WhileFluent<A>.EqualsStatementNested<A> withNewEqualsStatement()

withNewEqualsStatement

public A withNewEqualsStatement(Object left,
 Object right)

withNewEqualsStatementLike

public WhileFluent<A>.EqualsStatementNested<A> withNewEqualsStatementLike(Equals item)

withNewForStatement

public WhileFluent<A>.ForStatementNested<A> withNewForStatement()

withNewForStatementLike

public WhileFluent<A>.ForStatementNested<A> withNewForStatementLike(For item)

withNewForeachStatement

public WhileFluent<A>.ForeachStatementNested<A> withNewForeachStatement()

withNewForeachStatementLike

public WhileFluent<A>.ForeachStatementNested<A> withNewForeachStatementLike(Foreach item)

withNewGreaterThanCondition

public WhileFluent<A>.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
 Object right)

withNewGreaterThanConditionLike

public WhileFluent<A>.GreaterThanConditionNested<A> withNewGreaterThanConditionLike(GreaterThan item)

withNewGreaterThanOrEqualCondition

public WhileFluent<A>.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
 Object right)

withNewGreaterThanOrEqualConditionLike

public WhileFluent<A>.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualConditionLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualStatement

public WhileFluent<A>.GreaterThanOrEqualStatementNested<A> withNewGreaterThanOrEqualStatement()

withNewGreaterThanOrEqualStatement

public A withNewGreaterThanOrEqualStatement(Object left,
 Object right)

withNewGreaterThanOrEqualStatementLike

public WhileFluent<A>.GreaterThanOrEqualStatementNested<A> withNewGreaterThanOrEqualStatementLike(GreaterThanOrEqual item)

withNewGreaterThanStatement

public WhileFluent<A>.GreaterThanStatementNested<A> withNewGreaterThanStatement()

withNewGreaterThanStatement

public A withNewGreaterThanStatement(Object left,
 Object right)

withNewGreaterThanStatementLike

public WhileFluent<A>.GreaterThanStatementNested<A> withNewGreaterThanStatementLike(GreaterThan item)

withNewIfDslThenStepStatement

public WhileFluent<A>.IfDslThenStepStatementNested<A> withNewIfDslThenStepStatement()

withNewIfDslThenStepStatementLike

public WhileFluent<A>.IfDslThenStepStatementNested<A> withNewIfDslThenStepStatementLike(IfDslThenStep item)

withNewIfStatement

public WhileFluent<A>.IfStatementNested<A> withNewIfStatement()

withNewIfStatementLike

public WhileFluent<A>.IfStatementNested<A> withNewIfStatementLike(If item)

withNewIndexCondition

public WhileFluent<A>.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

public WhileFluent<A>.IndexConditionNested<A> withNewIndexConditionLike(Index item)

withNewInstanceOfCondition

public WhileFluent<A>.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

public WhileFluent<A>.InstanceOfConditionNested<A> withNewInstanceOfConditionLike(InstanceOf item)

withNewInverseCondition

public WhileFluent<A>.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

public WhileFluent<A>.InverseConditionNested<A> withNewInverseConditionLike(Inverse item)

withNewLambdaCondition

public WhileFluent<A>.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

public WhileFluent<A>.LambdaConditionNested<A> withNewLambdaConditionLike(Lambda item)

withNewLambdaStatement

public WhileFluent<A>.LambdaStatementNested<A> withNewLambdaStatement()

withNewLambdaStatementLike

public WhileFluent<A>.LambdaStatementNested<A> withNewLambdaStatementLike(Lambda item)

withNewLeftShiftCondition

public WhileFluent<A>.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
 Object right)

withNewLeftShiftConditionLike

public WhileFluent<A>.LeftShiftConditionNested<A> withNewLeftShiftConditionLike(LeftShift item)

withNewLeftShiftStatement

public WhileFluent<A>.LeftShiftStatementNested<A> withNewLeftShiftStatement()

withNewLeftShiftStatement

public A withNewLeftShiftStatement(Object left,
 Object right)

withNewLeftShiftStatementLike

public WhileFluent<A>.LeftShiftStatementNested<A> withNewLeftShiftStatementLike(LeftShift item)

withNewLessThanCondition

public WhileFluent<A>.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
 Object right)

withNewLessThanConditionLike

public WhileFluent<A>.LessThanConditionNested<A> withNewLessThanConditionLike(LessThan item)

withNewLessThanOrEqualCondition

public WhileFluent<A>.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
 Object right)

withNewLessThanOrEqualConditionLike

public WhileFluent<A>.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualConditionLike(LessThanOrEqual item)

withNewLessThanOrEqualStatement

public WhileFluent<A>.LessThanOrEqualStatementNested<A> withNewLessThanOrEqualStatement()

withNewLessThanOrEqualStatement

public A withNewLessThanOrEqualStatement(Object left,
 Object right)

withNewLessThanOrEqualStatementLike

public WhileFluent<A>.LessThanOrEqualStatementNested<A> withNewLessThanOrEqualStatementLike(LessThanOrEqual item)

withNewLessThanStatement

public WhileFluent<A>.LessThanStatementNested<A> withNewLessThanStatement()

withNewLessThanStatement

public A withNewLessThanStatement(Object left,
 Object right)

withNewLessThanStatementLike

public WhileFluent<A>.LessThanStatementNested<A> withNewLessThanStatementLike(LessThan item)

withNewLogicalAndCondition

public WhileFluent<A>.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
 Object right)

withNewLogicalAndConditionLike

public WhileFluent<A>.LogicalAndConditionNested<A> withNewLogicalAndConditionLike(LogicalAnd item)

withNewLogicalAndStatement

public WhileFluent<A>.LogicalAndStatementNested<A> withNewLogicalAndStatement()

withNewLogicalAndStatement

public A withNewLogicalAndStatement(Object left,
 Object right)

withNewLogicalAndStatementLike

public WhileFluent<A>.LogicalAndStatementNested<A> withNewLogicalAndStatementLike(LogicalAnd item)

withNewLogicalOrCondition

public WhileFluent<A>.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
 Object right)

withNewLogicalOrConditionLike

public WhileFluent<A>.LogicalOrConditionNested<A> withNewLogicalOrConditionLike(LogicalOr item)

withNewLogicalOrStatement

public WhileFluent<A>.LogicalOrStatementNested<A> withNewLogicalOrStatement()

withNewLogicalOrStatement

public A withNewLogicalOrStatement(Object left,
 Object right)

withNewLogicalOrStatementLike

public WhileFluent<A>.LogicalOrStatementNested<A> withNewLogicalOrStatementLike(LogicalOr item)

withNewMethodCallCondition

public WhileFluent<A>.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

public WhileFluent<A>.MethodCallConditionNested<A> withNewMethodCallConditionLike(MethodCall item)

withNewMethodCallStatement

public WhileFluent<A>.MethodCallStatementNested<A> withNewMethodCallStatement()

withNewMethodCallStatementLike

public WhileFluent<A>.MethodCallStatementNested<A> withNewMethodCallStatementLike(MethodCall item)

withNewMinusCondition

public WhileFluent<A>.MinusConditionNested<A> withNewMinusCondition()

withNewMinusCondition

public A withNewMinusCondition(Object left,
 Object right)

withNewMinusConditionLike

public WhileFluent<A>.MinusConditionNested<A> withNewMinusConditionLike(Minus item)

withNewMinusStatement

public WhileFluent<A>.MinusStatementNested<A> withNewMinusStatement()

withNewMinusStatement

public A withNewMinusStatement(Object left,
 Object right)

withNewMinusStatementLike

public WhileFluent<A>.MinusStatementNested<A> withNewMinusStatementLike(Minus item)

withNewModuloCondition

public WhileFluent<A>.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloCondition

public A withNewModuloCondition(Object left,
 Object right)

withNewModuloConditionLike

public WhileFluent<A>.ModuloConditionNested<A> withNewModuloConditionLike(Modulo item)

withNewModuloStatement

public WhileFluent<A>.ModuloStatementNested<A> withNewModuloStatement()

withNewModuloStatement

public A withNewModuloStatement(Object left,
 Object right)

withNewModuloStatementLike

public WhileFluent<A>.ModuloStatementNested<A> withNewModuloStatementLike(Modulo item)

withNewMultiplyCondition

public WhileFluent<A>.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
 Object right)

withNewMultiplyConditionLike

public WhileFluent<A>.MultiplyConditionNested<A> withNewMultiplyConditionLike(Multiply item)

withNewMultiplyStatement

public WhileFluent<A>.MultiplyStatementNested<A> withNewMultiplyStatement()

withNewMultiplyStatement

public A withNewMultiplyStatement(Object left,
 Object right)

withNewMultiplyStatementLike

public WhileFluent<A>.MultiplyStatementNested<A> withNewMultiplyStatementLike(Multiply item)

withNewNegativeCondition

public WhileFluent<A>.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

public WhileFluent<A>.NegativeConditionNested<A> withNewNegativeConditionLike(Negative item)

withNewNewArrayCondition

public WhileFluent<A>.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayCondition

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

withNewNewArrayConditionLike

public WhileFluent<A>.NewArrayConditionNested<A> withNewNewArrayConditionLike(NewArray item)

withNewNotCondition

public WhileFluent<A>.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

public WhileFluent<A>.NotConditionNested<A> withNewNotConditionLike(Not item)

withNewNotEqualsCondition

public WhileFluent<A>.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
 Object right)

withNewNotEqualsConditionLike

public WhileFluent<A>.NotEqualsConditionNested<A> withNewNotEqualsConditionLike(NotEquals item)

withNewNotEqualsStatement

public WhileFluent<A>.NotEqualsStatementNested<A> withNewNotEqualsStatement()

withNewNotEqualsStatement

public A withNewNotEqualsStatement(Object left,
 Object right)

withNewNotEqualsStatementLike

public WhileFluent<A>.NotEqualsStatementNested<A> withNewNotEqualsStatementLike(NotEquals item)

withNewPlusCondition

public WhileFluent<A>.PlusConditionNested<A> withNewPlusCondition()

withNewPlusCondition

public A withNewPlusCondition(Object left,
 Object right)

withNewPlusConditionLike

public WhileFluent<A>.PlusConditionNested<A> withNewPlusConditionLike(Plus item)

withNewPlusStatement

public WhileFluent<A>.PlusStatementNested<A> withNewPlusStatement()

withNewPlusStatement

public A withNewPlusStatement(Object left,
 Object right)

withNewPlusStatementLike

public WhileFluent<A>.PlusStatementNested<A> withNewPlusStatementLike(Plus item)

withNewPositiveCondition

public WhileFluent<A>.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

public WhileFluent<A>.PositiveConditionNested<A> withNewPositiveConditionLike(Positive item)

withNewPostDecrementCondition

public WhileFluent<A>.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

public WhileFluent<A>.PostDecrementConditionNested<A> withNewPostDecrementConditionLike(PostDecrement item)

withNewPostDecrementStatement

public WhileFluent<A>.PostDecrementStatementNested<A> withNewPostDecrementStatement()

withNewPostDecrementStatementLike

public WhileFluent<A>.PostDecrementStatementNested<A> withNewPostDecrementStatementLike(PostDecrement item)

withNewPostIncrementCondition

public WhileFluent<A>.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

public WhileFluent<A>.PostIncrementConditionNested<A> withNewPostIncrementConditionLike(PostIncrement item)

withNewPostIncrementStatement

public WhileFluent<A>.PostIncrementStatementNested<A> withNewPostIncrementStatement()

withNewPostIncrementStatementLike

public WhileFluent<A>.PostIncrementStatementNested<A> withNewPostIncrementStatementLike(PostIncrement item)

withNewPreDecrementCondition

public WhileFluent<A>.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

public WhileFluent<A>.PreDecrementConditionNested<A> withNewPreDecrementConditionLike(PreDecrement item)

withNewPreDecrementStatement

public WhileFluent<A>.PreDecrementStatementNested<A> withNewPreDecrementStatement()

withNewPreDecrementStatementLike

public WhileFluent<A>.PreDecrementStatementNested<A> withNewPreDecrementStatementLike(PreDecrement item)

withNewPreIncrementCondition

public WhileFluent<A>.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

public WhileFluent<A>.PreIncrementConditionNested<A> withNewPreIncrementConditionLike(PreIncrement item)

withNewPreIncrementStatement

public WhileFluent<A>.PreIncrementStatementNested<A> withNewPreIncrementStatement()

withNewPreIncrementStatementLike

public WhileFluent<A>.PreIncrementStatementNested<A> withNewPreIncrementStatementLike(PreIncrement item)

withNewPropertyCondition

public WhileFluent<A>.PropertyConditionNested<A> withNewPropertyCondition()

withNewPropertyConditionLike

public WhileFluent<A>.PropertyConditionNested<A> withNewPropertyConditionLike(Property item)

withNewPropertyRefCondition

public WhileFluent<A>.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

public WhileFluent<A>.PropertyRefConditionNested<A> withNewPropertyRefConditionLike(PropertyRef item)

withNewPropertyRefStatement

public WhileFluent<A>.PropertyRefStatementNested<A> withNewPropertyRefStatement()

withNewPropertyRefStatementLike

public WhileFluent<A>.PropertyRefStatementNested<A> withNewPropertyRefStatementLike(PropertyRef item)

withNewReturnDslThisStepStatement

public WhileFluent<A>.ReturnDslThisStepStatementNested<A> withNewReturnDslThisStepStatement()

withNewReturnDslThisStepStatementLike

public WhileFluent<A>.ReturnDslThisStepStatementNested<A> withNewReturnDslThisStepStatementLike(ReturnDslThisStep item)

withNewReturnDslVariableStepStatement

public WhileFluent<A>.ReturnDslVariableStepStatementNested<A> withNewReturnDslVariableStepStatement()

withNewReturnDslVariableStepStatement

public A withNewReturnDslVariableStepStatement(String name)

withNewReturnDslVariableStepStatementLike

public WhileFluent<A>.ReturnDslVariableStepStatementNested<A> withNewReturnDslVariableStepStatementLike(ReturnDslVariableStep item)

withNewReturnStatement

public WhileFluent<A>.ReturnStatementNested<A> withNewReturnStatement()

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewReturnStatementLike

public WhileFluent<A>.ReturnStatementNested<A> withNewReturnStatementLike(Return item)

withNewRightShiftCondition

public WhileFluent<A>.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
 Object right)

withNewRightShiftConditionLike

public WhileFluent<A>.RightShiftConditionNested<A> withNewRightShiftConditionLike(RightShift item)

withNewRightShiftStatement

public WhileFluent<A>.RightShiftStatementNested<A> withNewRightShiftStatement()

withNewRightShiftStatement

public A withNewRightShiftStatement(Object left,
 Object right)

withNewRightShiftStatementLike

public WhileFluent<A>.RightShiftStatementNested<A> withNewRightShiftStatementLike(RightShift item)

withNewRightUnsignedShiftCondition

public WhileFluent<A>.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
 Object right)

withNewRightUnsignedShiftConditionLike

public WhileFluent<A>.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftConditionLike(RightUnsignedShift item)

withNewRightUnsignedShiftStatement

public WhileFluent<A>.RightUnsignedShiftStatementNested<A> withNewRightUnsignedShiftStatement()

withNewRightUnsignedShiftStatement

public A withNewRightUnsignedShiftStatement(Object left,
 Object right)

withNewRightUnsignedShiftStatementLike

public WhileFluent<A>.RightUnsignedShiftStatementNested<A> withNewRightUnsignedShiftStatementLike(RightUnsignedShift item)

withNewStringStatement

public WhileFluent<A>.StringStatementNested<A> withNewStringStatement()

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewStringStatementLike

public WhileFluent<A>.StringStatementNested<A> withNewStringStatementLike(StringStatement item)

withNewSuperCondition

public WhileFluent<A>.SuperConditionNested<A> withNewSuperCondition()

withNewSuperConditionLike

public WhileFluent<A>.SuperConditionNested<A> withNewSuperConditionLike(Super item)

withNewSwitchStatement

public WhileFluent<A>.SwitchStatementNested<A> withNewSwitchStatement()

withNewSwitchStatementLike

public WhileFluent<A>.SwitchStatementNested<A> withNewSwitchStatementLike(Switch item)

withNewSynchronizedStatement

public WhileFluent<A>.SynchronizedStatementNested<A> withNewSynchronizedStatement()

withNewSynchronizedStatementLike

public WhileFluent<A>.SynchronizedStatementNested<A> withNewSynchronizedStatementLike(Synchronized item)

withNewTernaryCondition

public WhileFluent<A>.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

public WhileFluent<A>.TernaryConditionNested<A> withNewTernaryConditionLike(Ternary item)

withNewThisCondition

public WhileFluent<A>.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

public WhileFluent<A>.ThisConditionNested<A> withNewThisConditionLike(This item)

withNewThrowStatement

public WhileFluent<A>.ThrowStatementNested<A> withNewThrowStatement()

withNewThrowStatementLike

public WhileFluent<A>.ThrowStatementNested<A> withNewThrowStatementLike(Throw item)

withNewTryStatement

public WhileFluent<A>.TryStatementNested<A> withNewTryStatement()

withNewTryStatementLike

public WhileFluent<A>.TryStatementNested<A> withNewTryStatementLike(Try item)

withNewValueRefCondition

public WhileFluent<A>.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewValueRefConditionLike

public WhileFluent<A>.ValueRefConditionNested<A> withNewValueRefConditionLike(ValueRef item)

withNewWhileStatement

public WhileFluent<A>.WhileStatementNested<A> withNewWhileStatement()

withNewWhileStatementLike

public WhileFluent<A>.WhileStatementNested<A> withNewWhileStatementLike(While item)

withNewXorCondition

public WhileFluent<A>.XorConditionNested<A> withNewXorCondition()

withNewXorCondition

public A withNewXorCondition(Object left,
 Object right)

withNewXorConditionLike

public WhileFluent<A>.XorConditionNested<A> withNewXorConditionLike(Xor item)

withNewXorStatement

public WhileFluent<A>.XorStatementNested<A> withNewXorStatement()

withNewXorStatement

public A withNewXorStatement(Object left,
 Object right)

withNewXorStatementLike

public WhileFluent<A>.XorStatementNested<A> withNewXorStatementLike(Xor item)

withStatement

public A withStatement(Statement statement)