Package io.sundr.model

Class InverseFluent<A extends InverseFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.InverseFluent<A>

Direct Known Subclasses:

AssignFluent.InverseTargetNested, AssignFluent.InverseValueNested, BinaryExpressionFluent.InverseLeftNested, BinaryExpressionFluent.InverseRightNested, CastFluent.InverseExpressionNested, ConstructFluent.InverseArgumentsNested, DoFluent.InverseConditionNested, EnclosedFluent.InverseExpresionNested, ForeachFluent.InverseExpressionNested, ForFluent.InverseCompareNested, ForFluent.InverseInitNested, ForFluent.InverseUpdateNested, IfFluent.InverseConditionNested, IndexFluent.InverseExpressionNested, IndexFluent.InverseScopeNested, InstanceOfFluent.InverseExpressionNested, InverseBuilder, InverseFluent.InverseExpresionNested, MethodCallFluent.InverseArgumentsNested, MethodCallFluent.InverseScopeNested, NegativeFluent.InverseExpresionNested, NewArrayFluent.InverseExpressionsNested, NotFluent.InverseExpresionNested, PositiveFluent.InverseExpresionNested, PostDecrementFluent.InverseExpressionNested, PostIncrementFluent.InverseExpressionNested, PreDecrementFluent.InverseExpressionNested, PreIncrementFluent.InverseExpressionNested, PropertyRefFluent.InverseScopeNested, ReturnFluent.InverseExpressionNested, SwitchFluent.InverseExpressionNested, TernaryFluent.InverseAlternativeNested, TernaryFluent.InverseConditionNested, TernaryFluent.InverseResultNested, WhileFluent.InverseConditionNested

public class InverseFluent<A extends InverseFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
InverseFluent()
InverseFluent(Inverse instance)

Method Summary

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

InverseFluent

public InverseFluent()

InverseFluent

public InverseFluent(Inverse instance)

Method Detail

copyInstance

protected void copyInstance(Inverse instance)

buildExpresion

public Expression buildExpresion()

withExpresion

public A withExpresion(Expression expresion)

hasExpresion

public boolean hasExpresion()

withNewMultiplyExpresion

public InverseFluent.MultiplyExpresionNested<A> withNewMultiplyExpresion()

withNewMultiplyExpresionLike

public InverseFluent.MultiplyExpresionNested<A> withNewMultiplyExpresionLike(Multiply item)

withNewMultiplyExpresion

public A withNewMultiplyExpresion(Object left,
                                  Object right)

withNewNewArrayExpresion

public InverseFluent.NewArrayExpresionNested<A> withNewNewArrayExpresion()

withNewNewArrayExpresionLike

public InverseFluent.NewArrayExpresionNested<A> withNewNewArrayExpresionLike(NewArray item)

withNewNewArrayExpresion

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

withNewInstanceOfExpresion

public InverseFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresion()

withNewInstanceOfExpresionLike

public InverseFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresionLike(InstanceOf item)

withNewMethodCallExpresion

public InverseFluent.MethodCallExpresionNested<A> withNewMethodCallExpresion()

withNewMethodCallExpresionLike

public InverseFluent.MethodCallExpresionNested<A> withNewMethodCallExpresionLike(MethodCall item)

withNewInverseExpresion

public InverseFluent.InverseExpresionNested<A> withNewInverseExpresion()

withNewInverseExpresionLike

public InverseFluent.InverseExpresionNested<A> withNewInverseExpresionLike(Inverse item)

withNewIndexExpresion

public InverseFluent.IndexExpresionNested<A> withNewIndexExpresion()

withNewIndexExpresionLike

public InverseFluent.IndexExpresionNested<A> withNewIndexExpresionLike(Index item)

withNewGreaterThanOrEqualExpresion

public InverseFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresion()

withNewGreaterThanOrEqualExpresionLike

public InverseFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresionLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualExpresion

public A withNewGreaterThanOrEqualExpresion(Object left,
                                            Object right)

withNewBitwiseAndExpresion

public InverseFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresion()

withNewBitwiseAndExpresionLike

public InverseFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresionLike(BitwiseAnd item)

withNewBitwiseAndExpresion

public A withNewBitwiseAndExpresion(Object left,
                                    Object right)

withNewMinusExpresion

public InverseFluent.MinusExpresionNested<A> withNewMinusExpresion()

withNewMinusExpresionLike

public InverseFluent.MinusExpresionNested<A> withNewMinusExpresionLike(Minus item)

withNewMinusExpresion

public A withNewMinusExpresion(Object left,
                               Object right)

withNewLogicalOrExpresion

public InverseFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresion()

withNewLogicalOrExpresionLike

public InverseFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresionLike(LogicalOr item)

withNewLogicalOrExpresion

public A withNewLogicalOrExpresion(Object left,
                                   Object right)

withNewNotEqualsExpresion

public InverseFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresion()

withNewNotEqualsExpresionLike

public InverseFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresionLike(NotEquals item)

withNewNotEqualsExpresion

public A withNewNotEqualsExpresion(Object left,
                                   Object right)

withNewDivideExpresion

public InverseFluent.DivideExpresionNested<A> withNewDivideExpresion()

withNewDivideExpresionLike

public InverseFluent.DivideExpresionNested<A> withNewDivideExpresionLike(Divide item)

withNewDivideExpresion

public A withNewDivideExpresion(Object left,
                                Object right)

withNewLessThanExpresion

public InverseFluent.LessThanExpresionNested<A> withNewLessThanExpresion()

withNewLessThanExpresionLike

public InverseFluent.LessThanExpresionNested<A> withNewLessThanExpresionLike(LessThan item)

withNewLessThanExpresion

public A withNewLessThanExpresion(Object left,
                                  Object right)

withNewBitwiseOrExpresion

public InverseFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresion()

withNewBitwiseOrExpresionLike

public InverseFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresionLike(BitwiseOr item)

withNewBitwiseOrExpresion

public A withNewBitwiseOrExpresion(Object left,
                                   Object right)

withNewPropertyRefExpresion

public InverseFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresion()

withNewPropertyRefExpresionLike

public InverseFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresionLike(PropertyRef item)

withNewRightShiftExpresion

public InverseFluent.RightShiftExpresionNested<A> withNewRightShiftExpresion()

withNewRightShiftExpresionLike

public InverseFluent.RightShiftExpresionNested<A> withNewRightShiftExpresionLike(RightShift item)

withNewRightShiftExpresion

public A withNewRightShiftExpresion(Object left,
                                    Object right)

withNewGreaterThanExpresion

public InverseFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresion()

withNewGreaterThanExpresionLike

public InverseFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresionLike(GreaterThan item)

withNewGreaterThanExpresion

public A withNewGreaterThanExpresion(Object left,
                                     Object right)

withNewDeclareExpresion

public InverseFluent.DeclareExpresionNested<A> withNewDeclareExpresion()

withNewDeclareExpresionLike

public InverseFluent.DeclareExpresionNested<A> withNewDeclareExpresionLike(Declare item)

withNewDeclareExpresion

public A withNewDeclareExpresion(Class type,
                                 String name)

withNewDeclareExpresion

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

withNewCastExpresion

public InverseFluent.CastExpresionNested<A> withNewCastExpresion()

withNewCastExpresionLike

public InverseFluent.CastExpresionNested<A> withNewCastExpresionLike(Cast item)

withNewModuloExpresion

public InverseFluent.ModuloExpresionNested<A> withNewModuloExpresion()

withNewModuloExpresionLike

public InverseFluent.ModuloExpresionNested<A> withNewModuloExpresionLike(Modulo item)

withNewModuloExpresion

public A withNewModuloExpresion(Object left,
                                Object right)

withNewValueRefExpresion

public InverseFluent.ValueRefExpresionNested<A> withNewValueRefExpresion()

withNewValueRefExpresionLike

public InverseFluent.ValueRefExpresionNested<A> withNewValueRefExpresionLike(ValueRef item)

withNewValueRefExpresion

public A withNewValueRefExpresion(Object value)

withNewLeftShiftExpresion

public InverseFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresion()

withNewLeftShiftExpresionLike

public InverseFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresionLike(LeftShift item)

withNewLeftShiftExpresion

public A withNewLeftShiftExpresion(Object left,
                                   Object right)

withNewTernaryExpresion

public InverseFluent.TernaryExpresionNested<A> withNewTernaryExpresion()

withNewTernaryExpresionLike

public InverseFluent.TernaryExpresionNested<A> withNewTernaryExpresionLike(Ternary item)

withNewBinaryExpressionExpresion

public InverseFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresion()

withNewBinaryExpressionExpresionLike

public InverseFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresionLike(BinaryExpression item)

withNewEqualsExpresion

public InverseFluent.EqualsExpresionNested<A> withNewEqualsExpresion()

withNewEqualsExpresionLike

public InverseFluent.EqualsExpresionNested<A> withNewEqualsExpresionLike(Equals item)

withNewEqualsExpresion

public A withNewEqualsExpresion(Object left,
                                Object right)

withNewEnclosedExpresion

public InverseFluent.EnclosedExpresionNested<A> withNewEnclosedExpresion()

withNewEnclosedExpresionLike

public InverseFluent.EnclosedExpresionNested<A> withNewEnclosedExpresionLike(Enclosed item)

withNewPreDecrementExpresion

public InverseFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresion()

withNewPreDecrementExpresionLike

public InverseFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresionLike(PreDecrement item)

withNewPostDecrementExpresion

public InverseFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresion()

withNewPostDecrementExpresionLike

public InverseFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresionLike(PostDecrement item)

withNewLambdaExpresion

public InverseFluent.LambdaExpresionNested<A> withNewLambdaExpresion()

withNewLambdaExpresionLike

public InverseFluent.LambdaExpresionNested<A> withNewLambdaExpresionLike(Lambda item)

withNewNotExpresion

public InverseFluent.NotExpresionNested<A> withNewNotExpresion()

withNewNotExpresionLike

public InverseFluent.NotExpresionNested<A> withNewNotExpresionLike(Not item)

withNewAssignExpresion

public InverseFluent.AssignExpresionNested<A> withNewAssignExpresion()

withNewAssignExpresionLike

public InverseFluent.AssignExpresionNested<A> withNewAssignExpresionLike(Assign item)

withNewNegativeExpresion

public InverseFluent.NegativeExpresionNested<A> withNewNegativeExpresion()

withNewNegativeExpresionLike

public InverseFluent.NegativeExpresionNested<A> withNewNegativeExpresionLike(Negative item)

withNewThisExpresion

public InverseFluent.ThisExpresionNested<A> withNewThisExpresion()

withNewThisExpresionLike

public InverseFluent.ThisExpresionNested<A> withNewThisExpresionLike(This item)

withNewLogicalAndExpresion

public InverseFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresion()

withNewLogicalAndExpresionLike

public InverseFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresionLike(LogicalAnd item)

withNewLogicalAndExpresion

public A withNewLogicalAndExpresion(Object left,
                                    Object right)

withNewPostIncrementExpresion

public InverseFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresion()

withNewPostIncrementExpresionLike

public InverseFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresionLike(PostIncrement item)

withNewRightUnsignedShiftExpresion

public InverseFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresion()

withNewRightUnsignedShiftExpresionLike

public InverseFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresionLike(RightUnsignedShift item)

withNewRightUnsignedShiftExpresion

public A withNewRightUnsignedShiftExpresion(Object left,
                                            Object right)

withNewPlusExpresion

public InverseFluent.PlusExpresionNested<A> withNewPlusExpresion()

withNewPlusExpresionLike

public InverseFluent.PlusExpresionNested<A> withNewPlusExpresionLike(Plus item)

withNewPlusExpresion

public A withNewPlusExpresion(Object left,
                              Object right)

withNewConstructExpresion

public InverseFluent.ConstructExpresionNested<A> withNewConstructExpresion()

withNewConstructExpresionLike

public InverseFluent.ConstructExpresionNested<A> withNewConstructExpresionLike(Construct item)

withNewXorExpresion

public InverseFluent.XorExpresionNested<A> withNewXorExpresion()

withNewXorExpresionLike

public InverseFluent.XorExpresionNested<A> withNewXorExpresionLike(Xor item)

withNewXorExpresion

public A withNewXorExpresion(Object left,
                             Object right)

withNewPreIncrementExpresion

public InverseFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresion()

withNewPreIncrementExpresionLike

public InverseFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresionLike(PreIncrement item)

withNewLessThanOrEqualExpresion

public InverseFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresion()

withNewLessThanOrEqualExpresionLike

public InverseFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresionLike(LessThanOrEqual item)

withNewLessThanOrEqualExpresion

public A withNewLessThanOrEqualExpresion(Object left,
                                         Object right)

withNewPositiveExpresion

public InverseFluent.PositiveExpresionNested<A> withNewPositiveExpresion()

withNewPositiveExpresionLike

public InverseFluent.PositiveExpresionNested<A> withNewPositiveExpresionLike(Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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