Package io.sundr.model

Class ReturnFluent<A extends ReturnFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.ReturnFluent<A>

Direct Known Subclasses:

BlockFluent.ReturnStatementsNested, DoFluent.ReturnStatementNested, ForeachFluent.ReturnBodyNested, ForFluent.ReturnBodyNested, IfDslThenStepFluent.ReturnStatementsNested, IfFluent.ReturnElseStatementNested, IfFluent.ReturnStatementNested, LambdaFluent.ReturnStatementNested, ReturnBuilder, SynchronizedFluent.ReturnBodyNested, WhileFluent.ReturnStatementNested

public class ReturnFluent<A extends ReturnFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
ReturnFluent()
ReturnFluent(Return instance)

Method Summary

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

ReturnFluent

public ReturnFluent()

ReturnFluent

public ReturnFluent(Return instance)

Method Details

buildExpression

public Expression buildExpression()

builder

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

copyInstance

protected void copyInstance(Return instance)

equals

public boolean equals(Object o)

Overrides:

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

hasExpression

public boolean hasExpression()

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

withExpression

public A withExpression(Expression expression)

withNewAssignExpression

public ReturnFluent<A>.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewBinaryExpression

public ReturnFluent<A>.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewBitwiseAndExpression

public ReturnFluent<A>.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
 Object right)

withNewBitwiseAndExpressionLike

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

withNewBitwiseOrExpression

public ReturnFluent<A>.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
 Object right)

withNewBitwiseOrExpressionLike

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

withNewCastExpression

public ReturnFluent<A>.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewClassRefExpression

public ReturnFluent<A>.ClassRefExpressionNested<A> withNewClassRefExpression()

withNewClassRefExpressionLike

public ReturnFluent<A>.ClassRefExpressionNested<A> withNewClassRefExpressionLike(ClassRef item)

withNewConstructExpression

public ReturnFluent<A>.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewContextRefExpression

public ReturnFluent<A>.ContextRefExpressionNested<A> withNewContextRefExpression()

withNewContextRefExpression

public A withNewContextRefExpression(String name)

withNewContextRefExpressionLike

public ReturnFluent<A>.ContextRefExpressionNested<A> withNewContextRefExpressionLike(ContextRef item)

withNewDeclareExpression

public ReturnFluent<A>.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
 String name)

withNewDeclareExpression

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

withNewDeclareExpressionLike

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

withNewDivideExpression

public ReturnFluent<A>.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpression

public A withNewDivideExpression(Object left,
 Object right)

withNewDivideExpressionLike

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

withNewDotClassExpression

public ReturnFluent<A>.DotClassExpressionNested<A> withNewDotClassExpression()

withNewDotClassExpressionLike

public ReturnFluent<A>.DotClassExpressionNested<A> withNewDotClassExpressionLike(DotClass item)

withNewEmptyExpression

public ReturnFluent<A>.EmptyExpressionNested<A> withNewEmptyExpression()

withNewEmptyExpressionLike

public ReturnFluent<A>.EmptyExpressionNested<A> withNewEmptyExpressionLike(Empty item)

withNewEnclosedExpression

public ReturnFluent<A>.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewEqualsExpression

public ReturnFluent<A>.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
 Object right)

withNewEqualsExpressionLike

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

withNewGreaterThanExpression

public ReturnFluent<A>.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
 Object right)

withNewGreaterThanExpressionLike

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

withNewGreaterThanOrEqualExpression

public ReturnFluent<A>.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
 Object right)

withNewGreaterThanOrEqualExpressionLike

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

withNewIndexExpression

public ReturnFluent<A>.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewInstanceOfExpression

public ReturnFluent<A>.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewInverseExpression

public ReturnFluent<A>.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewLambdaExpression

public ReturnFluent<A>.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewLeftShiftExpression

public ReturnFluent<A>.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
 Object right)

withNewLeftShiftExpressionLike

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

withNewLessThanExpression

public ReturnFluent<A>.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
 Object right)

withNewLessThanExpressionLike

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

withNewLessThanOrEqualExpression

public ReturnFluent<A>.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
 Object right)

withNewLessThanOrEqualExpressionLike

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

withNewLogicalAndExpression

public ReturnFluent<A>.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
 Object right)

withNewLogicalAndExpressionLike

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

withNewLogicalOrExpression

public ReturnFluent<A>.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
 Object right)

withNewLogicalOrExpressionLike

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

withNewMethodCallExpression

public ReturnFluent<A>.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewMinusExpression

public ReturnFluent<A>.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpression

public A withNewMinusExpression(Object left,
 Object right)

withNewMinusExpressionLike

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

withNewModuloExpression

public ReturnFluent<A>.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpression

public A withNewModuloExpression(Object left,
 Object right)

withNewModuloExpressionLike

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

withNewMultiplyExpression

public ReturnFluent<A>.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
 Object right)

withNewMultiplyExpressionLike

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

withNewNegativeExpression

public ReturnFluent<A>.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewNewArrayExpression

public ReturnFluent<A>.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpression

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

withNewNewArrayExpressionLike

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

withNewNotEqualsExpression

public ReturnFluent<A>.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
 Object right)

withNewNotEqualsExpressionLike

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

withNewNotExpression

public ReturnFluent<A>.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewPlusExpression

public ReturnFluent<A>.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpression

public A withNewPlusExpression(Object left,
 Object right)

withNewPlusExpressionLike

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

withNewPositiveExpression

public ReturnFluent<A>.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

withNewPostDecrementExpression

public ReturnFluent<A>.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewPostIncrementExpression

public ReturnFluent<A>.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewPreDecrementExpression

public ReturnFluent<A>.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPreIncrementExpression

public ReturnFluent<A>.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewPropertyExpression

public ReturnFluent<A>.PropertyExpressionNested<A> withNewPropertyExpression()

withNewPropertyExpressionLike

public ReturnFluent<A>.PropertyExpressionNested<A> withNewPropertyExpressionLike(Property item)

withNewPropertyRefExpression

public ReturnFluent<A>.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public ReturnFluent<A>.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
 Object right)

withNewRightShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public ReturnFluent<A>.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
 Object right)

withNewRightUnsignedShiftExpressionLike

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

withNewSuperExpression

public ReturnFluent<A>.SuperExpressionNested<A> withNewSuperExpression()

withNewSuperExpressionLike

public ReturnFluent<A>.SuperExpressionNested<A> withNewSuperExpressionLike(Super item)

withNewTernaryExpression

public ReturnFluent<A>.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewThisExpression

public ReturnFluent<A>.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewValueRefExpression

public ReturnFluent<A>.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewValueRefExpressionLike

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

withNewXorExpression

public ReturnFluent<A>.XorExpressionNested<A> withNewXorExpression()

withNewXorExpression

public A withNewXorExpression(Object left,
 Object right)

withNewXorExpressionLike

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