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

public class IfFluent<A extends IfFluent<A>>
extends io.sundr.builder.BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	IfFluent.AssignConditionNested<N>
class	IfFluent.AssignStatementNested<N>
class	IfFluent.BinaryExpressionConditionNested<N>
class	IfFluent.BitwiseAndConditionNested<N>
class	IfFluent.BitwiseOrConditionNested<N>
class	IfFluent.BlockStatementNested<N>
class	IfFluent.BreakStatementNested<N>
class	IfFluent.CastConditionNested<N>
class	IfFluent.ConstructConditionNested<N>
class	IfFluent.ContinueStatementNested<N>
class	IfFluent.DeclareConditionNested<N>
class	IfFluent.DeclareStatementNested<N>
class	IfFluent.DivideConditionNested<N>
class	IfFluent.DoStatementNested<N>
class	IfFluent.EnclosedConditionNested<N>
class	IfFluent.EqualsConditionNested<N>
class	IfFluent.ForeachStatementNested<N>
class	IfFluent.ForStatementNested<N>
class	IfFluent.GreaterThanConditionNested<N>
class	IfFluent.GreaterThanOrEqualConditionNested<N>
class	IfFluent.IfStatementNested<N>
class	IfFluent.IndexConditionNested<N>
class	IfFluent.InstanceOfConditionNested<N>
class	IfFluent.InverseConditionNested<N>
class	IfFluent.LambdaConditionNested<N>
class	IfFluent.LambdaStatementNested<N>
class	IfFluent.LeftShiftConditionNested<N>
class	IfFluent.LessThanConditionNested<N>
class	IfFluent.LessThanOrEqualConditionNested<N>
class	IfFluent.LogicalAndConditionNested<N>
class	IfFluent.LogicalOrConditionNested<N>
class	IfFluent.MethodCallConditionNested<N>
class	IfFluent.MethodCallStatementNested<N>
class	IfFluent.MinusConditionNested<N>
class	IfFluent.ModuloConditionNested<N>
class	IfFluent.MultiplyConditionNested<N>
class	IfFluent.NegativeConditionNested<N>
class	IfFluent.NewArrayConditionNested<N>
class	IfFluent.NotConditionNested<N>
class	IfFluent.NotEqualsConditionNested<N>
class	IfFluent.PlusConditionNested<N>
class	IfFluent.PositiveConditionNested<N>
class	IfFluent.PostDecrementConditionNested<N>
class	IfFluent.PostIncrementConditionNested<N>
class	IfFluent.PreDecrementConditionNested<N>
class	IfFluent.PreIncrementConditionNested<N>
class	IfFluent.PropertyRefConditionNested<N>
class	IfFluent.ReturnStatementNested<N>
class	IfFluent.RightShiftConditionNested<N>
class	IfFluent.RightUnsignedShiftConditionNested<N>
class	IfFluent.StringStatementNested<N>
class	IfFluent.SwitchStatementNested<N>
class	IfFluent.TernaryConditionNested<N>
class	IfFluent.ThisConditionNested<N>
class	IfFluent.ValueRefConditionNested<N>
class	IfFluent.WhileStatementNested<N>
class	IfFluent.XorConditionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
IfFluent()
IfFluent(io.sundr.model.If instance)

Method Summary

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

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

IfFluent

public IfFluent()

IfFluent

public IfFluent(io.sundr.model.If instance)

Method Detail

copyInstance

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

buildCondition

public io.sundr.model.Expression buildCondition()

withCondition

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

hasCondition

public boolean hasCondition()

withNewMultiplyCondition

public IfFluent.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyConditionLike

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

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
                                  Object right)

withNewNewArrayCondition

public IfFluent.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayConditionLike

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

withNewNewArrayCondition

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

withNewInstanceOfCondition

public IfFluent.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

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

withNewMethodCallCondition

public IfFluent.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

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

withNewInverseCondition

public IfFluent.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

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

withNewIndexCondition

public IfFluent.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

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

withNewGreaterThanOrEqualCondition

public IfFluent.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
                                            Object right)

withNewBitwiseAndCondition

public IfFluent.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndConditionLike

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

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
                                    Object right)

withNewMinusCondition

public IfFluent.MinusConditionNested<A> withNewMinusCondition()

withNewMinusConditionLike

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

withNewMinusCondition

public A withNewMinusCondition(Object left,
                               Object right)

withNewLogicalOrCondition

public IfFluent.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrConditionLike

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

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
                                   Object right)

withNewNotEqualsCondition

public IfFluent.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsConditionLike

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

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
                                   Object right)

withNewDivideCondition

public IfFluent.DivideConditionNested<A> withNewDivideCondition()

withNewDivideConditionLike

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

withNewDivideCondition

public A withNewDivideCondition(Object left,
                                Object right)

withNewLessThanCondition

public IfFluent.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanConditionLike

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

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
                                  Object right)

withNewBitwiseOrCondition

public IfFluent.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrConditionLike

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

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
                                   Object right)

withNewPropertyRefCondition

public IfFluent.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

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

withNewRightShiftCondition

public IfFluent.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftConditionLike

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

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
                                    Object right)

withNewGreaterThanCondition

public IfFluent.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanConditionLike

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

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
                                     Object right)

withNewDeclareCondition

public IfFluent.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareConditionLike

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

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
                                 String name)

withNewDeclareCondition

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

withNewCastCondition

public IfFluent.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

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

withNewModuloCondition

public IfFluent.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloConditionLike

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

withNewModuloCondition

public A withNewModuloCondition(Object left,
                                Object right)

withNewValueRefCondition

public IfFluent.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefConditionLike

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

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewLeftShiftCondition

public IfFluent.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftConditionLike

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

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
                                   Object right)

withNewTernaryCondition

public IfFluent.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

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

withNewBinaryExpressionCondition

public IfFluent.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

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

withNewEqualsCondition

public IfFluent.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsConditionLike

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

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
                                Object right)

withNewEnclosedCondition

public IfFluent.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

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

withNewPreDecrementCondition

public IfFluent.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

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

withNewPostDecrementCondition

public IfFluent.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

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

withNewLambdaCondition

public IfFluent.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

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

withNewNotCondition

public IfFluent.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

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

withNewAssignCondition

public IfFluent.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

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

withNewNegativeCondition

public IfFluent.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

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

withNewThisCondition

public IfFluent.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

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

withNewLogicalAndCondition

public IfFluent.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndConditionLike

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

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
                                    Object right)

withNewPostIncrementCondition

public IfFluent.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

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

withNewRightUnsignedShiftCondition

public IfFluent.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
                                            Object right)

withNewPlusCondition

public IfFluent.PlusConditionNested<A> withNewPlusCondition()

withNewPlusConditionLike

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

withNewPlusCondition

public A withNewPlusCondition(Object left,
                              Object right)

withNewConstructCondition

public IfFluent.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

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

withNewXorCondition

public IfFluent.XorConditionNested<A> withNewXorCondition()

withNewXorConditionLike

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

withNewXorCondition

public A withNewXorCondition(Object left,
                             Object right)

withNewPreIncrementCondition

public IfFluent.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

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

withNewLessThanOrEqualCondition

public IfFluent.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
                                         Object right)

withNewPositiveCondition

public IfFluent.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

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

buildStatement

public io.sundr.model.Statement buildStatement()

withStatement

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

hasStatement

public boolean hasStatement()

withNewMethodCallStatement

public IfFluent.MethodCallStatementNested<A> withNewMethodCallStatement()

withNewMethodCallStatementLike

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

withNewSwitchStatement

public IfFluent.SwitchStatementNested<A> withNewSwitchStatement()

withNewSwitchStatementLike

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

withNewBreakStatement

public IfFluent.BreakStatementNested<A> withNewBreakStatement()

withNewBreakStatementLike

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

withNewDeclareStatement

public IfFluent.DeclareStatementNested<A> withNewDeclareStatement()

withNewDeclareStatementLike

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

withNewDeclareStatement

public A withNewDeclareStatement(Class type,
                                 String name)

withNewDeclareStatement

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

withNewWhileStatement

public IfFluent.WhileStatementNested<A> withNewWhileStatement()

withNewWhileStatementLike

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

withNewContinueStatement

public IfFluent.ContinueStatementNested<A> withNewContinueStatement()

withNewContinueStatementLike

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

withNewStringStatement

public IfFluent.StringStatementNested<A> withNewStringStatement()

withNewStringStatementLike

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

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewDoStatement

public IfFluent.DoStatementNested<A> withNewDoStatement()

withNewDoStatementLike

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

withNewForeachStatement

public IfFluent.ForeachStatementNested<A> withNewForeachStatement()

withNewForeachStatementLike

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

withNewBlockStatement

public IfFluent.BlockStatementNested<A> withNewBlockStatement()

withNewBlockStatementLike

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

withNewIfStatement

public IfFluent.IfStatementNested<A> withNewIfStatement()

withNewIfStatementLike

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

withNewLambdaStatement

public IfFluent.LambdaStatementNested<A> withNewLambdaStatement()

withNewLambdaStatementLike

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

withNewReturnStatement

public IfFluent.ReturnStatementNested<A> withNewReturnStatement()

withNewReturnStatementLike

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

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewAssignStatement

public IfFluent.AssignStatementNested<A> withNewAssignStatement()

withNewAssignStatementLike

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

withNewForStatement

public IfFluent.ForStatementNested<A> withNewForStatement()

withNewForStatementLike

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

withElseStatement

public A withElseStatement(Optional<io.sundr.model.Statement> elseStatement)

withElseStatement

public A withElseStatement(io.sundr.model.Statement elseStatement)

getElseStatement

public Optional<io.sundr.model.Statement> getElseStatement()

hasElseStatement

public boolean hasElseStatement()

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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