Package io.sundr.model

Class AssignFluent<A extends AssignFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.AssignFluent<A>

Direct Known Subclasses:

AssignBuilder, AssignFluent.AssignTargetNested, AssignFluent.AssignValueNested, BinaryExpressionFluent.AssignLeftNested, BinaryExpressionFluent.AssignRightNested, BlockFluent.AssignStatementsNested, CastFluent.AssignExpressionNested, ConstructFluent.AssignArgumentsNested, DoFluent.AssignConditionNested, DoFluent.AssignStatementNested, EnclosedFluent.AssignExpresionNested, ForeachFluent.AssignBodyNested, ForeachFluent.AssignExpressionNested, ForFluent.AssignBodyNested, ForFluent.AssignCompareNested, ForFluent.AssignInitNested, ForFluent.AssignUpdateNested, IfFluent.AssignConditionNested, IfFluent.AssignStatementNested, IndexFluent.AssignExpressionNested, IndexFluent.AssignScopeNested, InstanceOfFluent.AssignExpressionNested, InverseFluent.AssignExpresionNested, LambdaFluent.AssignStatementNested, MethodCallFluent.AssignArgumentsNested, MethodCallFluent.AssignScopeNested, NegativeFluent.AssignExpresionNested, NewArrayFluent.AssignExpressionsNested, NotFluent.AssignExpresionNested, PositiveFluent.AssignExpresionNested, PostDecrementFluent.AssignExpressionNested, PostIncrementFluent.AssignExpressionNested, PreDecrementFluent.AssignExpressionNested, PreIncrementFluent.AssignExpressionNested, PropertyRefFluent.AssignScopeNested, ReturnFluent.AssignExpressionNested, SwitchFluent.AssignExpressionNested, TernaryFluent.AssignAlternativeNested, TernaryFluent.AssignConditionNested, TernaryFluent.AssignResultNested, WhileFluent.AssignConditionNested, WhileFluent.AssignStatementNested

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	AssignFluent.AssignTargetNested<N>
class	AssignFluent.AssignValueNested<N>
class	AssignFluent.BinaryExpressionTargetNested<N>
class	AssignFluent.BinaryExpressionValueNested<N>
class	AssignFluent.BitwiseAndTargetNested<N>
class	AssignFluent.BitwiseAndValueNested<N>
class	AssignFluent.BitwiseOrTargetNested<N>
class	AssignFluent.BitwiseOrValueNested<N>
class	AssignFluent.CastTargetNested<N>
class	AssignFluent.CastValueNested<N>
class	AssignFluent.ConstructTargetNested<N>
class	AssignFluent.ConstructValueNested<N>
class	AssignFluent.DeclareTargetNested<N>
class	AssignFluent.DeclareValueNested<N>
class	AssignFluent.DivideTargetNested<N>
class	AssignFluent.DivideValueNested<N>
class	AssignFluent.EnclosedTargetNested<N>
class	AssignFluent.EnclosedValueNested<N>
class	AssignFluent.EqualsTargetNested<N>
class	AssignFluent.EqualsValueNested<N>
class	AssignFluent.GreaterThanOrEqualTargetNested<N>
class	AssignFluent.GreaterThanOrEqualValueNested<N>
class	AssignFluent.GreaterThanTargetNested<N>
class	AssignFluent.GreaterThanValueNested<N>
class	AssignFluent.IndexTargetNested<N>
class	AssignFluent.IndexValueNested<N>
class	AssignFluent.InstanceOfTargetNested<N>
class	AssignFluent.InstanceOfValueNested<N>
class	AssignFluent.InverseTargetNested<N>
class	AssignFluent.InverseValueNested<N>
class	AssignFluent.LambdaTargetNested<N>
class	AssignFluent.LambdaValueNested<N>
class	AssignFluent.LeftShiftTargetNested<N>
class	AssignFluent.LeftShiftValueNested<N>
class	AssignFluent.LessThanOrEqualTargetNested<N>
class	AssignFluent.LessThanOrEqualValueNested<N>
class	AssignFluent.LessThanTargetNested<N>
class	AssignFluent.LessThanValueNested<N>
class	AssignFluent.LogicalAndTargetNested<N>
class	AssignFluent.LogicalAndValueNested<N>
class	AssignFluent.LogicalOrTargetNested<N>
class	AssignFluent.LogicalOrValueNested<N>
class	AssignFluent.MethodCallTargetNested<N>
class	AssignFluent.MethodCallValueNested<N>
class	AssignFluent.MinusTargetNested<N>
class	AssignFluent.MinusValueNested<N>
class	AssignFluent.ModuloTargetNested<N>
class	AssignFluent.ModuloValueNested<N>
class	AssignFluent.MultiplyTargetNested<N>
class	AssignFluent.MultiplyValueNested<N>
class	AssignFluent.NegativeTargetNested<N>
class	AssignFluent.NegativeValueNested<N>
class	AssignFluent.NewArrayTargetNested<N>
class	AssignFluent.NewArrayValueNested<N>
class	AssignFluent.NotEqualsTargetNested<N>
class	AssignFluent.NotEqualsValueNested<N>
class	AssignFluent.NotTargetNested<N>
class	AssignFluent.NotValueNested<N>
class	AssignFluent.PlusTargetNested<N>
class	AssignFluent.PlusValueNested<N>
class	AssignFluent.PositiveTargetNested<N>
class	AssignFluent.PositiveValueNested<N>
class	AssignFluent.PostDecrementTargetNested<N>
class	AssignFluent.PostDecrementValueNested<N>
class	AssignFluent.PostIncrementTargetNested<N>
class	AssignFluent.PostIncrementValueNested<N>
class	AssignFluent.PreDecrementTargetNested<N>
class	AssignFluent.PreDecrementValueNested<N>
class	AssignFluent.PreIncrementTargetNested<N>
class	AssignFluent.PreIncrementValueNested<N>
class	AssignFluent.PropertyRefTargetNested<N>
class	AssignFluent.PropertyRefValueNested<N>
class	AssignFluent.RightShiftTargetNested<N>
class	AssignFluent.RightShiftValueNested<N>
class	AssignFluent.RightUnsignedShiftTargetNested<N>
class	AssignFluent.RightUnsignedShiftValueNested<N>
class	AssignFluent.TernaryTargetNested<N>
class	AssignFluent.TernaryValueNested<N>
class	AssignFluent.ThisTargetNested<N>
class	AssignFluent.ThisValueNested<N>
class	AssignFluent.ValueRefTargetNested<N>
class	AssignFluent.ValueRefValueNested<N>
class	AssignFluent.XorTargetNested<N>
class	AssignFluent.XorValueNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
AssignFluent()
AssignFluent(io.sundr.model.Assign instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Expression	buildTarget()
io.sundr.model.Expression	buildValue()
protected void	copyInstance(io.sundr.model.Assign instance)
boolean	equals(Object o)
int	hashCode()
boolean	hasTarget()
boolean	hasValue()
String	toString()
AssignFluent.AssignTargetNested<A>	withNewAssignTarget()
AssignFluent.AssignTargetNested<A>	withNewAssignTargetLike(io.sundr.model.Assign item)
AssignFluent.AssignValueNested<A>	withNewAssignValue()
AssignFluent.AssignValueNested<A>	withNewAssignValueLike(io.sundr.model.Assign item)
AssignFluent.BinaryExpressionTargetNested<A>	withNewBinaryExpressionTarget()
AssignFluent.BinaryExpressionTargetNested<A>	withNewBinaryExpressionTargetLike(io.sundr.model.BinaryExpression item)
AssignFluent.BinaryExpressionValueNested<A>	withNewBinaryExpressionValue()
AssignFluent.BinaryExpressionValueNested<A>	withNewBinaryExpressionValueLike(io.sundr.model.BinaryExpression item)
AssignFluent.BitwiseAndTargetNested<A>	withNewBitwiseAndTarget()
A	withNewBitwiseAndTarget(Object left, Object right)
AssignFluent.BitwiseAndTargetNested<A>	withNewBitwiseAndTargetLike(io.sundr.model.BitwiseAnd item)
AssignFluent.BitwiseAndValueNested<A>	withNewBitwiseAndValue()
A	withNewBitwiseAndValue(Object left, Object right)
AssignFluent.BitwiseAndValueNested<A>	withNewBitwiseAndValueLike(io.sundr.model.BitwiseAnd item)
AssignFluent.BitwiseOrTargetNested<A>	withNewBitwiseOrTarget()
A	withNewBitwiseOrTarget(Object left, Object right)
AssignFluent.BitwiseOrTargetNested<A>	withNewBitwiseOrTargetLike(io.sundr.model.BitwiseOr item)
AssignFluent.BitwiseOrValueNested<A>	withNewBitwiseOrValue()
A	withNewBitwiseOrValue(Object left, Object right)
AssignFluent.BitwiseOrValueNested<A>	withNewBitwiseOrValueLike(io.sundr.model.BitwiseOr item)
AssignFluent.CastTargetNested<A>	withNewCastTarget()
AssignFluent.CastTargetNested<A>	withNewCastTargetLike(io.sundr.model.Cast item)
AssignFluent.CastValueNested<A>	withNewCastValue()
AssignFluent.CastValueNested<A>	withNewCastValueLike(io.sundr.model.Cast item)
AssignFluent.ConstructTargetNested<A>	withNewConstructTarget()
AssignFluent.ConstructTargetNested<A>	withNewConstructTargetLike(io.sundr.model.Construct item)
AssignFluent.ConstructValueNested<A>	withNewConstructValue()
AssignFluent.ConstructValueNested<A>	withNewConstructValueLike(io.sundr.model.Construct item)
AssignFluent.DeclareTargetNested<A>	withNewDeclareTarget()
A	withNewDeclareTarget(Class type, String name)
A	withNewDeclareTarget(Class type, String name, Object value)
AssignFluent.DeclareTargetNested<A>	withNewDeclareTargetLike(io.sundr.model.Declare item)
AssignFluent.DeclareValueNested<A>	withNewDeclareValue()
A	withNewDeclareValue(Class type, String name)
A	withNewDeclareValue(Class type, String name, Object value)
AssignFluent.DeclareValueNested<A>	withNewDeclareValueLike(io.sundr.model.Declare item)
AssignFluent.DivideTargetNested<A>	withNewDivideTarget()
A	withNewDivideTarget(Object left, Object right)
AssignFluent.DivideTargetNested<A>	withNewDivideTargetLike(io.sundr.model.Divide item)
AssignFluent.DivideValueNested<A>	withNewDivideValue()
A	withNewDivideValue(Object left, Object right)
AssignFluent.DivideValueNested<A>	withNewDivideValueLike(io.sundr.model.Divide item)
AssignFluent.EnclosedTargetNested<A>	withNewEnclosedTarget()
AssignFluent.EnclosedTargetNested<A>	withNewEnclosedTargetLike(io.sundr.model.Enclosed item)
AssignFluent.EnclosedValueNested<A>	withNewEnclosedValue()
AssignFluent.EnclosedValueNested<A>	withNewEnclosedValueLike(io.sundr.model.Enclosed item)
AssignFluent.EqualsTargetNested<A>	withNewEqualsTarget()
A	withNewEqualsTarget(Object left, Object right)
AssignFluent.EqualsTargetNested<A>	withNewEqualsTargetLike(io.sundr.model.Equals item)
AssignFluent.EqualsValueNested<A>	withNewEqualsValue()
A	withNewEqualsValue(Object left, Object right)
AssignFluent.EqualsValueNested<A>	withNewEqualsValueLike(io.sundr.model.Equals item)
AssignFluent.GreaterThanOrEqualTargetNested<A>	withNewGreaterThanOrEqualTarget()
A	withNewGreaterThanOrEqualTarget(Object left, Object right)
AssignFluent.GreaterThanOrEqualTargetNested<A>	withNewGreaterThanOrEqualTargetLike(io.sundr.model.GreaterThanOrEqual item)
AssignFluent.GreaterThanOrEqualValueNested<A>	withNewGreaterThanOrEqualValue()
A	withNewGreaterThanOrEqualValue(Object left, Object right)
AssignFluent.GreaterThanOrEqualValueNested<A>	withNewGreaterThanOrEqualValueLike(io.sundr.model.GreaterThanOrEqual item)
AssignFluent.GreaterThanTargetNested<A>	withNewGreaterThanTarget()
A	withNewGreaterThanTarget(Object left, Object right)
AssignFluent.GreaterThanTargetNested<A>	withNewGreaterThanTargetLike(io.sundr.model.GreaterThan item)
AssignFluent.GreaterThanValueNested<A>	withNewGreaterThanValue()
A	withNewGreaterThanValue(Object left, Object right)
AssignFluent.GreaterThanValueNested<A>	withNewGreaterThanValueLike(io.sundr.model.GreaterThan item)
AssignFluent.IndexTargetNested<A>	withNewIndexTarget()
AssignFluent.IndexTargetNested<A>	withNewIndexTargetLike(io.sundr.model.Index item)
AssignFluent.IndexValueNested<A>	withNewIndexValue()
AssignFluent.IndexValueNested<A>	withNewIndexValueLike(io.sundr.model.Index item)
AssignFluent.InstanceOfTargetNested<A>	withNewInstanceOfTarget()
AssignFluent.InstanceOfTargetNested<A>	withNewInstanceOfTargetLike(io.sundr.model.InstanceOf item)
AssignFluent.InstanceOfValueNested<A>	withNewInstanceOfValue()
AssignFluent.InstanceOfValueNested<A>	withNewInstanceOfValueLike(io.sundr.model.InstanceOf item)
AssignFluent.InverseTargetNested<A>	withNewInverseTarget()
AssignFluent.InverseTargetNested<A>	withNewInverseTargetLike(io.sundr.model.Inverse item)
AssignFluent.InverseValueNested<A>	withNewInverseValue()
AssignFluent.InverseValueNested<A>	withNewInverseValueLike(io.sundr.model.Inverse item)
AssignFluent.LambdaTargetNested<A>	withNewLambdaTarget()
AssignFluent.LambdaTargetNested<A>	withNewLambdaTargetLike(io.sundr.model.Lambda item)
AssignFluent.LambdaValueNested<A>	withNewLambdaValue()
AssignFluent.LambdaValueNested<A>	withNewLambdaValueLike(io.sundr.model.Lambda item)
AssignFluent.LeftShiftTargetNested<A>	withNewLeftShiftTarget()
A	withNewLeftShiftTarget(Object left, Object right)
AssignFluent.LeftShiftTargetNested<A>	withNewLeftShiftTargetLike(io.sundr.model.LeftShift item)
AssignFluent.LeftShiftValueNested<A>	withNewLeftShiftValue()
A	withNewLeftShiftValue(Object left, Object right)
AssignFluent.LeftShiftValueNested<A>	withNewLeftShiftValueLike(io.sundr.model.LeftShift item)
AssignFluent.LessThanOrEqualTargetNested<A>	withNewLessThanOrEqualTarget()
A	withNewLessThanOrEqualTarget(Object left, Object right)
AssignFluent.LessThanOrEqualTargetNested<A>	withNewLessThanOrEqualTargetLike(io.sundr.model.LessThanOrEqual item)
AssignFluent.LessThanOrEqualValueNested<A>	withNewLessThanOrEqualValue()
A	withNewLessThanOrEqualValue(Object left, Object right)
AssignFluent.LessThanOrEqualValueNested<A>	withNewLessThanOrEqualValueLike(io.sundr.model.LessThanOrEqual item)
AssignFluent.LessThanTargetNested<A>	withNewLessThanTarget()
A	withNewLessThanTarget(Object left, Object right)
AssignFluent.LessThanTargetNested<A>	withNewLessThanTargetLike(io.sundr.model.LessThan item)
AssignFluent.LessThanValueNested<A>	withNewLessThanValue()
A	withNewLessThanValue(Object left, Object right)
AssignFluent.LessThanValueNested<A>	withNewLessThanValueLike(io.sundr.model.LessThan item)
AssignFluent.LogicalAndTargetNested<A>	withNewLogicalAndTarget()
A	withNewLogicalAndTarget(Object left, Object right)
AssignFluent.LogicalAndTargetNested<A>	withNewLogicalAndTargetLike(io.sundr.model.LogicalAnd item)
AssignFluent.LogicalAndValueNested<A>	withNewLogicalAndValue()
A	withNewLogicalAndValue(Object left, Object right)
AssignFluent.LogicalAndValueNested<A>	withNewLogicalAndValueLike(io.sundr.model.LogicalAnd item)
AssignFluent.LogicalOrTargetNested<A>	withNewLogicalOrTarget()
A	withNewLogicalOrTarget(Object left, Object right)
AssignFluent.LogicalOrTargetNested<A>	withNewLogicalOrTargetLike(io.sundr.model.LogicalOr item)
AssignFluent.LogicalOrValueNested<A>	withNewLogicalOrValue()
A	withNewLogicalOrValue(Object left, Object right)
AssignFluent.LogicalOrValueNested<A>	withNewLogicalOrValueLike(io.sundr.model.LogicalOr item)
AssignFluent.MethodCallTargetNested<A>	withNewMethodCallTarget()
AssignFluent.MethodCallTargetNested<A>	withNewMethodCallTargetLike(io.sundr.model.MethodCall item)
AssignFluent.MethodCallValueNested<A>	withNewMethodCallValue()
AssignFluent.MethodCallValueNested<A>	withNewMethodCallValueLike(io.sundr.model.MethodCall item)
AssignFluent.MinusTargetNested<A>	withNewMinusTarget()
A	withNewMinusTarget(Object left, Object right)
AssignFluent.MinusTargetNested<A>	withNewMinusTargetLike(io.sundr.model.Minus item)
AssignFluent.MinusValueNested<A>	withNewMinusValue()
A	withNewMinusValue(Object left, Object right)
AssignFluent.MinusValueNested<A>	withNewMinusValueLike(io.sundr.model.Minus item)
AssignFluent.ModuloTargetNested<A>	withNewModuloTarget()
A	withNewModuloTarget(Object left, Object right)
AssignFluent.ModuloTargetNested<A>	withNewModuloTargetLike(io.sundr.model.Modulo item)
AssignFluent.ModuloValueNested<A>	withNewModuloValue()
A	withNewModuloValue(Object left, Object right)
AssignFluent.ModuloValueNested<A>	withNewModuloValueLike(io.sundr.model.Modulo item)
AssignFluent.MultiplyTargetNested<A>	withNewMultiplyTarget()
A	withNewMultiplyTarget(Object left, Object right)
AssignFluent.MultiplyTargetNested<A>	withNewMultiplyTargetLike(io.sundr.model.Multiply item)
AssignFluent.MultiplyValueNested<A>	withNewMultiplyValue()
A	withNewMultiplyValue(Object left, Object right)
AssignFluent.MultiplyValueNested<A>	withNewMultiplyValueLike(io.sundr.model.Multiply item)
AssignFluent.NegativeTargetNested<A>	withNewNegativeTarget()
AssignFluent.NegativeTargetNested<A>	withNewNegativeTargetLike(io.sundr.model.Negative item)
AssignFluent.NegativeValueNested<A>	withNewNegativeValue()
AssignFluent.NegativeValueNested<A>	withNewNegativeValueLike(io.sundr.model.Negative item)
AssignFluent.NewArrayTargetNested<A>	withNewNewArrayTarget()
A	withNewNewArrayTarget(Class type, Integer[] sizes)
AssignFluent.NewArrayTargetNested<A>	withNewNewArrayTargetLike(io.sundr.model.NewArray item)
AssignFluent.NewArrayValueNested<A>	withNewNewArrayValue()
A	withNewNewArrayValue(Class type, Integer[] sizes)
AssignFluent.NewArrayValueNested<A>	withNewNewArrayValueLike(io.sundr.model.NewArray item)
AssignFluent.NotEqualsTargetNested<A>	withNewNotEqualsTarget()
A	withNewNotEqualsTarget(Object left, Object right)
AssignFluent.NotEqualsTargetNested<A>	withNewNotEqualsTargetLike(io.sundr.model.NotEquals item)
AssignFluent.NotEqualsValueNested<A>	withNewNotEqualsValue()
A	withNewNotEqualsValue(Object left, Object right)
AssignFluent.NotEqualsValueNested<A>	withNewNotEqualsValueLike(io.sundr.model.NotEquals item)
AssignFluent.NotTargetNested<A>	withNewNotTarget()
AssignFluent.NotTargetNested<A>	withNewNotTargetLike(io.sundr.model.Not item)
AssignFluent.NotValueNested<A>	withNewNotValue()
AssignFluent.NotValueNested<A>	withNewNotValueLike(io.sundr.model.Not item)
AssignFluent.PlusTargetNested<A>	withNewPlusTarget()
A	withNewPlusTarget(Object left, Object right)
AssignFluent.PlusTargetNested<A>	withNewPlusTargetLike(io.sundr.model.Plus item)
AssignFluent.PlusValueNested<A>	withNewPlusValue()
A	withNewPlusValue(Object left, Object right)
AssignFluent.PlusValueNested<A>	withNewPlusValueLike(io.sundr.model.Plus item)
AssignFluent.PositiveTargetNested<A>	withNewPositiveTarget()
AssignFluent.PositiveTargetNested<A>	withNewPositiveTargetLike(io.sundr.model.Positive item)
AssignFluent.PositiveValueNested<A>	withNewPositiveValue()
AssignFluent.PositiveValueNested<A>	withNewPositiveValueLike(io.sundr.model.Positive item)
AssignFluent.PostDecrementTargetNested<A>	withNewPostDecrementTarget()
AssignFluent.PostDecrementTargetNested<A>	withNewPostDecrementTargetLike(io.sundr.model.PostDecrement item)
AssignFluent.PostDecrementValueNested<A>	withNewPostDecrementValue()
AssignFluent.PostDecrementValueNested<A>	withNewPostDecrementValueLike(io.sundr.model.PostDecrement item)
AssignFluent.PostIncrementTargetNested<A>	withNewPostIncrementTarget()
AssignFluent.PostIncrementTargetNested<A>	withNewPostIncrementTargetLike(io.sundr.model.PostIncrement item)
AssignFluent.PostIncrementValueNested<A>	withNewPostIncrementValue()
AssignFluent.PostIncrementValueNested<A>	withNewPostIncrementValueLike(io.sundr.model.PostIncrement item)
AssignFluent.PreDecrementTargetNested<A>	withNewPreDecrementTarget()
AssignFluent.PreDecrementTargetNested<A>	withNewPreDecrementTargetLike(io.sundr.model.PreDecrement item)
AssignFluent.PreDecrementValueNested<A>	withNewPreDecrementValue()
AssignFluent.PreDecrementValueNested<A>	withNewPreDecrementValueLike(io.sundr.model.PreDecrement item)
AssignFluent.PreIncrementTargetNested<A>	withNewPreIncrementTarget()
AssignFluent.PreIncrementTargetNested<A>	withNewPreIncrementTargetLike(io.sundr.model.PreIncrement item)
AssignFluent.PreIncrementValueNested<A>	withNewPreIncrementValue()
AssignFluent.PreIncrementValueNested<A>	withNewPreIncrementValueLike(io.sundr.model.PreIncrement item)
AssignFluent.PropertyRefTargetNested<A>	withNewPropertyRefTarget()
AssignFluent.PropertyRefTargetNested<A>	withNewPropertyRefTargetLike(io.sundr.model.PropertyRef item)
AssignFluent.PropertyRefValueNested<A>	withNewPropertyRefValue()
AssignFluent.PropertyRefValueNested<A>	withNewPropertyRefValueLike(io.sundr.model.PropertyRef item)
AssignFluent.RightShiftTargetNested<A>	withNewRightShiftTarget()
A	withNewRightShiftTarget(Object left, Object right)
AssignFluent.RightShiftTargetNested<A>	withNewRightShiftTargetLike(io.sundr.model.RightShift item)
AssignFluent.RightShiftValueNested<A>	withNewRightShiftValue()
A	withNewRightShiftValue(Object left, Object right)
AssignFluent.RightShiftValueNested<A>	withNewRightShiftValueLike(io.sundr.model.RightShift item)
AssignFluent.RightUnsignedShiftTargetNested<A>	withNewRightUnsignedShiftTarget()
A	withNewRightUnsignedShiftTarget(Object left, Object right)
AssignFluent.RightUnsignedShiftTargetNested<A>	withNewRightUnsignedShiftTargetLike(io.sundr.model.RightUnsignedShift item)
AssignFluent.RightUnsignedShiftValueNested<A>	withNewRightUnsignedShiftValue()
A	withNewRightUnsignedShiftValue(Object left, Object right)
AssignFluent.RightUnsignedShiftValueNested<A>	withNewRightUnsignedShiftValueLike(io.sundr.model.RightUnsignedShift item)
AssignFluent.TernaryTargetNested<A>	withNewTernaryTarget()
AssignFluent.TernaryTargetNested<A>	withNewTernaryTargetLike(io.sundr.model.Ternary item)
AssignFluent.TernaryValueNested<A>	withNewTernaryValue()
AssignFluent.TernaryValueNested<A>	withNewTernaryValueLike(io.sundr.model.Ternary item)
AssignFluent.ThisTargetNested<A>	withNewThisTarget()
AssignFluent.ThisTargetNested<A>	withNewThisTargetLike(io.sundr.model.This item)
AssignFluent.ThisValueNested<A>	withNewThisValue()
AssignFluent.ThisValueNested<A>	withNewThisValueLike(io.sundr.model.This item)
AssignFluent.ValueRefTargetNested<A>	withNewValueRefTarget()
A	withNewValueRefTarget(Object value)
AssignFluent.ValueRefTargetNested<A>	withNewValueRefTargetLike(io.sundr.model.ValueRef item)
AssignFluent.ValueRefValueNested<A>	withNewValueRefValue()
A	withNewValueRefValue(Object value)
AssignFluent.ValueRefValueNested<A>	withNewValueRefValueLike(io.sundr.model.ValueRef item)
AssignFluent.XorTargetNested<A>	withNewXorTarget()
A	withNewXorTarget(Object left, Object right)
AssignFluent.XorTargetNested<A>	withNewXorTargetLike(io.sundr.model.Xor item)
AssignFluent.XorValueNested<A>	withNewXorValue()
A	withNewXorValue(Object left, Object right)
AssignFluent.XorValueNested<A>	withNewXorValueLike(io.sundr.model.Xor item)
A	withTarget(io.sundr.model.Expression target)
A	withValue(io.sundr.model.Expression value)

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

AssignFluent

public AssignFluent()

AssignFluent

public AssignFluent(io.sundr.model.Assign instance)

Method Detail

copyInstance

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

buildTarget

public io.sundr.model.Expression buildTarget()

withTarget

public A withTarget(io.sundr.model.Expression target)

hasTarget

public boolean hasTarget()

withNewMultiplyTarget

public AssignFluent.MultiplyTargetNested<A> withNewMultiplyTarget()

withNewMultiplyTargetLike

public AssignFluent.MultiplyTargetNested<A> withNewMultiplyTargetLike(io.sundr.model.Multiply item)

withNewMultiplyTarget

public A withNewMultiplyTarget(Object left,
                               Object right)

withNewNewArrayTarget

public AssignFluent.NewArrayTargetNested<A> withNewNewArrayTarget()

withNewNewArrayTargetLike

public AssignFluent.NewArrayTargetNested<A> withNewNewArrayTargetLike(io.sundr.model.NewArray item)

withNewNewArrayTarget

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

withNewInstanceOfTarget

public AssignFluent.InstanceOfTargetNested<A> withNewInstanceOfTarget()

withNewInstanceOfTargetLike

public AssignFluent.InstanceOfTargetNested<A> withNewInstanceOfTargetLike(io.sundr.model.InstanceOf item)

withNewMethodCallTarget

public AssignFluent.MethodCallTargetNested<A> withNewMethodCallTarget()

withNewMethodCallTargetLike

public AssignFluent.MethodCallTargetNested<A> withNewMethodCallTargetLike(io.sundr.model.MethodCall item)

withNewInverseTarget

public AssignFluent.InverseTargetNested<A> withNewInverseTarget()

withNewInverseTargetLike

public AssignFluent.InverseTargetNested<A> withNewInverseTargetLike(io.sundr.model.Inverse item)

withNewIndexTarget

public AssignFluent.IndexTargetNested<A> withNewIndexTarget()

withNewIndexTargetLike

public AssignFluent.IndexTargetNested<A> withNewIndexTargetLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualTarget

public AssignFluent.GreaterThanOrEqualTargetNested<A> withNewGreaterThanOrEqualTarget()

withNewGreaterThanOrEqualTargetLike

public AssignFluent.GreaterThanOrEqualTargetNested<A> withNewGreaterThanOrEqualTargetLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualTarget

public A withNewGreaterThanOrEqualTarget(Object left,
                                         Object right)

withNewBitwiseAndTarget

public AssignFluent.BitwiseAndTargetNested<A> withNewBitwiseAndTarget()

withNewBitwiseAndTargetLike

public AssignFluent.BitwiseAndTargetNested<A> withNewBitwiseAndTargetLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndTarget

public A withNewBitwiseAndTarget(Object left,
                                 Object right)

withNewMinusTarget

public AssignFluent.MinusTargetNested<A> withNewMinusTarget()

withNewMinusTargetLike

public AssignFluent.MinusTargetNested<A> withNewMinusTargetLike(io.sundr.model.Minus item)

withNewMinusTarget

public A withNewMinusTarget(Object left,
                            Object right)

withNewLogicalOrTarget

public AssignFluent.LogicalOrTargetNested<A> withNewLogicalOrTarget()

withNewLogicalOrTargetLike

public AssignFluent.LogicalOrTargetNested<A> withNewLogicalOrTargetLike(io.sundr.model.LogicalOr item)

withNewLogicalOrTarget

public A withNewLogicalOrTarget(Object left,
                                Object right)

withNewNotEqualsTarget

public AssignFluent.NotEqualsTargetNested<A> withNewNotEqualsTarget()

withNewNotEqualsTargetLike

public AssignFluent.NotEqualsTargetNested<A> withNewNotEqualsTargetLike(io.sundr.model.NotEquals item)

withNewNotEqualsTarget

public A withNewNotEqualsTarget(Object left,
                                Object right)

withNewDivideTarget

public AssignFluent.DivideTargetNested<A> withNewDivideTarget()

withNewDivideTargetLike

public AssignFluent.DivideTargetNested<A> withNewDivideTargetLike(io.sundr.model.Divide item)

withNewDivideTarget

public A withNewDivideTarget(Object left,
                             Object right)

withNewLessThanTarget

public AssignFluent.LessThanTargetNested<A> withNewLessThanTarget()

withNewLessThanTargetLike

public AssignFluent.LessThanTargetNested<A> withNewLessThanTargetLike(io.sundr.model.LessThan item)

withNewLessThanTarget

public A withNewLessThanTarget(Object left,
                               Object right)

withNewBitwiseOrTarget

public AssignFluent.BitwiseOrTargetNested<A> withNewBitwiseOrTarget()

withNewBitwiseOrTargetLike

public AssignFluent.BitwiseOrTargetNested<A> withNewBitwiseOrTargetLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrTarget

public A withNewBitwiseOrTarget(Object left,
                                Object right)

withNewPropertyRefTarget

public AssignFluent.PropertyRefTargetNested<A> withNewPropertyRefTarget()

withNewPropertyRefTargetLike

public AssignFluent.PropertyRefTargetNested<A> withNewPropertyRefTargetLike(io.sundr.model.PropertyRef item)

withNewRightShiftTarget

public AssignFluent.RightShiftTargetNested<A> withNewRightShiftTarget()

withNewRightShiftTargetLike

public AssignFluent.RightShiftTargetNested<A> withNewRightShiftTargetLike(io.sundr.model.RightShift item)

withNewRightShiftTarget

public A withNewRightShiftTarget(Object left,
                                 Object right)

withNewGreaterThanTarget

public AssignFluent.GreaterThanTargetNested<A> withNewGreaterThanTarget()

withNewGreaterThanTargetLike

public AssignFluent.GreaterThanTargetNested<A> withNewGreaterThanTargetLike(io.sundr.model.GreaterThan item)

withNewGreaterThanTarget

public A withNewGreaterThanTarget(Object left,
                                  Object right)

withNewDeclareTarget

public AssignFluent.DeclareTargetNested<A> withNewDeclareTarget()

withNewDeclareTargetLike

public AssignFluent.DeclareTargetNested<A> withNewDeclareTargetLike(io.sundr.model.Declare item)

withNewDeclareTarget

public A withNewDeclareTarget(Class type,
                              String name)

withNewDeclareTarget

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

withNewCastTarget

public AssignFluent.CastTargetNested<A> withNewCastTarget()

withNewCastTargetLike

public AssignFluent.CastTargetNested<A> withNewCastTargetLike(io.sundr.model.Cast item)

withNewModuloTarget

public AssignFluent.ModuloTargetNested<A> withNewModuloTarget()

withNewModuloTargetLike

public AssignFluent.ModuloTargetNested<A> withNewModuloTargetLike(io.sundr.model.Modulo item)

withNewModuloTarget

public A withNewModuloTarget(Object left,
                             Object right)

withNewValueRefTarget

public AssignFluent.ValueRefTargetNested<A> withNewValueRefTarget()

withNewValueRefTargetLike

public AssignFluent.ValueRefTargetNested<A> withNewValueRefTargetLike(io.sundr.model.ValueRef item)

withNewValueRefTarget

public A withNewValueRefTarget(Object value)

withNewLeftShiftTarget

public AssignFluent.LeftShiftTargetNested<A> withNewLeftShiftTarget()

withNewLeftShiftTargetLike

public AssignFluent.LeftShiftTargetNested<A> withNewLeftShiftTargetLike(io.sundr.model.LeftShift item)

withNewLeftShiftTarget

public A withNewLeftShiftTarget(Object left,
                                Object right)

withNewTernaryTarget

public AssignFluent.TernaryTargetNested<A> withNewTernaryTarget()

withNewTernaryTargetLike

public AssignFluent.TernaryTargetNested<A> withNewTernaryTargetLike(io.sundr.model.Ternary item)

withNewBinaryExpressionTarget

public AssignFluent.BinaryExpressionTargetNested<A> withNewBinaryExpressionTarget()

withNewBinaryExpressionTargetLike

public AssignFluent.BinaryExpressionTargetNested<A> withNewBinaryExpressionTargetLike(io.sundr.model.BinaryExpression item)

withNewEqualsTarget

public AssignFluent.EqualsTargetNested<A> withNewEqualsTarget()

withNewEqualsTargetLike

public AssignFluent.EqualsTargetNested<A> withNewEqualsTargetLike(io.sundr.model.Equals item)

withNewEqualsTarget

public A withNewEqualsTarget(Object left,
                             Object right)

withNewEnclosedTarget

public AssignFluent.EnclosedTargetNested<A> withNewEnclosedTarget()

withNewEnclosedTargetLike

public AssignFluent.EnclosedTargetNested<A> withNewEnclosedTargetLike(io.sundr.model.Enclosed item)

withNewPreDecrementTarget

public AssignFluent.PreDecrementTargetNested<A> withNewPreDecrementTarget()

withNewPreDecrementTargetLike

public AssignFluent.PreDecrementTargetNested<A> withNewPreDecrementTargetLike(io.sundr.model.PreDecrement item)

withNewPostDecrementTarget

public AssignFluent.PostDecrementTargetNested<A> withNewPostDecrementTarget()

withNewPostDecrementTargetLike

public AssignFluent.PostDecrementTargetNested<A> withNewPostDecrementTargetLike(io.sundr.model.PostDecrement item)

withNewLambdaTarget

public AssignFluent.LambdaTargetNested<A> withNewLambdaTarget()

withNewLambdaTargetLike

public AssignFluent.LambdaTargetNested<A> withNewLambdaTargetLike(io.sundr.model.Lambda item)

withNewNotTarget

public AssignFluent.NotTargetNested<A> withNewNotTarget()

withNewNotTargetLike

public AssignFluent.NotTargetNested<A> withNewNotTargetLike(io.sundr.model.Not item)

withNewAssignTarget

public AssignFluent.AssignTargetNested<A> withNewAssignTarget()

withNewAssignTargetLike

public AssignFluent.AssignTargetNested<A> withNewAssignTargetLike(io.sundr.model.Assign item)

withNewNegativeTarget

public AssignFluent.NegativeTargetNested<A> withNewNegativeTarget()

withNewNegativeTargetLike

public AssignFluent.NegativeTargetNested<A> withNewNegativeTargetLike(io.sundr.model.Negative item)

withNewThisTarget

public AssignFluent.ThisTargetNested<A> withNewThisTarget()

withNewThisTargetLike

public AssignFluent.ThisTargetNested<A> withNewThisTargetLike(io.sundr.model.This item)

withNewLogicalAndTarget

public AssignFluent.LogicalAndTargetNested<A> withNewLogicalAndTarget()

withNewLogicalAndTargetLike

public AssignFluent.LogicalAndTargetNested<A> withNewLogicalAndTargetLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndTarget

public A withNewLogicalAndTarget(Object left,
                                 Object right)

withNewPostIncrementTarget

public AssignFluent.PostIncrementTargetNested<A> withNewPostIncrementTarget()

withNewPostIncrementTargetLike

public AssignFluent.PostIncrementTargetNested<A> withNewPostIncrementTargetLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftTarget

public AssignFluent.RightUnsignedShiftTargetNested<A> withNewRightUnsignedShiftTarget()

withNewRightUnsignedShiftTargetLike

public AssignFluent.RightUnsignedShiftTargetNested<A> withNewRightUnsignedShiftTargetLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftTarget

public A withNewRightUnsignedShiftTarget(Object left,
                                         Object right)

withNewPlusTarget

public AssignFluent.PlusTargetNested<A> withNewPlusTarget()

withNewPlusTargetLike

public AssignFluent.PlusTargetNested<A> withNewPlusTargetLike(io.sundr.model.Plus item)

withNewPlusTarget

public A withNewPlusTarget(Object left,
                           Object right)

withNewConstructTarget

public AssignFluent.ConstructTargetNested<A> withNewConstructTarget()

withNewConstructTargetLike

public AssignFluent.ConstructTargetNested<A> withNewConstructTargetLike(io.sundr.model.Construct item)

withNewXorTarget

public AssignFluent.XorTargetNested<A> withNewXorTarget()

withNewXorTargetLike

public AssignFluent.XorTargetNested<A> withNewXorTargetLike(io.sundr.model.Xor item)

withNewXorTarget

public A withNewXorTarget(Object left,
                          Object right)

withNewPreIncrementTarget

public AssignFluent.PreIncrementTargetNested<A> withNewPreIncrementTarget()

withNewPreIncrementTargetLike

public AssignFluent.PreIncrementTargetNested<A> withNewPreIncrementTargetLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualTarget

public AssignFluent.LessThanOrEqualTargetNested<A> withNewLessThanOrEqualTarget()

withNewLessThanOrEqualTargetLike

public AssignFluent.LessThanOrEqualTargetNested<A> withNewLessThanOrEqualTargetLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualTarget

public A withNewLessThanOrEqualTarget(Object left,
                                      Object right)

withNewPositiveTarget

public AssignFluent.PositiveTargetNested<A> withNewPositiveTarget()

withNewPositiveTargetLike

public AssignFluent.PositiveTargetNested<A> withNewPositiveTargetLike(io.sundr.model.Positive item)

buildValue

public io.sundr.model.Expression buildValue()

withValue

public A withValue(io.sundr.model.Expression value)

hasValue

public boolean hasValue()

withNewMultiplyValue

public AssignFluent.MultiplyValueNested<A> withNewMultiplyValue()

withNewMultiplyValueLike

public AssignFluent.MultiplyValueNested<A> withNewMultiplyValueLike(io.sundr.model.Multiply item)

withNewMultiplyValue

public A withNewMultiplyValue(Object left,
                              Object right)

withNewNewArrayValue

public AssignFluent.NewArrayValueNested<A> withNewNewArrayValue()

withNewNewArrayValueLike

public AssignFluent.NewArrayValueNested<A> withNewNewArrayValueLike(io.sundr.model.NewArray item)

withNewNewArrayValue

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

withNewInstanceOfValue

public AssignFluent.InstanceOfValueNested<A> withNewInstanceOfValue()

withNewInstanceOfValueLike

public AssignFluent.InstanceOfValueNested<A> withNewInstanceOfValueLike(io.sundr.model.InstanceOf item)

withNewMethodCallValue

public AssignFluent.MethodCallValueNested<A> withNewMethodCallValue()

withNewMethodCallValueLike

public AssignFluent.MethodCallValueNested<A> withNewMethodCallValueLike(io.sundr.model.MethodCall item)

withNewInverseValue

public AssignFluent.InverseValueNested<A> withNewInverseValue()

withNewInverseValueLike

public AssignFluent.InverseValueNested<A> withNewInverseValueLike(io.sundr.model.Inverse item)

withNewIndexValue

public AssignFluent.IndexValueNested<A> withNewIndexValue()

withNewIndexValueLike

public AssignFluent.IndexValueNested<A> withNewIndexValueLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualValue

public AssignFluent.GreaterThanOrEqualValueNested<A> withNewGreaterThanOrEqualValue()

withNewGreaterThanOrEqualValueLike

public AssignFluent.GreaterThanOrEqualValueNested<A> withNewGreaterThanOrEqualValueLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualValue

public A withNewGreaterThanOrEqualValue(Object left,
                                        Object right)

withNewBitwiseAndValue

public AssignFluent.BitwiseAndValueNested<A> withNewBitwiseAndValue()

withNewBitwiseAndValueLike

public AssignFluent.BitwiseAndValueNested<A> withNewBitwiseAndValueLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndValue

public A withNewBitwiseAndValue(Object left,
                                Object right)

withNewMinusValue

public AssignFluent.MinusValueNested<A> withNewMinusValue()

withNewMinusValueLike

public AssignFluent.MinusValueNested<A> withNewMinusValueLike(io.sundr.model.Minus item)

withNewMinusValue

public A withNewMinusValue(Object left,
                           Object right)

withNewLogicalOrValue

public AssignFluent.LogicalOrValueNested<A> withNewLogicalOrValue()

withNewLogicalOrValueLike

public AssignFluent.LogicalOrValueNested<A> withNewLogicalOrValueLike(io.sundr.model.LogicalOr item)

withNewLogicalOrValue

public A withNewLogicalOrValue(Object left,
                               Object right)

withNewNotEqualsValue

public AssignFluent.NotEqualsValueNested<A> withNewNotEqualsValue()

withNewNotEqualsValueLike

public AssignFluent.NotEqualsValueNested<A> withNewNotEqualsValueLike(io.sundr.model.NotEquals item)

withNewNotEqualsValue

public A withNewNotEqualsValue(Object left,
                               Object right)

withNewDivideValue

public AssignFluent.DivideValueNested<A> withNewDivideValue()

withNewDivideValueLike

public AssignFluent.DivideValueNested<A> withNewDivideValueLike(io.sundr.model.Divide item)

withNewDivideValue

public A withNewDivideValue(Object left,
                            Object right)

withNewLessThanValue

public AssignFluent.LessThanValueNested<A> withNewLessThanValue()

withNewLessThanValueLike

public AssignFluent.LessThanValueNested<A> withNewLessThanValueLike(io.sundr.model.LessThan item)

withNewLessThanValue

public A withNewLessThanValue(Object left,
                              Object right)

withNewBitwiseOrValue

public AssignFluent.BitwiseOrValueNested<A> withNewBitwiseOrValue()

withNewBitwiseOrValueLike

public AssignFluent.BitwiseOrValueNested<A> withNewBitwiseOrValueLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrValue

public A withNewBitwiseOrValue(Object left,
                               Object right)

withNewPropertyRefValue

public AssignFluent.PropertyRefValueNested<A> withNewPropertyRefValue()

withNewPropertyRefValueLike

public AssignFluent.PropertyRefValueNested<A> withNewPropertyRefValueLike(io.sundr.model.PropertyRef item)

withNewRightShiftValue

public AssignFluent.RightShiftValueNested<A> withNewRightShiftValue()

withNewRightShiftValueLike

public AssignFluent.RightShiftValueNested<A> withNewRightShiftValueLike(io.sundr.model.RightShift item)

withNewRightShiftValue

public A withNewRightShiftValue(Object left,
                                Object right)

withNewGreaterThanValue

public AssignFluent.GreaterThanValueNested<A> withNewGreaterThanValue()

withNewGreaterThanValueLike

public AssignFluent.GreaterThanValueNested<A> withNewGreaterThanValueLike(io.sundr.model.GreaterThan item)

withNewGreaterThanValue

public A withNewGreaterThanValue(Object left,
                                 Object right)

withNewDeclareValue

public AssignFluent.DeclareValueNested<A> withNewDeclareValue()

withNewDeclareValueLike

public AssignFluent.DeclareValueNested<A> withNewDeclareValueLike(io.sundr.model.Declare item)

withNewDeclareValue

public A withNewDeclareValue(Class type,
                             String name)

withNewDeclareValue

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

withNewCastValue

public AssignFluent.CastValueNested<A> withNewCastValue()

withNewCastValueLike

public AssignFluent.CastValueNested<A> withNewCastValueLike(io.sundr.model.Cast item)

withNewModuloValue

public AssignFluent.ModuloValueNested<A> withNewModuloValue()

withNewModuloValueLike

public AssignFluent.ModuloValueNested<A> withNewModuloValueLike(io.sundr.model.Modulo item)

withNewModuloValue

public A withNewModuloValue(Object left,
                            Object right)

withNewValueRefValue

public AssignFluent.ValueRefValueNested<A> withNewValueRefValue()

withNewValueRefValueLike

public AssignFluent.ValueRefValueNested<A> withNewValueRefValueLike(io.sundr.model.ValueRef item)

withNewValueRefValue

public A withNewValueRefValue(Object value)

withNewLeftShiftValue

public AssignFluent.LeftShiftValueNested<A> withNewLeftShiftValue()

withNewLeftShiftValueLike

public AssignFluent.LeftShiftValueNested<A> withNewLeftShiftValueLike(io.sundr.model.LeftShift item)

withNewLeftShiftValue

public A withNewLeftShiftValue(Object left,
                               Object right)

withNewTernaryValue

public AssignFluent.TernaryValueNested<A> withNewTernaryValue()

withNewTernaryValueLike

public AssignFluent.TernaryValueNested<A> withNewTernaryValueLike(io.sundr.model.Ternary item)

withNewBinaryExpressionValue

public AssignFluent.BinaryExpressionValueNested<A> withNewBinaryExpressionValue()

withNewBinaryExpressionValueLike

public AssignFluent.BinaryExpressionValueNested<A> withNewBinaryExpressionValueLike(io.sundr.model.BinaryExpression item)

withNewEqualsValue

public AssignFluent.EqualsValueNested<A> withNewEqualsValue()

withNewEqualsValueLike

public AssignFluent.EqualsValueNested<A> withNewEqualsValueLike(io.sundr.model.Equals item)

withNewEqualsValue

public A withNewEqualsValue(Object left,
                            Object right)

withNewEnclosedValue

public AssignFluent.EnclosedValueNested<A> withNewEnclosedValue()

withNewEnclosedValueLike

public AssignFluent.EnclosedValueNested<A> withNewEnclosedValueLike(io.sundr.model.Enclosed item)

withNewPreDecrementValue

public AssignFluent.PreDecrementValueNested<A> withNewPreDecrementValue()

withNewPreDecrementValueLike

public AssignFluent.PreDecrementValueNested<A> withNewPreDecrementValueLike(io.sundr.model.PreDecrement item)

withNewPostDecrementValue

public AssignFluent.PostDecrementValueNested<A> withNewPostDecrementValue()

withNewPostDecrementValueLike

public AssignFluent.PostDecrementValueNested<A> withNewPostDecrementValueLike(io.sundr.model.PostDecrement item)

withNewLambdaValue

public AssignFluent.LambdaValueNested<A> withNewLambdaValue()

withNewLambdaValueLike

public AssignFluent.LambdaValueNested<A> withNewLambdaValueLike(io.sundr.model.Lambda item)

withNewNotValue

public AssignFluent.NotValueNested<A> withNewNotValue()

withNewNotValueLike

public AssignFluent.NotValueNested<A> withNewNotValueLike(io.sundr.model.Not item)

withNewAssignValue

public AssignFluent.AssignValueNested<A> withNewAssignValue()

withNewAssignValueLike

public AssignFluent.AssignValueNested<A> withNewAssignValueLike(io.sundr.model.Assign item)

withNewNegativeValue

public AssignFluent.NegativeValueNested<A> withNewNegativeValue()

withNewNegativeValueLike

public AssignFluent.NegativeValueNested<A> withNewNegativeValueLike(io.sundr.model.Negative item)

withNewThisValue

public AssignFluent.ThisValueNested<A> withNewThisValue()

withNewThisValueLike

public AssignFluent.ThisValueNested<A> withNewThisValueLike(io.sundr.model.This item)

withNewLogicalAndValue

public AssignFluent.LogicalAndValueNested<A> withNewLogicalAndValue()

withNewLogicalAndValueLike

public AssignFluent.LogicalAndValueNested<A> withNewLogicalAndValueLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndValue

public A withNewLogicalAndValue(Object left,
                                Object right)

withNewPostIncrementValue

public AssignFluent.PostIncrementValueNested<A> withNewPostIncrementValue()

withNewPostIncrementValueLike

public AssignFluent.PostIncrementValueNested<A> withNewPostIncrementValueLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftValue

public AssignFluent.RightUnsignedShiftValueNested<A> withNewRightUnsignedShiftValue()

withNewRightUnsignedShiftValueLike

public AssignFluent.RightUnsignedShiftValueNested<A> withNewRightUnsignedShiftValueLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftValue

public A withNewRightUnsignedShiftValue(Object left,
                                        Object right)

withNewPlusValue

public AssignFluent.PlusValueNested<A> withNewPlusValue()

withNewPlusValueLike

public AssignFluent.PlusValueNested<A> withNewPlusValueLike(io.sundr.model.Plus item)

withNewPlusValue

public A withNewPlusValue(Object left,
                          Object right)

withNewConstructValue

public AssignFluent.ConstructValueNested<A> withNewConstructValue()

withNewConstructValueLike

public AssignFluent.ConstructValueNested<A> withNewConstructValueLike(io.sundr.model.Construct item)

withNewXorValue

public AssignFluent.XorValueNested<A> withNewXorValue()

withNewXorValueLike

public AssignFluent.XorValueNested<A> withNewXorValueLike(io.sundr.model.Xor item)

withNewXorValue

public A withNewXorValue(Object left,
                         Object right)

withNewPreIncrementValue

public AssignFluent.PreIncrementValueNested<A> withNewPreIncrementValue()

withNewPreIncrementValueLike

public AssignFluent.PreIncrementValueNested<A> withNewPreIncrementValueLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualValue

public AssignFluent.LessThanOrEqualValueNested<A> withNewLessThanOrEqualValue()

withNewLessThanOrEqualValueLike

public AssignFluent.LessThanOrEqualValueNested<A> withNewLessThanOrEqualValueLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualValue

public A withNewLessThanOrEqualValue(Object left,
                                     Object right)

withNewPositiveValue

public AssignFluent.PositiveValueNested<A> withNewPositiveValue()

withNewPositiveValueLike

public AssignFluent.PositiveValueNested<A> withNewPositiveValueLike(io.sundr.model.Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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