Package io.sundr.model

Class EnclosedFluent<A extends EnclosedFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.EnclosedFluent<A>

Direct Known Subclasses:

AssignFluent.EnclosedTargetNested, AssignFluent.EnclosedValueNested, BinaryExpressionFluent.EnclosedLeftNested, BinaryExpressionFluent.EnclosedRightNested, CastFluent.EnclosedExpressionNested, ConstructFluent.EnclosedArgumentsNested, DoFluent.EnclosedConditionNested, EnclosedBuilder, EnclosedFluent.EnclosedExpresionNested, ForeachFluent.EnclosedExpressionNested, ForFluent.EnclosedCompareNested, ForFluent.EnclosedInitNested, ForFluent.EnclosedUpdateNested, IfFluent.EnclosedConditionNested, IndexFluent.EnclosedExpressionNested, IndexFluent.EnclosedScopeNested, InstanceOfFluent.EnclosedExpressionNested, InverseFluent.EnclosedExpresionNested, MethodCallFluent.EnclosedArgumentsNested, MethodCallFluent.EnclosedScopeNested, NegativeFluent.EnclosedExpresionNested, NewArrayFluent.EnclosedExpressionsNested, NotFluent.EnclosedExpresionNested, PositiveFluent.EnclosedExpresionNested, PostDecrementFluent.EnclosedExpressionNested, PostIncrementFluent.EnclosedExpressionNested, PreDecrementFluent.EnclosedExpressionNested, PreIncrementFluent.EnclosedExpressionNested, PropertyRefFluent.EnclosedScopeNested, ReturnFluent.EnclosedExpressionNested, SwitchFluent.EnclosedExpressionNested, TernaryFluent.EnclosedAlternativeNested, TernaryFluent.EnclosedConditionNested, TernaryFluent.EnclosedResultNested, WhileFluent.EnclosedConditionNested

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	EnclosedFluent.AssignExpresionNested<N>
class	EnclosedFluent.BinaryExpressionExpresionNested<N>
class	EnclosedFluent.BitwiseAndExpresionNested<N>
class	EnclosedFluent.BitwiseOrExpresionNested<N>
class	EnclosedFluent.CastExpresionNested<N>
class	EnclosedFluent.ConstructExpresionNested<N>
class	EnclosedFluent.DeclareExpresionNested<N>
class	EnclosedFluent.DivideExpresionNested<N>
class	EnclosedFluent.EnclosedExpresionNested<N>
class	EnclosedFluent.EqualsExpresionNested<N>
class	EnclosedFluent.GreaterThanExpresionNested<N>
class	EnclosedFluent.GreaterThanOrEqualExpresionNested<N>
class	EnclosedFluent.IndexExpresionNested<N>
class	EnclosedFluent.InstanceOfExpresionNested<N>
class	EnclosedFluent.InverseExpresionNested<N>
class	EnclosedFluent.LambdaExpresionNested<N>
class	EnclosedFluent.LeftShiftExpresionNested<N>
class	EnclosedFluent.LessThanExpresionNested<N>
class	EnclosedFluent.LessThanOrEqualExpresionNested<N>
class	EnclosedFluent.LogicalAndExpresionNested<N>
class	EnclosedFluent.LogicalOrExpresionNested<N>
class	EnclosedFluent.MethodCallExpresionNested<N>
class	EnclosedFluent.MinusExpresionNested<N>
class	EnclosedFluent.ModuloExpresionNested<N>
class	EnclosedFluent.MultiplyExpresionNested<N>
class	EnclosedFluent.NegativeExpresionNested<N>
class	EnclosedFluent.NewArrayExpresionNested<N>
class	EnclosedFluent.NotEqualsExpresionNested<N>
class	EnclosedFluent.NotExpresionNested<N>
class	EnclosedFluent.PlusExpresionNested<N>
class	EnclosedFluent.PositiveExpresionNested<N>
class	EnclosedFluent.PostDecrementExpresionNested<N>
class	EnclosedFluent.PostIncrementExpresionNested<N>
class	EnclosedFluent.PreDecrementExpresionNested<N>
class	EnclosedFluent.PreIncrementExpresionNested<N>
class	EnclosedFluent.PropertyRefExpresionNested<N>
class	EnclosedFluent.RightShiftExpresionNested<N>
class	EnclosedFluent.RightUnsignedShiftExpresionNested<N>
class	EnclosedFluent.TernaryExpresionNested<N>
class	EnclosedFluent.ThisExpresionNested<N>
class	EnclosedFluent.ValueRefExpresionNested<N>
class	EnclosedFluent.XorExpresionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
EnclosedFluent()
EnclosedFluent(io.sundr.model.Enclosed instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Expression	buildExpresion()
protected void	copyInstance(io.sundr.model.Enclosed instance)
boolean	equals(Object o)
boolean	hasExpresion()
int	hashCode()
String	toString()
A	withExpresion(io.sundr.model.Expression expresion)
EnclosedFluent.AssignExpresionNested<A>	withNewAssignExpresion()
EnclosedFluent.AssignExpresionNested<A>	withNewAssignExpresionLike(io.sundr.model.Assign item)
EnclosedFluent.BinaryExpressionExpresionNested<A>	withNewBinaryExpressionExpresion()
EnclosedFluent.BinaryExpressionExpresionNested<A>	withNewBinaryExpressionExpresionLike(io.sundr.model.BinaryExpression item)
EnclosedFluent.BitwiseAndExpresionNested<A>	withNewBitwiseAndExpresion()
A	withNewBitwiseAndExpresion(Object left, Object right)
EnclosedFluent.BitwiseAndExpresionNested<A>	withNewBitwiseAndExpresionLike(io.sundr.model.BitwiseAnd item)
EnclosedFluent.BitwiseOrExpresionNested<A>	withNewBitwiseOrExpresion()
A	withNewBitwiseOrExpresion(Object left, Object right)
EnclosedFluent.BitwiseOrExpresionNested<A>	withNewBitwiseOrExpresionLike(io.sundr.model.BitwiseOr item)
EnclosedFluent.CastExpresionNested<A>	withNewCastExpresion()
EnclosedFluent.CastExpresionNested<A>	withNewCastExpresionLike(io.sundr.model.Cast item)
EnclosedFluent.ConstructExpresionNested<A>	withNewConstructExpresion()
EnclosedFluent.ConstructExpresionNested<A>	withNewConstructExpresionLike(io.sundr.model.Construct item)
EnclosedFluent.DeclareExpresionNested<A>	withNewDeclareExpresion()
A	withNewDeclareExpresion(Class type, String name)
A	withNewDeclareExpresion(Class type, String name, Object value)
EnclosedFluent.DeclareExpresionNested<A>	withNewDeclareExpresionLike(io.sundr.model.Declare item)
EnclosedFluent.DivideExpresionNested<A>	withNewDivideExpresion()
A	withNewDivideExpresion(Object left, Object right)
EnclosedFluent.DivideExpresionNested<A>	withNewDivideExpresionLike(io.sundr.model.Divide item)
EnclosedFluent.EnclosedExpresionNested<A>	withNewEnclosedExpresion()
EnclosedFluent.EnclosedExpresionNested<A>	withNewEnclosedExpresionLike(io.sundr.model.Enclosed item)
EnclosedFluent.EqualsExpresionNested<A>	withNewEqualsExpresion()
A	withNewEqualsExpresion(Object left, Object right)
EnclosedFluent.EqualsExpresionNested<A>	withNewEqualsExpresionLike(io.sundr.model.Equals item)
EnclosedFluent.GreaterThanExpresionNested<A>	withNewGreaterThanExpresion()
A	withNewGreaterThanExpresion(Object left, Object right)
EnclosedFluent.GreaterThanExpresionNested<A>	withNewGreaterThanExpresionLike(io.sundr.model.GreaterThan item)
EnclosedFluent.GreaterThanOrEqualExpresionNested<A>	withNewGreaterThanOrEqualExpresion()
A	withNewGreaterThanOrEqualExpresion(Object left, Object right)
EnclosedFluent.GreaterThanOrEqualExpresionNested<A>	withNewGreaterThanOrEqualExpresionLike(io.sundr.model.GreaterThanOrEqual item)
EnclosedFluent.IndexExpresionNested<A>	withNewIndexExpresion()
EnclosedFluent.IndexExpresionNested<A>	withNewIndexExpresionLike(io.sundr.model.Index item)
EnclosedFluent.InstanceOfExpresionNested<A>	withNewInstanceOfExpresion()
EnclosedFluent.InstanceOfExpresionNested<A>	withNewInstanceOfExpresionLike(io.sundr.model.InstanceOf item)
EnclosedFluent.InverseExpresionNested<A>	withNewInverseExpresion()
EnclosedFluent.InverseExpresionNested<A>	withNewInverseExpresionLike(io.sundr.model.Inverse item)
EnclosedFluent.LambdaExpresionNested<A>	withNewLambdaExpresion()
EnclosedFluent.LambdaExpresionNested<A>	withNewLambdaExpresionLike(io.sundr.model.Lambda item)
EnclosedFluent.LeftShiftExpresionNested<A>	withNewLeftShiftExpresion()
A	withNewLeftShiftExpresion(Object left, Object right)
EnclosedFluent.LeftShiftExpresionNested<A>	withNewLeftShiftExpresionLike(io.sundr.model.LeftShift item)
EnclosedFluent.LessThanExpresionNested<A>	withNewLessThanExpresion()
A	withNewLessThanExpresion(Object left, Object right)
EnclosedFluent.LessThanExpresionNested<A>	withNewLessThanExpresionLike(io.sundr.model.LessThan item)
EnclosedFluent.LessThanOrEqualExpresionNested<A>	withNewLessThanOrEqualExpresion()
A	withNewLessThanOrEqualExpresion(Object left, Object right)
EnclosedFluent.LessThanOrEqualExpresionNested<A>	withNewLessThanOrEqualExpresionLike(io.sundr.model.LessThanOrEqual item)
EnclosedFluent.LogicalAndExpresionNested<A>	withNewLogicalAndExpresion()
A	withNewLogicalAndExpresion(Object left, Object right)
EnclosedFluent.LogicalAndExpresionNested<A>	withNewLogicalAndExpresionLike(io.sundr.model.LogicalAnd item)
EnclosedFluent.LogicalOrExpresionNested<A>	withNewLogicalOrExpresion()
A	withNewLogicalOrExpresion(Object left, Object right)
EnclosedFluent.LogicalOrExpresionNested<A>	withNewLogicalOrExpresionLike(io.sundr.model.LogicalOr item)
EnclosedFluent.MethodCallExpresionNested<A>	withNewMethodCallExpresion()
EnclosedFluent.MethodCallExpresionNested<A>	withNewMethodCallExpresionLike(io.sundr.model.MethodCall item)
EnclosedFluent.MinusExpresionNested<A>	withNewMinusExpresion()
A	withNewMinusExpresion(Object left, Object right)
EnclosedFluent.MinusExpresionNested<A>	withNewMinusExpresionLike(io.sundr.model.Minus item)
EnclosedFluent.ModuloExpresionNested<A>	withNewModuloExpresion()
A	withNewModuloExpresion(Object left, Object right)
EnclosedFluent.ModuloExpresionNested<A>	withNewModuloExpresionLike(io.sundr.model.Modulo item)
EnclosedFluent.MultiplyExpresionNested<A>	withNewMultiplyExpresion()
A	withNewMultiplyExpresion(Object left, Object right)
EnclosedFluent.MultiplyExpresionNested<A>	withNewMultiplyExpresionLike(io.sundr.model.Multiply item)
EnclosedFluent.NegativeExpresionNested<A>	withNewNegativeExpresion()
EnclosedFluent.NegativeExpresionNested<A>	withNewNegativeExpresionLike(io.sundr.model.Negative item)
EnclosedFluent.NewArrayExpresionNested<A>	withNewNewArrayExpresion()
A	withNewNewArrayExpresion(Class type, Integer[] sizes)
EnclosedFluent.NewArrayExpresionNested<A>	withNewNewArrayExpresionLike(io.sundr.model.NewArray item)
EnclosedFluent.NotEqualsExpresionNested<A>	withNewNotEqualsExpresion()
A	withNewNotEqualsExpresion(Object left, Object right)
EnclosedFluent.NotEqualsExpresionNested<A>	withNewNotEqualsExpresionLike(io.sundr.model.NotEquals item)
EnclosedFluent.NotExpresionNested<A>	withNewNotExpresion()
EnclosedFluent.NotExpresionNested<A>	withNewNotExpresionLike(io.sundr.model.Not item)
EnclosedFluent.PlusExpresionNested<A>	withNewPlusExpresion()
A	withNewPlusExpresion(Object left, Object right)
EnclosedFluent.PlusExpresionNested<A>	withNewPlusExpresionLike(io.sundr.model.Plus item)
EnclosedFluent.PositiveExpresionNested<A>	withNewPositiveExpresion()
EnclosedFluent.PositiveExpresionNested<A>	withNewPositiveExpresionLike(io.sundr.model.Positive item)
EnclosedFluent.PostDecrementExpresionNested<A>	withNewPostDecrementExpresion()
EnclosedFluent.PostDecrementExpresionNested<A>	withNewPostDecrementExpresionLike(io.sundr.model.PostDecrement item)
EnclosedFluent.PostIncrementExpresionNested<A>	withNewPostIncrementExpresion()
EnclosedFluent.PostIncrementExpresionNested<A>	withNewPostIncrementExpresionLike(io.sundr.model.PostIncrement item)
EnclosedFluent.PreDecrementExpresionNested<A>	withNewPreDecrementExpresion()
EnclosedFluent.PreDecrementExpresionNested<A>	withNewPreDecrementExpresionLike(io.sundr.model.PreDecrement item)
EnclosedFluent.PreIncrementExpresionNested<A>	withNewPreIncrementExpresion()
EnclosedFluent.PreIncrementExpresionNested<A>	withNewPreIncrementExpresionLike(io.sundr.model.PreIncrement item)
EnclosedFluent.PropertyRefExpresionNested<A>	withNewPropertyRefExpresion()
EnclosedFluent.PropertyRefExpresionNested<A>	withNewPropertyRefExpresionLike(io.sundr.model.PropertyRef item)
EnclosedFluent.RightShiftExpresionNested<A>	withNewRightShiftExpresion()
A	withNewRightShiftExpresion(Object left, Object right)
EnclosedFluent.RightShiftExpresionNested<A>	withNewRightShiftExpresionLike(io.sundr.model.RightShift item)
EnclosedFluent.RightUnsignedShiftExpresionNested<A>	withNewRightUnsignedShiftExpresion()
A	withNewRightUnsignedShiftExpresion(Object left, Object right)
EnclosedFluent.RightUnsignedShiftExpresionNested<A>	withNewRightUnsignedShiftExpresionLike(io.sundr.model.RightUnsignedShift item)
EnclosedFluent.TernaryExpresionNested<A>	withNewTernaryExpresion()
EnclosedFluent.TernaryExpresionNested<A>	withNewTernaryExpresionLike(io.sundr.model.Ternary item)
EnclosedFluent.ThisExpresionNested<A>	withNewThisExpresion()
EnclosedFluent.ThisExpresionNested<A>	withNewThisExpresionLike(io.sundr.model.This item)
EnclosedFluent.ValueRefExpresionNested<A>	withNewValueRefExpresion()
A	withNewValueRefExpresion(Object value)
EnclosedFluent.ValueRefExpresionNested<A>	withNewValueRefExpresionLike(io.sundr.model.ValueRef item)
EnclosedFluent.XorExpresionNested<A>	withNewXorExpresion()
A	withNewXorExpresion(Object left, Object right)
EnclosedFluent.XorExpresionNested<A>	withNewXorExpresionLike(io.sundr.model.Xor item)

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

EnclosedFluent

public EnclosedFluent()

EnclosedFluent

public EnclosedFluent(io.sundr.model.Enclosed instance)

Method Detail

copyInstance

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

buildExpresion

public io.sundr.model.Expression buildExpresion()

withExpresion

public A withExpresion(io.sundr.model.Expression expresion)

hasExpresion

public boolean hasExpresion()

withNewMultiplyExpresion

public EnclosedFluent.MultiplyExpresionNested<A> withNewMultiplyExpresion()

withNewMultiplyExpresionLike

public EnclosedFluent.MultiplyExpresionNested<A> withNewMultiplyExpresionLike(io.sundr.model.Multiply item)

withNewMultiplyExpresion

public A withNewMultiplyExpresion(Object left,
                                  Object right)

withNewNewArrayExpresion

public EnclosedFluent.NewArrayExpresionNested<A> withNewNewArrayExpresion()

withNewNewArrayExpresionLike

public EnclosedFluent.NewArrayExpresionNested<A> withNewNewArrayExpresionLike(io.sundr.model.NewArray item)

withNewNewArrayExpresion

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

withNewInstanceOfExpresion

public EnclosedFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresion()

withNewInstanceOfExpresionLike

public EnclosedFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresionLike(io.sundr.model.InstanceOf item)

withNewMethodCallExpresion

public EnclosedFluent.MethodCallExpresionNested<A> withNewMethodCallExpresion()

withNewMethodCallExpresionLike

public EnclosedFluent.MethodCallExpresionNested<A> withNewMethodCallExpresionLike(io.sundr.model.MethodCall item)

withNewInverseExpresion

public EnclosedFluent.InverseExpresionNested<A> withNewInverseExpresion()

withNewInverseExpresionLike

public EnclosedFluent.InverseExpresionNested<A> withNewInverseExpresionLike(io.sundr.model.Inverse item)

withNewIndexExpresion

public EnclosedFluent.IndexExpresionNested<A> withNewIndexExpresion()

withNewIndexExpresionLike

public EnclosedFluent.IndexExpresionNested<A> withNewIndexExpresionLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualExpresion

public EnclosedFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresion()

withNewGreaterThanOrEqualExpresionLike

public EnclosedFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresionLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualExpresion

public A withNewGreaterThanOrEqualExpresion(Object left,
                                            Object right)

withNewBitwiseAndExpresion

public EnclosedFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresion()

withNewBitwiseAndExpresionLike

public EnclosedFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresionLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndExpresion

public A withNewBitwiseAndExpresion(Object left,
                                    Object right)

withNewMinusExpresion

public EnclosedFluent.MinusExpresionNested<A> withNewMinusExpresion()

withNewMinusExpresionLike

public EnclosedFluent.MinusExpresionNested<A> withNewMinusExpresionLike(io.sundr.model.Minus item)

withNewMinusExpresion

public A withNewMinusExpresion(Object left,
                               Object right)

withNewLogicalOrExpresion

public EnclosedFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresion()

withNewLogicalOrExpresionLike

public EnclosedFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresionLike(io.sundr.model.LogicalOr item)

withNewLogicalOrExpresion

public A withNewLogicalOrExpresion(Object left,
                                   Object right)

withNewNotEqualsExpresion

public EnclosedFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresion()

withNewNotEqualsExpresionLike

public EnclosedFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresionLike(io.sundr.model.NotEquals item)

withNewNotEqualsExpresion

public A withNewNotEqualsExpresion(Object left,
                                   Object right)

withNewDivideExpresion

public EnclosedFluent.DivideExpresionNested<A> withNewDivideExpresion()

withNewDivideExpresionLike

public EnclosedFluent.DivideExpresionNested<A> withNewDivideExpresionLike(io.sundr.model.Divide item)

withNewDivideExpresion

public A withNewDivideExpresion(Object left,
                                Object right)

withNewLessThanExpresion

public EnclosedFluent.LessThanExpresionNested<A> withNewLessThanExpresion()

withNewLessThanExpresionLike

public EnclosedFluent.LessThanExpresionNested<A> withNewLessThanExpresionLike(io.sundr.model.LessThan item)

withNewLessThanExpresion

public A withNewLessThanExpresion(Object left,
                                  Object right)

withNewBitwiseOrExpresion

public EnclosedFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresion()

withNewBitwiseOrExpresionLike

public EnclosedFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresionLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrExpresion

public A withNewBitwiseOrExpresion(Object left,
                                   Object right)

withNewPropertyRefExpresion

public EnclosedFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresion()

withNewPropertyRefExpresionLike

public EnclosedFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresionLike(io.sundr.model.PropertyRef item)

withNewRightShiftExpresion

public EnclosedFluent.RightShiftExpresionNested<A> withNewRightShiftExpresion()

withNewRightShiftExpresionLike

public EnclosedFluent.RightShiftExpresionNested<A> withNewRightShiftExpresionLike(io.sundr.model.RightShift item)

withNewRightShiftExpresion

public A withNewRightShiftExpresion(Object left,
                                    Object right)

withNewGreaterThanExpresion

public EnclosedFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresion()

withNewGreaterThanExpresionLike

public EnclosedFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresionLike(io.sundr.model.GreaterThan item)

withNewGreaterThanExpresion

public A withNewGreaterThanExpresion(Object left,
                                     Object right)

withNewDeclareExpresion

public EnclosedFluent.DeclareExpresionNested<A> withNewDeclareExpresion()

withNewDeclareExpresionLike

public EnclosedFluent.DeclareExpresionNested<A> withNewDeclareExpresionLike(io.sundr.model.Declare item)

withNewDeclareExpresion

public A withNewDeclareExpresion(Class type,
                                 String name)

withNewDeclareExpresion

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

withNewCastExpresion

public EnclosedFluent.CastExpresionNested<A> withNewCastExpresion()

withNewCastExpresionLike

public EnclosedFluent.CastExpresionNested<A> withNewCastExpresionLike(io.sundr.model.Cast item)

withNewModuloExpresion

public EnclosedFluent.ModuloExpresionNested<A> withNewModuloExpresion()

withNewModuloExpresionLike

public EnclosedFluent.ModuloExpresionNested<A> withNewModuloExpresionLike(io.sundr.model.Modulo item)

withNewModuloExpresion

public A withNewModuloExpresion(Object left,
                                Object right)

withNewValueRefExpresion

public EnclosedFluent.ValueRefExpresionNested<A> withNewValueRefExpresion()

withNewValueRefExpresionLike

public EnclosedFluent.ValueRefExpresionNested<A> withNewValueRefExpresionLike(io.sundr.model.ValueRef item)

withNewValueRefExpresion

public A withNewValueRefExpresion(Object value)

withNewLeftShiftExpresion

public EnclosedFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresion()

withNewLeftShiftExpresionLike

public EnclosedFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresionLike(io.sundr.model.LeftShift item)

withNewLeftShiftExpresion

public A withNewLeftShiftExpresion(Object left,
                                   Object right)

withNewTernaryExpresion

public EnclosedFluent.TernaryExpresionNested<A> withNewTernaryExpresion()

withNewTernaryExpresionLike

public EnclosedFluent.TernaryExpresionNested<A> withNewTernaryExpresionLike(io.sundr.model.Ternary item)

withNewBinaryExpressionExpresion

public EnclosedFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresion()

withNewBinaryExpressionExpresionLike

public EnclosedFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresionLike(io.sundr.model.BinaryExpression item)

withNewEqualsExpresion

public EnclosedFluent.EqualsExpresionNested<A> withNewEqualsExpresion()

withNewEqualsExpresionLike

public EnclosedFluent.EqualsExpresionNested<A> withNewEqualsExpresionLike(io.sundr.model.Equals item)

withNewEqualsExpresion

public A withNewEqualsExpresion(Object left,
                                Object right)

withNewEnclosedExpresion

public EnclosedFluent.EnclosedExpresionNested<A> withNewEnclosedExpresion()

withNewEnclosedExpresionLike

public EnclosedFluent.EnclosedExpresionNested<A> withNewEnclosedExpresionLike(io.sundr.model.Enclosed item)

withNewPreDecrementExpresion

public EnclosedFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresion()

withNewPreDecrementExpresionLike

public EnclosedFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresionLike(io.sundr.model.PreDecrement item)

withNewPostDecrementExpresion

public EnclosedFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresion()

withNewPostDecrementExpresionLike

public EnclosedFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresionLike(io.sundr.model.PostDecrement item)

withNewLambdaExpresion

public EnclosedFluent.LambdaExpresionNested<A> withNewLambdaExpresion()

withNewLambdaExpresionLike

public EnclosedFluent.LambdaExpresionNested<A> withNewLambdaExpresionLike(io.sundr.model.Lambda item)

withNewNotExpresion

public EnclosedFluent.NotExpresionNested<A> withNewNotExpresion()

withNewNotExpresionLike

public EnclosedFluent.NotExpresionNested<A> withNewNotExpresionLike(io.sundr.model.Not item)

withNewAssignExpresion

public EnclosedFluent.AssignExpresionNested<A> withNewAssignExpresion()

withNewAssignExpresionLike

public EnclosedFluent.AssignExpresionNested<A> withNewAssignExpresionLike(io.sundr.model.Assign item)

withNewNegativeExpresion

public EnclosedFluent.NegativeExpresionNested<A> withNewNegativeExpresion()

withNewNegativeExpresionLike

public EnclosedFluent.NegativeExpresionNested<A> withNewNegativeExpresionLike(io.sundr.model.Negative item)

withNewThisExpresion

public EnclosedFluent.ThisExpresionNested<A> withNewThisExpresion()

withNewThisExpresionLike

public EnclosedFluent.ThisExpresionNested<A> withNewThisExpresionLike(io.sundr.model.This item)

withNewLogicalAndExpresion

public EnclosedFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresion()

withNewLogicalAndExpresionLike

public EnclosedFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresionLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndExpresion

public A withNewLogicalAndExpresion(Object left,
                                    Object right)

withNewPostIncrementExpresion

public EnclosedFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresion()

withNewPostIncrementExpresionLike

public EnclosedFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresionLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftExpresion

public EnclosedFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresion()

withNewRightUnsignedShiftExpresionLike

public EnclosedFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresionLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftExpresion

public A withNewRightUnsignedShiftExpresion(Object left,
                                            Object right)

withNewPlusExpresion

public EnclosedFluent.PlusExpresionNested<A> withNewPlusExpresion()

withNewPlusExpresionLike

public EnclosedFluent.PlusExpresionNested<A> withNewPlusExpresionLike(io.sundr.model.Plus item)

withNewPlusExpresion

public A withNewPlusExpresion(Object left,
                              Object right)

withNewConstructExpresion

public EnclosedFluent.ConstructExpresionNested<A> withNewConstructExpresion()

withNewConstructExpresionLike

public EnclosedFluent.ConstructExpresionNested<A> withNewConstructExpresionLike(io.sundr.model.Construct item)

withNewXorExpresion

public EnclosedFluent.XorExpresionNested<A> withNewXorExpresion()

withNewXorExpresionLike

public EnclosedFluent.XorExpresionNested<A> withNewXorExpresionLike(io.sundr.model.Xor item)

withNewXorExpresion

public A withNewXorExpresion(Object left,
                             Object right)

withNewPreIncrementExpresion

public EnclosedFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresion()

withNewPreIncrementExpresionLike

public EnclosedFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresionLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualExpresion

public EnclosedFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresion()

withNewLessThanOrEqualExpresionLike

public EnclosedFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresionLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualExpresion

public A withNewLessThanOrEqualExpresion(Object left,
                                         Object right)

withNewPositiveExpresion

public EnclosedFluent.PositiveExpresionNested<A> withNewPositiveExpresion()

withNewPositiveExpresionLike

public EnclosedFluent.PositiveExpresionNested<A> withNewPositiveExpresionLike(io.sundr.model.Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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