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

Direct Known Subclasses:

AssignFluent.ConstructTargetNested, AssignFluent.ConstructValueNested, BinaryExpressionFluent.ConstructLeftNested, BinaryExpressionFluent.ConstructRightNested, CastFluent.ConstructExpressionNested, ConstructBuilder, ConstructFluent.ConstructArgumentsNested, DoFluent.ConstructConditionNested, EnclosedFluent.ConstructExpresionNested, ForeachFluent.ConstructExpressionNested, ForFluent.ConstructCompareNested, ForFluent.ConstructInitNested, ForFluent.ConstructUpdateNested, IfFluent.ConstructConditionNested, IndexFluent.ConstructExpressionNested, IndexFluent.ConstructScopeNested, InstanceOfFluent.ConstructExpressionNested, InverseFluent.ConstructExpresionNested, MethodCallFluent.ConstructArgumentsNested, MethodCallFluent.ConstructScopeNested, NegativeFluent.ConstructExpresionNested, NewArrayFluent.ConstructExpressionsNested, NotFluent.ConstructExpresionNested, PositiveFluent.ConstructExpresionNested, PostDecrementFluent.ConstructExpressionNested, PostIncrementFluent.ConstructExpressionNested, PreDecrementFluent.ConstructExpressionNested, PreIncrementFluent.ConstructExpressionNested, PropertyRefFluent.ConstructScopeNested, ReturnFluent.ConstructExpressionNested, SwitchFluent.ConstructExpressionNested, TernaryFluent.ConstructAlternativeNested, TernaryFluent.ConstructConditionNested, TernaryFluent.ConstructResultNested, WhileFluent.ConstructConditionNested
```
public class ConstructFluent<A extends ConstructFluent<A>>
extends BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`ConstructFluent.AssignArgumentsNested<N>`
`class`	`ConstructFluent.BinaryExpressionArgumentsNested<N>`
`class`	`ConstructFluent.BitwiseAndArgumentsNested<N>`
`class`	`ConstructFluent.BitwiseOrArgumentsNested<N>`
`class`	`ConstructFluent.CastArgumentsNested<N>`
`class`	`ConstructFluent.ClassRefParametersNested<N>`
`class`	`ConstructFluent.ConstructArgumentsNested<N>`
`class`	`ConstructFluent.DeclareArgumentsNested<N>`
`class`	`ConstructFluent.DivideArgumentsNested<N>`
`class`	`ConstructFluent.EnclosedArgumentsNested<N>`
`class`	`ConstructFluent.EqualsArgumentsNested<N>`
`class`	`ConstructFluent.GreaterThanArgumentsNested<N>`
`class`	`ConstructFluent.GreaterThanOrEqualArgumentsNested<N>`
`class`	`ConstructFluent.IndexArgumentsNested<N>`
`class`	`ConstructFluent.InstanceOfArgumentsNested<N>`
`class`	`ConstructFluent.InverseArgumentsNested<N>`
`class`	`ConstructFluent.LambdaArgumentsNested<N>`
`class`	`ConstructFluent.LeftShiftArgumentsNested<N>`
`class`	`ConstructFluent.LessThanArgumentsNested<N>`
`class`	`ConstructFluent.LessThanOrEqualArgumentsNested<N>`
`class`	`ConstructFluent.LogicalAndArgumentsNested<N>`
`class`	`ConstructFluent.LogicalOrArgumentsNested<N>`
`class`	`ConstructFluent.MethodCallArgumentsNested<N>`
`class`	`ConstructFluent.MinusArgumentsNested<N>`
`class`	`ConstructFluent.ModuloArgumentsNested<N>`
`class`	`ConstructFluent.MultiplyArgumentsNested<N>`
`class`	`ConstructFluent.NegativeArgumentsNested<N>`
`class`	`ConstructFluent.NewArrayArgumentsNested<N>`
`class`	`ConstructFluent.NotArgumentsNested<N>`
`class`	`ConstructFluent.NotEqualsArgumentsNested<N>`
`class`	`ConstructFluent.PlusArgumentsNested<N>`
`class`	`ConstructFluent.PositiveArgumentsNested<N>`
`class`	`ConstructFluent.PostDecrementArgumentsNested<N>`
`class`	`ConstructFluent.PostIncrementArgumentsNested<N>`
`class`	`ConstructFluent.PreDecrementArgumentsNested<N>`
`class`	`ConstructFluent.PreIncrementArgumentsNested<N>`
`class`	`ConstructFluent.PrimitiveRefParametersNested<N>`
`class`	`ConstructFluent.PropertyRefArgumentsNested<N>`
`class`	`ConstructFluent.RightShiftArgumentsNested<N>`
`class`	`ConstructFluent.RightUnsignedShiftArgumentsNested<N>`
`class`	`ConstructFluent.TernaryArgumentsNested<N>`
`class`	`ConstructFluent.ThisArgumentsNested<N>`
`class`	`ConstructFluent.TypeNested<N>`
`class`	`ConstructFluent.TypeParamRefParametersNested<N>`
`class`	`ConstructFluent.ValueRefArgumentsNested<N>`
`class`	`ConstructFluent.VoidRefParametersNested<N>`
`class`	`ConstructFluent.WildcardRefParametersNested<N>`
`class`	`ConstructFluent.XorArgumentsNested<N>`

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

Constructor Summary

Constructors
Constructor Description

ConstructFluent()

ConstructFluent(Construct instance)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToArguments(Collection<Expression> items)`
`A`	`addAllToParameters(Collection<TypeRef> items)`
`ConstructFluent.AssignArgumentsNested<A>`	`addNewAssignArgument()`
`ConstructFluent.AssignArgumentsNested<A>`	`addNewAssignArgumentLike(Assign item)`
`ConstructFluent.BinaryExpressionArgumentsNested<A>`	`addNewBinaryExpressionArgument()`
`ConstructFluent.BinaryExpressionArgumentsNested<A>`	`addNewBinaryExpressionArgumentLike(BinaryExpression item)`
`ConstructFluent.BitwiseAndArgumentsNested<A>`	`addNewBitwiseAndArgument()`
`A`	`addNewBitwiseAndArgument(Object left, Object right)`
`ConstructFluent.BitwiseAndArgumentsNested<A>`	`addNewBitwiseAndArgumentLike(BitwiseAnd item)`
`ConstructFluent.BitwiseOrArgumentsNested<A>`	`addNewBitwiseOrArgument()`
`A`	`addNewBitwiseOrArgument(Object left, Object right)`
`ConstructFluent.BitwiseOrArgumentsNested<A>`	`addNewBitwiseOrArgumentLike(BitwiseOr item)`
`ConstructFluent.CastArgumentsNested<A>`	`addNewCastArgument()`
`ConstructFluent.CastArgumentsNested<A>`	`addNewCastArgumentLike(Cast item)`
`ConstructFluent.ClassRefParametersNested<A>`	`addNewClassRefParameter()`
`ConstructFluent.ClassRefParametersNested<A>`	`addNewClassRefParameterLike(ClassRef item)`
`ConstructFluent.ConstructArgumentsNested<A>`	`addNewConstructArgument()`
`ConstructFluent.ConstructArgumentsNested<A>`	`addNewConstructArgumentLike(Construct item)`
`ConstructFluent.DeclareArgumentsNested<A>`	`addNewDeclareArgument()`
`A`	`addNewDeclareArgument(Class type, String name)`
`A`	`addNewDeclareArgument(Class type, String name, Object value)`
`ConstructFluent.DeclareArgumentsNested<A>`	`addNewDeclareArgumentLike(Declare item)`
`ConstructFluent.DivideArgumentsNested<A>`	`addNewDivideArgument()`
`A`	`addNewDivideArgument(Object left, Object right)`
`ConstructFluent.DivideArgumentsNested<A>`	`addNewDivideArgumentLike(Divide item)`
`ConstructFluent.EnclosedArgumentsNested<A>`	`addNewEnclosedArgument()`
`ConstructFluent.EnclosedArgumentsNested<A>`	`addNewEnclosedArgumentLike(Enclosed item)`
`ConstructFluent.EqualsArgumentsNested<A>`	`addNewEqualsArgument()`
`A`	`addNewEqualsArgument(Object left, Object right)`
`ConstructFluent.EqualsArgumentsNested<A>`	`addNewEqualsArgumentLike(Equals item)`
`ConstructFluent.GreaterThanArgumentsNested<A>`	`addNewGreaterThanArgument()`
`A`	`addNewGreaterThanArgument(Object left, Object right)`
`ConstructFluent.GreaterThanArgumentsNested<A>`	`addNewGreaterThanArgumentLike(GreaterThan item)`
`ConstructFluent.GreaterThanOrEqualArgumentsNested<A>`	`addNewGreaterThanOrEqualArgument()`
`A`	`addNewGreaterThanOrEqualArgument(Object left, Object right)`
`ConstructFluent.GreaterThanOrEqualArgumentsNested<A>`	`addNewGreaterThanOrEqualArgumentLike(GreaterThanOrEqual item)`
`ConstructFluent.IndexArgumentsNested<A>`	`addNewIndexArgument()`
`ConstructFluent.IndexArgumentsNested<A>`	`addNewIndexArgumentLike(Index item)`
`ConstructFluent.InstanceOfArgumentsNested<A>`	`addNewInstanceOfArgument()`
`ConstructFluent.InstanceOfArgumentsNested<A>`	`addNewInstanceOfArgumentLike(InstanceOf item)`
`ConstructFluent.InverseArgumentsNested<A>`	`addNewInverseArgument()`
`ConstructFluent.InverseArgumentsNested<A>`	`addNewInverseArgumentLike(Inverse item)`
`ConstructFluent.LambdaArgumentsNested<A>`	`addNewLambdaArgument()`
`ConstructFluent.LambdaArgumentsNested<A>`	`addNewLambdaArgumentLike(Lambda item)`
`ConstructFluent.LeftShiftArgumentsNested<A>`	`addNewLeftShiftArgument()`
`A`	`addNewLeftShiftArgument(Object left, Object right)`
`ConstructFluent.LeftShiftArgumentsNested<A>`	`addNewLeftShiftArgumentLike(LeftShift item)`
`ConstructFluent.LessThanArgumentsNested<A>`	`addNewLessThanArgument()`
`A`	`addNewLessThanArgument(Object left, Object right)`
`ConstructFluent.LessThanArgumentsNested<A>`	`addNewLessThanArgumentLike(LessThan item)`
`ConstructFluent.LessThanOrEqualArgumentsNested<A>`	`addNewLessThanOrEqualArgument()`
`A`	`addNewLessThanOrEqualArgument(Object left, Object right)`
`ConstructFluent.LessThanOrEqualArgumentsNested<A>`	`addNewLessThanOrEqualArgumentLike(LessThanOrEqual item)`
`ConstructFluent.LogicalAndArgumentsNested<A>`	`addNewLogicalAndArgument()`
`A`	`addNewLogicalAndArgument(Object left, Object right)`
`ConstructFluent.LogicalAndArgumentsNested<A>`	`addNewLogicalAndArgumentLike(LogicalAnd item)`
`ConstructFluent.LogicalOrArgumentsNested<A>`	`addNewLogicalOrArgument()`
`A`	`addNewLogicalOrArgument(Object left, Object right)`
`ConstructFluent.LogicalOrArgumentsNested<A>`	`addNewLogicalOrArgumentLike(LogicalOr item)`
`ConstructFluent.MethodCallArgumentsNested<A>`	`addNewMethodCallArgument()`
`ConstructFluent.MethodCallArgumentsNested<A>`	`addNewMethodCallArgumentLike(MethodCall item)`
`ConstructFluent.MinusArgumentsNested<A>`	`addNewMinusArgument()`
`A`	`addNewMinusArgument(Object left, Object right)`
`ConstructFluent.MinusArgumentsNested<A>`	`addNewMinusArgumentLike(Minus item)`
`ConstructFluent.ModuloArgumentsNested<A>`	`addNewModuloArgument()`
`A`	`addNewModuloArgument(Object left, Object right)`
`ConstructFluent.ModuloArgumentsNested<A>`	`addNewModuloArgumentLike(Modulo item)`
`ConstructFluent.MultiplyArgumentsNested<A>`	`addNewMultiplyArgument()`
`A`	`addNewMultiplyArgument(Object left, Object right)`
`ConstructFluent.MultiplyArgumentsNested<A>`	`addNewMultiplyArgumentLike(Multiply item)`
`ConstructFluent.NegativeArgumentsNested<A>`	`addNewNegativeArgument()`
`ConstructFluent.NegativeArgumentsNested<A>`	`addNewNegativeArgumentLike(Negative item)`
`ConstructFluent.NewArrayArgumentsNested<A>`	`addNewNewArrayArgument()`
`A`	`addNewNewArrayArgument(Class type, Integer[] sizes)`
`ConstructFluent.NewArrayArgumentsNested<A>`	`addNewNewArrayArgumentLike(NewArray item)`
`ConstructFluent.NotArgumentsNested<A>`	`addNewNotArgument()`
`ConstructFluent.NotArgumentsNested<A>`	`addNewNotArgumentLike(Not item)`
`ConstructFluent.NotEqualsArgumentsNested<A>`	`addNewNotEqualsArgument()`
`A`	`addNewNotEqualsArgument(Object left, Object right)`
`ConstructFluent.NotEqualsArgumentsNested<A>`	`addNewNotEqualsArgumentLike(NotEquals item)`
`ConstructFluent.PlusArgumentsNested<A>`	`addNewPlusArgument()`
`A`	`addNewPlusArgument(Object left, Object right)`
`ConstructFluent.PlusArgumentsNested<A>`	`addNewPlusArgumentLike(Plus item)`
`ConstructFluent.PositiveArgumentsNested<A>`	`addNewPositiveArgument()`
`ConstructFluent.PositiveArgumentsNested<A>`	`addNewPositiveArgumentLike(Positive item)`
`ConstructFluent.PostDecrementArgumentsNested<A>`	`addNewPostDecrementArgument()`
`ConstructFluent.PostDecrementArgumentsNested<A>`	`addNewPostDecrementArgumentLike(PostDecrement item)`
`ConstructFluent.PostIncrementArgumentsNested<A>`	`addNewPostIncrementArgument()`
`ConstructFluent.PostIncrementArgumentsNested<A>`	`addNewPostIncrementArgumentLike(PostIncrement item)`
`ConstructFluent.PreDecrementArgumentsNested<A>`	`addNewPreDecrementArgument()`
`ConstructFluent.PreDecrementArgumentsNested<A>`	`addNewPreDecrementArgumentLike(PreDecrement item)`
`ConstructFluent.PreIncrementArgumentsNested<A>`	`addNewPreIncrementArgument()`
`ConstructFluent.PreIncrementArgumentsNested<A>`	`addNewPreIncrementArgumentLike(PreIncrement item)`
`ConstructFluent.PrimitiveRefParametersNested<A>`	`addNewPrimitiveRefParameter()`
`ConstructFluent.PrimitiveRefParametersNested<A>`	`addNewPrimitiveRefParameterLike(PrimitiveRef item)`
`ConstructFluent.PropertyRefArgumentsNested<A>`	`addNewPropertyRefArgument()`
`ConstructFluent.PropertyRefArgumentsNested<A>`	`addNewPropertyRefArgumentLike(PropertyRef item)`
`ConstructFluent.RightShiftArgumentsNested<A>`	`addNewRightShiftArgument()`
`A`	`addNewRightShiftArgument(Object left, Object right)`
`ConstructFluent.RightShiftArgumentsNested<A>`	`addNewRightShiftArgumentLike(RightShift item)`
`ConstructFluent.RightUnsignedShiftArgumentsNested<A>`	`addNewRightUnsignedShiftArgument()`
`A`	`addNewRightUnsignedShiftArgument(Object left, Object right)`
`ConstructFluent.RightUnsignedShiftArgumentsNested<A>`	`addNewRightUnsignedShiftArgumentLike(RightUnsignedShift item)`
`ConstructFluent.TernaryArgumentsNested<A>`	`addNewTernaryArgument()`
`ConstructFluent.TernaryArgumentsNested<A>`	`addNewTernaryArgumentLike(Ternary item)`
`ConstructFluent.ThisArgumentsNested<A>`	`addNewThisArgument()`
`ConstructFluent.ThisArgumentsNested<A>`	`addNewThisArgumentLike(This item)`
`ConstructFluent.TypeParamRefParametersNested<A>`	`addNewTypeParamRefParameter()`
`ConstructFluent.TypeParamRefParametersNested<A>`	`addNewTypeParamRefParameterLike(TypeParamRef item)`
`ConstructFluent.ValueRefArgumentsNested<A>`	`addNewValueRefArgument()`
`A`	`addNewValueRefArgument(Object value)`
`ConstructFluent.ValueRefArgumentsNested<A>`	`addNewValueRefArgumentLike(ValueRef item)`
`ConstructFluent.VoidRefParametersNested<A>`	`addNewVoidRefParameter()`
`ConstructFluent.VoidRefParametersNested<A>`	`addNewVoidRefParameterLike(VoidRef item)`
`ConstructFluent.WildcardRefParametersNested<A>`	`addNewWildcardRefParameter()`
`ConstructFluent.WildcardRefParametersNested<A>`	`addNewWildcardRefParameterLike(WildcardRef item)`
`ConstructFluent.XorArgumentsNested<A>`	`addNewXorArgument()`
`A`	`addNewXorArgument(Object left, Object right)`
`ConstructFluent.XorArgumentsNested<A>`	`addNewXorArgumentLike(Xor item)`
`A`	`addToArguments(int index, VisitableBuilder<? extends Expression,?> builder)`
`A`	`addToArguments(int index, Expression item)`
`A`	`addToArguments(VisitableBuilder<? extends Expression,?> builder)`
`A`	`addToArguments(Expression... items)`
`A`	`addToParameters(int index, VisitableBuilder<? extends TypeRef,?> builder)`
`A`	`addToParameters(int index, TypeRef item)`
`A`	`addToParameters(VisitableBuilder<? extends TypeRef,?> builder)`
`A`	`addToParameters(TypeRef... items)`
`Expression`	`buildArgument(int index)`
`List<Expression>`	`buildArguments()`
`protected static <T> VisitableBuilder<T,?>`	`builder(Object item)`
`Expression`	`buildFirstArgument()`
`TypeRef`	`buildFirstParameter()`
`Expression`	`buildLastArgument()`
`TypeRef`	`buildLastParameter()`
`Expression`	`buildMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)`
`TypeRef`	`buildMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)`
`TypeRef`	`buildParameter(int index)`
`List<TypeRef>`	`buildParameters()`
`ClassRef`	`buildType()`
`protected void`	`copyInstance(Construct instance)`
`ConstructFluent.TypeNested<A>`	`editOrNewType()`
`ConstructFluent.TypeNested<A>`	`editOrNewTypeLike(ClassRef item)`
`ConstructFluent.TypeNested<A>`	`editType()`
`boolean`	`equals(Object o)`
`boolean`	`hasArguments()`
`int`	`hashCode()`
`boolean`	`hasMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)`
`boolean`	`hasMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)`
`boolean`	`hasParameters()`
`boolean`	`hasType()`
`A`	`removeAllFromArguments(Collection<Expression> items)`
`A`	`removeAllFromParameters(Collection<TypeRef> items)`
`A`	`removeFromArguments(VisitableBuilder<? extends Expression,?> builder)`
`A`	`removeFromArguments(Expression... items)`
`A`	`removeFromParameters(VisitableBuilder<? extends TypeRef,?> builder)`
`A`	`removeFromParameters(TypeRef... items)`
`A`	`removeMatchingFromArguments(Predicate<VisitableBuilder<? extends Expression,?>> predicate)`
`A`	`removeMatchingFromParameters(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)`
`ConstructFluent.AssignArgumentsNested<A>`	`setNewAssignArgumentLike(int index, Assign item)`
`ConstructFluent.BinaryExpressionArgumentsNested<A>`	`setNewBinaryExpressionArgumentLike(int index, BinaryExpression item)`
`ConstructFluent.BitwiseAndArgumentsNested<A>`	`setNewBitwiseAndArgumentLike(int index, BitwiseAnd item)`
`ConstructFluent.BitwiseOrArgumentsNested<A>`	`setNewBitwiseOrArgumentLike(int index, BitwiseOr item)`
`ConstructFluent.CastArgumentsNested<A>`	`setNewCastArgumentLike(int index, Cast item)`
`ConstructFluent.ClassRefParametersNested<A>`	`setNewClassRefParameterLike(int index, ClassRef item)`
`ConstructFluent.ConstructArgumentsNested<A>`	`setNewConstructArgumentLike(int index, Construct item)`
`ConstructFluent.DeclareArgumentsNested<A>`	`setNewDeclareArgumentLike(int index, Declare item)`
`ConstructFluent.DivideArgumentsNested<A>`	`setNewDivideArgumentLike(int index, Divide item)`
`ConstructFluent.EnclosedArgumentsNested<A>`	`setNewEnclosedArgumentLike(int index, Enclosed item)`
`ConstructFluent.EqualsArgumentsNested<A>`	`setNewEqualsArgumentLike(int index, Equals item)`
`ConstructFluent.GreaterThanArgumentsNested<A>`	`setNewGreaterThanArgumentLike(int index, GreaterThan item)`
`ConstructFluent.GreaterThanOrEqualArgumentsNested<A>`	`setNewGreaterThanOrEqualArgumentLike(int index, GreaterThanOrEqual item)`
`ConstructFluent.IndexArgumentsNested<A>`	`setNewIndexArgumentLike(int index, Index item)`
`ConstructFluent.InstanceOfArgumentsNested<A>`	`setNewInstanceOfArgumentLike(int index, InstanceOf item)`
`ConstructFluent.InverseArgumentsNested<A>`	`setNewInverseArgumentLike(int index, Inverse item)`
`ConstructFluent.LambdaArgumentsNested<A>`	`setNewLambdaArgumentLike(int index, Lambda item)`
`ConstructFluent.LeftShiftArgumentsNested<A>`	`setNewLeftShiftArgumentLike(int index, LeftShift item)`
`ConstructFluent.LessThanArgumentsNested<A>`	`setNewLessThanArgumentLike(int index, LessThan item)`
`ConstructFluent.LessThanOrEqualArgumentsNested<A>`	`setNewLessThanOrEqualArgumentLike(int index, LessThanOrEqual item)`
`ConstructFluent.LogicalAndArgumentsNested<A>`	`setNewLogicalAndArgumentLike(int index, LogicalAnd item)`
`ConstructFluent.LogicalOrArgumentsNested<A>`	`setNewLogicalOrArgumentLike(int index, LogicalOr item)`
`ConstructFluent.MethodCallArgumentsNested<A>`	`setNewMethodCallArgumentLike(int index, MethodCall item)`
`ConstructFluent.MinusArgumentsNested<A>`	`setNewMinusArgumentLike(int index, Minus item)`
`ConstructFluent.ModuloArgumentsNested<A>`	`setNewModuloArgumentLike(int index, Modulo item)`
`ConstructFluent.MultiplyArgumentsNested<A>`	`setNewMultiplyArgumentLike(int index, Multiply item)`
`ConstructFluent.NegativeArgumentsNested<A>`	`setNewNegativeArgumentLike(int index, Negative item)`
`ConstructFluent.NewArrayArgumentsNested<A>`	`setNewNewArrayArgumentLike(int index, NewArray item)`
`ConstructFluent.NotArgumentsNested<A>`	`setNewNotArgumentLike(int index, Not item)`
`ConstructFluent.NotEqualsArgumentsNested<A>`	`setNewNotEqualsArgumentLike(int index, NotEquals item)`
`ConstructFluent.PlusArgumentsNested<A>`	`setNewPlusArgumentLike(int index, Plus item)`
`ConstructFluent.PositiveArgumentsNested<A>`	`setNewPositiveArgumentLike(int index, Positive item)`
`ConstructFluent.PostDecrementArgumentsNested<A>`	`setNewPostDecrementArgumentLike(int index, PostDecrement item)`
`ConstructFluent.PostIncrementArgumentsNested<A>`	`setNewPostIncrementArgumentLike(int index, PostIncrement item)`
`ConstructFluent.PreDecrementArgumentsNested<A>`	`setNewPreDecrementArgumentLike(int index, PreDecrement item)`
`ConstructFluent.PreIncrementArgumentsNested<A>`	`setNewPreIncrementArgumentLike(int index, PreIncrement item)`
`ConstructFluent.PrimitiveRefParametersNested<A>`	`setNewPrimitiveRefParameterLike(int index, PrimitiveRef item)`
`ConstructFluent.PropertyRefArgumentsNested<A>`	`setNewPropertyRefArgumentLike(int index, PropertyRef item)`
`ConstructFluent.RightShiftArgumentsNested<A>`	`setNewRightShiftArgumentLike(int index, RightShift item)`
`ConstructFluent.RightUnsignedShiftArgumentsNested<A>`	`setNewRightUnsignedShiftArgumentLike(int index, RightUnsignedShift item)`
`ConstructFluent.TernaryArgumentsNested<A>`	`setNewTernaryArgumentLike(int index, Ternary item)`
`ConstructFluent.ThisArgumentsNested<A>`	`setNewThisArgumentLike(int index, This item)`
`ConstructFluent.TypeParamRefParametersNested<A>`	`setNewTypeParamRefParameterLike(int index, TypeParamRef item)`
`ConstructFluent.ValueRefArgumentsNested<A>`	`setNewValueRefArgumentLike(int index, ValueRef item)`
`ConstructFluent.VoidRefParametersNested<A>`	`setNewVoidRefParameterLike(int index, VoidRef item)`
`ConstructFluent.WildcardRefParametersNested<A>`	`setNewWildcardRefParameterLike(int index, WildcardRef item)`
`ConstructFluent.XorArgumentsNested<A>`	`setNewXorArgumentLike(int index, Xor item)`
`A`	`setToArguments(int index, Expression item)`
`A`	`setToParameters(int index, TypeRef item)`
`String`	`toString()`
`A`	`withArguments(Expression... arguments)`
`A`	`withArguments(List<Expression> arguments)`
`ConstructFluent.TypeNested<A>`	`withNewType()`
`ConstructFluent.TypeNested<A>`	`withNewTypeLike(ClassRef item)`
`A`	`withParameters(TypeRef... parameters)`
`A`	`withParameters(List<TypeRef> parameters)`
`A`	`withType(ClassRef type)`

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

ConstructFluent
```
public ConstructFluent()
```

ConstructFluent

public ConstructFluent(Construct instance)

Method Detail

copyInstance

protected void copyInstance(Construct instance)

buildType
```
public ClassRef buildType()
```

withType
```
public A withType(ClassRef type)
```

hasType
```
public boolean hasType()
```

withNewType

public ConstructFluent.TypeNested<A> withNewType()

withNewTypeLike

public ConstructFluent.TypeNested<A> withNewTypeLike(ClassRef item)

editType

public ConstructFluent.TypeNested<A> editType()

editOrNewType

public ConstructFluent.TypeNested<A> editOrNewType()

editOrNewTypeLike

public ConstructFluent.TypeNested<A> editOrNewTypeLike(ClassRef item)

addToParameters

public A addToParameters(VisitableBuilder<? extends TypeRef,?> builder)

addToParameters

public A addToParameters(int index,
                         VisitableBuilder<? extends TypeRef,?> builder)

addToParameters

public A addToParameters(int index,
                         TypeRef item)

setToParameters

public A setToParameters(int index,
                         TypeRef item)

addToParameters

public A addToParameters(TypeRef... items)

addAllToParameters

public A addAllToParameters(Collection<TypeRef> items)

removeFromParameters

public A removeFromParameters(VisitableBuilder<? extends TypeRef,?> builder)

removeFromParameters

public A removeFromParameters(TypeRef... items)

removeAllFromParameters

public A removeAllFromParameters(Collection<TypeRef> items)

removeMatchingFromParameters

public A removeMatchingFromParameters(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

buildParameters

public List<TypeRef> buildParameters()

buildParameter

public TypeRef buildParameter(int index)

buildFirstParameter
```
public TypeRef buildFirstParameter()
```

buildLastParameter
```
public TypeRef buildLastParameter()
```

buildMatchingParameter

public TypeRef buildMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

hasMatchingParameter

public boolean hasMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

withParameters

public A withParameters(List<TypeRef> parameters)

withParameters

public A withParameters(TypeRef... parameters)

hasParameters
```
public boolean hasParameters()
```

addNewClassRefParameter

public ConstructFluent.ClassRefParametersNested<A> addNewClassRefParameter()

addNewClassRefParameterLike

public ConstructFluent.ClassRefParametersNested<A> addNewClassRefParameterLike(ClassRef item)

setNewClassRefParameterLike

public ConstructFluent.ClassRefParametersNested<A> setNewClassRefParameterLike(int index,
                                                                               ClassRef item)

addNewPrimitiveRefParameter

public ConstructFluent.PrimitiveRefParametersNested<A> addNewPrimitiveRefParameter()

addNewPrimitiveRefParameterLike

public ConstructFluent.PrimitiveRefParametersNested<A> addNewPrimitiveRefParameterLike(PrimitiveRef item)

setNewPrimitiveRefParameterLike

public ConstructFluent.PrimitiveRefParametersNested<A> setNewPrimitiveRefParameterLike(int index,
                                                                                       PrimitiveRef item)

addNewVoidRefParameter

public ConstructFluent.VoidRefParametersNested<A> addNewVoidRefParameter()

addNewVoidRefParameterLike

public ConstructFluent.VoidRefParametersNested<A> addNewVoidRefParameterLike(VoidRef item)

setNewVoidRefParameterLike

public ConstructFluent.VoidRefParametersNested<A> setNewVoidRefParameterLike(int index,
                                                                             VoidRef item)

addNewTypeParamRefParameter

public ConstructFluent.TypeParamRefParametersNested<A> addNewTypeParamRefParameter()

addNewTypeParamRefParameterLike

public ConstructFluent.TypeParamRefParametersNested<A> addNewTypeParamRefParameterLike(TypeParamRef item)

setNewTypeParamRefParameterLike

public ConstructFluent.TypeParamRefParametersNested<A> setNewTypeParamRefParameterLike(int index,
                                                                                       TypeParamRef item)

addNewWildcardRefParameter

public ConstructFluent.WildcardRefParametersNested<A> addNewWildcardRefParameter()

addNewWildcardRefParameterLike

public ConstructFluent.WildcardRefParametersNested<A> addNewWildcardRefParameterLike(WildcardRef item)

setNewWildcardRefParameterLike

public ConstructFluent.WildcardRefParametersNested<A> setNewWildcardRefParameterLike(int index,
                                                                                     WildcardRef item)

addToArguments

public A addToArguments(VisitableBuilder<? extends Expression,?> builder)

addToArguments

public A addToArguments(int index,
                        VisitableBuilder<? extends Expression,?> builder)

addToArguments

public A addToArguments(int index,
                        Expression item)

setToArguments

public A setToArguments(int index,
                        Expression item)

addToArguments

public A addToArguments(Expression... items)

addAllToArguments

public A addAllToArguments(Collection<Expression> items)

removeFromArguments

public A removeFromArguments(VisitableBuilder<? extends Expression,?> builder)

removeFromArguments

public A removeFromArguments(Expression... items)

removeAllFromArguments

public A removeAllFromArguments(Collection<Expression> items)

removeMatchingFromArguments

public A removeMatchingFromArguments(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

buildArguments

public List<Expression> buildArguments()

buildArgument

public Expression buildArgument(int index)

buildFirstArgument

public Expression buildFirstArgument()

buildLastArgument
```
public Expression buildLastArgument()
```

buildMatchingArgument

public Expression buildMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

hasMatchingArgument

public boolean hasMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

withArguments

public A withArguments(List<Expression> arguments)

withArguments

public A withArguments(Expression... arguments)

hasArguments
```
public boolean hasArguments()
```

addNewMultiplyArgument

public ConstructFluent.MultiplyArgumentsNested<A> addNewMultiplyArgument()

addNewMultiplyArgumentLike

public ConstructFluent.MultiplyArgumentsNested<A> addNewMultiplyArgumentLike(Multiply item)

addNewMultiplyArgument

public A addNewMultiplyArgument(Object left,
                                Object right)

setNewMultiplyArgumentLike

public ConstructFluent.MultiplyArgumentsNested<A> setNewMultiplyArgumentLike(int index,
                                                                             Multiply item)

addNewNewArrayArgument

public ConstructFluent.NewArrayArgumentsNested<A> addNewNewArrayArgument()

addNewNewArrayArgumentLike

public ConstructFluent.NewArrayArgumentsNested<A> addNewNewArrayArgumentLike(NewArray item)

addNewNewArrayArgument

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

setNewNewArrayArgumentLike

public ConstructFluent.NewArrayArgumentsNested<A> setNewNewArrayArgumentLike(int index,
                                                                             NewArray item)

addNewInstanceOfArgument

public ConstructFluent.InstanceOfArgumentsNested<A> addNewInstanceOfArgument()

addNewInstanceOfArgumentLike

public ConstructFluent.InstanceOfArgumentsNested<A> addNewInstanceOfArgumentLike(InstanceOf item)

setNewInstanceOfArgumentLike

public ConstructFluent.InstanceOfArgumentsNested<A> setNewInstanceOfArgumentLike(int index,
                                                                                 InstanceOf item)

addNewMethodCallArgument

public ConstructFluent.MethodCallArgumentsNested<A> addNewMethodCallArgument()

addNewMethodCallArgumentLike

public ConstructFluent.MethodCallArgumentsNested<A> addNewMethodCallArgumentLike(MethodCall item)

setNewMethodCallArgumentLike

public ConstructFluent.MethodCallArgumentsNested<A> setNewMethodCallArgumentLike(int index,
                                                                                 MethodCall item)

addNewInverseArgument

public ConstructFluent.InverseArgumentsNested<A> addNewInverseArgument()

addNewInverseArgumentLike

public ConstructFluent.InverseArgumentsNested<A> addNewInverseArgumentLike(Inverse item)

setNewInverseArgumentLike

public ConstructFluent.InverseArgumentsNested<A> setNewInverseArgumentLike(int index,
                                                                           Inverse item)

addNewIndexArgument

public ConstructFluent.IndexArgumentsNested<A> addNewIndexArgument()

addNewIndexArgumentLike

public ConstructFluent.IndexArgumentsNested<A> addNewIndexArgumentLike(Index item)

setNewIndexArgumentLike

public ConstructFluent.IndexArgumentsNested<A> setNewIndexArgumentLike(int index,
                                                                       Index item)

addNewGreaterThanOrEqualArgument

public ConstructFluent.GreaterThanOrEqualArgumentsNested<A> addNewGreaterThanOrEqualArgument()

addNewGreaterThanOrEqualArgumentLike

public ConstructFluent.GreaterThanOrEqualArgumentsNested<A> addNewGreaterThanOrEqualArgumentLike(GreaterThanOrEqual item)

addNewGreaterThanOrEqualArgument

public A addNewGreaterThanOrEqualArgument(Object left,
                                          Object right)

setNewGreaterThanOrEqualArgumentLike

public ConstructFluent.GreaterThanOrEqualArgumentsNested<A> setNewGreaterThanOrEqualArgumentLike(int index,
                                                                                                 GreaterThanOrEqual item)

addNewBitwiseAndArgument

public ConstructFluent.BitwiseAndArgumentsNested<A> addNewBitwiseAndArgument()

addNewBitwiseAndArgumentLike

public ConstructFluent.BitwiseAndArgumentsNested<A> addNewBitwiseAndArgumentLike(BitwiseAnd item)

addNewBitwiseAndArgument

public A addNewBitwiseAndArgument(Object left,
                                  Object right)

setNewBitwiseAndArgumentLike

public ConstructFluent.BitwiseAndArgumentsNested<A> setNewBitwiseAndArgumentLike(int index,
                                                                                 BitwiseAnd item)

addNewMinusArgument

public ConstructFluent.MinusArgumentsNested<A> addNewMinusArgument()

addNewMinusArgumentLike

public ConstructFluent.MinusArgumentsNested<A> addNewMinusArgumentLike(Minus item)

addNewMinusArgument

public A addNewMinusArgument(Object left,
                             Object right)

setNewMinusArgumentLike

public ConstructFluent.MinusArgumentsNested<A> setNewMinusArgumentLike(int index,
                                                                       Minus item)

addNewLogicalOrArgument

public ConstructFluent.LogicalOrArgumentsNested<A> addNewLogicalOrArgument()

addNewLogicalOrArgumentLike

public ConstructFluent.LogicalOrArgumentsNested<A> addNewLogicalOrArgumentLike(LogicalOr item)

addNewLogicalOrArgument

public A addNewLogicalOrArgument(Object left,
                                 Object right)

setNewLogicalOrArgumentLike

public ConstructFluent.LogicalOrArgumentsNested<A> setNewLogicalOrArgumentLike(int index,
                                                                               LogicalOr item)

addNewNotEqualsArgument

public ConstructFluent.NotEqualsArgumentsNested<A> addNewNotEqualsArgument()

addNewNotEqualsArgumentLike

public ConstructFluent.NotEqualsArgumentsNested<A> addNewNotEqualsArgumentLike(NotEquals item)

addNewNotEqualsArgument

public A addNewNotEqualsArgument(Object left,
                                 Object right)

setNewNotEqualsArgumentLike

public ConstructFluent.NotEqualsArgumentsNested<A> setNewNotEqualsArgumentLike(int index,
                                                                               NotEquals item)

addNewDivideArgument

public ConstructFluent.DivideArgumentsNested<A> addNewDivideArgument()

addNewDivideArgumentLike

public ConstructFluent.DivideArgumentsNested<A> addNewDivideArgumentLike(Divide item)

addNewDivideArgument

public A addNewDivideArgument(Object left,
                              Object right)

setNewDivideArgumentLike

public ConstructFluent.DivideArgumentsNested<A> setNewDivideArgumentLike(int index,
                                                                         Divide item)

addNewLessThanArgument

public ConstructFluent.LessThanArgumentsNested<A> addNewLessThanArgument()

addNewLessThanArgumentLike

public ConstructFluent.LessThanArgumentsNested<A> addNewLessThanArgumentLike(LessThan item)

addNewLessThanArgument

public A addNewLessThanArgument(Object left,
                                Object right)

setNewLessThanArgumentLike

public ConstructFluent.LessThanArgumentsNested<A> setNewLessThanArgumentLike(int index,
                                                                             LessThan item)

addNewBitwiseOrArgument

public ConstructFluent.BitwiseOrArgumentsNested<A> addNewBitwiseOrArgument()

addNewBitwiseOrArgumentLike

public ConstructFluent.BitwiseOrArgumentsNested<A> addNewBitwiseOrArgumentLike(BitwiseOr item)

addNewBitwiseOrArgument

public A addNewBitwiseOrArgument(Object left,
                                 Object right)

setNewBitwiseOrArgumentLike

public ConstructFluent.BitwiseOrArgumentsNested<A> setNewBitwiseOrArgumentLike(int index,
                                                                               BitwiseOr item)

addNewPropertyRefArgument

public ConstructFluent.PropertyRefArgumentsNested<A> addNewPropertyRefArgument()

addNewPropertyRefArgumentLike

public ConstructFluent.PropertyRefArgumentsNested<A> addNewPropertyRefArgumentLike(PropertyRef item)

setNewPropertyRefArgumentLike

public ConstructFluent.PropertyRefArgumentsNested<A> setNewPropertyRefArgumentLike(int index,
                                                                                   PropertyRef item)

addNewRightShiftArgument

public ConstructFluent.RightShiftArgumentsNested<A> addNewRightShiftArgument()

addNewRightShiftArgumentLike

public ConstructFluent.RightShiftArgumentsNested<A> addNewRightShiftArgumentLike(RightShift item)

addNewRightShiftArgument

public A addNewRightShiftArgument(Object left,
                                  Object right)

setNewRightShiftArgumentLike

public ConstructFluent.RightShiftArgumentsNested<A> setNewRightShiftArgumentLike(int index,
                                                                                 RightShift item)

addNewGreaterThanArgument

public ConstructFluent.GreaterThanArgumentsNested<A> addNewGreaterThanArgument()

addNewGreaterThanArgumentLike

public ConstructFluent.GreaterThanArgumentsNested<A> addNewGreaterThanArgumentLike(GreaterThan item)

addNewGreaterThanArgument

public A addNewGreaterThanArgument(Object left,
                                   Object right)

setNewGreaterThanArgumentLike

public ConstructFluent.GreaterThanArgumentsNested<A> setNewGreaterThanArgumentLike(int index,
                                                                                   GreaterThan item)

addNewDeclareArgument

public ConstructFluent.DeclareArgumentsNested<A> addNewDeclareArgument()

addNewDeclareArgumentLike

public ConstructFluent.DeclareArgumentsNested<A> addNewDeclareArgumentLike(Declare item)

addNewDeclareArgument

public A addNewDeclareArgument(Class type,
                               String name)

addNewDeclareArgument

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

setNewDeclareArgumentLike

public ConstructFluent.DeclareArgumentsNested<A> setNewDeclareArgumentLike(int index,
                                                                           Declare item)

addNewCastArgument

public ConstructFluent.CastArgumentsNested<A> addNewCastArgument()

addNewCastArgumentLike

public ConstructFluent.CastArgumentsNested<A> addNewCastArgumentLike(Cast item)

setNewCastArgumentLike

public ConstructFluent.CastArgumentsNested<A> setNewCastArgumentLike(int index,
                                                                     Cast item)

addNewModuloArgument

public ConstructFluent.ModuloArgumentsNested<A> addNewModuloArgument()

addNewModuloArgumentLike

public ConstructFluent.ModuloArgumentsNested<A> addNewModuloArgumentLike(Modulo item)

addNewModuloArgument

public A addNewModuloArgument(Object left,
                              Object right)

setNewModuloArgumentLike

public ConstructFluent.ModuloArgumentsNested<A> setNewModuloArgumentLike(int index,
                                                                         Modulo item)

addNewValueRefArgument

public ConstructFluent.ValueRefArgumentsNested<A> addNewValueRefArgument()

addNewValueRefArgumentLike

public ConstructFluent.ValueRefArgumentsNested<A> addNewValueRefArgumentLike(ValueRef item)

addNewValueRefArgument

public A addNewValueRefArgument(Object value)

setNewValueRefArgumentLike

public ConstructFluent.ValueRefArgumentsNested<A> setNewValueRefArgumentLike(int index,
                                                                             ValueRef item)

addNewLeftShiftArgument

public ConstructFluent.LeftShiftArgumentsNested<A> addNewLeftShiftArgument()

addNewLeftShiftArgumentLike

public ConstructFluent.LeftShiftArgumentsNested<A> addNewLeftShiftArgumentLike(LeftShift item)

addNewLeftShiftArgument

public A addNewLeftShiftArgument(Object left,
                                 Object right)

setNewLeftShiftArgumentLike

public ConstructFluent.LeftShiftArgumentsNested<A> setNewLeftShiftArgumentLike(int index,
                                                                               LeftShift item)

addNewTernaryArgument

public ConstructFluent.TernaryArgumentsNested<A> addNewTernaryArgument()

addNewTernaryArgumentLike

public ConstructFluent.TernaryArgumentsNested<A> addNewTernaryArgumentLike(Ternary item)

setNewTernaryArgumentLike

public ConstructFluent.TernaryArgumentsNested<A> setNewTernaryArgumentLike(int index,
                                                                           Ternary item)

addNewBinaryExpressionArgument

public ConstructFluent.BinaryExpressionArgumentsNested<A> addNewBinaryExpressionArgument()

addNewBinaryExpressionArgumentLike

public ConstructFluent.BinaryExpressionArgumentsNested<A> addNewBinaryExpressionArgumentLike(BinaryExpression item)

setNewBinaryExpressionArgumentLike

public ConstructFluent.BinaryExpressionArgumentsNested<A> setNewBinaryExpressionArgumentLike(int index,
                                                                                             BinaryExpression item)

addNewEqualsArgument

public ConstructFluent.EqualsArgumentsNested<A> addNewEqualsArgument()

addNewEqualsArgumentLike

public ConstructFluent.EqualsArgumentsNested<A> addNewEqualsArgumentLike(Equals item)

addNewEqualsArgument

public A addNewEqualsArgument(Object left,
                              Object right)

setNewEqualsArgumentLike

public ConstructFluent.EqualsArgumentsNested<A> setNewEqualsArgumentLike(int index,
                                                                         Equals item)

addNewEnclosedArgument

public ConstructFluent.EnclosedArgumentsNested<A> addNewEnclosedArgument()

addNewEnclosedArgumentLike

public ConstructFluent.EnclosedArgumentsNested<A> addNewEnclosedArgumentLike(Enclosed item)

setNewEnclosedArgumentLike

public ConstructFluent.EnclosedArgumentsNested<A> setNewEnclosedArgumentLike(int index,
                                                                             Enclosed item)

addNewPreDecrementArgument

public ConstructFluent.PreDecrementArgumentsNested<A> addNewPreDecrementArgument()

addNewPreDecrementArgumentLike

public ConstructFluent.PreDecrementArgumentsNested<A> addNewPreDecrementArgumentLike(PreDecrement item)

setNewPreDecrementArgumentLike

public ConstructFluent.PreDecrementArgumentsNested<A> setNewPreDecrementArgumentLike(int index,
                                                                                     PreDecrement item)

addNewPostDecrementArgument

public ConstructFluent.PostDecrementArgumentsNested<A> addNewPostDecrementArgument()

addNewPostDecrementArgumentLike

public ConstructFluent.PostDecrementArgumentsNested<A> addNewPostDecrementArgumentLike(PostDecrement item)

setNewPostDecrementArgumentLike

public ConstructFluent.PostDecrementArgumentsNested<A> setNewPostDecrementArgumentLike(int index,
                                                                                       PostDecrement item)

addNewLambdaArgument

public ConstructFluent.LambdaArgumentsNested<A> addNewLambdaArgument()

addNewLambdaArgumentLike

public ConstructFluent.LambdaArgumentsNested<A> addNewLambdaArgumentLike(Lambda item)

setNewLambdaArgumentLike

public ConstructFluent.LambdaArgumentsNested<A> setNewLambdaArgumentLike(int index,
                                                                         Lambda item)

addNewNotArgument

public ConstructFluent.NotArgumentsNested<A> addNewNotArgument()

addNewNotArgumentLike

public ConstructFluent.NotArgumentsNested<A> addNewNotArgumentLike(Not item)

setNewNotArgumentLike

public ConstructFluent.NotArgumentsNested<A> setNewNotArgumentLike(int index,
                                                                   Not item)

addNewAssignArgument

public ConstructFluent.AssignArgumentsNested<A> addNewAssignArgument()

addNewAssignArgumentLike

public ConstructFluent.AssignArgumentsNested<A> addNewAssignArgumentLike(Assign item)

setNewAssignArgumentLike

public ConstructFluent.AssignArgumentsNested<A> setNewAssignArgumentLike(int index,
                                                                         Assign item)

addNewNegativeArgument

public ConstructFluent.NegativeArgumentsNested<A> addNewNegativeArgument()

addNewNegativeArgumentLike

public ConstructFluent.NegativeArgumentsNested<A> addNewNegativeArgumentLike(Negative item)

setNewNegativeArgumentLike

public ConstructFluent.NegativeArgumentsNested<A> setNewNegativeArgumentLike(int index,
                                                                             Negative item)

addNewThisArgument

public ConstructFluent.ThisArgumentsNested<A> addNewThisArgument()

addNewThisArgumentLike

public ConstructFluent.ThisArgumentsNested<A> addNewThisArgumentLike(This item)

setNewThisArgumentLike

public ConstructFluent.ThisArgumentsNested<A> setNewThisArgumentLike(int index,
                                                                     This item)

addNewLogicalAndArgument

public ConstructFluent.LogicalAndArgumentsNested<A> addNewLogicalAndArgument()

addNewLogicalAndArgumentLike

public ConstructFluent.LogicalAndArgumentsNested<A> addNewLogicalAndArgumentLike(LogicalAnd item)

addNewLogicalAndArgument

public A addNewLogicalAndArgument(Object left,
                                  Object right)

setNewLogicalAndArgumentLike

public ConstructFluent.LogicalAndArgumentsNested<A> setNewLogicalAndArgumentLike(int index,
                                                                                 LogicalAnd item)

addNewPostIncrementArgument

public ConstructFluent.PostIncrementArgumentsNested<A> addNewPostIncrementArgument()

addNewPostIncrementArgumentLike

public ConstructFluent.PostIncrementArgumentsNested<A> addNewPostIncrementArgumentLike(PostIncrement item)

setNewPostIncrementArgumentLike

public ConstructFluent.PostIncrementArgumentsNested<A> setNewPostIncrementArgumentLike(int index,
                                                                                       PostIncrement item)

addNewRightUnsignedShiftArgument

public ConstructFluent.RightUnsignedShiftArgumentsNested<A> addNewRightUnsignedShiftArgument()

addNewRightUnsignedShiftArgumentLike

public ConstructFluent.RightUnsignedShiftArgumentsNested<A> addNewRightUnsignedShiftArgumentLike(RightUnsignedShift item)

addNewRightUnsignedShiftArgument

public A addNewRightUnsignedShiftArgument(Object left,
                                          Object right)

setNewRightUnsignedShiftArgumentLike

public ConstructFluent.RightUnsignedShiftArgumentsNested<A> setNewRightUnsignedShiftArgumentLike(int index,
                                                                                                 RightUnsignedShift item)

addNewPlusArgument

public ConstructFluent.PlusArgumentsNested<A> addNewPlusArgument()

addNewPlusArgumentLike

public ConstructFluent.PlusArgumentsNested<A> addNewPlusArgumentLike(Plus item)

addNewPlusArgument

public A addNewPlusArgument(Object left,
                            Object right)

setNewPlusArgumentLike

public ConstructFluent.PlusArgumentsNested<A> setNewPlusArgumentLike(int index,
                                                                     Plus item)

addNewConstructArgument

public ConstructFluent.ConstructArgumentsNested<A> addNewConstructArgument()

addNewConstructArgumentLike

public ConstructFluent.ConstructArgumentsNested<A> addNewConstructArgumentLike(Construct item)

setNewConstructArgumentLike

public ConstructFluent.ConstructArgumentsNested<A> setNewConstructArgumentLike(int index,
                                                                               Construct item)

addNewXorArgument

public ConstructFluent.XorArgumentsNested<A> addNewXorArgument()

addNewXorArgumentLike

public ConstructFluent.XorArgumentsNested<A> addNewXorArgumentLike(Xor item)

addNewXorArgument

public A addNewXorArgument(Object left,
                           Object right)

setNewXorArgumentLike

public ConstructFluent.XorArgumentsNested<A> setNewXorArgumentLike(int index,
                                                                   Xor item)

addNewPreIncrementArgument

public ConstructFluent.PreIncrementArgumentsNested<A> addNewPreIncrementArgument()

addNewPreIncrementArgumentLike

public ConstructFluent.PreIncrementArgumentsNested<A> addNewPreIncrementArgumentLike(PreIncrement item)

setNewPreIncrementArgumentLike

public ConstructFluent.PreIncrementArgumentsNested<A> setNewPreIncrementArgumentLike(int index,
                                                                                     PreIncrement item)

addNewLessThanOrEqualArgument

public ConstructFluent.LessThanOrEqualArgumentsNested<A> addNewLessThanOrEqualArgument()

addNewLessThanOrEqualArgumentLike

public ConstructFluent.LessThanOrEqualArgumentsNested<A> addNewLessThanOrEqualArgumentLike(LessThanOrEqual item)

addNewLessThanOrEqualArgument

public A addNewLessThanOrEqualArgument(Object left,
                                       Object right)

setNewLessThanOrEqualArgumentLike

public ConstructFluent.LessThanOrEqualArgumentsNested<A> setNewLessThanOrEqualArgumentLike(int index,
                                                                                           LessThanOrEqual item)

addNewPositiveArgument

public ConstructFluent.PositiveArgumentsNested<A> addNewPositiveArgument()

addNewPositiveArgumentLike

public ConstructFluent.PositiveArgumentsNested<A> addNewPositiveArgumentLike(Positive item)

setNewPositiveArgumentLike

public ConstructFluent.PositiveArgumentsNested<A> setNewPositiveArgumentLike(int index,
                                                                             Positive item)

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

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

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

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

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

toString in class Object

builder

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

Class ConstructFluent<A extends ConstructFluent<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

ConstructFluent

ConstructFluent

Method Detail

copyInstance

buildType

withType

hasType

withNewType

withNewTypeLike

editType

editOrNewType

editOrNewTypeLike

addToParameters

addToParameters

addToParameters

setToParameters

addToParameters

addAllToParameters

removeFromParameters

removeFromParameters

removeAllFromParameters

removeMatchingFromParameters

buildParameters

buildParameter

buildFirstParameter

buildLastParameter

buildMatchingParameter

hasMatchingParameter

withParameters

withParameters

hasParameters

addNewClassRefParameter

addNewClassRefParameterLike

setNewClassRefParameterLike

addNewPrimitiveRefParameter

addNewPrimitiveRefParameterLike

setNewPrimitiveRefParameterLike

addNewVoidRefParameter

addNewVoidRefParameterLike

setNewVoidRefParameterLike

addNewTypeParamRefParameter

addNewTypeParamRefParameterLike

setNewTypeParamRefParameterLike

addNewWildcardRefParameter

addNewWildcardRefParameterLike

setNewWildcardRefParameterLike

addToArguments

addToArguments

addToArguments

setToArguments

addToArguments

addAllToArguments

removeFromArguments

removeFromArguments

removeAllFromArguments

removeMatchingFromArguments

buildArguments

buildArgument

buildFirstArgument

buildLastArgument

buildMatchingArgument

hasMatchingArgument

withArguments

withArguments

hasArguments

addNewMultiplyArgument

addNewMultiplyArgumentLike

addNewMultiplyArgument

setNewMultiplyArgumentLike

addNewNewArrayArgument

addNewNewArrayArgumentLike