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, IfFluent.ReturnStatementNested, LambdaFluent.ReturnStatementNested, ReturnBuilder, WhileFluent.ReturnStatementNested

public class ReturnFluent<A extends ReturnFluent<A>>
extends io.sundr.builder.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.ConstructExpressionNested<N>
class	ReturnFluent.DeclareExpressionNested<N>
class	ReturnFluent.DivideExpressionNested<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.PropertyRefExpressionNested<N>
class	ReturnFluent.RightShiftExpressionNested<N>
class	ReturnFluent.RightUnsignedShiftExpressionNested<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(io.sundr.model.Return instance)

Method Summary

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

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ReturnFluent

public ReturnFluent()

ReturnFluent

public ReturnFluent(io.sundr.model.Return instance)

Method Detail

copyInstance

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

buildExpression

public io.sundr.model.Expression buildExpression()

withExpression

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

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public ReturnFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public ReturnFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public ReturnFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public ReturnFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public ReturnFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public ReturnFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public ReturnFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public ReturnFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public ReturnFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public ReturnFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public ReturnFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public ReturnFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public ReturnFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public ReturnFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public ReturnFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public ReturnFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public ReturnFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public ReturnFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

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

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
                                  String name)

withNewDeclareExpression

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

withNewCastExpression

public ReturnFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewModuloExpression

public ReturnFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public ReturnFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public ReturnFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public ReturnFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public ReturnFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public ReturnFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public ReturnFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public ReturnFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public ReturnFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public ReturnFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public ReturnFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public ReturnFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public ReturnFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public ReturnFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public ReturnFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public ReturnFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public ReturnFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public ReturnFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public ReturnFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public ReturnFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public ReturnFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public ReturnFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public ReturnFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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