java.lang.Object
- io.sundr.builder.BaseFluent<A>
- - io.sundr.model.DoFluent<A>

Direct Known Subclasses:

BlockFluent.DoStatementsNested, DoBuilder, DoFluent.DoStatementNested, ForeachFluent.DoBodyNested, ForFluent.DoBodyNested, IfFluent.DoStatementNested, LambdaFluent.DoStatementNested, WhileFluent.DoStatementNested
```
public class DoFluent<A extends DoFluent<A>>
extends io.sundr.builder.BaseFluent<A>
```
Generated

Nested Class Summary

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

Field Summary
- Fields inherited from class io.sundr.builder.BaseFluent
  _visitables

Constructor Summary

Constructors
Constructor Description

DoFluent()

DoFluent(io.sundr.model.Do instance)

Method Summary

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

DoFluent
```
public DoFluent()
```

DoFluent

public DoFluent(io.sundr.model.Do instance)

Method Detail

copyInstance

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

buildCondition

public io.sundr.model.Expression buildCondition()

withCondition

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

hasCondition
```
public boolean hasCondition()
```

withNewMultiplyCondition

public DoFluent.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyConditionLike

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

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
                                  Object right)

withNewNewArrayCondition

public DoFluent.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayConditionLike

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

withNewNewArrayCondition

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

withNewInstanceOfCondition

public DoFluent.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

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

withNewMethodCallCondition

public DoFluent.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

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

withNewInverseCondition

public DoFluent.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

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

withNewIndexCondition

public DoFluent.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

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

withNewGreaterThanOrEqualCondition

public DoFluent.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
                                            Object right)

withNewBitwiseAndCondition

public DoFluent.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndConditionLike

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

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
                                    Object right)

withNewMinusCondition

public DoFluent.MinusConditionNested<A> withNewMinusCondition()

withNewMinusConditionLike

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

withNewMinusCondition

public A withNewMinusCondition(Object left,
                               Object right)

withNewLogicalOrCondition

public DoFluent.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrConditionLike

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

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
                                   Object right)

withNewNotEqualsCondition

public DoFluent.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsConditionLike

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

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
                                   Object right)

withNewDivideCondition

public DoFluent.DivideConditionNested<A> withNewDivideCondition()

withNewDivideConditionLike

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

withNewDivideCondition

public A withNewDivideCondition(Object left,
                                Object right)

withNewLessThanCondition

public DoFluent.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanConditionLike

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

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
                                  Object right)

withNewBitwiseOrCondition

public DoFluent.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrConditionLike

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

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
                                   Object right)

withNewPropertyRefCondition

public DoFluent.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

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

withNewRightShiftCondition

public DoFluent.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftConditionLike

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

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
                                    Object right)

withNewGreaterThanCondition

public DoFluent.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanConditionLike

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

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
                                     Object right)

withNewDeclareCondition

public DoFluent.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareConditionLike

public DoFluent.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 DoFluent.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

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

withNewModuloCondition

public DoFluent.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloConditionLike

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

withNewModuloCondition

public A withNewModuloCondition(Object left,
                                Object right)

withNewValueRefCondition

public DoFluent.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefConditionLike

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

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewLeftShiftCondition

public DoFluent.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftConditionLike

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

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
                                   Object right)

withNewTernaryCondition

public DoFluent.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

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

withNewBinaryExpressionCondition

public DoFluent.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

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

withNewEqualsCondition

public DoFluent.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsConditionLike

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

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
                                Object right)

withNewEnclosedCondition

public DoFluent.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

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

withNewPreDecrementCondition

public DoFluent.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

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

withNewPostDecrementCondition

public DoFluent.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

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

withNewLambdaCondition

public DoFluent.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

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

withNewNotCondition

public DoFluent.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

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

withNewAssignCondition

public DoFluent.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

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

withNewNegativeCondition

public DoFluent.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

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

withNewThisCondition

public DoFluent.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

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

withNewLogicalAndCondition

public DoFluent.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndConditionLike

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

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
                                    Object right)

withNewPostIncrementCondition

public DoFluent.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

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

withNewRightUnsignedShiftCondition

public DoFluent.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
                                            Object right)

withNewPlusCondition

public DoFluent.PlusConditionNested<A> withNewPlusCondition()

withNewPlusConditionLike

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

withNewPlusCondition

public A withNewPlusCondition(Object left,
                              Object right)

withNewConstructCondition

public DoFluent.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

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

withNewXorCondition

public DoFluent.XorConditionNested<A> withNewXorCondition()

withNewXorConditionLike

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

withNewXorCondition

public A withNewXorCondition(Object left,
                             Object right)

withNewPreIncrementCondition

public DoFluent.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

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

withNewLessThanOrEqualCondition

public DoFluent.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
                                         Object right)

withNewPositiveCondition

public DoFluent.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

public DoFluent.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 DoFluent.MethodCallStatementNested<A> withNewMethodCallStatement()

withNewMethodCallStatementLike

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

withNewSwitchStatement

public DoFluent.SwitchStatementNested<A> withNewSwitchStatement()

withNewSwitchStatementLike

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

withNewBreakStatement

public DoFluent.BreakStatementNested<A> withNewBreakStatement()

withNewBreakStatementLike

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

withNewDeclareStatement

public DoFluent.DeclareStatementNested<A> withNewDeclareStatement()

withNewDeclareStatementLike

public DoFluent.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 DoFluent.WhileStatementNested<A> withNewWhileStatement()

withNewWhileStatementLike

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

withNewContinueStatement

public DoFluent.ContinueStatementNested<A> withNewContinueStatement()

withNewContinueStatementLike

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

withNewStringStatement

public DoFluent.StringStatementNested<A> withNewStringStatement()

withNewStringStatementLike

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

withNewStringStatement

public A withNewStringStatement(String data)

withNewStringStatement

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

withNewDoStatement

public DoFluent.DoStatementNested<A> withNewDoStatement()

withNewDoStatementLike

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

withNewForeachStatement

public DoFluent.ForeachStatementNested<A> withNewForeachStatement()

withNewForeachStatementLike

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

withNewBlockStatement

public DoFluent.BlockStatementNested<A> withNewBlockStatement()

withNewBlockStatementLike

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

withNewIfStatement

public DoFluent.IfStatementNested<A> withNewIfStatement()

withNewIfStatementLike

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

withNewLambdaStatement

public DoFluent.LambdaStatementNested<A> withNewLambdaStatement()

withNewLambdaStatementLike

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

withNewReturnStatement

public DoFluent.ReturnStatementNested<A> withNewReturnStatement()

withNewReturnStatementLike

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

withNewReturnStatement

public A withNewReturnStatement(Object object)

withNewAssignStatement

public DoFluent.AssignStatementNested<A> withNewAssignStatement()

withNewAssignStatementLike

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

withNewForStatement

public DoFluent.ForStatementNested<A> withNewForStatement()

withNewForStatementLike

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

equals
```
public boolean equals(Object o)
```
Overrides:

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

hashCode
```
public int hashCode()
```
Overrides:

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

toString
```
public String toString()
```
Overrides:

toString in class Object

builder

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

Class DoFluent<A extends DoFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.sundr.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

DoFluent

DoFluent

Method Detail

copyInstance

buildCondition

withCondition

hasCondition

withNewMultiplyCondition

withNewMultiplyConditionLike

withNewMultiplyCondition

withNewNewArrayCondition

withNewNewArrayConditionLike

withNewNewArrayCondition

withNewInstanceOfCondition

withNewInstanceOfConditionLike

withNewMethodCallCondition

withNewMethodCallConditionLike

withNewInverseCondition

withNewInverseConditionLike

withNewIndexCondition

withNewIndexConditionLike

withNewGreaterThanOrEqualCondition

withNewGreaterThanOrEqualConditionLike

withNewGreaterThanOrEqualCondition

withNewBitwiseAndCondition

withNewBitwiseAndConditionLike

withNewBitwiseAndCondition

withNewMinusCondition

withNewMinusConditionLike

withNewMinusCondition

withNewLogicalOrCondition

withNewLogicalOrConditionLike

withNewLogicalOrCondition

withNewNotEqualsCondition

withNewNotEqualsConditionLike

withNewNotEqualsCondition

withNewDivideCondition

withNewDivideConditionLike

withNewDivideCondition

withNewLessThanCondition

withNewLessThanConditionLike

withNewLessThanCondition

withNewBitwiseOrCondition

withNewBitwiseOrConditionLike

withNewBitwiseOrCondition

withNewPropertyRefCondition

withNewPropertyRefConditionLike

withNewRightShiftCondition

withNewRightShiftConditionLike

withNewRightShiftCondition

withNewGreaterThanCondition

withNewGreaterThanConditionLike

withNewGreaterThanCondition

withNewDeclareCondition

withNewDeclareConditionLike

withNewDeclareCondition

withNewDeclareCondition

withNewCastCondition

withNewCastConditionLike

withNewModuloCondition

withNewModuloConditionLike

withNewModuloCondition

withNewValueRefCondition

withNewValueRefConditionLike

withNewValueRefCondition

withNewLeftShiftCondition

withNewLeftShiftConditionLike

withNewLeftShiftCondition

withNewTernaryCondition

withNewTernaryConditionLike

withNewBinaryExpressionCondition