Package io.sundr.model

Class InstanceOfFluent<A extends InstanceOfFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.InstanceOfFluent<A>

Direct Known Subclasses:

AssignFluent.InstanceOfTargetNested, AssignFluent.InstanceOfValueNested, BinaryExpressionFluent.InstanceOfLeftNested, BinaryExpressionFluent.InstanceOfRightNested, CastFluent.InstanceOfExpressionNested, ConstructFluent.InstanceOfArgumentsNested, DoFluent.InstanceOfConditionNested, EnclosedFluent.InstanceOfExpresionNested, ForeachFluent.InstanceOfExpressionNested, ForFluent.InstanceOfCompareNested, ForFluent.InstanceOfInitNested, ForFluent.InstanceOfUpdateNested, IfFluent.InstanceOfConditionNested, IndexFluent.InstanceOfExpressionNested, IndexFluent.InstanceOfScopeNested, InstanceOfBuilder, InstanceOfFluent.InstanceOfExpressionNested, InverseFluent.InstanceOfExpresionNested, MethodCallFluent.InstanceOfArgumentsNested, MethodCallFluent.InstanceOfScopeNested, NegativeFluent.InstanceOfExpresionNested, NewArrayFluent.InstanceOfExpressionsNested, NotFluent.InstanceOfExpresionNested, PositiveFluent.InstanceOfExpresionNested, PostDecrementFluent.InstanceOfExpressionNested, PostIncrementFluent.InstanceOfExpressionNested, PreDecrementFluent.InstanceOfExpressionNested, PreIncrementFluent.InstanceOfExpressionNested, PropertyRefFluent.InstanceOfScopeNested, ReturnFluent.InstanceOfExpressionNested, SwitchFluent.InstanceOfExpressionNested, TernaryFluent.InstanceOfAlternativeNested, TernaryFluent.InstanceOfConditionNested, TernaryFluent.InstanceOfResultNested, WhileFluent.InstanceOfConditionNested

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	InstanceOfFluent.AssignExpressionNested<N>
class	InstanceOfFluent.BinaryExpressionNested<N>
class	InstanceOfFluent.BitwiseAndExpressionNested<N>
class	InstanceOfFluent.BitwiseOrExpressionNested<N>
class	InstanceOfFluent.CastExpressionNested<N>
class	InstanceOfFluent.ConstructExpressionNested<N>
class	InstanceOfFluent.DeclareExpressionNested<N>
class	InstanceOfFluent.DivideExpressionNested<N>
class	InstanceOfFluent.EnclosedExpressionNested<N>
class	InstanceOfFluent.EqualsExpressionNested<N>
class	InstanceOfFluent.GreaterThanExpressionNested<N>
class	InstanceOfFluent.GreaterThanOrEqualExpressionNested<N>
class	InstanceOfFluent.IndexExpressionNested<N>
class	InstanceOfFluent.InstanceOfExpressionNested<N>
class	InstanceOfFluent.InverseExpressionNested<N>
class	InstanceOfFluent.LambdaExpressionNested<N>
class	InstanceOfFluent.LeftShiftExpressionNested<N>
class	InstanceOfFluent.LessThanExpressionNested<N>
class	InstanceOfFluent.LessThanOrEqualExpressionNested<N>
class	InstanceOfFluent.LogicalAndExpressionNested<N>
class	InstanceOfFluent.LogicalOrExpressionNested<N>
class	InstanceOfFluent.MethodCallExpressionNested<N>
class	InstanceOfFluent.MinusExpressionNested<N>
class	InstanceOfFluent.ModuloExpressionNested<N>
class	InstanceOfFluent.MultiplyExpressionNested<N>
class	InstanceOfFluent.NegativeExpressionNested<N>
class	InstanceOfFluent.NewArrayExpressionNested<N>
class	InstanceOfFluent.NotEqualsExpressionNested<N>
class	InstanceOfFluent.NotExpressionNested<N>
class	InstanceOfFluent.PlusExpressionNested<N>
class	InstanceOfFluent.PositiveExpressionNested<N>
class	InstanceOfFluent.PostDecrementExpressionNested<N>
class	InstanceOfFluent.PostIncrementExpressionNested<N>
class	InstanceOfFluent.PreDecrementExpressionNested<N>
class	InstanceOfFluent.PreIncrementExpressionNested<N>
class	InstanceOfFluent.PropertyRefExpressionNested<N>
class	InstanceOfFluent.RightShiftExpressionNested<N>
class	InstanceOfFluent.RightUnsignedShiftExpressionNested<N>
class	InstanceOfFluent.TernaryExpressionNested<N>
class	InstanceOfFluent.ThisExpressionNested<N>
class	InstanceOfFluent.TypeNested<N>
class	InstanceOfFluent.ValueRefExpressionNested<N>
class	InstanceOfFluent.XorExpressionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
InstanceOfFluent()
InstanceOfFluent(io.sundr.model.InstanceOf instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Expression	buildExpression()
io.sundr.model.ClassRef	buildType()
protected void	copyInstance(io.sundr.model.InstanceOf instance)
InstanceOfFluent.TypeNested<A>	editOrNewType()
InstanceOfFluent.TypeNested<A>	editOrNewTypeLike(io.sundr.model.ClassRef item)
InstanceOfFluent.TypeNested<A>	editType()
boolean	equals(Object o)
boolean	hasExpression()
int	hashCode()
boolean	hasType()
String	toString()
A	withExpression(io.sundr.model.Expression expression)
InstanceOfFluent.AssignExpressionNested<A>	withNewAssignExpression()
InstanceOfFluent.AssignExpressionNested<A>	withNewAssignExpressionLike(io.sundr.model.Assign item)
InstanceOfFluent.BinaryExpressionNested<A>	withNewBinaryExpression()
InstanceOfFluent.BinaryExpressionNested<A>	withNewBinaryExpressionLike(io.sundr.model.BinaryExpression item)
InstanceOfFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpression()
A	withNewBitwiseAndExpression(Object left, Object right)
InstanceOfFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpressionLike(io.sundr.model.BitwiseAnd item)
InstanceOfFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpression()
A	withNewBitwiseOrExpression(Object left, Object right)
InstanceOfFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpressionLike(io.sundr.model.BitwiseOr item)
InstanceOfFluent.CastExpressionNested<A>	withNewCastExpression()
InstanceOfFluent.CastExpressionNested<A>	withNewCastExpressionLike(io.sundr.model.Cast item)
InstanceOfFluent.ConstructExpressionNested<A>	withNewConstructExpression()
InstanceOfFluent.ConstructExpressionNested<A>	withNewConstructExpressionLike(io.sundr.model.Construct item)
InstanceOfFluent.DeclareExpressionNested<A>	withNewDeclareExpression()
A	withNewDeclareExpression(Class type, String name)
A	withNewDeclareExpression(Class type, String name, Object value)
InstanceOfFluent.DeclareExpressionNested<A>	withNewDeclareExpressionLike(io.sundr.model.Declare item)
InstanceOfFluent.DivideExpressionNested<A>	withNewDivideExpression()
A	withNewDivideExpression(Object left, Object right)
InstanceOfFluent.DivideExpressionNested<A>	withNewDivideExpressionLike(io.sundr.model.Divide item)
InstanceOfFluent.EnclosedExpressionNested<A>	withNewEnclosedExpression()
InstanceOfFluent.EnclosedExpressionNested<A>	withNewEnclosedExpressionLike(io.sundr.model.Enclosed item)
InstanceOfFluent.EqualsExpressionNested<A>	withNewEqualsExpression()
A	withNewEqualsExpression(Object left, Object right)
InstanceOfFluent.EqualsExpressionNested<A>	withNewEqualsExpressionLike(io.sundr.model.Equals item)
InstanceOfFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpression()
A	withNewGreaterThanExpression(Object left, Object right)
InstanceOfFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpressionLike(io.sundr.model.GreaterThan item)
InstanceOfFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpression()
A	withNewGreaterThanOrEqualExpression(Object left, Object right)
InstanceOfFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpressionLike(io.sundr.model.GreaterThanOrEqual item)
InstanceOfFluent.IndexExpressionNested<A>	withNewIndexExpression()
InstanceOfFluent.IndexExpressionNested<A>	withNewIndexExpressionLike(io.sundr.model.Index item)
InstanceOfFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpression()
InstanceOfFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpressionLike(io.sundr.model.InstanceOf item)
InstanceOfFluent.InverseExpressionNested<A>	withNewInverseExpression()
InstanceOfFluent.InverseExpressionNested<A>	withNewInverseExpressionLike(io.sundr.model.Inverse item)
InstanceOfFluent.LambdaExpressionNested<A>	withNewLambdaExpression()
InstanceOfFluent.LambdaExpressionNested<A>	withNewLambdaExpressionLike(io.sundr.model.Lambda item)
InstanceOfFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpression()
A	withNewLeftShiftExpression(Object left, Object right)
InstanceOfFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpressionLike(io.sundr.model.LeftShift item)
InstanceOfFluent.LessThanExpressionNested<A>	withNewLessThanExpression()
A	withNewLessThanExpression(Object left, Object right)
InstanceOfFluent.LessThanExpressionNested<A>	withNewLessThanExpressionLike(io.sundr.model.LessThan item)
InstanceOfFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpression()
A	withNewLessThanOrEqualExpression(Object left, Object right)
InstanceOfFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpressionLike(io.sundr.model.LessThanOrEqual item)
InstanceOfFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpression()
A	withNewLogicalAndExpression(Object left, Object right)
InstanceOfFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpressionLike(io.sundr.model.LogicalAnd item)
InstanceOfFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpression()
A	withNewLogicalOrExpression(Object left, Object right)
InstanceOfFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpressionLike(io.sundr.model.LogicalOr item)
InstanceOfFluent.MethodCallExpressionNested<A>	withNewMethodCallExpression()
InstanceOfFluent.MethodCallExpressionNested<A>	withNewMethodCallExpressionLike(io.sundr.model.MethodCall item)
InstanceOfFluent.MinusExpressionNested<A>	withNewMinusExpression()
A	withNewMinusExpression(Object left, Object right)
InstanceOfFluent.MinusExpressionNested<A>	withNewMinusExpressionLike(io.sundr.model.Minus item)
InstanceOfFluent.ModuloExpressionNested<A>	withNewModuloExpression()
A	withNewModuloExpression(Object left, Object right)
InstanceOfFluent.ModuloExpressionNested<A>	withNewModuloExpressionLike(io.sundr.model.Modulo item)
InstanceOfFluent.MultiplyExpressionNested<A>	withNewMultiplyExpression()
A	withNewMultiplyExpression(Object left, Object right)
InstanceOfFluent.MultiplyExpressionNested<A>	withNewMultiplyExpressionLike(io.sundr.model.Multiply item)
InstanceOfFluent.NegativeExpressionNested<A>	withNewNegativeExpression()
InstanceOfFluent.NegativeExpressionNested<A>	withNewNegativeExpressionLike(io.sundr.model.Negative item)
InstanceOfFluent.NewArrayExpressionNested<A>	withNewNewArrayExpression()
A	withNewNewArrayExpression(Class type, Integer[] sizes)
InstanceOfFluent.NewArrayExpressionNested<A>	withNewNewArrayExpressionLike(io.sundr.model.NewArray item)
InstanceOfFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpression()
A	withNewNotEqualsExpression(Object left, Object right)
InstanceOfFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpressionLike(io.sundr.model.NotEquals item)
InstanceOfFluent.NotExpressionNested<A>	withNewNotExpression()
InstanceOfFluent.NotExpressionNested<A>	withNewNotExpressionLike(io.sundr.model.Not item)
InstanceOfFluent.PlusExpressionNested<A>	withNewPlusExpression()
A	withNewPlusExpression(Object left, Object right)
InstanceOfFluent.PlusExpressionNested<A>	withNewPlusExpressionLike(io.sundr.model.Plus item)
InstanceOfFluent.PositiveExpressionNested<A>	withNewPositiveExpression()
InstanceOfFluent.PositiveExpressionNested<A>	withNewPositiveExpressionLike(io.sundr.model.Positive item)
InstanceOfFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpression()
InstanceOfFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpressionLike(io.sundr.model.PostDecrement item)
InstanceOfFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpression()
InstanceOfFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpressionLike(io.sundr.model.PostIncrement item)
InstanceOfFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpression()
InstanceOfFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpressionLike(io.sundr.model.PreDecrement item)
InstanceOfFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpression()
InstanceOfFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpressionLike(io.sundr.model.PreIncrement item)
InstanceOfFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpression()
InstanceOfFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpressionLike(io.sundr.model.PropertyRef item)
InstanceOfFluent.RightShiftExpressionNested<A>	withNewRightShiftExpression()
A	withNewRightShiftExpression(Object left, Object right)
InstanceOfFluent.RightShiftExpressionNested<A>	withNewRightShiftExpressionLike(io.sundr.model.RightShift item)
InstanceOfFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpression()
A	withNewRightUnsignedShiftExpression(Object left, Object right)
InstanceOfFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpressionLike(io.sundr.model.RightUnsignedShift item)
InstanceOfFluent.TernaryExpressionNested<A>	withNewTernaryExpression()
InstanceOfFluent.TernaryExpressionNested<A>	withNewTernaryExpressionLike(io.sundr.model.Ternary item)
InstanceOfFluent.ThisExpressionNested<A>	withNewThisExpression()
InstanceOfFluent.ThisExpressionNested<A>	withNewThisExpressionLike(io.sundr.model.This item)
InstanceOfFluent.TypeNested<A>	withNewType()
InstanceOfFluent.TypeNested<A>	withNewTypeLike(io.sundr.model.ClassRef item)
InstanceOfFluent.ValueRefExpressionNested<A>	withNewValueRefExpression()
A	withNewValueRefExpression(Object value)
InstanceOfFluent.ValueRefExpressionNested<A>	withNewValueRefExpressionLike(io.sundr.model.ValueRef item)
InstanceOfFluent.XorExpressionNested<A>	withNewXorExpression()
A	withNewXorExpression(Object left, Object right)
InstanceOfFluent.XorExpressionNested<A>	withNewXorExpressionLike(io.sundr.model.Xor item)
A	withType(io.sundr.model.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

InstanceOfFluent

public InstanceOfFluent()

InstanceOfFluent

public InstanceOfFluent(io.sundr.model.InstanceOf instance)

Method Detail

copyInstance

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

buildExpression

public io.sundr.model.Expression buildExpression()

withExpression

public A withExpression(io.sundr.model.Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public InstanceOfFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

public InstanceOfFluent.MultiplyExpressionNested<A> withNewMultiplyExpressionLike(io.sundr.model.Multiply item)

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public InstanceOfFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

public InstanceOfFluent.NewArrayExpressionNested<A> withNewNewArrayExpressionLike(io.sundr.model.NewArray item)

withNewNewArrayExpression

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

withNewInstanceOfExpression

public InstanceOfFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

public InstanceOfFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpressionLike(io.sundr.model.InstanceOf item)

withNewMethodCallExpression

public InstanceOfFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

public InstanceOfFluent.MethodCallExpressionNested<A> withNewMethodCallExpressionLike(io.sundr.model.MethodCall item)

withNewInverseExpression

public InstanceOfFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

public InstanceOfFluent.InverseExpressionNested<A> withNewInverseExpressionLike(io.sundr.model.Inverse item)

withNewIndexExpression

public InstanceOfFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

public InstanceOfFluent.IndexExpressionNested<A> withNewIndexExpressionLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualExpression

public InstanceOfFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

public InstanceOfFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpressionLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public InstanceOfFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

public InstanceOfFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpressionLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public InstanceOfFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

public InstanceOfFluent.MinusExpressionNested<A> withNewMinusExpressionLike(io.sundr.model.Minus item)

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public InstanceOfFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

public InstanceOfFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpressionLike(io.sundr.model.LogicalOr item)

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public InstanceOfFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

public InstanceOfFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpressionLike(io.sundr.model.NotEquals item)

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public InstanceOfFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

public InstanceOfFluent.DivideExpressionNested<A> withNewDivideExpressionLike(io.sundr.model.Divide item)

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public InstanceOfFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

public InstanceOfFluent.LessThanExpressionNested<A> withNewLessThanExpressionLike(io.sundr.model.LessThan item)

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public InstanceOfFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

public InstanceOfFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpressionLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public InstanceOfFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

public InstanceOfFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpressionLike(io.sundr.model.PropertyRef item)

withNewRightShiftExpression

public InstanceOfFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

public InstanceOfFluent.RightShiftExpressionNested<A> withNewRightShiftExpressionLike(io.sundr.model.RightShift item)

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public InstanceOfFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

public InstanceOfFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpressionLike(io.sundr.model.GreaterThan item)

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public InstanceOfFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

public InstanceOfFluent.DeclareExpressionNested<A> withNewDeclareExpressionLike(io.sundr.model.Declare item)

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
                                  String name)

withNewDeclareExpression

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

withNewCastExpression

public InstanceOfFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

public InstanceOfFluent.CastExpressionNested<A> withNewCastExpressionLike(io.sundr.model.Cast item)

withNewModuloExpression

public InstanceOfFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

public InstanceOfFluent.ModuloExpressionNested<A> withNewModuloExpressionLike(io.sundr.model.Modulo item)

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public InstanceOfFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

public InstanceOfFluent.ValueRefExpressionNested<A> withNewValueRefExpressionLike(io.sundr.model.ValueRef item)

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public InstanceOfFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

public InstanceOfFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpressionLike(io.sundr.model.LeftShift item)

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public InstanceOfFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

public InstanceOfFluent.TernaryExpressionNested<A> withNewTernaryExpressionLike(io.sundr.model.Ternary item)

withNewBinaryExpression

public InstanceOfFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

public InstanceOfFluent.BinaryExpressionNested<A> withNewBinaryExpressionLike(io.sundr.model.BinaryExpression item)

withNewEqualsExpression

public InstanceOfFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

public InstanceOfFluent.EqualsExpressionNested<A> withNewEqualsExpressionLike(io.sundr.model.Equals item)

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public InstanceOfFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

public InstanceOfFluent.EnclosedExpressionNested<A> withNewEnclosedExpressionLike(io.sundr.model.Enclosed item)

withNewPreDecrementExpression

public InstanceOfFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

public InstanceOfFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpressionLike(io.sundr.model.PreDecrement item)

withNewPostDecrementExpression

public InstanceOfFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

public InstanceOfFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpressionLike(io.sundr.model.PostDecrement item)

withNewLambdaExpression

public InstanceOfFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

public InstanceOfFluent.LambdaExpressionNested<A> withNewLambdaExpressionLike(io.sundr.model.Lambda item)

withNewNotExpression

public InstanceOfFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

public InstanceOfFluent.NotExpressionNested<A> withNewNotExpressionLike(io.sundr.model.Not item)

withNewAssignExpression

public InstanceOfFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

public InstanceOfFluent.AssignExpressionNested<A> withNewAssignExpressionLike(io.sundr.model.Assign item)

withNewNegativeExpression

public InstanceOfFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

public InstanceOfFluent.NegativeExpressionNested<A> withNewNegativeExpressionLike(io.sundr.model.Negative item)

withNewThisExpression

public InstanceOfFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

public InstanceOfFluent.ThisExpressionNested<A> withNewThisExpressionLike(io.sundr.model.This item)

withNewLogicalAndExpression

public InstanceOfFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

public InstanceOfFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpressionLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public InstanceOfFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

public InstanceOfFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpressionLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftExpression

public InstanceOfFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

public InstanceOfFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpressionLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public InstanceOfFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

public InstanceOfFluent.PlusExpressionNested<A> withNewPlusExpressionLike(io.sundr.model.Plus item)

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public InstanceOfFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

public InstanceOfFluent.ConstructExpressionNested<A> withNewConstructExpressionLike(io.sundr.model.Construct item)

withNewXorExpression

public InstanceOfFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

public InstanceOfFluent.XorExpressionNested<A> withNewXorExpressionLike(io.sundr.model.Xor item)

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public InstanceOfFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

public InstanceOfFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpressionLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualExpression

public InstanceOfFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

public InstanceOfFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpressionLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public InstanceOfFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

public InstanceOfFluent.PositiveExpressionNested<A> withNewPositiveExpressionLike(io.sundr.model.Positive item)

buildType

public io.sundr.model.ClassRef buildType()

withType

public A withType(io.sundr.model.ClassRef type)

hasType

public boolean hasType()

withNewType

public InstanceOfFluent.TypeNested<A> withNewType()

withNewTypeLike

public InstanceOfFluent.TypeNested<A> withNewTypeLike(io.sundr.model.ClassRef item)

editType

public InstanceOfFluent.TypeNested<A> editType()

editOrNewType

public InstanceOfFluent.TypeNested<A> editOrNewType()

editOrNewTypeLike

public InstanceOfFluent.TypeNested<A> editOrNewTypeLike(io.sundr.model.ClassRef item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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