Package io.sundr.model

Class IfFluent<A extends IfFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.IfFluent<A>

Direct Known Subclasses:

BlockFluent.IfStatementsNested, DoFluent.IfStatementNested, ForeachFluent.IfBodyNested, ForFluent.IfBodyNested, IfBuilder, IfDslThenStepFluent.IfStatementsNested, IfFluent.IfElseStatementNested, IfFluent.IfStatementNested, LambdaFluent.IfStatementNested, SynchronizedFluent.IfBodyNested, WhileFluent.IfStatementNested

public class IfFluent<A extends IfFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	IfFluent.AssignConditionNested<N>
class	IfFluent.AssignElseStatementNested<N>
class	IfFluent.AssignStatementNested<N>
class	IfFluent.BinaryExpressionConditionNested<N>
class	IfFluent.BinaryExpressionElseStatementNested<N>
class	IfFluent.BinaryExpressionStatementNested<N>
class	IfFluent.BitwiseAndConditionNested<N>
class	IfFluent.BitwiseAndElseStatementNested<N>
class	IfFluent.BitwiseAndStatementNested<N>
class	IfFluent.BitwiseOrConditionNested<N>
class	IfFluent.BitwiseOrElseStatementNested<N>
class	IfFluent.BitwiseOrStatementNested<N>
class	IfFluent.BlockElseStatementNested<N>
class	IfFluent.BlockStatementNested<N>
class	IfFluent.BreakElseStatementNested<N>
class	IfFluent.BreakStatementNested<N>
class	IfFluent.CastConditionNested<N>
class	IfFluent.ClassRefConditionNested<N>
class	IfFluent.ConstructConditionNested<N>
class	IfFluent.ConstructElseStatementNested<N>
class	IfFluent.ConstructStatementNested<N>
class	IfFluent.ContextRefConditionNested<N>
class	IfFluent.ContinueElseStatementNested<N>
class	IfFluent.ContinueStatementNested<N>
class	IfFluent.DeclareConditionNested<N>
class	IfFluent.DeclareElseStatementNested<N>
class	IfFluent.DeclareStatementNested<N>
class	IfFluent.DivideConditionNested<N>
class	IfFluent.DivideElseStatementNested<N>
class	IfFluent.DivideStatementNested<N>
class	IfFluent.DoElseStatementNested<N>
class	IfFluent.DoStatementNested<N>
class	IfFluent.DotClassConditionNested<N>
class	IfFluent.EmptyConditionNested<N>
class	IfFluent.EmptyElseStatementNested<N>
class	IfFluent.EmptyStatementNested<N>
class	IfFluent.EnclosedConditionNested<N>
class	IfFluent.EqualsConditionNested<N>
class	IfFluent.EqualsElseStatementNested<N>
class	IfFluent.EqualsStatementNested<N>
class	IfFluent.ForeachElseStatementNested<N>
class	IfFluent.ForeachStatementNested<N>
class	IfFluent.ForElseStatementNested<N>
class	IfFluent.ForStatementNested<N>
class	IfFluent.GreaterThanConditionNested<N>
class	IfFluent.GreaterThanElseStatementNested<N>
class	IfFluent.GreaterThanOrEqualConditionNested<N>
class	IfFluent.GreaterThanOrEqualElseStatementNested<N>
class	IfFluent.GreaterThanOrEqualStatementNested<N>
class	IfFluent.GreaterThanStatementNested<N>
class	IfFluent.IfDslThenStepElseStatementNested<N>
class	IfFluent.IfDslThenStepStatementNested<N>
class	IfFluent.IfElseStatementNested<N>
class	IfFluent.IfStatementNested<N>
class	IfFluent.IndexConditionNested<N>
class	IfFluent.InstanceOfConditionNested<N>
class	IfFluent.InverseConditionNested<N>
class	IfFluent.LambdaConditionNested<N>
class	IfFluent.LambdaElseStatementNested<N>
class	IfFluent.LambdaStatementNested<N>
class	IfFluent.LeftShiftConditionNested<N>
class	IfFluent.LeftShiftElseStatementNested<N>
class	IfFluent.LeftShiftStatementNested<N>
class	IfFluent.LessThanConditionNested<N>
class	IfFluent.LessThanElseStatementNested<N>
class	IfFluent.LessThanOrEqualConditionNested<N>
class	IfFluent.LessThanOrEqualElseStatementNested<N>
class	IfFluent.LessThanOrEqualStatementNested<N>
class	IfFluent.LessThanStatementNested<N>
class	IfFluent.LogicalAndConditionNested<N>
class	IfFluent.LogicalAndElseStatementNested<N>
class	IfFluent.LogicalAndStatementNested<N>
class	IfFluent.LogicalOrConditionNested<N>
class	IfFluent.LogicalOrElseStatementNested<N>
class	IfFluent.LogicalOrStatementNested<N>
class	IfFluent.MethodCallConditionNested<N>
class	IfFluent.MethodCallElseStatementNested<N>
class	IfFluent.MethodCallStatementNested<N>
class	IfFluent.MinusConditionNested<N>
class	IfFluent.MinusElseStatementNested<N>
class	IfFluent.MinusStatementNested<N>
class	IfFluent.ModuloConditionNested<N>
class	IfFluent.ModuloElseStatementNested<N>
class	IfFluent.ModuloStatementNested<N>
class	IfFluent.MultiplyConditionNested<N>
class	IfFluent.MultiplyElseStatementNested<N>
class	IfFluent.MultiplyStatementNested<N>
class	IfFluent.NegativeConditionNested<N>
class	IfFluent.NewArrayConditionNested<N>
class	IfFluent.NotConditionNested<N>
class	IfFluent.NotEqualsConditionNested<N>
class	IfFluent.NotEqualsElseStatementNested<N>
class	IfFluent.NotEqualsStatementNested<N>
class	IfFluent.PlusConditionNested<N>
class	IfFluent.PlusElseStatementNested<N>
class	IfFluent.PlusStatementNested<N>
class	IfFluent.PositiveConditionNested<N>
class	IfFluent.PostDecrementConditionNested<N>
class	IfFluent.PostDecrementElseStatementNested<N>
class	IfFluent.PostDecrementStatementNested<N>
class	IfFluent.PostIncrementConditionNested<N>
class	IfFluent.PostIncrementElseStatementNested<N>
class	IfFluent.PostIncrementStatementNested<N>
class	IfFluent.PreDecrementConditionNested<N>
class	IfFluent.PreDecrementElseStatementNested<N>
class	IfFluent.PreDecrementStatementNested<N>
class	IfFluent.PreIncrementConditionNested<N>
class	IfFluent.PreIncrementElseStatementNested<N>
class	IfFluent.PreIncrementStatementNested<N>
class	IfFluent.PropertyConditionNested<N>
class	IfFluent.PropertyRefConditionNested<N>
class	IfFluent.PropertyRefElseStatementNested<N>
class	IfFluent.PropertyRefStatementNested<N>
class	IfFluent.ReturnDslThisStepElseStatementNested<N>
class	IfFluent.ReturnDslThisStepStatementNested<N>
class	IfFluent.ReturnDslVariableStepElseStatementNested<N>
class	IfFluent.ReturnDslVariableStepStatementNested<N>
class	IfFluent.ReturnElseStatementNested<N>
class	IfFluent.ReturnStatementNested<N>
class	IfFluent.RightShiftConditionNested<N>
class	IfFluent.RightShiftElseStatementNested<N>
class	IfFluent.RightShiftStatementNested<N>
class	IfFluent.RightUnsignedShiftConditionNested<N>
class	IfFluent.RightUnsignedShiftElseStatementNested<N>
class	IfFluent.RightUnsignedShiftStatementNested<N>
class	IfFluent.StringStatementElseNested<N>
class	IfFluent.StringStatementNested<N>
class	IfFluent.SuperConditionNested<N>
class	IfFluent.SwitchElseStatementNested<N>
class	IfFluent.SwitchStatementNested<N>
class	IfFluent.SynchronizedElseStatementNested<N>
class	IfFluent.SynchronizedStatementNested<N>
class	IfFluent.TernaryConditionNested<N>
class	IfFluent.ThisConditionNested<N>
class	IfFluent.ThrowElseStatementNested<N>
class	IfFluent.ThrowStatementNested<N>
class	IfFluent.TryElseStatementNested<N>
class	IfFluent.TryStatementNested<N>
class	IfFluent.ValueRefConditionNested<N>
class	IfFluent.WhileElseStatementNested<N>
class	IfFluent.WhileStatementNested<N>
class	IfFluent.XorConditionNested<N>
class	IfFluent.XorElseStatementNested<N>
class	IfFluent.XorStatementNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
IfFluent()
IfFluent(If instance)

Method Summary

Modifier and Type	Method	Description
Expression	buildCondition()
Optional<Statement>	buildElseStatement()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Statement	buildStatement()
protected void	copyInstance(If instance)
boolean	equals(Object o)
boolean	hasCondition()
boolean	hasElseStatement()
int	hashCode()
boolean	hasStatement()
String	toString()
A	withCondition(Expression condition)
A	withElseStatement(Statement elseStatement)
A	withElseStatement(Optional<Statement> elseStatement)
IfFluent<A>.AssignConditionNested<A>	withNewAssignCondition()
IfFluent<A>.AssignConditionNested<A>	withNewAssignConditionLike(Assign item)
IfFluent<A>.AssignElseStatementNested<A>	withNewAssignElseStatement()
IfFluent<A>.AssignElseStatementNested<A>	withNewAssignElseStatementLike(Assign item)
IfFluent<A>.AssignStatementNested<A>	withNewAssignStatement()
IfFluent<A>.AssignStatementNested<A>	withNewAssignStatementLike(Assign item)
IfFluent<A>.BinaryExpressionConditionNested<A>	withNewBinaryExpressionCondition()
IfFluent<A>.BinaryExpressionConditionNested<A>	withNewBinaryExpressionConditionLike(BinaryExpression item)
IfFluent<A>.BinaryExpressionElseStatementNested<A>	withNewBinaryExpressionElseStatement()
IfFluent<A>.BinaryExpressionElseStatementNested<A>	withNewBinaryExpressionElseStatementLike(BinaryExpression item)
IfFluent<A>.BinaryExpressionStatementNested<A>	withNewBinaryExpressionStatement()
IfFluent<A>.BinaryExpressionStatementNested<A>	withNewBinaryExpressionStatementLike(BinaryExpression item)
IfFluent<A>.BitwiseAndConditionNested<A>	withNewBitwiseAndCondition()
A	withNewBitwiseAndCondition(Object left, Object right)
IfFluent<A>.BitwiseAndConditionNested<A>	withNewBitwiseAndConditionLike(BitwiseAnd item)
IfFluent<A>.BitwiseAndElseStatementNested<A>	withNewBitwiseAndElseStatement()
A	withNewBitwiseAndElseStatement(Object left, Object right)
IfFluent<A>.BitwiseAndElseStatementNested<A>	withNewBitwiseAndElseStatementLike(BitwiseAnd item)
IfFluent<A>.BitwiseAndStatementNested<A>	withNewBitwiseAndStatement()
A	withNewBitwiseAndStatement(Object left, Object right)
IfFluent<A>.BitwiseAndStatementNested<A>	withNewBitwiseAndStatementLike(BitwiseAnd item)
IfFluent<A>.BitwiseOrConditionNested<A>	withNewBitwiseOrCondition()
A	withNewBitwiseOrCondition(Object left, Object right)
IfFluent<A>.BitwiseOrConditionNested<A>	withNewBitwiseOrConditionLike(BitwiseOr item)
IfFluent<A>.BitwiseOrElseStatementNested<A>	withNewBitwiseOrElseStatement()
A	withNewBitwiseOrElseStatement(Object left, Object right)
IfFluent<A>.BitwiseOrElseStatementNested<A>	withNewBitwiseOrElseStatementLike(BitwiseOr item)
IfFluent<A>.BitwiseOrStatementNested<A>	withNewBitwiseOrStatement()
A	withNewBitwiseOrStatement(Object left, Object right)
IfFluent<A>.BitwiseOrStatementNested<A>	withNewBitwiseOrStatementLike(BitwiseOr item)
IfFluent<A>.BlockElseStatementNested<A>	withNewBlockElseStatement()
IfFluent<A>.BlockElseStatementNested<A>	withNewBlockElseStatementLike(Block item)
IfFluent<A>.BlockStatementNested<A>	withNewBlockStatement()
IfFluent<A>.BlockStatementNested<A>	withNewBlockStatementLike(Block item)
IfFluent<A>.BreakElseStatementNested<A>	withNewBreakElseStatement()
IfFluent<A>.BreakElseStatementNested<A>	withNewBreakElseStatementLike(Break item)
IfFluent<A>.BreakStatementNested<A>	withNewBreakStatement()
IfFluent<A>.BreakStatementNested<A>	withNewBreakStatementLike(Break item)
IfFluent<A>.CastConditionNested<A>	withNewCastCondition()
IfFluent<A>.CastConditionNested<A>	withNewCastConditionLike(Cast item)
IfFluent<A>.ClassRefConditionNested<A>	withNewClassRefCondition()
IfFluent<A>.ClassRefConditionNested<A>	withNewClassRefConditionLike(ClassRef item)
IfFluent<A>.ConstructConditionNested<A>	withNewConstructCondition()
IfFluent<A>.ConstructConditionNested<A>	withNewConstructConditionLike(Construct item)
IfFluent<A>.ConstructElseStatementNested<A>	withNewConstructElseStatement()
IfFluent<A>.ConstructElseStatementNested<A>	withNewConstructElseStatementLike(Construct item)
IfFluent<A>.ConstructStatementNested<A>	withNewConstructStatement()
IfFluent<A>.ConstructStatementNested<A>	withNewConstructStatementLike(Construct item)
IfFluent<A>.ContextRefConditionNested<A>	withNewContextRefCondition()
A	withNewContextRefCondition(String name)
IfFluent<A>.ContextRefConditionNested<A>	withNewContextRefConditionLike(ContextRef item)
IfFluent<A>.ContinueElseStatementNested<A>	withNewContinueElseStatement()
IfFluent<A>.ContinueElseStatementNested<A>	withNewContinueElseStatementLike(Continue item)
IfFluent<A>.ContinueStatementNested<A>	withNewContinueStatement()
IfFluent<A>.ContinueStatementNested<A>	withNewContinueStatementLike(Continue item)
IfFluent<A>.DeclareConditionNested<A>	withNewDeclareCondition()
A	withNewDeclareCondition(Class type, String name)
A	withNewDeclareCondition(Class type, String name, Object value)
IfFluent<A>.DeclareConditionNested<A>	withNewDeclareConditionLike(Declare item)
IfFluent<A>.DeclareElseStatementNested<A>	withNewDeclareElseStatement()
A	withNewDeclareElseStatement(Class type, String name)
A	withNewDeclareElseStatement(Class type, String name, Object value)
IfFluent<A>.DeclareElseStatementNested<A>	withNewDeclareElseStatementLike(Declare item)
IfFluent<A>.DeclareStatementNested<A>	withNewDeclareStatement()
A	withNewDeclareStatement(Class type, String name)
A	withNewDeclareStatement(Class type, String name, Object value)
IfFluent<A>.DeclareStatementNested<A>	withNewDeclareStatementLike(Declare item)
IfFluent<A>.DivideConditionNested<A>	withNewDivideCondition()
A	withNewDivideCondition(Object left, Object right)
IfFluent<A>.DivideConditionNested<A>	withNewDivideConditionLike(Divide item)
IfFluent<A>.DivideElseStatementNested<A>	withNewDivideElseStatement()
A	withNewDivideElseStatement(Object left, Object right)
IfFluent<A>.DivideElseStatementNested<A>	withNewDivideElseStatementLike(Divide item)
IfFluent<A>.DivideStatementNested<A>	withNewDivideStatement()
A	withNewDivideStatement(Object left, Object right)
IfFluent<A>.DivideStatementNested<A>	withNewDivideStatementLike(Divide item)
IfFluent<A>.DoElseStatementNested<A>	withNewDoElseStatement()
IfFluent<A>.DoElseStatementNested<A>	withNewDoElseStatementLike(Do item)
IfFluent<A>.DoStatementNested<A>	withNewDoStatement()
IfFluent<A>.DoStatementNested<A>	withNewDoStatementLike(Do item)
IfFluent<A>.DotClassConditionNested<A>	withNewDotClassCondition()
IfFluent<A>.DotClassConditionNested<A>	withNewDotClassConditionLike(DotClass item)
IfFluent<A>.EmptyConditionNested<A>	withNewEmptyCondition()
IfFluent<A>.EmptyConditionNested<A>	withNewEmptyConditionLike(Empty item)
IfFluent<A>.EmptyElseStatementNested<A>	withNewEmptyElseStatement()
IfFluent<A>.EmptyElseStatementNested<A>	withNewEmptyElseStatementLike(Empty item)
IfFluent<A>.EmptyStatementNested<A>	withNewEmptyStatement()
IfFluent<A>.EmptyStatementNested<A>	withNewEmptyStatementLike(Empty item)
IfFluent<A>.EnclosedConditionNested<A>	withNewEnclosedCondition()
IfFluent<A>.EnclosedConditionNested<A>	withNewEnclosedConditionLike(Enclosed item)
IfFluent<A>.EqualsConditionNested<A>	withNewEqualsCondition()
A	withNewEqualsCondition(Object left, Object right)
IfFluent<A>.EqualsConditionNested<A>	withNewEqualsConditionLike(Equals item)
IfFluent<A>.EqualsElseStatementNested<A>	withNewEqualsElseStatement()
A	withNewEqualsElseStatement(Object left, Object right)
IfFluent<A>.EqualsElseStatementNested<A>	withNewEqualsElseStatementLike(Equals item)
IfFluent<A>.EqualsStatementNested<A>	withNewEqualsStatement()
A	withNewEqualsStatement(Object left, Object right)
IfFluent<A>.EqualsStatementNested<A>	withNewEqualsStatementLike(Equals item)
IfFluent<A>.ForeachElseStatementNested<A>	withNewForeachElseStatement()
IfFluent<A>.ForeachElseStatementNested<A>	withNewForeachElseStatementLike(Foreach item)
IfFluent<A>.ForeachStatementNested<A>	withNewForeachStatement()
IfFluent<A>.ForeachStatementNested<A>	withNewForeachStatementLike(Foreach item)
IfFluent<A>.ForElseStatementNested<A>	withNewForElseStatement()
IfFluent<A>.ForElseStatementNested<A>	withNewForElseStatementLike(For item)
IfFluent<A>.ForStatementNested<A>	withNewForStatement()
IfFluent<A>.ForStatementNested<A>	withNewForStatementLike(For item)
IfFluent<A>.GreaterThanConditionNested<A>	withNewGreaterThanCondition()
A	withNewGreaterThanCondition(Object left, Object right)
IfFluent<A>.GreaterThanConditionNested<A>	withNewGreaterThanConditionLike(GreaterThan item)
IfFluent<A>.GreaterThanElseStatementNested<A>	withNewGreaterThanElseStatement()
A	withNewGreaterThanElseStatement(Object left, Object right)
IfFluent<A>.GreaterThanElseStatementNested<A>	withNewGreaterThanElseStatementLike(GreaterThan item)
IfFluent<A>.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualCondition()
A	withNewGreaterThanOrEqualCondition(Object left, Object right)
IfFluent<A>.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualConditionLike(GreaterThanOrEqual item)
IfFluent<A>.GreaterThanOrEqualElseStatementNested<A>	withNewGreaterThanOrEqualElseStatement()
A	withNewGreaterThanOrEqualElseStatement(Object left, Object right)
IfFluent<A>.GreaterThanOrEqualElseStatementNested<A>	withNewGreaterThanOrEqualElseStatementLike(GreaterThanOrEqual item)
IfFluent<A>.GreaterThanOrEqualStatementNested<A>	withNewGreaterThanOrEqualStatement()
A	withNewGreaterThanOrEqualStatement(Object left, Object right)
IfFluent<A>.GreaterThanOrEqualStatementNested<A>	withNewGreaterThanOrEqualStatementLike(GreaterThanOrEqual item)
IfFluent<A>.GreaterThanStatementNested<A>	withNewGreaterThanStatement()
A	withNewGreaterThanStatement(Object left, Object right)
IfFluent<A>.GreaterThanStatementNested<A>	withNewGreaterThanStatementLike(GreaterThan item)
IfFluent<A>.IfDslThenStepElseStatementNested<A>	withNewIfDslThenStepElseStatement()
IfFluent<A>.IfDslThenStepElseStatementNested<A>	withNewIfDslThenStepElseStatementLike(IfDslThenStep item)
IfFluent<A>.IfDslThenStepStatementNested<A>	withNewIfDslThenStepStatement()
IfFluent<A>.IfDslThenStepStatementNested<A>	withNewIfDslThenStepStatementLike(IfDslThenStep item)
IfFluent<A>.IfElseStatementNested<A>	withNewIfElseStatement()
IfFluent<A>.IfElseStatementNested<A>	withNewIfElseStatementLike(If item)
IfFluent<A>.IfStatementNested<A>	withNewIfStatement()
IfFluent<A>.IfStatementNested<A>	withNewIfStatementLike(If item)
IfFluent<A>.IndexConditionNested<A>	withNewIndexCondition()
IfFluent<A>.IndexConditionNested<A>	withNewIndexConditionLike(Index item)
IfFluent<A>.InstanceOfConditionNested<A>	withNewInstanceOfCondition()
IfFluent<A>.InstanceOfConditionNested<A>	withNewInstanceOfConditionLike(InstanceOf item)
IfFluent<A>.InverseConditionNested<A>	withNewInverseCondition()
IfFluent<A>.InverseConditionNested<A>	withNewInverseConditionLike(Inverse item)
IfFluent<A>.LambdaConditionNested<A>	withNewLambdaCondition()
IfFluent<A>.LambdaConditionNested<A>	withNewLambdaConditionLike(Lambda item)
IfFluent<A>.LambdaElseStatementNested<A>	withNewLambdaElseStatement()
IfFluent<A>.LambdaElseStatementNested<A>	withNewLambdaElseStatementLike(Lambda item)
IfFluent<A>.LambdaStatementNested<A>	withNewLambdaStatement()
IfFluent<A>.LambdaStatementNested<A>	withNewLambdaStatementLike(Lambda item)
IfFluent<A>.LeftShiftConditionNested<A>	withNewLeftShiftCondition()
A	withNewLeftShiftCondition(Object left, Object right)
IfFluent<A>.LeftShiftConditionNested<A>	withNewLeftShiftConditionLike(LeftShift item)
IfFluent<A>.LeftShiftElseStatementNested<A>	withNewLeftShiftElseStatement()
A	withNewLeftShiftElseStatement(Object left, Object right)
IfFluent<A>.LeftShiftElseStatementNested<A>	withNewLeftShiftElseStatementLike(LeftShift item)
IfFluent<A>.LeftShiftStatementNested<A>	withNewLeftShiftStatement()
A	withNewLeftShiftStatement(Object left, Object right)
IfFluent<A>.LeftShiftStatementNested<A>	withNewLeftShiftStatementLike(LeftShift item)
IfFluent<A>.LessThanConditionNested<A>	withNewLessThanCondition()
A	withNewLessThanCondition(Object left, Object right)
IfFluent<A>.LessThanConditionNested<A>	withNewLessThanConditionLike(LessThan item)
IfFluent<A>.LessThanElseStatementNested<A>	withNewLessThanElseStatement()
A	withNewLessThanElseStatement(Object left, Object right)
IfFluent<A>.LessThanElseStatementNested<A>	withNewLessThanElseStatementLike(LessThan item)
IfFluent<A>.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualCondition()
A	withNewLessThanOrEqualCondition(Object left, Object right)
IfFluent<A>.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualConditionLike(LessThanOrEqual item)
IfFluent<A>.LessThanOrEqualElseStatementNested<A>	withNewLessThanOrEqualElseStatement()
A	withNewLessThanOrEqualElseStatement(Object left, Object right)
IfFluent<A>.LessThanOrEqualElseStatementNested<A>	withNewLessThanOrEqualElseStatementLike(LessThanOrEqual item)
IfFluent<A>.LessThanOrEqualStatementNested<A>	withNewLessThanOrEqualStatement()
A	withNewLessThanOrEqualStatement(Object left, Object right)
IfFluent<A>.LessThanOrEqualStatementNested<A>	withNewLessThanOrEqualStatementLike(LessThanOrEqual item)
IfFluent<A>.LessThanStatementNested<A>	withNewLessThanStatement()
A	withNewLessThanStatement(Object left, Object right)
IfFluent<A>.LessThanStatementNested<A>	withNewLessThanStatementLike(LessThan item)
IfFluent<A>.LogicalAndConditionNested<A>	withNewLogicalAndCondition()
A	withNewLogicalAndCondition(Object left, Object right)
IfFluent<A>.LogicalAndConditionNested<A>	withNewLogicalAndConditionLike(LogicalAnd item)
IfFluent<A>.LogicalAndElseStatementNested<A>	withNewLogicalAndElseStatement()
A	withNewLogicalAndElseStatement(Object left, Object right)
IfFluent<A>.LogicalAndElseStatementNested<A>	withNewLogicalAndElseStatementLike(LogicalAnd item)
IfFluent<A>.LogicalAndStatementNested<A>	withNewLogicalAndStatement()
A	withNewLogicalAndStatement(Object left, Object right)
IfFluent<A>.LogicalAndStatementNested<A>	withNewLogicalAndStatementLike(LogicalAnd item)
IfFluent<A>.LogicalOrConditionNested<A>	withNewLogicalOrCondition()
A	withNewLogicalOrCondition(Object left, Object right)
IfFluent<A>.LogicalOrConditionNested<A>	withNewLogicalOrConditionLike(LogicalOr item)
IfFluent<A>.LogicalOrElseStatementNested<A>	withNewLogicalOrElseStatement()
A	withNewLogicalOrElseStatement(Object left, Object right)
IfFluent<A>.LogicalOrElseStatementNested<A>	withNewLogicalOrElseStatementLike(LogicalOr item)
IfFluent<A>.LogicalOrStatementNested<A>	withNewLogicalOrStatement()
A	withNewLogicalOrStatement(Object left, Object right)
IfFluent<A>.LogicalOrStatementNested<A>	withNewLogicalOrStatementLike(LogicalOr item)
IfFluent<A>.MethodCallConditionNested<A>	withNewMethodCallCondition()
IfFluent<A>.MethodCallConditionNested<A>	withNewMethodCallConditionLike(MethodCall item)
IfFluent<A>.MethodCallElseStatementNested<A>	withNewMethodCallElseStatement()
IfFluent<A>.MethodCallElseStatementNested<A>	withNewMethodCallElseStatementLike(MethodCall item)
IfFluent<A>.MethodCallStatementNested<A>	withNewMethodCallStatement()
IfFluent<A>.MethodCallStatementNested<A>	withNewMethodCallStatementLike(MethodCall item)
IfFluent<A>.MinusConditionNested<A>	withNewMinusCondition()
A	withNewMinusCondition(Object left, Object right)
IfFluent<A>.MinusConditionNested<A>	withNewMinusConditionLike(Minus item)
IfFluent<A>.MinusElseStatementNested<A>	withNewMinusElseStatement()
A	withNewMinusElseStatement(Object left, Object right)
IfFluent<A>.MinusElseStatementNested<A>	withNewMinusElseStatementLike(Minus item)
IfFluent<A>.MinusStatementNested<A>	withNewMinusStatement()
A	withNewMinusStatement(Object left, Object right)
IfFluent<A>.MinusStatementNested<A>	withNewMinusStatementLike(Minus item)
IfFluent<A>.ModuloConditionNested<A>	withNewModuloCondition()
A	withNewModuloCondition(Object left, Object right)
IfFluent<A>.ModuloConditionNested<A>	withNewModuloConditionLike(Modulo item)
IfFluent<A>.ModuloElseStatementNested<A>	withNewModuloElseStatement()
A	withNewModuloElseStatement(Object left, Object right)
IfFluent<A>.ModuloElseStatementNested<A>	withNewModuloElseStatementLike(Modulo item)
IfFluent<A>.ModuloStatementNested<A>	withNewModuloStatement()
A	withNewModuloStatement(Object left, Object right)
IfFluent<A>.ModuloStatementNested<A>	withNewModuloStatementLike(Modulo item)
IfFluent<A>.MultiplyConditionNested<A>	withNewMultiplyCondition()
A	withNewMultiplyCondition(Object left, Object right)
IfFluent<A>.MultiplyConditionNested<A>	withNewMultiplyConditionLike(Multiply item)
IfFluent<A>.MultiplyElseStatementNested<A>	withNewMultiplyElseStatement()
A	withNewMultiplyElseStatement(Object left, Object right)
IfFluent<A>.MultiplyElseStatementNested<A>	withNewMultiplyElseStatementLike(Multiply item)
IfFluent<A>.MultiplyStatementNested<A>	withNewMultiplyStatement()
A	withNewMultiplyStatement(Object left, Object right)
IfFluent<A>.MultiplyStatementNested<A>	withNewMultiplyStatementLike(Multiply item)
IfFluent<A>.NegativeConditionNested<A>	withNewNegativeCondition()
IfFluent<A>.NegativeConditionNested<A>	withNewNegativeConditionLike(Negative item)
IfFluent<A>.NewArrayConditionNested<A>	withNewNewArrayCondition()
A	withNewNewArrayCondition(Class type, Integer[] sizes)
IfFluent<A>.NewArrayConditionNested<A>	withNewNewArrayConditionLike(NewArray item)
IfFluent<A>.NotConditionNested<A>	withNewNotCondition()
IfFluent<A>.NotConditionNested<A>	withNewNotConditionLike(Not item)
IfFluent<A>.NotEqualsConditionNested<A>	withNewNotEqualsCondition()
A	withNewNotEqualsCondition(Object left, Object right)
IfFluent<A>.NotEqualsConditionNested<A>	withNewNotEqualsConditionLike(NotEquals item)
IfFluent<A>.NotEqualsElseStatementNested<A>	withNewNotEqualsElseStatement()
A	withNewNotEqualsElseStatement(Object left, Object right)
IfFluent<A>.NotEqualsElseStatementNested<A>	withNewNotEqualsElseStatementLike(NotEquals item)
IfFluent<A>.NotEqualsStatementNested<A>	withNewNotEqualsStatement()
A	withNewNotEqualsStatement(Object left, Object right)
IfFluent<A>.NotEqualsStatementNested<A>	withNewNotEqualsStatementLike(NotEquals item)
IfFluent<A>.PlusConditionNested<A>	withNewPlusCondition()
A	withNewPlusCondition(Object left, Object right)
IfFluent<A>.PlusConditionNested<A>	withNewPlusConditionLike(Plus item)
IfFluent<A>.PlusElseStatementNested<A>	withNewPlusElseStatement()
A	withNewPlusElseStatement(Object left, Object right)
IfFluent<A>.PlusElseStatementNested<A>	withNewPlusElseStatementLike(Plus item)
IfFluent<A>.PlusStatementNested<A>	withNewPlusStatement()
A	withNewPlusStatement(Object left, Object right)
IfFluent<A>.PlusStatementNested<A>	withNewPlusStatementLike(Plus item)
IfFluent<A>.PositiveConditionNested<A>	withNewPositiveCondition()
IfFluent<A>.PositiveConditionNested<A>	withNewPositiveConditionLike(Positive item)
IfFluent<A>.PostDecrementConditionNested<A>	withNewPostDecrementCondition()
IfFluent<A>.PostDecrementConditionNested<A>	withNewPostDecrementConditionLike(PostDecrement item)
IfFluent<A>.PostDecrementElseStatementNested<A>	withNewPostDecrementElseStatement()
IfFluent<A>.PostDecrementElseStatementNested<A>	withNewPostDecrementElseStatementLike(PostDecrement item)
IfFluent<A>.PostDecrementStatementNested<A>	withNewPostDecrementStatement()
IfFluent<A>.PostDecrementStatementNested<A>	withNewPostDecrementStatementLike(PostDecrement item)
IfFluent<A>.PostIncrementConditionNested<A>	withNewPostIncrementCondition()
IfFluent<A>.PostIncrementConditionNested<A>	withNewPostIncrementConditionLike(PostIncrement item)
IfFluent<A>.PostIncrementElseStatementNested<A>	withNewPostIncrementElseStatement()
IfFluent<A>.PostIncrementElseStatementNested<A>	withNewPostIncrementElseStatementLike(PostIncrement item)
IfFluent<A>.PostIncrementStatementNested<A>	withNewPostIncrementStatement()
IfFluent<A>.PostIncrementStatementNested<A>	withNewPostIncrementStatementLike(PostIncrement item)
IfFluent<A>.PreDecrementConditionNested<A>	withNewPreDecrementCondition()
IfFluent<A>.PreDecrementConditionNested<A>	withNewPreDecrementConditionLike(PreDecrement item)
IfFluent<A>.PreDecrementElseStatementNested<A>	withNewPreDecrementElseStatement()
IfFluent<A>.PreDecrementElseStatementNested<A>	withNewPreDecrementElseStatementLike(PreDecrement item)
IfFluent<A>.PreDecrementStatementNested<A>	withNewPreDecrementStatement()
IfFluent<A>.PreDecrementStatementNested<A>	withNewPreDecrementStatementLike(PreDecrement item)
IfFluent<A>.PreIncrementConditionNested<A>	withNewPreIncrementCondition()
IfFluent<A>.PreIncrementConditionNested<A>	withNewPreIncrementConditionLike(PreIncrement item)
IfFluent<A>.PreIncrementElseStatementNested<A>	withNewPreIncrementElseStatement()
IfFluent<A>.PreIncrementElseStatementNested<A>	withNewPreIncrementElseStatementLike(PreIncrement item)
IfFluent<A>.PreIncrementStatementNested<A>	withNewPreIncrementStatement()
IfFluent<A>.PreIncrementStatementNested<A>	withNewPreIncrementStatementLike(PreIncrement item)
IfFluent<A>.PropertyConditionNested<A>	withNewPropertyCondition()
IfFluent<A>.PropertyConditionNested<A>	withNewPropertyConditionLike(Property item)
IfFluent<A>.PropertyRefConditionNested<A>	withNewPropertyRefCondition()
IfFluent<A>.PropertyRefConditionNested<A>	withNewPropertyRefConditionLike(PropertyRef item)
IfFluent<A>.PropertyRefElseStatementNested<A>	withNewPropertyRefElseStatement()
IfFluent<A>.PropertyRefElseStatementNested<A>	withNewPropertyRefElseStatementLike(PropertyRef item)
IfFluent<A>.PropertyRefStatementNested<A>	withNewPropertyRefStatement()
IfFluent<A>.PropertyRefStatementNested<A>	withNewPropertyRefStatementLike(PropertyRef item)
IfFluent<A>.ReturnDslThisStepElseStatementNested<A>	withNewReturnDslThisStepElseStatement()
IfFluent<A>.ReturnDslThisStepElseStatementNested<A>	withNewReturnDslThisStepElseStatementLike(ReturnDslThisStep item)
IfFluent<A>.ReturnDslThisStepStatementNested<A>	withNewReturnDslThisStepStatement()
IfFluent<A>.ReturnDslThisStepStatementNested<A>	withNewReturnDslThisStepStatementLike(ReturnDslThisStep item)
IfFluent<A>.ReturnDslVariableStepElseStatementNested<A>	withNewReturnDslVariableStepElseStatement()
A	withNewReturnDslVariableStepElseStatement(String name)
IfFluent<A>.ReturnDslVariableStepElseStatementNested<A>	withNewReturnDslVariableStepElseStatementLike(ReturnDslVariableStep item)
IfFluent<A>.ReturnDslVariableStepStatementNested<A>	withNewReturnDslVariableStepStatement()
A	withNewReturnDslVariableStepStatement(String name)
IfFluent<A>.ReturnDslVariableStepStatementNested<A>	withNewReturnDslVariableStepStatementLike(ReturnDslVariableStep item)
IfFluent<A>.ReturnElseStatementNested<A>	withNewReturnElseStatement()
A	withNewReturnElseStatement(Object object)
IfFluent<A>.ReturnElseStatementNested<A>	withNewReturnElseStatementLike(Return item)
IfFluent<A>.ReturnStatementNested<A>	withNewReturnStatement()
A	withNewReturnStatement(Object object)
IfFluent<A>.ReturnStatementNested<A>	withNewReturnStatementLike(Return item)
IfFluent<A>.RightShiftConditionNested<A>	withNewRightShiftCondition()
A	withNewRightShiftCondition(Object left, Object right)
IfFluent<A>.RightShiftConditionNested<A>	withNewRightShiftConditionLike(RightShift item)
IfFluent<A>.RightShiftElseStatementNested<A>	withNewRightShiftElseStatement()
A	withNewRightShiftElseStatement(Object left, Object right)
IfFluent<A>.RightShiftElseStatementNested<A>	withNewRightShiftElseStatementLike(RightShift item)
IfFluent<A>.RightShiftStatementNested<A>	withNewRightShiftStatement()
A	withNewRightShiftStatement(Object left, Object right)
IfFluent<A>.RightShiftStatementNested<A>	withNewRightShiftStatementLike(RightShift item)
IfFluent<A>.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftCondition()
A	withNewRightUnsignedShiftCondition(Object left, Object right)
IfFluent<A>.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftConditionLike(RightUnsignedShift item)
IfFluent<A>.RightUnsignedShiftElseStatementNested<A>	withNewRightUnsignedShiftElseStatement()
A	withNewRightUnsignedShiftElseStatement(Object left, Object right)
IfFluent<A>.RightUnsignedShiftElseStatementNested<A>	withNewRightUnsignedShiftElseStatementLike(RightUnsignedShift item)
IfFluent<A>.RightUnsignedShiftStatementNested<A>	withNewRightUnsignedShiftStatement()
A	withNewRightUnsignedShiftStatement(Object left, Object right)
IfFluent<A>.RightUnsignedShiftStatementNested<A>	withNewRightUnsignedShiftStatementLike(RightUnsignedShift item)
IfFluent<A>.StringStatementNested<A>	withNewStringStatement()
A	withNewStringStatement(String data)
A	withNewStringStatement(String data, Object[] parameters)
IfFluent<A>.StringStatementElseNested<A>	withNewStringStatementElse()
A	withNewStringStatementElse(String data)
A	withNewStringStatementElse(String data, Object[] parameters)
IfFluent<A>.StringStatementElseNested<A>	withNewStringStatementElseLike(StringStatement item)
IfFluent<A>.StringStatementNested<A>	withNewStringStatementLike(StringStatement item)
IfFluent<A>.SuperConditionNested<A>	withNewSuperCondition()
IfFluent<A>.SuperConditionNested<A>	withNewSuperConditionLike(Super item)
IfFluent<A>.SwitchElseStatementNested<A>	withNewSwitchElseStatement()
IfFluent<A>.SwitchElseStatementNested<A>	withNewSwitchElseStatementLike(Switch item)
IfFluent<A>.SwitchStatementNested<A>	withNewSwitchStatement()
IfFluent<A>.SwitchStatementNested<A>	withNewSwitchStatementLike(Switch item)
IfFluent<A>.SynchronizedElseStatementNested<A>	withNewSynchronizedElseStatement()
IfFluent<A>.SynchronizedElseStatementNested<A>	withNewSynchronizedElseStatementLike(Synchronized item)
IfFluent<A>.SynchronizedStatementNested<A>	withNewSynchronizedStatement()
IfFluent<A>.SynchronizedStatementNested<A>	withNewSynchronizedStatementLike(Synchronized item)
IfFluent<A>.TernaryConditionNested<A>	withNewTernaryCondition()
IfFluent<A>.TernaryConditionNested<A>	withNewTernaryConditionLike(Ternary item)
IfFluent<A>.ThisConditionNested<A>	withNewThisCondition()
IfFluent<A>.ThisConditionNested<A>	withNewThisConditionLike(This item)
IfFluent<A>.ThrowElseStatementNested<A>	withNewThrowElseStatement()
IfFluent<A>.ThrowElseStatementNested<A>	withNewThrowElseStatementLike(Throw item)
IfFluent<A>.ThrowStatementNested<A>	withNewThrowStatement()
IfFluent<A>.ThrowStatementNested<A>	withNewThrowStatementLike(Throw item)
IfFluent<A>.TryElseStatementNested<A>	withNewTryElseStatement()
IfFluent<A>.TryElseStatementNested<A>	withNewTryElseStatementLike(Try item)
IfFluent<A>.TryStatementNested<A>	withNewTryStatement()
IfFluent<A>.TryStatementNested<A>	withNewTryStatementLike(Try item)
IfFluent<A>.ValueRefConditionNested<A>	withNewValueRefCondition()
A	withNewValueRefCondition(Object value)
IfFluent<A>.ValueRefConditionNested<A>	withNewValueRefConditionLike(ValueRef item)
IfFluent<A>.WhileElseStatementNested<A>	withNewWhileElseStatement()
IfFluent<A>.WhileElseStatementNested<A>	withNewWhileElseStatementLike(While item)
IfFluent<A>.WhileStatementNested<A>	withNewWhileStatement()
IfFluent<A>.WhileStatementNested<A>	withNewWhileStatementLike(While item)
IfFluent<A>.XorConditionNested<A>	withNewXorCondition()
A	withNewXorCondition(Object left, Object right)
IfFluent<A>.XorConditionNested<A>	withNewXorConditionLike(Xor item)
IfFluent<A>.XorElseStatementNested<A>	withNewXorElseStatement()
A	withNewXorElseStatement(Object left, Object right)
IfFluent<A>.XorElseStatementNested<A>	withNewXorElseStatementLike(Xor item)
IfFluent<A>.XorStatementNested<A>	withNewXorStatement()
A	withNewXorStatement(Object left, Object right)
IfFluent<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

IfFluent

public IfFluent()

IfFluent

public IfFluent(If instance)

Method Details

buildCondition

public Expression buildCondition()

buildElseStatement

public Optional<Statement> buildElseStatement()

buildStatement

public Statement buildStatement()

builder

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

copyInstance

protected void copyInstance(If instance)

equals

public boolean equals(Object o)

Overrides:

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

hasCondition

public boolean hasCondition()

hasElseStatement

public boolean hasElseStatement()

hasStatement

public boolean hasStatement()

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

withCondition

public A withCondition(Expression condition)

withElseStatement

public A withElseStatement(Optional<Statement> elseStatement)

withElseStatement

public A withElseStatement(Statement elseStatement)

withNewAssignCondition

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

withNewAssignConditionLike

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

withNewAssignElseStatement

public IfFluent<A>.AssignElseStatementNested<A> withNewAssignElseStatement()

withNewAssignElseStatementLike

public IfFluent<A>.AssignElseStatementNested<A> withNewAssignElseStatementLike(Assign item)

withNewAssignStatement

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

withNewAssignStatementLike

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

withNewBinaryExpressionCondition

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

withNewBinaryExpressionConditionLike

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

withNewBinaryExpressionElseStatement

public IfFluent<A>.BinaryExpressionElseStatementNested<A> withNewBinaryExpressionElseStatement()

withNewBinaryExpressionElseStatementLike

public IfFluent<A>.BinaryExpressionElseStatementNested<A> withNewBinaryExpressionElseStatementLike(BinaryExpression item)

withNewBinaryExpressionStatement

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

withNewBinaryExpressionStatementLike

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

withNewBitwiseAndCondition

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

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
 Object right)

withNewBitwiseAndConditionLike

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

withNewBitwiseAndElseStatement

public IfFluent<A>.BitwiseAndElseStatementNested<A> withNewBitwiseAndElseStatement()

withNewBitwiseAndElseStatement

public A withNewBitwiseAndElseStatement(Object left,
 Object right)

withNewBitwiseAndElseStatementLike

public IfFluent<A>.BitwiseAndElseStatementNested<A> withNewBitwiseAndElseStatementLike(BitwiseAnd item)

withNewBitwiseAndStatement

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

withNewBitwiseAndStatement

public A withNewBitwiseAndStatement(Object left,
 Object right)

withNewBitwiseAndStatementLike

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

withNewBitwiseOrCondition

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

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
 Object right)

withNewBitwiseOrConditionLike

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

withNewBitwiseOrElseStatement

public IfFluent<A>.BitwiseOrElseStatementNested<A> withNewBitwiseOrElseStatement()

withNewBitwiseOrElseStatement

public A withNewBitwiseOrElseStatement(Object left,
 Object right)

withNewBitwiseOrElseStatementLike

public IfFluent<A>.BitwiseOrElseStatementNested<A> withNewBitwiseOrElseStatementLike(BitwiseOr item)

withNewBitwiseOrStatement

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

withNewBitwiseOrStatement

public A withNewBitwiseOrStatement(Object left,
 Object right)

withNewBitwiseOrStatementLike

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

withNewBlockElseStatement

public IfFluent<A>.BlockElseStatementNested<A> withNewBlockElseStatement()

withNewBlockElseStatementLike

public IfFluent<A>.BlockElseStatementNested<A> withNewBlockElseStatementLike(Block item)

withNewBlockStatement

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

withNewBlockStatementLike

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

withNewBreakElseStatement

public IfFluent<A>.BreakElseStatementNested<A> withNewBreakElseStatement()

withNewBreakElseStatementLike

public IfFluent<A>.BreakElseStatementNested<A> withNewBreakElseStatementLike(Break item)

withNewBreakStatement

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

withNewBreakStatementLike

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

withNewCastCondition

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

withNewCastConditionLike

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

withNewClassRefCondition

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

withNewClassRefConditionLike

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

withNewConstructCondition

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

withNewConstructConditionLike

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

withNewConstructElseStatement

public IfFluent<A>.ConstructElseStatementNested<A> withNewConstructElseStatement()

withNewConstructElseStatementLike

public IfFluent<A>.ConstructElseStatementNested<A> withNewConstructElseStatementLike(Construct item)

withNewConstructStatement

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

withNewConstructStatementLike

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

withNewContextRefCondition

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

withNewContextRefCondition

public A withNewContextRefCondition(String name)

withNewContextRefConditionLike

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

withNewContinueElseStatement

public IfFluent<A>.ContinueElseStatementNested<A> withNewContinueElseStatement()

withNewContinueElseStatementLike

public IfFluent<A>.ContinueElseStatementNested<A> withNewContinueElseStatementLike(Continue item)

withNewContinueStatement

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

withNewContinueStatementLike

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

withNewDeclareCondition

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

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
 String name)

withNewDeclareCondition

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

withNewDeclareConditionLike

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

withNewDeclareElseStatement

public IfFluent<A>.DeclareElseStatementNested<A> withNewDeclareElseStatement()

withNewDeclareElseStatement

public A withNewDeclareElseStatement(Class type,
 String name)

withNewDeclareElseStatement

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

withNewDeclareElseStatementLike

public IfFluent<A>.DeclareElseStatementNested<A> withNewDeclareElseStatementLike(Declare item)

withNewDeclareStatement

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

withNewDeclareStatement

public A withNewDeclareStatement(Class type,
 String name)

withNewDeclareStatement

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

withNewDeclareStatementLike

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

withNewDivideCondition

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

withNewDivideCondition

public A withNewDivideCondition(Object left,
 Object right)

withNewDivideConditionLike

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

withNewDivideElseStatement

public IfFluent<A>.DivideElseStatementNested<A> withNewDivideElseStatement()

withNewDivideElseStatement

public A withNewDivideElseStatement(Object left,
 Object right)

withNewDivideElseStatementLike

public IfFluent<A>.DivideElseStatementNested<A> withNewDivideElseStatementLike(Divide item)

withNewDivideStatement

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

withNewDivideStatement

public A withNewDivideStatement(Object left,
 Object right)

withNewDivideStatementLike

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

withNewDoElseStatement

public IfFluent<A>.DoElseStatementNested<A> withNewDoElseStatement()

withNewDoElseStatementLike

public IfFluent<A>.DoElseStatementNested<A> withNewDoElseStatementLike(Do item)

withNewDoStatement

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

withNewDoStatementLike

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

withNewDotClassCondition

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

withNewDotClassConditionLike

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

withNewEmptyCondition

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

withNewEmptyConditionLike

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

withNewEmptyElseStatement

public IfFluent<A>.EmptyElseStatementNested<A> withNewEmptyElseStatement()

withNewEmptyElseStatementLike

public IfFluent<A>.EmptyElseStatementNested<A> withNewEmptyElseStatementLike(Empty item)

withNewEmptyStatement

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

withNewEmptyStatementLike

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

withNewEnclosedCondition

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

withNewEnclosedConditionLike

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

withNewEqualsCondition

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

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
 Object right)

withNewEqualsConditionLike

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

withNewEqualsElseStatement

public IfFluent<A>.EqualsElseStatementNested<A> withNewEqualsElseStatement()

withNewEqualsElseStatement

public A withNewEqualsElseStatement(Object left,
 Object right)

withNewEqualsElseStatementLike

public IfFluent<A>.EqualsElseStatementNested<A> withNewEqualsElseStatementLike(Equals item)

withNewEqualsStatement

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

withNewEqualsStatement

public A withNewEqualsStatement(Object left,
 Object right)

withNewEqualsStatementLike

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

withNewForElseStatement

public IfFluent<A>.ForElseStatementNested<A> withNewForElseStatement()

withNewForElseStatementLike

public IfFluent<A>.ForElseStatementNested<A> withNewForElseStatementLike(For item)

withNewForStatement

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

withNewForStatementLike

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

withNewForeachElseStatement

public IfFluent<A>.ForeachElseStatementNested<A> withNewForeachElseStatement()

withNewForeachElseStatementLike

public IfFluent<A>.ForeachElseStatementNested<A> withNewForeachElseStatementLike(Foreach item)

withNewForeachStatement

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

withNewForeachStatementLike

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

withNewGreaterThanCondition

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

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
 Object right)

withNewGreaterThanConditionLike

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

withNewGreaterThanElseStatement

public IfFluent<A>.GreaterThanElseStatementNested<A> withNewGreaterThanElseStatement()

withNewGreaterThanElseStatement

public A withNewGreaterThanElseStatement(Object left,
 Object right)

withNewGreaterThanElseStatementLike

public IfFluent<A>.GreaterThanElseStatementNested<A> withNewGreaterThanElseStatementLike(GreaterThan item)

withNewGreaterThanOrEqualCondition

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

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
 Object right)

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualElseStatement

public IfFluent<A>.GreaterThanOrEqualElseStatementNested<A> withNewGreaterThanOrEqualElseStatement()

withNewGreaterThanOrEqualElseStatement

public A withNewGreaterThanOrEqualElseStatement(Object left,
 Object right)

withNewGreaterThanOrEqualElseStatementLike

public IfFluent<A>.GreaterThanOrEqualElseStatementNested<A> withNewGreaterThanOrEqualElseStatementLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualStatement

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

withNewGreaterThanOrEqualStatement

public A withNewGreaterThanOrEqualStatement(Object left,
 Object right)

withNewGreaterThanOrEqualStatementLike

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

withNewGreaterThanStatement

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

withNewGreaterThanStatement

public A withNewGreaterThanStatement(Object left,
 Object right)

withNewGreaterThanStatementLike

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

withNewIfDslThenStepElseStatement

public IfFluent<A>.IfDslThenStepElseStatementNested<A> withNewIfDslThenStepElseStatement()

withNewIfDslThenStepElseStatementLike

public IfFluent<A>.IfDslThenStepElseStatementNested<A> withNewIfDslThenStepElseStatementLike(IfDslThenStep item)

withNewIfDslThenStepStatement

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

withNewIfDslThenStepStatementLike

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

withNewIfElseStatement

public IfFluent<A>.IfElseStatementNested<A> withNewIfElseStatement()

withNewIfElseStatementLike

public IfFluent<A>.IfElseStatementNested<A> withNewIfElseStatementLike(If item)

withNewIfStatement

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

withNewIfStatementLike

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

withNewIndexCondition

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

withNewIndexConditionLike

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

withNewInstanceOfCondition

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

withNewInstanceOfConditionLike

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

withNewInverseCondition

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

withNewInverseConditionLike

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

withNewLambdaCondition

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

withNewLambdaConditionLike

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

withNewLambdaElseStatement

public IfFluent<A>.LambdaElseStatementNested<A> withNewLambdaElseStatement()

withNewLambdaElseStatementLike

public IfFluent<A>.LambdaElseStatementNested<A> withNewLambdaElseStatementLike(Lambda item)

withNewLambdaStatement

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

withNewLambdaStatementLike

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

withNewLeftShiftCondition

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

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
 Object right)

withNewLeftShiftConditionLike

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

withNewLeftShiftElseStatement

public IfFluent<A>.LeftShiftElseStatementNested<A> withNewLeftShiftElseStatement()

withNewLeftShiftElseStatement

public A withNewLeftShiftElseStatement(Object left,
 Object right)

withNewLeftShiftElseStatementLike

public IfFluent<A>.LeftShiftElseStatementNested<A> withNewLeftShiftElseStatementLike(LeftShift item)

withNewLeftShiftStatement

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

withNewLeftShiftStatement

public A withNewLeftShiftStatement(Object left,
 Object right)

withNewLeftShiftStatementLike

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

withNewLessThanCondition

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

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
 Object right)

withNewLessThanConditionLike

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

withNewLessThanElseStatement

public IfFluent<A>.LessThanElseStatementNested<A> withNewLessThanElseStatement()

withNewLessThanElseStatement

public A withNewLessThanElseStatement(Object left,
 Object right)

withNewLessThanElseStatementLike

public IfFluent<A>.LessThanElseStatementNested<A> withNewLessThanElseStatementLike(LessThan item)

withNewLessThanOrEqualCondition

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

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
 Object right)

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualElseStatement

public IfFluent<A>.LessThanOrEqualElseStatementNested<A> withNewLessThanOrEqualElseStatement()

withNewLessThanOrEqualElseStatement

public A withNewLessThanOrEqualElseStatement(Object left,
 Object right)

withNewLessThanOrEqualElseStatementLike

public IfFluent<A>.LessThanOrEqualElseStatementNested<A> withNewLessThanOrEqualElseStatementLike(LessThanOrEqual item)

withNewLessThanOrEqualStatement

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

withNewLessThanOrEqualStatement

public A withNewLessThanOrEqualStatement(Object left,
 Object right)

withNewLessThanOrEqualStatementLike

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

withNewLessThanStatement

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

withNewLessThanStatement

public A withNewLessThanStatement(Object left,
 Object right)

withNewLessThanStatementLike

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

withNewLogicalAndCondition

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

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
 Object right)

withNewLogicalAndConditionLike

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

withNewLogicalAndElseStatement

public IfFluent<A>.LogicalAndElseStatementNested<A> withNewLogicalAndElseStatement()

withNewLogicalAndElseStatement

public A withNewLogicalAndElseStatement(Object left,
 Object right)

withNewLogicalAndElseStatementLike

public IfFluent<A>.LogicalAndElseStatementNested<A> withNewLogicalAndElseStatementLike(LogicalAnd item)

withNewLogicalAndStatement

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

withNewLogicalAndStatement

public A withNewLogicalAndStatement(Object left,
 Object right)

withNewLogicalAndStatementLike

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

withNewLogicalOrCondition

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

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
 Object right)

withNewLogicalOrConditionLike

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

withNewLogicalOrElseStatement

public IfFluent<A>.LogicalOrElseStatementNested<A> withNewLogicalOrElseStatement()

withNewLogicalOrElseStatement

public A withNewLogicalOrElseStatement(Object left,
 Object right)

withNewLogicalOrElseStatementLike

public IfFluent<A>.LogicalOrElseStatementNested<A> withNewLogicalOrElseStatementLike(LogicalOr item)

withNewLogicalOrStatement

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

withNewLogicalOrStatement

public A withNewLogicalOrStatement(Object left,
 Object right)

withNewLogicalOrStatementLike

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

withNewMethodCallCondition

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

withNewMethodCallConditionLike

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

withNewMethodCallElseStatement

public IfFluent<A>.MethodCallElseStatementNested<A> withNewMethodCallElseStatement()

withNewMethodCallElseStatementLike

public IfFluent<A>.MethodCallElseStatementNested<A> withNewMethodCallElseStatementLike(MethodCall item)

withNewMethodCallStatement

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

withNewMethodCallStatementLike

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

withNewMinusCondition

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

withNewMinusCondition

public A withNewMinusCondition(Object left,
 Object right)

withNewMinusConditionLike

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

withNewMinusElseStatement

public IfFluent<A>.MinusElseStatementNested<A> withNewMinusElseStatement()

withNewMinusElseStatement

public A withNewMinusElseStatement(Object left,
 Object right)

withNewMinusElseStatementLike

public IfFluent<A>.MinusElseStatementNested<A> withNewMinusElseStatementLike(Minus item)

withNewMinusStatement

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

withNewMinusStatement

public A withNewMinusStatement(Object left,
 Object right)

withNewMinusStatementLike

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

withNewModuloCondition

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

withNewModuloCondition

public A withNewModuloCondition(Object left,
 Object right)

withNewModuloConditionLike

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

withNewModuloElseStatement

public IfFluent<A>.ModuloElseStatementNested<A> withNewModuloElseStatement()

withNewModuloElseStatement

public A withNewModuloElseStatement(Object left,
 Object right)

withNewModuloElseStatementLike

public IfFluent<A>.ModuloElseStatementNested<A> withNewModuloElseStatementLike(Modulo item)

withNewModuloStatement

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

withNewModuloStatement

public A withNewModuloStatement(Object left,
 Object right)

withNewModuloStatementLike

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

withNewMultiplyCondition

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

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
 Object right)

withNewMultiplyConditionLike

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

withNewMultiplyElseStatement

public IfFluent<A>.MultiplyElseStatementNested<A> withNewMultiplyElseStatement()

withNewMultiplyElseStatement

public A withNewMultiplyElseStatement(Object left,
 Object right)

withNewMultiplyElseStatementLike

public IfFluent<A>.MultiplyElseStatementNested<A> withNewMultiplyElseStatementLike(Multiply item)

withNewMultiplyStatement

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

withNewMultiplyStatement

public A withNewMultiplyStatement(Object left,
 Object right)

withNewMultiplyStatementLike

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

withNewNegativeCondition

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

withNewNegativeConditionLike

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

withNewNewArrayCondition

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

withNewNewArrayCondition

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

withNewNewArrayConditionLike

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

withNewNotCondition

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

withNewNotConditionLike

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

withNewNotEqualsCondition

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

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
 Object right)

withNewNotEqualsConditionLike

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

withNewNotEqualsElseStatement

public IfFluent<A>.NotEqualsElseStatementNested<A> withNewNotEqualsElseStatement()

withNewNotEqualsElseStatement

public A withNewNotEqualsElseStatement(Object left,
 Object right)

withNewNotEqualsElseStatementLike

public IfFluent<A>.NotEqualsElseStatementNested<A> withNewNotEqualsElseStatementLike(NotEquals item)

withNewNotEqualsStatement

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

withNewNotEqualsStatement

public A withNewNotEqualsStatement(Object left,
 Object right)

withNewNotEqualsStatementLike

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

withNewPlusCondition

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

withNewPlusCondition

public A withNewPlusCondition(Object left,
 Object right)

withNewPlusConditionLike

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

withNewPlusElseStatement

public IfFluent<A>.PlusElseStatementNested<A> withNewPlusElseStatement()

withNewPlusElseStatement

public A withNewPlusElseStatement(Object left,
 Object right)

withNewPlusElseStatementLike

public IfFluent<A>.PlusElseStatementNested<A> withNewPlusElseStatementLike(Plus item)

withNewPlusStatement

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

withNewPlusStatement

public A withNewPlusStatement(Object left,
 Object right)

withNewPlusStatementLike

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

withNewPositiveCondition

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

withNewPositiveConditionLike

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

withNewPostDecrementCondition

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

withNewPostDecrementConditionLike

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

withNewPostDecrementElseStatement

public IfFluent<A>.PostDecrementElseStatementNested<A> withNewPostDecrementElseStatement()

withNewPostDecrementElseStatementLike

public IfFluent<A>.PostDecrementElseStatementNested<A> withNewPostDecrementElseStatementLike(PostDecrement item)

withNewPostDecrementStatement

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

withNewPostDecrementStatementLike

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

withNewPostIncrementCondition

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

withNewPostIncrementConditionLike

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

withNewPostIncrementElseStatement

public IfFluent<A>.PostIncrementElseStatementNested<A> withNewPostIncrementElseStatement()

withNewPostIncrementElseStatementLike

public IfFluent<A>.PostIncrementElseStatementNested<A> withNewPostIncrementElseStatementLike(PostIncrement item)

withNewPostIncrementStatement

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

withNewPostIncrementStatementLike

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

withNewPreDecrementCondition

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

withNewPreDecrementConditionLike

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

withNewPreDecrementElseStatement

public IfFluent<A>.PreDecrementElseStatementNested<A> withNewPreDecrementElseStatement()

withNewPreDecrementElseStatementLike

public IfFluent<A>.PreDecrementElseStatementNested<A> withNewPreDecrementElseStatementLike(PreDecrement item)

withNewPreDecrementStatement

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

withNewPreDecrementStatementLike

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

withNewPreIncrementCondition

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

withNewPreIncrementConditionLike

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

withNewPreIncrementElseStatement

public IfFluent<A>.PreIncrementElseStatementNested<A> withNewPreIncrementElseStatement()

withNewPreIncrementElseStatementLike

public IfFluent<A>.PreIncrementElseStatementNested<A> withNewPreIncrementElseStatementLike(PreIncrement item)

withNewPreIncrementStatement

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

withNewPreIncrementStatementLike

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

withNewPropertyCondition

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

withNewPropertyConditionLike

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

withNewPropertyRefCondition

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

withNewPropertyRefConditionLike

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

withNewPropertyRefElseStatement

public IfFluent<A>.PropertyRefElseStatementNested<A> withNewPropertyRefElseStatement()

withNewPropertyRefElseStatementLike

public IfFluent<A>.PropertyRefElseStatementNested<A> withNewPropertyRefElseStatementLike(PropertyRef item)

withNewPropertyRefStatement

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

withNewPropertyRefStatementLike

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

withNewReturnDslThisStepElseStatement

public IfFluent<A>.ReturnDslThisStepElseStatementNested<A> withNewReturnDslThisStepElseStatement()

withNewReturnDslThisStepElseStatementLike

public IfFluent<A>.ReturnDslThisStepElseStatementNested<A> withNewReturnDslThisStepElseStatementLike(ReturnDslThisStep item)

withNewReturnDslThisStepStatement

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

withNewReturnDslThisStepStatementLike

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

withNewReturnDslVariableStepElseStatement

public IfFluent<A>.ReturnDslVariableStepElseStatementNested<A> withNewReturnDslVariableStepElseStatement()

withNewReturnDslVariableStepElseStatement

public A withNewReturnDslVariableStepElseStatement(String name)

withNewReturnDslVariableStepElseStatementLike

public IfFluent<A>.ReturnDslVariableStepElseStatementNested<A> withNewReturnDslVariableStepElseStatementLike(ReturnDslVariableStep item)

withNewReturnDslVariableStepStatement

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

withNewReturnDslVariableStepStatement

public A withNewReturnDslVariableStepStatement(String name)

withNewReturnDslVariableStepStatementLike

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

withNewReturnElseStatement

public IfFluent<A>.ReturnElseStatementNested<A> withNewReturnElseStatement()

withNewReturnElseStatement

public A withNewReturnElseStatement(Object object)

withNewReturnElseStatementLike

public IfFluent<A>.ReturnElseStatementNested<A> withNewReturnElseStatementLike(Return item)

withNewReturnStatement

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

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewReturnStatementLike

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

withNewRightShiftCondition

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

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
 Object right)

withNewRightShiftConditionLike

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

withNewRightShiftElseStatement

public IfFluent<A>.RightShiftElseStatementNested<A> withNewRightShiftElseStatement()

withNewRightShiftElseStatement

public A withNewRightShiftElseStatement(Object left,
 Object right)

withNewRightShiftElseStatementLike

public IfFluent<A>.RightShiftElseStatementNested<A> withNewRightShiftElseStatementLike(RightShift item)

withNewRightShiftStatement

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

withNewRightShiftStatement

public A withNewRightShiftStatement(Object left,
 Object right)

withNewRightShiftStatementLike

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

withNewRightUnsignedShiftCondition

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

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
 Object right)

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftElseStatement

public IfFluent<A>.RightUnsignedShiftElseStatementNested<A> withNewRightUnsignedShiftElseStatement()

withNewRightUnsignedShiftElseStatement

public A withNewRightUnsignedShiftElseStatement(Object left,
 Object right)

withNewRightUnsignedShiftElseStatementLike

public IfFluent<A>.RightUnsignedShiftElseStatementNested<A> withNewRightUnsignedShiftElseStatementLike(RightUnsignedShift item)

withNewRightUnsignedShiftStatement

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

withNewRightUnsignedShiftStatement

public A withNewRightUnsignedShiftStatement(Object left,
 Object right)

withNewRightUnsignedShiftStatementLike

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

withNewStringStatement

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

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewStringStatementElse

public IfFluent<A>.StringStatementElseNested<A> withNewStringStatementElse()

withNewStringStatementElse

public A withNewStringStatementElse(String data)

withNewStringStatementElse

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

withNewStringStatementElseLike

public IfFluent<A>.StringStatementElseNested<A> withNewStringStatementElseLike(StringStatement item)

withNewStringStatementLike

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

withNewSuperCondition

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

withNewSuperConditionLike

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

withNewSwitchElseStatement

public IfFluent<A>.SwitchElseStatementNested<A> withNewSwitchElseStatement()

withNewSwitchElseStatementLike

public IfFluent<A>.SwitchElseStatementNested<A> withNewSwitchElseStatementLike(Switch item)

withNewSwitchStatement

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

withNewSwitchStatementLike

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

withNewSynchronizedElseStatement

public IfFluent<A>.SynchronizedElseStatementNested<A> withNewSynchronizedElseStatement()

withNewSynchronizedElseStatementLike

public IfFluent<A>.SynchronizedElseStatementNested<A> withNewSynchronizedElseStatementLike(Synchronized item)

withNewSynchronizedStatement

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

withNewSynchronizedStatementLike

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

withNewTernaryCondition

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

withNewTernaryConditionLike

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

withNewThisCondition

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

withNewThisConditionLike

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

withNewThrowElseStatement

public IfFluent<A>.ThrowElseStatementNested<A> withNewThrowElseStatement()

withNewThrowElseStatementLike

public IfFluent<A>.ThrowElseStatementNested<A> withNewThrowElseStatementLike(Throw item)

withNewThrowStatement

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

withNewThrowStatementLike

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

withNewTryElseStatement

public IfFluent<A>.TryElseStatementNested<A> withNewTryElseStatement()

withNewTryElseStatementLike

public IfFluent<A>.TryElseStatementNested<A> withNewTryElseStatementLike(Try item)

withNewTryStatement

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

withNewTryStatementLike

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

withNewValueRefCondition

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

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewValueRefConditionLike

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

withNewWhileElseStatement

public IfFluent<A>.WhileElseStatementNested<A> withNewWhileElseStatement()

withNewWhileElseStatementLike

public IfFluent<A>.WhileElseStatementNested<A> withNewWhileElseStatementLike(While item)

withNewWhileStatement

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

withNewWhileStatementLike

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

withNewXorCondition

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

withNewXorCondition

public A withNewXorCondition(Object left,
 Object right)

withNewXorConditionLike

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

withNewXorElseStatement

public IfFluent<A>.XorElseStatementNested<A> withNewXorElseStatement()

withNewXorElseStatement

public A withNewXorElseStatement(Object left,
 Object right)

withNewXorElseStatementLike

public IfFluent<A>.XorElseStatementNested<A> withNewXorElseStatementLike(Xor item)

withNewXorStatement

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

withNewXorStatement

public A withNewXorStatement(Object left,
 Object right)

withNewXorStatementLike

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

withStatement

public A withStatement(Statement statement)