Package io.sundr.model

Class PreIncrementFluent<A extends PreIncrementFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.PreIncrementFluent<A>

Direct Known Subclasses:

AssignFluent.PreIncrementTargetNested, AssignFluent.PreIncrementValueNested, BinaryExpressionFluent.PreIncrementLeftNested, BinaryExpressionFluent.PreIncrementRightNested, CastFluent.PreIncrementExpressionNested, ConstructFluent.PreIncrementArgumentsNested, DoFluent.PreIncrementConditionNested, EnclosedFluent.PreIncrementExpresionNested, ForeachFluent.PreIncrementExpressionNested, ForFluent.PreIncrementCompareNested, ForFluent.PreIncrementInitNested, ForFluent.PreIncrementUpdateNested, IfFluent.PreIncrementConditionNested, IndexFluent.PreIncrementExpressionNested, IndexFluent.PreIncrementScopeNested, InstanceOfFluent.PreIncrementExpressionNested, InverseFluent.PreIncrementExpresionNested, MethodCallFluent.PreIncrementArgumentsNested, MethodCallFluent.PreIncrementScopeNested, NegativeFluent.PreIncrementExpresionNested, NewArrayFluent.PreIncrementExpressionsNested, NotFluent.PreIncrementExpresionNested, PositiveFluent.PreIncrementExpresionNested, PostDecrementFluent.PreIncrementExpressionNested, PostIncrementFluent.PreIncrementExpressionNested, PreDecrementFluent.PreIncrementExpressionNested, PreIncrementBuilder, PreIncrementFluent.PreIncrementExpressionNested, PropertyRefFluent.PreIncrementScopeNested, ReturnFluent.PreIncrementExpressionNested, SwitchFluent.PreIncrementExpressionNested, TernaryFluent.PreIncrementAlternativeNested, TernaryFluent.PreIncrementConditionNested, TernaryFluent.PreIncrementResultNested, WhileFluent.PreIncrementConditionNested

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

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
PreIncrementFluent()
PreIncrementFluent(io.sundr.model.PreIncrement instance)

Method Summary

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

PreIncrementFluent

public PreIncrementFluent()

PreIncrementFluent

public PreIncrementFluent(io.sundr.model.PreIncrement instance)

Method Detail

copyInstance

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

buildExpression

public io.sundr.model.Expression buildExpression()

withExpression

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

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public PreIncrementFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public PreIncrementFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public PreIncrementFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public PreIncrementFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public PreIncrementFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public PreIncrementFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public PreIncrementFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public PreIncrementFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public PreIncrementFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public PreIncrementFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public PreIncrementFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public PreIncrementFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public PreIncrementFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public PreIncrementFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public PreIncrementFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public PreIncrementFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public PreIncrementFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public PreIncrementFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

public PreIncrementFluent.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 PreIncrementFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewModuloExpression

public PreIncrementFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public PreIncrementFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public PreIncrementFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public PreIncrementFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public PreIncrementFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public PreIncrementFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public PreIncrementFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public PreIncrementFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public PreIncrementFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public PreIncrementFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public PreIncrementFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public PreIncrementFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public PreIncrementFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public PreIncrementFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public PreIncrementFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public PreIncrementFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public PreIncrementFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public PreIncrementFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public PreIncrementFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public PreIncrementFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public PreIncrementFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public PreIncrementFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public PreIncrementFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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