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, IfFluent.WhileStatementNested, LambdaFluent.WhileStatementNested, WhileBuilder, WhileFluent.WhileStatementNested

public class WhileFluent<A extends WhileFluent<A>>
extends io.sundr.builder.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.BitwiseAndConditionNested<N>
class	WhileFluent.BitwiseOrConditionNested<N>
class	WhileFluent.BlockStatementNested<N>
class	WhileFluent.BreakStatementNested<N>
class	WhileFluent.CastConditionNested<N>
class	WhileFluent.ConstructConditionNested<N>
class	WhileFluent.ContinueStatementNested<N>
class	WhileFluent.DeclareConditionNested<N>
class	WhileFluent.DeclareStatementNested<N>
class	WhileFluent.DivideConditionNested<N>
class	WhileFluent.DoStatementNested<N>
class	WhileFluent.EnclosedConditionNested<N>
class	WhileFluent.EqualsConditionNested<N>
class	WhileFluent.ForeachStatementNested<N>
class	WhileFluent.ForStatementNested<N>
class	WhileFluent.GreaterThanConditionNested<N>
class	WhileFluent.GreaterThanOrEqualConditionNested<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.LessThanConditionNested<N>
class	WhileFluent.LessThanOrEqualConditionNested<N>
class	WhileFluent.LogicalAndConditionNested<N>
class	WhileFluent.LogicalOrConditionNested<N>
class	WhileFluent.MethodCallConditionNested<N>
class	WhileFluent.MethodCallStatementNested<N>
class	WhileFluent.MinusConditionNested<N>
class	WhileFluent.ModuloConditionNested<N>
class	WhileFluent.MultiplyConditionNested<N>
class	WhileFluent.NegativeConditionNested<N>
class	WhileFluent.NewArrayConditionNested<N>
class	WhileFluent.NotConditionNested<N>
class	WhileFluent.NotEqualsConditionNested<N>
class	WhileFluent.PlusConditionNested<N>
class	WhileFluent.PositiveConditionNested<N>
class	WhileFluent.PostDecrementConditionNested<N>
class	WhileFluent.PostIncrementConditionNested<N>
class	WhileFluent.PreDecrementConditionNested<N>
class	WhileFluent.PreIncrementConditionNested<N>
class	WhileFluent.PropertyRefConditionNested<N>
class	WhileFluent.ReturnStatementNested<N>
class	WhileFluent.RightShiftConditionNested<N>
class	WhileFluent.RightUnsignedShiftConditionNested<N>
class	WhileFluent.StringStatementNested<N>
class	WhileFluent.SwitchStatementNested<N>
class	WhileFluent.TernaryConditionNested<N>
class	WhileFluent.ThisConditionNested<N>
class	WhileFluent.ValueRefConditionNested<N>
class	WhileFluent.WhileStatementNested<N>
class	WhileFluent.XorConditionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
WhileFluent()
WhileFluent(io.sundr.model.While instance)

Method Summary

Modifier and Type	Method	Description
io.sundr.model.Expression	buildCondition()
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Statement	buildStatement()
protected void	copyInstance(io.sundr.model.While instance)
boolean	equals(Object o)
boolean	hasCondition()
int	hashCode()
boolean	hasStatement()
String	toString()
A	withCondition(io.sundr.model.Expression condition)
WhileFluent.AssignConditionNested<A>	withNewAssignCondition()
WhileFluent.AssignConditionNested<A>	withNewAssignConditionLike(io.sundr.model.Assign item)
WhileFluent.AssignStatementNested<A>	withNewAssignStatement()
WhileFluent.AssignStatementNested<A>	withNewAssignStatementLike(io.sundr.model.Assign item)
WhileFluent.BinaryExpressionConditionNested<A>	withNewBinaryExpressionCondition()
WhileFluent.BinaryExpressionConditionNested<A>	withNewBinaryExpressionConditionLike(io.sundr.model.BinaryExpression item)
WhileFluent.BitwiseAndConditionNested<A>	withNewBitwiseAndCondition()
A	withNewBitwiseAndCondition(Object left, Object right)
WhileFluent.BitwiseAndConditionNested<A>	withNewBitwiseAndConditionLike(io.sundr.model.BitwiseAnd item)
WhileFluent.BitwiseOrConditionNested<A>	withNewBitwiseOrCondition()
A	withNewBitwiseOrCondition(Object left, Object right)
WhileFluent.BitwiseOrConditionNested<A>	withNewBitwiseOrConditionLike(io.sundr.model.BitwiseOr item)
WhileFluent.BlockStatementNested<A>	withNewBlockStatement()
WhileFluent.BlockStatementNested<A>	withNewBlockStatementLike(io.sundr.model.Block item)
WhileFluent.BreakStatementNested<A>	withNewBreakStatement()
WhileFluent.BreakStatementNested<A>	withNewBreakStatementLike(io.sundr.model.Break item)
WhileFluent.CastConditionNested<A>	withNewCastCondition()
WhileFluent.CastConditionNested<A>	withNewCastConditionLike(io.sundr.model.Cast item)
WhileFluent.ConstructConditionNested<A>	withNewConstructCondition()
WhileFluent.ConstructConditionNested<A>	withNewConstructConditionLike(io.sundr.model.Construct item)
WhileFluent.ContinueStatementNested<A>	withNewContinueStatement()
WhileFluent.ContinueStatementNested<A>	withNewContinueStatementLike(io.sundr.model.Continue item)
WhileFluent.DeclareConditionNested<A>	withNewDeclareCondition()
A	withNewDeclareCondition(Class type, String name)
A	withNewDeclareCondition(Class type, String name, Object value)
WhileFluent.DeclareConditionNested<A>	withNewDeclareConditionLike(io.sundr.model.Declare item)
WhileFluent.DeclareStatementNested<A>	withNewDeclareStatement()
A	withNewDeclareStatement(Class type, String name)
A	withNewDeclareStatement(Class type, String name, Object value)
WhileFluent.DeclareStatementNested<A>	withNewDeclareStatementLike(io.sundr.model.Declare item)
WhileFluent.DivideConditionNested<A>	withNewDivideCondition()
A	withNewDivideCondition(Object left, Object right)
WhileFluent.DivideConditionNested<A>	withNewDivideConditionLike(io.sundr.model.Divide item)
WhileFluent.DoStatementNested<A>	withNewDoStatement()
WhileFluent.DoStatementNested<A>	withNewDoStatementLike(io.sundr.model.Do item)
WhileFluent.EnclosedConditionNested<A>	withNewEnclosedCondition()
WhileFluent.EnclosedConditionNested<A>	withNewEnclosedConditionLike(io.sundr.model.Enclosed item)
WhileFluent.EqualsConditionNested<A>	withNewEqualsCondition()
A	withNewEqualsCondition(Object left, Object right)
WhileFluent.EqualsConditionNested<A>	withNewEqualsConditionLike(io.sundr.model.Equals item)
WhileFluent.ForeachStatementNested<A>	withNewForeachStatement()
WhileFluent.ForeachStatementNested<A>	withNewForeachStatementLike(io.sundr.model.Foreach item)
WhileFluent.ForStatementNested<A>	withNewForStatement()
WhileFluent.ForStatementNested<A>	withNewForStatementLike(io.sundr.model.For item)
WhileFluent.GreaterThanConditionNested<A>	withNewGreaterThanCondition()
A	withNewGreaterThanCondition(Object left, Object right)
WhileFluent.GreaterThanConditionNested<A>	withNewGreaterThanConditionLike(io.sundr.model.GreaterThan item)
WhileFluent.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualCondition()
A	withNewGreaterThanOrEqualCondition(Object left, Object right)
WhileFluent.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualConditionLike(io.sundr.model.GreaterThanOrEqual item)
WhileFluent.IfStatementNested<A>	withNewIfStatement()
WhileFluent.IfStatementNested<A>	withNewIfStatementLike(io.sundr.model.If item)
WhileFluent.IndexConditionNested<A>	withNewIndexCondition()
WhileFluent.IndexConditionNested<A>	withNewIndexConditionLike(io.sundr.model.Index item)
WhileFluent.InstanceOfConditionNested<A>	withNewInstanceOfCondition()
WhileFluent.InstanceOfConditionNested<A>	withNewInstanceOfConditionLike(io.sundr.model.InstanceOf item)
WhileFluent.InverseConditionNested<A>	withNewInverseCondition()
WhileFluent.InverseConditionNested<A>	withNewInverseConditionLike(io.sundr.model.Inverse item)
WhileFluent.LambdaConditionNested<A>	withNewLambdaCondition()
WhileFluent.LambdaConditionNested<A>	withNewLambdaConditionLike(io.sundr.model.Lambda item)
WhileFluent.LambdaStatementNested<A>	withNewLambdaStatement()
WhileFluent.LambdaStatementNested<A>	withNewLambdaStatementLike(io.sundr.model.Lambda item)
WhileFluent.LeftShiftConditionNested<A>	withNewLeftShiftCondition()
A	withNewLeftShiftCondition(Object left, Object right)
WhileFluent.LeftShiftConditionNested<A>	withNewLeftShiftConditionLike(io.sundr.model.LeftShift item)
WhileFluent.LessThanConditionNested<A>	withNewLessThanCondition()
A	withNewLessThanCondition(Object left, Object right)
WhileFluent.LessThanConditionNested<A>	withNewLessThanConditionLike(io.sundr.model.LessThan item)
WhileFluent.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualCondition()
A	withNewLessThanOrEqualCondition(Object left, Object right)
WhileFluent.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualConditionLike(io.sundr.model.LessThanOrEqual item)
WhileFluent.LogicalAndConditionNested<A>	withNewLogicalAndCondition()
A	withNewLogicalAndCondition(Object left, Object right)
WhileFluent.LogicalAndConditionNested<A>	withNewLogicalAndConditionLike(io.sundr.model.LogicalAnd item)
WhileFluent.LogicalOrConditionNested<A>	withNewLogicalOrCondition()
A	withNewLogicalOrCondition(Object left, Object right)
WhileFluent.LogicalOrConditionNested<A>	withNewLogicalOrConditionLike(io.sundr.model.LogicalOr item)
WhileFluent.MethodCallConditionNested<A>	withNewMethodCallCondition()
WhileFluent.MethodCallConditionNested<A>	withNewMethodCallConditionLike(io.sundr.model.MethodCall item)
WhileFluent.MethodCallStatementNested<A>	withNewMethodCallStatement()
WhileFluent.MethodCallStatementNested<A>	withNewMethodCallStatementLike(io.sundr.model.MethodCall item)
WhileFluent.MinusConditionNested<A>	withNewMinusCondition()
A	withNewMinusCondition(Object left, Object right)
WhileFluent.MinusConditionNested<A>	withNewMinusConditionLike(io.sundr.model.Minus item)
WhileFluent.ModuloConditionNested<A>	withNewModuloCondition()
A	withNewModuloCondition(Object left, Object right)
WhileFluent.ModuloConditionNested<A>	withNewModuloConditionLike(io.sundr.model.Modulo item)
WhileFluent.MultiplyConditionNested<A>	withNewMultiplyCondition()
A	withNewMultiplyCondition(Object left, Object right)
WhileFluent.MultiplyConditionNested<A>	withNewMultiplyConditionLike(io.sundr.model.Multiply item)
WhileFluent.NegativeConditionNested<A>	withNewNegativeCondition()
WhileFluent.NegativeConditionNested<A>	withNewNegativeConditionLike(io.sundr.model.Negative item)
WhileFluent.NewArrayConditionNested<A>	withNewNewArrayCondition()
A	withNewNewArrayCondition(Class type, Integer[] sizes)
WhileFluent.NewArrayConditionNested<A>	withNewNewArrayConditionLike(io.sundr.model.NewArray item)
WhileFluent.NotConditionNested<A>	withNewNotCondition()
WhileFluent.NotConditionNested<A>	withNewNotConditionLike(io.sundr.model.Not item)
WhileFluent.NotEqualsConditionNested<A>	withNewNotEqualsCondition()
A	withNewNotEqualsCondition(Object left, Object right)
WhileFluent.NotEqualsConditionNested<A>	withNewNotEqualsConditionLike(io.sundr.model.NotEquals item)
WhileFluent.PlusConditionNested<A>	withNewPlusCondition()
A	withNewPlusCondition(Object left, Object right)
WhileFluent.PlusConditionNested<A>	withNewPlusConditionLike(io.sundr.model.Plus item)
WhileFluent.PositiveConditionNested<A>	withNewPositiveCondition()
WhileFluent.PositiveConditionNested<A>	withNewPositiveConditionLike(io.sundr.model.Positive item)
WhileFluent.PostDecrementConditionNested<A>	withNewPostDecrementCondition()
WhileFluent.PostDecrementConditionNested<A>	withNewPostDecrementConditionLike(io.sundr.model.PostDecrement item)
WhileFluent.PostIncrementConditionNested<A>	withNewPostIncrementCondition()
WhileFluent.PostIncrementConditionNested<A>	withNewPostIncrementConditionLike(io.sundr.model.PostIncrement item)
WhileFluent.PreDecrementConditionNested<A>	withNewPreDecrementCondition()
WhileFluent.PreDecrementConditionNested<A>	withNewPreDecrementConditionLike(io.sundr.model.PreDecrement item)
WhileFluent.PreIncrementConditionNested<A>	withNewPreIncrementCondition()
WhileFluent.PreIncrementConditionNested<A>	withNewPreIncrementConditionLike(io.sundr.model.PreIncrement item)
WhileFluent.PropertyRefConditionNested<A>	withNewPropertyRefCondition()
WhileFluent.PropertyRefConditionNested<A>	withNewPropertyRefConditionLike(io.sundr.model.PropertyRef item)
WhileFluent.ReturnStatementNested<A>	withNewReturnStatement()
A	withNewReturnStatement(Object object)
WhileFluent.ReturnStatementNested<A>	withNewReturnStatementLike(io.sundr.model.Return item)
WhileFluent.RightShiftConditionNested<A>	withNewRightShiftCondition()
A	withNewRightShiftCondition(Object left, Object right)
WhileFluent.RightShiftConditionNested<A>	withNewRightShiftConditionLike(io.sundr.model.RightShift item)
WhileFluent.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftCondition()
A	withNewRightUnsignedShiftCondition(Object left, Object right)
WhileFluent.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftConditionLike(io.sundr.model.RightUnsignedShift item)
WhileFluent.StringStatementNested<A>	withNewStringStatement()
A	withNewStringStatement(String data)
A	withNewStringStatement(String data, Object[] parameters)
WhileFluent.StringStatementNested<A>	withNewStringStatementLike(io.sundr.model.StringStatement item)
WhileFluent.SwitchStatementNested<A>	withNewSwitchStatement()
WhileFluent.SwitchStatementNested<A>	withNewSwitchStatementLike(io.sundr.model.Switch item)
WhileFluent.TernaryConditionNested<A>	withNewTernaryCondition()
WhileFluent.TernaryConditionNested<A>	withNewTernaryConditionLike(io.sundr.model.Ternary item)
WhileFluent.ThisConditionNested<A>	withNewThisCondition()
WhileFluent.ThisConditionNested<A>	withNewThisConditionLike(io.sundr.model.This item)
WhileFluent.ValueRefConditionNested<A>	withNewValueRefCondition()
A	withNewValueRefCondition(Object value)
WhileFluent.ValueRefConditionNested<A>	withNewValueRefConditionLike(io.sundr.model.ValueRef item)
WhileFluent.WhileStatementNested<A>	withNewWhileStatement()
WhileFluent.WhileStatementNested<A>	withNewWhileStatementLike(io.sundr.model.While item)
WhileFluent.XorConditionNested<A>	withNewXorCondition()
A	withNewXorCondition(Object left, Object right)
WhileFluent.XorConditionNested<A>	withNewXorConditionLike(io.sundr.model.Xor item)
A	withStatement(io.sundr.model.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 Detail

WhileFluent

public WhileFluent()

WhileFluent

public WhileFluent(io.sundr.model.While instance)

Method Detail

copyInstance

protected void copyInstance(io.sundr.model.While instance)

buildCondition

public io.sundr.model.Expression buildCondition()

withCondition

public A withCondition(io.sundr.model.Expression condition)

hasCondition

public boolean hasCondition()

withNewMultiplyCondition

public WhileFluent.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyConditionLike

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

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
                                  Object right)

withNewNewArrayCondition

public WhileFluent.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayConditionLike

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

withNewNewArrayCondition

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

withNewInstanceOfCondition

public WhileFluent.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

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

withNewMethodCallCondition

public WhileFluent.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

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

withNewInverseCondition

public WhileFluent.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

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

withNewIndexCondition

public WhileFluent.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

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

withNewGreaterThanOrEqualCondition

public WhileFluent.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
                                            Object right)

withNewBitwiseAndCondition

public WhileFluent.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndConditionLike

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

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
                                    Object right)

withNewMinusCondition

public WhileFluent.MinusConditionNested<A> withNewMinusCondition()

withNewMinusConditionLike

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

withNewMinusCondition

public A withNewMinusCondition(Object left,
                               Object right)

withNewLogicalOrCondition

public WhileFluent.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrConditionLike

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

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
                                   Object right)

withNewNotEqualsCondition

public WhileFluent.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsConditionLike

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

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
                                   Object right)

withNewDivideCondition

public WhileFluent.DivideConditionNested<A> withNewDivideCondition()

withNewDivideConditionLike

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

withNewDivideCondition

public A withNewDivideCondition(Object left,
                                Object right)

withNewLessThanCondition

public WhileFluent.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanConditionLike

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

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
                                  Object right)

withNewBitwiseOrCondition

public WhileFluent.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrConditionLike

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

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
                                   Object right)

withNewPropertyRefCondition

public WhileFluent.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

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

withNewRightShiftCondition

public WhileFluent.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftConditionLike

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

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
                                    Object right)

withNewGreaterThanCondition

public WhileFluent.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanConditionLike

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

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
                                     Object right)

withNewDeclareCondition

public WhileFluent.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareConditionLike

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

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
                                 String name)

withNewDeclareCondition

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

withNewCastCondition

public WhileFluent.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

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

withNewModuloCondition

public WhileFluent.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloConditionLike

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

withNewModuloCondition

public A withNewModuloCondition(Object left,
                                Object right)

withNewValueRefCondition

public WhileFluent.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefConditionLike

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

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewLeftShiftCondition

public WhileFluent.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftConditionLike

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

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
                                   Object right)

withNewTernaryCondition

public WhileFluent.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

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

withNewBinaryExpressionCondition

public WhileFluent.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

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

withNewEqualsCondition

public WhileFluent.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsConditionLike

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

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
                                Object right)

withNewEnclosedCondition

public WhileFluent.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

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

withNewPreDecrementCondition

public WhileFluent.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

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

withNewPostDecrementCondition

public WhileFluent.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

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

withNewLambdaCondition

public WhileFluent.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

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

withNewNotCondition

public WhileFluent.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

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

withNewAssignCondition

public WhileFluent.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

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

withNewNegativeCondition

public WhileFluent.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

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

withNewThisCondition

public WhileFluent.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

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

withNewLogicalAndCondition

public WhileFluent.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndConditionLike

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

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
                                    Object right)

withNewPostIncrementCondition

public WhileFluent.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

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

withNewRightUnsignedShiftCondition

public WhileFluent.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
                                            Object right)

withNewPlusCondition

public WhileFluent.PlusConditionNested<A> withNewPlusCondition()

withNewPlusConditionLike

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

withNewPlusCondition

public A withNewPlusCondition(Object left,
                              Object right)

withNewConstructCondition

public WhileFluent.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

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

withNewXorCondition

public WhileFluent.XorConditionNested<A> withNewXorCondition()

withNewXorConditionLike

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

withNewXorCondition

public A withNewXorCondition(Object left,
                             Object right)

withNewPreIncrementCondition

public WhileFluent.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

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

withNewLessThanOrEqualCondition

public WhileFluent.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
                                         Object right)

withNewPositiveCondition

public WhileFluent.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

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

buildStatement

public io.sundr.model.Statement buildStatement()

withStatement

public A withStatement(io.sundr.model.Statement statement)

hasStatement

public boolean hasStatement()

withNewMethodCallStatement

public WhileFluent.MethodCallStatementNested<A> withNewMethodCallStatement()

withNewMethodCallStatementLike

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

withNewSwitchStatement

public WhileFluent.SwitchStatementNested<A> withNewSwitchStatement()

withNewSwitchStatementLike

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

withNewBreakStatement

public WhileFluent.BreakStatementNested<A> withNewBreakStatement()

withNewBreakStatementLike

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

withNewDeclareStatement

public WhileFluent.DeclareStatementNested<A> withNewDeclareStatement()

withNewDeclareStatementLike

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

withNewDeclareStatement

public A withNewDeclareStatement(Class type,
                                 String name)

withNewDeclareStatement

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

withNewWhileStatement

public WhileFluent.WhileStatementNested<A> withNewWhileStatement()

withNewWhileStatementLike

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

withNewContinueStatement

public WhileFluent.ContinueStatementNested<A> withNewContinueStatement()

withNewContinueStatementLike

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

withNewStringStatement

public WhileFluent.StringStatementNested<A> withNewStringStatement()

withNewStringStatementLike

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

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewDoStatement

public WhileFluent.DoStatementNested<A> withNewDoStatement()

withNewDoStatementLike

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

withNewForeachStatement

public WhileFluent.ForeachStatementNested<A> withNewForeachStatement()

withNewForeachStatementLike

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

withNewBlockStatement

public WhileFluent.BlockStatementNested<A> withNewBlockStatement()

withNewBlockStatementLike

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

withNewIfStatement

public WhileFluent.IfStatementNested<A> withNewIfStatement()

withNewIfStatementLike

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

withNewLambdaStatement

public WhileFluent.LambdaStatementNested<A> withNewLambdaStatement()

withNewLambdaStatementLike

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

withNewReturnStatement

public WhileFluent.ReturnStatementNested<A> withNewReturnStatement()

withNewReturnStatementLike

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

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewAssignStatement

public WhileFluent.AssignStatementNested<A> withNewAssignStatement()

withNewAssignStatementLike

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

withNewForStatement

public WhileFluent.ForStatementNested<A> withNewForStatement()

withNewForStatementLike

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

equals

public boolean equals(Object o)

Overrides:

equals in class io.sundr.builder.BaseFluent<A extends WhileFluent<A>>

hashCode

public int hashCode()

Overrides:

hashCode in class io.sundr.builder.BaseFluent<A extends WhileFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

builder

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