Package io.sundr.model

Class SwitchFluent<A extends SwitchFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.SwitchFluent<A>

Direct Known Subclasses:

BlockFluent.SwitchStatementsNested, DoFluent.SwitchStatementNested, ForeachFluent.SwitchBodyNested, ForFluent.SwitchBodyNested, IfDslThenStepFluent.SwitchStatementsNested, IfFluent.SwitchElseStatementNested, IfFluent.SwitchStatementNested, LambdaFluent.SwitchStatementNested, SwitchBuilder, SynchronizedFluent.SwitchBodyNested, WhileFluent.SwitchStatementNested

public class SwitchFluent<A extends SwitchFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
SwitchFluent()
SwitchFluent(Switch instance)

Method Summary

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

SwitchFluent

public SwitchFluent()

SwitchFluent

public SwitchFluent(Switch instance)

Method Details

addToCases

public A addToCases(Map<ValueRef,Block> map)

addToCases

public A addToCases(ValueRef key,
 Block value)

buildDefaultCase

public Optional<Block> buildDefaultCase()

buildExpression

public Expression buildExpression()

builder

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

copyInstance

protected void copyInstance(Switch instance)

editDefaultCase

public SwitchFluent<A>.DefaultCaseNested<A> editDefaultCase()

editOrNewDefaultCase

public <T> SwitchFluent<A>.DefaultCaseNested<?> editOrNewDefaultCase()

editOrNewDefaultCaseLike

public SwitchFluent<A>.DefaultCaseNested<A> editOrNewDefaultCaseLike(Block item)

equals

public boolean equals(Object o)

Overrides:

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

getCases

public Map<ValueRef,Block> getCases()

hasCases

public boolean hasCases()

hasDefaultCase

public boolean hasDefaultCase()

hasExpression

public boolean hasExpression()

hashCode

public int hashCode()

Overrides:

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

removeFromCases

public A removeFromCases(ValueRef key)

removeFromCases

public A removeFromCases(Map<ValueRef,Block> map)

toString

public String toString()

Overrides:

toString in class Object

withCases

public <K,
V> A withCases(Map<ValueRef,Block> cases)

withDefaultCase

public A withDefaultCase(Optional<Block> defaultCase)

withDefaultCase

public A withDefaultCase(Block defaultCase)

withExpression

public A withExpression(Expression expression)

withNewAssignExpression

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

withNewAssignExpressionLike

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

withNewBinaryExpression

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

withNewBinaryExpressionLike

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

withNewBitwiseAndExpression

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
 Object right)

withNewBitwiseAndExpressionLike

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

withNewBitwiseOrExpression

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
 Object right)

withNewBitwiseOrExpressionLike

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

withNewCastExpression

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

withNewCastExpressionLike

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

withNewClassRefExpression

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

withNewClassRefExpressionLike

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

withNewConstructExpression

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

withNewConstructExpressionLike

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

withNewContextRefExpression

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

withNewContextRefExpression

public A withNewContextRefExpression(String name)

withNewContextRefExpressionLike

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

withNewDeclareExpression

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

withNewDeclareExpression

public A withNewDeclareExpression(Class type,
 String name)

withNewDeclareExpression

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

withNewDeclareExpressionLike

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

withNewDefaultCase

public SwitchFluent<A>.DefaultCaseNested<A> withNewDefaultCase()

withNewDefaultCaseLike

public SwitchFluent<A>.DefaultCaseNested<A> withNewDefaultCaseLike(Block item)

withNewDivideExpression

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
 Object right)

withNewDivideExpressionLike

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

withNewDotClassExpression

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

withNewDotClassExpressionLike

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

withNewEmptyExpression

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

withNewEmptyExpressionLike

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

withNewEnclosedExpression

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

withNewEnclosedExpressionLike

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

withNewEqualsExpression

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
 Object right)

withNewEqualsExpressionLike

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

withNewGreaterThanExpression

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
 Object right)

withNewGreaterThanExpressionLike

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

withNewGreaterThanOrEqualExpression

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
 Object right)

withNewGreaterThanOrEqualExpressionLike

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

withNewIndexExpression

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

withNewIndexExpressionLike

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

withNewInstanceOfExpression

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

withNewInstanceOfExpressionLike

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

withNewInverseExpression

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

withNewInverseExpressionLike

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

withNewLambdaExpression

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

withNewLambdaExpressionLike

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

withNewLeftShiftExpression

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
 Object right)

withNewLeftShiftExpressionLike

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

withNewLessThanExpression

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
 Object right)

withNewLessThanExpressionLike

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

withNewLessThanOrEqualExpression

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
 Object right)

withNewLessThanOrEqualExpressionLike

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

withNewLogicalAndExpression

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
 Object right)

withNewLogicalAndExpressionLike

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

withNewLogicalOrExpression

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
 Object right)

withNewLogicalOrExpressionLike

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

withNewMethodCallExpression

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

withNewMethodCallExpressionLike

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

withNewMinusExpression

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
 Object right)

withNewMinusExpressionLike

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

withNewModuloExpression

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
 Object right)

withNewModuloExpressionLike

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

withNewMultiplyExpression

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
 Object right)

withNewMultiplyExpressionLike

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

withNewNegativeExpression

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

withNewNegativeExpressionLike

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

withNewNewArrayExpression

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

withNewNewArrayExpression

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

withNewNewArrayExpressionLike

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

withNewNotEqualsExpression

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
 Object right)

withNewNotEqualsExpressionLike

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

withNewNotExpression

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

withNewNotExpressionLike

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

withNewPlusExpression

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
 Object right)

withNewPlusExpressionLike

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

withNewPositiveExpression

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

withNewPositiveExpressionLike

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

withNewPostDecrementExpression

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

withNewPostDecrementExpressionLike

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

withNewPostIncrementExpression

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

withNewPostIncrementExpressionLike

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

withNewPreDecrementExpression

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

withNewPreDecrementExpressionLike

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

withNewPreIncrementExpression

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

withNewPreIncrementExpressionLike

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

withNewPropertyExpression

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

withNewPropertyExpressionLike

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

withNewPropertyRefExpression

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

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
 Object right)

withNewRightShiftExpressionLike

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

withNewRightUnsignedShiftExpression

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
 Object right)

withNewRightUnsignedShiftExpressionLike

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

withNewSuperExpression

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

withNewSuperExpressionLike

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

withNewTernaryExpression

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

withNewTernaryExpressionLike

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

withNewThisExpression

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

withNewThisExpressionLike

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

withNewValueRefExpression

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewValueRefExpressionLike

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

withNewXorExpression

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

withNewXorExpression

public A withNewXorExpression(Object left,
 Object right)

withNewXorExpressionLike

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