Package io.sundr.model

Class CastFluent<A extends CastFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.CastFluent<A>

Direct Known Subclasses:

AssignFluent.CastTargetNested, AssignFluent.CastValueNested, BinaryExpressionFluent.CastLeftNested, BinaryExpressionFluent.CastRightNested, CastBuilder, CastFluent.CastExpressionNested, ConstructFluent.CastArgumentsNested, DoFluent.CastConditionNested, EnclosedFluent.CastExpresionNested, ForeachFluent.CastExpressionNested, ForFluent.CastCompareNested, ForFluent.CastInitNested, ForFluent.CastUpdateNested, IfFluent.CastConditionNested, IndexFluent.CastExpressionNested, IndexFluent.CastScopeNested, InstanceOfFluent.CastExpressionNested, InverseFluent.CastExpresionNested, MethodCallFluent.CastArgumentsNested, MethodCallFluent.CastScopeNested, NegativeFluent.CastExpresionNested, NewArrayFluent.CastExpressionsNested, NotFluent.CastExpresionNested, PositiveFluent.CastExpresionNested, PostDecrementFluent.CastExpressionNested, PostIncrementFluent.CastExpressionNested, PreDecrementFluent.CastExpressionNested, PreIncrementFluent.CastExpressionNested, PropertyRefFluent.CastScopeNested, ReturnFluent.CastExpressionNested, SwitchFluent.CastExpressionNested, TernaryFluent.CastAlternativeNested, TernaryFluent.CastConditionNested, TernaryFluent.CastResultNested, WhileFluent.CastConditionNested

public class CastFluent<A extends CastFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
CastFluent()
CastFluent(Cast instance)

Method Summary

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

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

CastFluent

public CastFluent()

CastFluent

public CastFluent(Cast instance)

Method Detail

copyInstance

protected void copyInstance(Cast instance)

buildType

public TypeRef buildType()

withType

public A withType(TypeRef type)

hasType

public boolean hasType()

withNewClassRefType

public CastFluent.ClassRefTypeNested<A> withNewClassRefType()

withNewClassRefTypeLike

public CastFluent.ClassRefTypeNested<A> withNewClassRefTypeLike(ClassRef item)

withNewPrimitiveRefType

public CastFluent.PrimitiveRefTypeNested<A> withNewPrimitiveRefType()

withNewPrimitiveRefTypeLike

public CastFluent.PrimitiveRefTypeNested<A> withNewPrimitiveRefTypeLike(PrimitiveRef item)

withNewVoidRefType

public CastFluent.VoidRefTypeNested<A> withNewVoidRefType()

withNewVoidRefTypeLike

public CastFluent.VoidRefTypeNested<A> withNewVoidRefTypeLike(VoidRef item)

withNewTypeParamRefType

public CastFluent.TypeParamRefTypeNested<A> withNewTypeParamRefType()

withNewTypeParamRefTypeLike

public CastFluent.TypeParamRefTypeNested<A> withNewTypeParamRefTypeLike(TypeParamRef item)

withNewWildcardRefType

public CastFluent.WildcardRefTypeNested<A> withNewWildcardRefType()

withNewWildcardRefTypeLike

public CastFluent.WildcardRefTypeNested<A> withNewWildcardRefTypeLike(WildcardRef item)

buildExpression

public Expression buildExpression()

withExpression

public A withExpression(Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public CastFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public CastFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public CastFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public CastFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public CastFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public CastFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public CastFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public CastFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public CastFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public CastFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public CastFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public CastFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public CastFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public CastFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public CastFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public CastFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public CastFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public CastFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

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

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
                                  String name)

withNewDeclareExpression

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

withNewCastExpression

public CastFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewModuloExpression

public CastFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public CastFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public CastFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public CastFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public CastFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public CastFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public CastFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public CastFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public CastFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public CastFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public CastFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public CastFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public CastFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public CastFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public CastFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public CastFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public CastFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public CastFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public CastFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public CastFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public CastFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public CastFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public CastFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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