Package io.sundr.model

Class PostIncrementFluent<A extends PostIncrementFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.PostIncrementFluent<A>

Direct Known Subclasses:

AssignFluent.PostIncrementTargetNested, AssignFluent.PostIncrementValueNested, BinaryExpressionFluent.PostIncrementLeftNested, BinaryExpressionFluent.PostIncrementRightNested, CastFluent.PostIncrementExpressionNested, ConstructFluent.PostIncrementArgumentsNested, DoFluent.PostIncrementConditionNested, EnclosedFluent.PostIncrementExpresionNested, ForeachFluent.PostIncrementExpressionNested, ForFluent.PostIncrementCompareNested, ForFluent.PostIncrementInitNested, ForFluent.PostIncrementUpdateNested, IfFluent.PostIncrementConditionNested, IndexFluent.PostIncrementExpressionNested, IndexFluent.PostIncrementScopeNested, InstanceOfFluent.PostIncrementExpressionNested, InverseFluent.PostIncrementExpresionNested, MethodCallFluent.PostIncrementArgumentsNested, MethodCallFluent.PostIncrementScopeNested, NegativeFluent.PostIncrementExpresionNested, NewArrayFluent.PostIncrementExpressionsNested, NotFluent.PostIncrementExpresionNested, PositiveFluent.PostIncrementExpresionNested, PostDecrementFluent.PostIncrementExpressionNested, PostIncrementBuilder, PostIncrementFluent.PostIncrementExpressionNested, PreDecrementFluent.PostIncrementExpressionNested, PreIncrementFluent.PostIncrementExpressionNested, PropertyRefFluent.PostIncrementScopeNested, ReturnFluent.PostIncrementExpressionNested, SwitchFluent.PostIncrementExpressionNested, TernaryFluent.PostIncrementAlternativeNested, TernaryFluent.PostIncrementConditionNested, TernaryFluent.PostIncrementResultNested, WhileFluent.PostIncrementConditionNested

public class PostIncrementFluent<A extends PostIncrementFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
PostIncrementFluent()
PostIncrementFluent(PostIncrement instance)

Method Summary

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

PostIncrementFluent

public PostIncrementFluent()

PostIncrementFluent

public PostIncrementFluent(PostIncrement instance)

Method Detail

copyInstance

protected void copyInstance(PostIncrement instance)

buildExpression

public Expression buildExpression()

withExpression

public A withExpression(Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public PostIncrementFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

public PostIncrementFluent.MultiplyExpressionNested<A> withNewMultiplyExpressionLike(Multiply item)

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public PostIncrementFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

public PostIncrementFluent.NewArrayExpressionNested<A> withNewNewArrayExpressionLike(NewArray item)

withNewNewArrayExpression

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

withNewInstanceOfExpression

public PostIncrementFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

public PostIncrementFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpressionLike(InstanceOf item)

withNewMethodCallExpression

public PostIncrementFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

public PostIncrementFluent.MethodCallExpressionNested<A> withNewMethodCallExpressionLike(MethodCall item)

withNewInverseExpression

public PostIncrementFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

public PostIncrementFluent.InverseExpressionNested<A> withNewInverseExpressionLike(Inverse item)

withNewIndexExpression

public PostIncrementFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

public PostIncrementFluent.IndexExpressionNested<A> withNewIndexExpressionLike(Index item)

withNewGreaterThanOrEqualExpression

public PostIncrementFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

public PostIncrementFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public PostIncrementFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

public PostIncrementFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpressionLike(BitwiseAnd item)

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public PostIncrementFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

public PostIncrementFluent.MinusExpressionNested<A> withNewMinusExpressionLike(Minus item)

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public PostIncrementFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

public PostIncrementFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpressionLike(LogicalOr item)

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public PostIncrementFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

public PostIncrementFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpressionLike(NotEquals item)

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public PostIncrementFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

public PostIncrementFluent.DivideExpressionNested<A> withNewDivideExpressionLike(Divide item)

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public PostIncrementFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

public PostIncrementFluent.LessThanExpressionNested<A> withNewLessThanExpressionLike(LessThan item)

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public PostIncrementFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

public PostIncrementFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpressionLike(BitwiseOr item)

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public PostIncrementFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

public PostIncrementFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpressionLike(PropertyRef item)

withNewRightShiftExpression

public PostIncrementFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

public PostIncrementFluent.RightShiftExpressionNested<A> withNewRightShiftExpressionLike(RightShift item)

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public PostIncrementFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

public PostIncrementFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpressionLike(GreaterThan item)

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public PostIncrementFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

public PostIncrementFluent.DeclareExpressionNested<A> withNewDeclareExpressionLike(Declare item)

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
                                  String name)

withNewDeclareExpression

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

withNewCastExpression

public PostIncrementFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

public PostIncrementFluent.CastExpressionNested<A> withNewCastExpressionLike(Cast item)

withNewModuloExpression

public PostIncrementFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

public PostIncrementFluent.ModuloExpressionNested<A> withNewModuloExpressionLike(Modulo item)

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public PostIncrementFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

public PostIncrementFluent.ValueRefExpressionNested<A> withNewValueRefExpressionLike(ValueRef item)

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public PostIncrementFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

public PostIncrementFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpressionLike(LeftShift item)

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public PostIncrementFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

public PostIncrementFluent.TernaryExpressionNested<A> withNewTernaryExpressionLike(Ternary item)

withNewBinaryExpression

public PostIncrementFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

public PostIncrementFluent.BinaryExpressionNested<A> withNewBinaryExpressionLike(BinaryExpression item)

withNewEqualsExpression

public PostIncrementFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

public PostIncrementFluent.EqualsExpressionNested<A> withNewEqualsExpressionLike(Equals item)

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public PostIncrementFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

public PostIncrementFluent.EnclosedExpressionNested<A> withNewEnclosedExpressionLike(Enclosed item)

withNewPreDecrementExpression

public PostIncrementFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

public PostIncrementFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpressionLike(PreDecrement item)

withNewPostDecrementExpression

public PostIncrementFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

public PostIncrementFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpressionLike(PostDecrement item)

withNewLambdaExpression

public PostIncrementFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

public PostIncrementFluent.LambdaExpressionNested<A> withNewLambdaExpressionLike(Lambda item)

withNewNotExpression

public PostIncrementFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

public PostIncrementFluent.NotExpressionNested<A> withNewNotExpressionLike(Not item)

withNewAssignExpression

public PostIncrementFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

public PostIncrementFluent.AssignExpressionNested<A> withNewAssignExpressionLike(Assign item)

withNewNegativeExpression

public PostIncrementFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

public PostIncrementFluent.NegativeExpressionNested<A> withNewNegativeExpressionLike(Negative item)

withNewThisExpression

public PostIncrementFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

public PostIncrementFluent.ThisExpressionNested<A> withNewThisExpressionLike(This item)

withNewLogicalAndExpression

public PostIncrementFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

public PostIncrementFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpressionLike(LogicalAnd item)

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public PostIncrementFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

public PostIncrementFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpressionLike(PostIncrement item)

withNewRightUnsignedShiftExpression

public PostIncrementFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

public PostIncrementFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public PostIncrementFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

public PostIncrementFluent.PlusExpressionNested<A> withNewPlusExpressionLike(Plus item)

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public PostIncrementFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

public PostIncrementFluent.ConstructExpressionNested<A> withNewConstructExpressionLike(Construct item)

withNewXorExpression

public PostIncrementFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

public PostIncrementFluent.XorExpressionNested<A> withNewXorExpressionLike(Xor item)

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public PostIncrementFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

public PostIncrementFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpressionLike(PreIncrement item)

withNewLessThanOrEqualExpression

public PostIncrementFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

public PostIncrementFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public PostIncrementFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

public PostIncrementFluent.PositiveExpressionNested<A> withNewPositiveExpressionLike(Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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