Package io.sundr.model

Class PositiveFluent<A extends PositiveFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.PositiveFluent<A>

Direct Known Subclasses:

AssignFluent.PositiveTargetNested, AssignFluent.PositiveValueNested, BinaryExpressionFluent.PositiveLeftNested, BinaryExpressionFluent.PositiveRightNested, CastFluent.PositiveExpressionNested, ConstructFluent.PositiveArgumentsNested, DoFluent.PositiveConditionNested, EnclosedFluent.PositiveExpresionNested, ForeachFluent.PositiveExpressionNested, ForFluent.PositiveCompareNested, ForFluent.PositiveInitNested, ForFluent.PositiveUpdateNested, IfFluent.PositiveConditionNested, IndexFluent.PositiveExpressionNested, IndexFluent.PositiveScopeNested, InstanceOfFluent.PositiveExpressionNested, InverseFluent.PositiveExpresionNested, MethodCallFluent.PositiveArgumentsNested, MethodCallFluent.PositiveScopeNested, NegativeFluent.PositiveExpresionNested, NewArrayFluent.PositiveExpressionsNested, NotFluent.PositiveExpresionNested, PositiveBuilder, PositiveFluent.PositiveExpresionNested, PostDecrementFluent.PositiveExpressionNested, PostIncrementFluent.PositiveExpressionNested, PreDecrementFluent.PositiveExpressionNested, PreIncrementFluent.PositiveExpressionNested, PropertyRefFluent.PositiveScopeNested, ReturnFluent.PositiveExpressionNested, SwitchFluent.PositiveExpressionNested, TernaryFluent.PositiveAlternativeNested, TernaryFluent.PositiveConditionNested, TernaryFluent.PositiveResultNested, WhileFluent.PositiveConditionNested

public class PositiveFluent<A extends PositiveFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
PositiveFluent()
PositiveFluent(Positive instance)

Method Summary

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

PositiveFluent

public PositiveFluent()

PositiveFluent

public PositiveFluent(Positive instance)

Method Detail

copyInstance

protected void copyInstance(Positive instance)

buildExpresion

public Expression buildExpresion()

withExpresion

public A withExpresion(Expression expresion)

hasExpresion

public boolean hasExpresion()

withNewMultiplyExpresion

public PositiveFluent.MultiplyExpresionNested<A> withNewMultiplyExpresion()

withNewMultiplyExpresionLike

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

withNewMultiplyExpresion

public A withNewMultiplyExpresion(Object left,
                                  Object right)

withNewNewArrayExpresion

public PositiveFluent.NewArrayExpresionNested<A> withNewNewArrayExpresion()

withNewNewArrayExpresionLike

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

withNewNewArrayExpresion

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

withNewInstanceOfExpresion

public PositiveFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresion()

withNewInstanceOfExpresionLike

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

withNewMethodCallExpresion

public PositiveFluent.MethodCallExpresionNested<A> withNewMethodCallExpresion()

withNewMethodCallExpresionLike

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

withNewInverseExpresion

public PositiveFluent.InverseExpresionNested<A> withNewInverseExpresion()

withNewInverseExpresionLike

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

withNewIndexExpresion

public PositiveFluent.IndexExpresionNested<A> withNewIndexExpresion()

withNewIndexExpresionLike

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

withNewGreaterThanOrEqualExpresion

public PositiveFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresion()

withNewGreaterThanOrEqualExpresionLike

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

withNewGreaterThanOrEqualExpresion

public A withNewGreaterThanOrEqualExpresion(Object left,
                                            Object right)

withNewBitwiseAndExpresion

public PositiveFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresion()

withNewBitwiseAndExpresionLike

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

withNewBitwiseAndExpresion

public A withNewBitwiseAndExpresion(Object left,
                                    Object right)

withNewMinusExpresion

public PositiveFluent.MinusExpresionNested<A> withNewMinusExpresion()

withNewMinusExpresionLike

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

withNewMinusExpresion

public A withNewMinusExpresion(Object left,
                               Object right)

withNewLogicalOrExpresion

public PositiveFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresion()

withNewLogicalOrExpresionLike

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

withNewLogicalOrExpresion

public A withNewLogicalOrExpresion(Object left,
                                   Object right)

withNewNotEqualsExpresion

public PositiveFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresion()

withNewNotEqualsExpresionLike

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

withNewNotEqualsExpresion

public A withNewNotEqualsExpresion(Object left,
                                   Object right)

withNewDivideExpresion

public PositiveFluent.DivideExpresionNested<A> withNewDivideExpresion()

withNewDivideExpresionLike

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

withNewDivideExpresion

public A withNewDivideExpresion(Object left,
                                Object right)

withNewLessThanExpresion

public PositiveFluent.LessThanExpresionNested<A> withNewLessThanExpresion()

withNewLessThanExpresionLike

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

withNewLessThanExpresion

public A withNewLessThanExpresion(Object left,
                                  Object right)

withNewBitwiseOrExpresion

public PositiveFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresion()

withNewBitwiseOrExpresionLike

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

withNewBitwiseOrExpresion

public A withNewBitwiseOrExpresion(Object left,
                                   Object right)

withNewPropertyRefExpresion

public PositiveFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresion()

withNewPropertyRefExpresionLike

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

withNewRightShiftExpresion

public PositiveFluent.RightShiftExpresionNested<A> withNewRightShiftExpresion()

withNewRightShiftExpresionLike

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

withNewRightShiftExpresion

public A withNewRightShiftExpresion(Object left,
                                    Object right)

withNewGreaterThanExpresion

public PositiveFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresion()

withNewGreaterThanExpresionLike

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

withNewGreaterThanExpresion

public A withNewGreaterThanExpresion(Object left,
                                     Object right)

withNewDeclareExpresion

public PositiveFluent.DeclareExpresionNested<A> withNewDeclareExpresion()

withNewDeclareExpresionLike

public PositiveFluent.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 PositiveFluent.CastExpresionNested<A> withNewCastExpresion()

withNewCastExpresionLike

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

withNewModuloExpresion

public PositiveFluent.ModuloExpresionNested<A> withNewModuloExpresion()

withNewModuloExpresionLike

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

withNewModuloExpresion

public A withNewModuloExpresion(Object left,
                                Object right)

withNewValueRefExpresion

public PositiveFluent.ValueRefExpresionNested<A> withNewValueRefExpresion()

withNewValueRefExpresionLike

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

withNewValueRefExpresion

public A withNewValueRefExpresion(Object value)

withNewLeftShiftExpresion

public PositiveFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresion()

withNewLeftShiftExpresionLike

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

withNewLeftShiftExpresion

public A withNewLeftShiftExpresion(Object left,
                                   Object right)

withNewTernaryExpresion

public PositiveFluent.TernaryExpresionNested<A> withNewTernaryExpresion()

withNewTernaryExpresionLike

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

withNewBinaryExpressionExpresion

public PositiveFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresion()

withNewBinaryExpressionExpresionLike

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

withNewEqualsExpresion

public PositiveFluent.EqualsExpresionNested<A> withNewEqualsExpresion()

withNewEqualsExpresionLike

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

withNewEqualsExpresion

public A withNewEqualsExpresion(Object left,
                                Object right)

withNewEnclosedExpresion

public PositiveFluent.EnclosedExpresionNested<A> withNewEnclosedExpresion()

withNewEnclosedExpresionLike

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

withNewPreDecrementExpresion

public PositiveFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresion()

withNewPreDecrementExpresionLike

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

withNewPostDecrementExpresion

public PositiveFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresion()

withNewPostDecrementExpresionLike

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

withNewLambdaExpresion

public PositiveFluent.LambdaExpresionNested<A> withNewLambdaExpresion()

withNewLambdaExpresionLike

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

withNewNotExpresion

public PositiveFluent.NotExpresionNested<A> withNewNotExpresion()

withNewNotExpresionLike

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

withNewAssignExpresion

public PositiveFluent.AssignExpresionNested<A> withNewAssignExpresion()

withNewAssignExpresionLike

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

withNewNegativeExpresion

public PositiveFluent.NegativeExpresionNested<A> withNewNegativeExpresion()

withNewNegativeExpresionLike

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

withNewThisExpresion

public PositiveFluent.ThisExpresionNested<A> withNewThisExpresion()

withNewThisExpresionLike

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

withNewLogicalAndExpresion

public PositiveFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresion()

withNewLogicalAndExpresionLike

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

withNewLogicalAndExpresion

public A withNewLogicalAndExpresion(Object left,
                                    Object right)

withNewPostIncrementExpresion

public PositiveFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresion()

withNewPostIncrementExpresionLike

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

withNewRightUnsignedShiftExpresion

public PositiveFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresion()

withNewRightUnsignedShiftExpresionLike

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

withNewRightUnsignedShiftExpresion

public A withNewRightUnsignedShiftExpresion(Object left,
                                            Object right)

withNewPlusExpresion

public PositiveFluent.PlusExpresionNested<A> withNewPlusExpresion()

withNewPlusExpresionLike

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

withNewPlusExpresion

public A withNewPlusExpresion(Object left,
                              Object right)

withNewConstructExpresion

public PositiveFluent.ConstructExpresionNested<A> withNewConstructExpresion()

withNewConstructExpresionLike

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

withNewXorExpresion

public PositiveFluent.XorExpresionNested<A> withNewXorExpresion()

withNewXorExpresionLike

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

withNewXorExpresion

public A withNewXorExpresion(Object left,
                             Object right)

withNewPreIncrementExpresion

public PositiveFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresion()

withNewPreIncrementExpresionLike

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

withNewLessThanOrEqualExpresion

public PositiveFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresion()

withNewLessThanOrEqualExpresionLike

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

withNewLessThanOrEqualExpresion

public A withNewLessThanOrEqualExpresion(Object left,
                                         Object right)

withNewPositiveExpresion

public PositiveFluent.PositiveExpresionNested<A> withNewPositiveExpresion()

withNewPositiveExpresionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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