Package io.sundr.model

Class DoFluent<A extends DoFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.DoFluent<A>

Direct Known Subclasses:

BlockFluent.DoStatementsNested, DoBuilder, DoFluent.DoStatementNested, ForeachFluent.DoBodyNested, ForFluent.DoBodyNested, IfDslThenStepFluent.DoStatementsNested, IfFluent.DoElseStatementNested, IfFluent.DoStatementNested, LambdaFluent.DoStatementNested, SynchronizedFluent.DoBodyNested, WhileFluent.DoStatementNested

public class DoFluent<A extends DoFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
DoFluent()
DoFluent(Do instance)

Method Summary

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

DoFluent

public DoFluent()

DoFluent

public DoFluent(Do instance)

Method Details

buildCondition

public Expression buildCondition()

buildStatement

public Statement buildStatement()

builder

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

copyInstance

protected void copyInstance(Do instance)

equals

public boolean equals(Object o)

Overrides:

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

hasCondition

public boolean hasCondition()

hasStatement

public boolean hasStatement()

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

withCondition

public A withCondition(Expression condition)

withNewAssignCondition

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

withNewAssignConditionLike

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

withNewAssignStatement

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

withNewAssignStatementLike

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

withNewBinaryExpressionCondition

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

withNewBinaryExpressionConditionLike

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

withNewBinaryExpressionStatement

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

withNewBinaryExpressionStatementLike

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

withNewBitwiseAndCondition

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

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
 Object right)

withNewBitwiseAndConditionLike

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

withNewBitwiseAndStatement

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

withNewBitwiseAndStatement

public A withNewBitwiseAndStatement(Object left,
 Object right)

withNewBitwiseAndStatementLike

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

withNewBitwiseOrCondition

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

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
 Object right)

withNewBitwiseOrConditionLike

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

withNewBitwiseOrStatement

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

withNewBitwiseOrStatement

public A withNewBitwiseOrStatement(Object left,
 Object right)

withNewBitwiseOrStatementLike

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

withNewBlockStatement

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

withNewBlockStatementLike

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

withNewBreakStatement

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

withNewBreakStatementLike

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

withNewCastCondition

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

withNewCastConditionLike

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

withNewClassRefCondition

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

withNewClassRefConditionLike

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

withNewConstructCondition

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

withNewConstructConditionLike

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

withNewConstructStatement

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

withNewConstructStatementLike

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

withNewContextRefCondition

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

withNewContextRefCondition

public A withNewContextRefCondition(String name)

withNewContextRefConditionLike

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

withNewContinueStatement

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

withNewContinueStatementLike

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

withNewDeclareCondition

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

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
 String name)

withNewDeclareCondition

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

withNewDeclareConditionLike

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

withNewDeclareStatement

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

withNewDeclareStatement

public A withNewDeclareStatement(Class type,
 String name)

withNewDeclareStatement

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

withNewDeclareStatementLike

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

withNewDivideCondition

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

withNewDivideCondition

public A withNewDivideCondition(Object left,
 Object right)

withNewDivideConditionLike

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

withNewDivideStatement

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

withNewDivideStatement

public A withNewDivideStatement(Object left,
 Object right)

withNewDivideStatementLike

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

withNewDoStatement

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

withNewDoStatementLike

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

withNewDotClassCondition

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

withNewDotClassConditionLike

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

withNewEmptyCondition

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

withNewEmptyConditionLike

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

withNewEmptyStatement

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

withNewEmptyStatementLike

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

withNewEnclosedCondition

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

withNewEnclosedConditionLike

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

withNewEqualsCondition

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

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
 Object right)

withNewEqualsConditionLike

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

withNewEqualsStatement

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

withNewEqualsStatement

public A withNewEqualsStatement(Object left,
 Object right)

withNewEqualsStatementLike

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

withNewForStatement

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

withNewForStatementLike

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

withNewForeachStatement

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

withNewForeachStatementLike

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

withNewGreaterThanCondition

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

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
 Object right)

withNewGreaterThanConditionLike

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

withNewGreaterThanOrEqualCondition

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

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
 Object right)

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualStatement

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

withNewGreaterThanOrEqualStatement

public A withNewGreaterThanOrEqualStatement(Object left,
 Object right)

withNewGreaterThanOrEqualStatementLike

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

withNewGreaterThanStatement

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

withNewGreaterThanStatement

public A withNewGreaterThanStatement(Object left,
 Object right)

withNewGreaterThanStatementLike

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

withNewIfDslThenStepStatement

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

withNewIfDslThenStepStatementLike

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

withNewIfStatement

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

withNewIfStatementLike

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

withNewIndexCondition

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

withNewIndexConditionLike

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

withNewInstanceOfCondition

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

withNewInstanceOfConditionLike

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

withNewInverseCondition

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

withNewInverseConditionLike

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

withNewLambdaCondition

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

withNewLambdaConditionLike

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

withNewLambdaStatement

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

withNewLambdaStatementLike

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

withNewLeftShiftCondition

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

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
 Object right)

withNewLeftShiftConditionLike

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

withNewLeftShiftStatement

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

withNewLeftShiftStatement

public A withNewLeftShiftStatement(Object left,
 Object right)

withNewLeftShiftStatementLike

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

withNewLessThanCondition

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

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
 Object right)

withNewLessThanConditionLike

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

withNewLessThanOrEqualCondition

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

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
 Object right)

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualStatement

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

withNewLessThanOrEqualStatement

public A withNewLessThanOrEqualStatement(Object left,
 Object right)

withNewLessThanOrEqualStatementLike

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

withNewLessThanStatement

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

withNewLessThanStatement

public A withNewLessThanStatement(Object left,
 Object right)

withNewLessThanStatementLike

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

withNewLogicalAndCondition

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

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
 Object right)

withNewLogicalAndConditionLike

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

withNewLogicalAndStatement

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

withNewLogicalAndStatement

public A withNewLogicalAndStatement(Object left,
 Object right)

withNewLogicalAndStatementLike

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

withNewLogicalOrCondition

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

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
 Object right)

withNewLogicalOrConditionLike

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

withNewLogicalOrStatement

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

withNewLogicalOrStatement

public A withNewLogicalOrStatement(Object left,
 Object right)

withNewLogicalOrStatementLike

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

withNewMethodCallCondition

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

withNewMethodCallConditionLike

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

withNewMethodCallStatement

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

withNewMethodCallStatementLike

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

withNewMinusCondition

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

withNewMinusCondition

public A withNewMinusCondition(Object left,
 Object right)

withNewMinusConditionLike

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

withNewMinusStatement

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

withNewMinusStatement

public A withNewMinusStatement(Object left,
 Object right)

withNewMinusStatementLike

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

withNewModuloCondition

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

withNewModuloCondition

public A withNewModuloCondition(Object left,
 Object right)

withNewModuloConditionLike

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

withNewModuloStatement

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

withNewModuloStatement

public A withNewModuloStatement(Object left,
 Object right)

withNewModuloStatementLike

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

withNewMultiplyCondition

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

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
 Object right)

withNewMultiplyConditionLike

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

withNewMultiplyStatement

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

withNewMultiplyStatement

public A withNewMultiplyStatement(Object left,
 Object right)

withNewMultiplyStatementLike

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

withNewNegativeCondition

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

withNewNegativeConditionLike

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

withNewNewArrayCondition

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

withNewNewArrayCondition

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

withNewNewArrayConditionLike

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

withNewNotCondition

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

withNewNotConditionLike

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

withNewNotEqualsCondition

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

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
 Object right)

withNewNotEqualsConditionLike

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

withNewNotEqualsStatement

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

withNewNotEqualsStatement

public A withNewNotEqualsStatement(Object left,
 Object right)

withNewNotEqualsStatementLike

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

withNewPlusCondition

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

withNewPlusCondition

public A withNewPlusCondition(Object left,
 Object right)

withNewPlusConditionLike

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

withNewPlusStatement

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

withNewPlusStatement

public A withNewPlusStatement(Object left,
 Object right)

withNewPlusStatementLike

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

withNewPositiveCondition

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

withNewPositiveConditionLike

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

withNewPostDecrementCondition

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

withNewPostDecrementConditionLike

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

withNewPostDecrementStatement

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

withNewPostDecrementStatementLike

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

withNewPostIncrementCondition

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

withNewPostIncrementConditionLike

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

withNewPostIncrementStatement

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

withNewPostIncrementStatementLike

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

withNewPreDecrementCondition

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

withNewPreDecrementConditionLike

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

withNewPreDecrementStatement

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

withNewPreDecrementStatementLike

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

withNewPreIncrementCondition

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

withNewPreIncrementConditionLike

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

withNewPreIncrementStatement

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

withNewPreIncrementStatementLike

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

withNewPropertyCondition

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

withNewPropertyConditionLike

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

withNewPropertyRefCondition

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

withNewPropertyRefConditionLike

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

withNewPropertyRefStatement

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

withNewPropertyRefStatementLike

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

withNewReturnDslThisStepStatement

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

withNewReturnDslThisStepStatementLike

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

withNewReturnDslVariableStepStatement

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

withNewReturnDslVariableStepStatement

public A withNewReturnDslVariableStepStatement(String name)

withNewReturnDslVariableStepStatementLike

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

withNewReturnStatement

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

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewReturnStatementLike

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

withNewRightShiftCondition

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

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
 Object right)

withNewRightShiftConditionLike

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

withNewRightShiftStatement

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

withNewRightShiftStatement

public A withNewRightShiftStatement(Object left,
 Object right)

withNewRightShiftStatementLike

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

withNewRightUnsignedShiftCondition

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

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
 Object right)

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftStatement

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

withNewRightUnsignedShiftStatement

public A withNewRightUnsignedShiftStatement(Object left,
 Object right)

withNewRightUnsignedShiftStatementLike

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

withNewStringStatement

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

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewStringStatementLike

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

withNewSuperCondition

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

withNewSuperConditionLike

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

withNewSwitchStatement

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

withNewSwitchStatementLike

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

withNewSynchronizedStatement

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

withNewSynchronizedStatementLike

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

withNewTernaryCondition

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

withNewTernaryConditionLike

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

withNewThisCondition

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

withNewThisConditionLike

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

withNewThrowStatement

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

withNewThrowStatementLike

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

withNewTryStatement

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

withNewTryStatementLike

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

withNewValueRefCondition

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

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewValueRefConditionLike

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

withNewWhileStatement

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

withNewWhileStatementLike

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

withNewXorCondition

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

withNewXorCondition

public A withNewXorCondition(Object left,
 Object right)

withNewXorConditionLike

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

withNewXorStatement

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

withNewXorStatement

public A withNewXorStatement(Object left,
 Object right)

withNewXorStatementLike

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

withStatement

public A withStatement(Statement statement)