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, IfFluent.SwitchStatementNested, LambdaFluent.SwitchStatementNested, SwitchBuilder, 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.ConstructExpressionNested<N>
class	SwitchFluent.DeclareExpressionNested<N>
class	SwitchFluent.DefaultCaseNested<N>
class	SwitchFluent.DivideExpressionNested<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.PropertyRefExpressionNested<N>
class	SwitchFluent.RightShiftExpressionNested<N>
class	SwitchFluent.RightUnsignedShiftExpressionNested<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.DefaultCaseNested<A>	editDefaultCase()
<T> SwitchFluent.DefaultCaseNested<?>	editOrNewDefaultCase()
SwitchFluent.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.AssignExpressionNested<A>	withNewAssignExpression()
SwitchFluent.AssignExpressionNested<A>	withNewAssignExpressionLike(Assign item)
SwitchFluent.BinaryExpressionNested<A>	withNewBinaryExpression()
SwitchFluent.BinaryExpressionNested<A>	withNewBinaryExpressionLike(BinaryExpression item)
SwitchFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpression()
A	withNewBitwiseAndExpression(Object left, Object right)
SwitchFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpressionLike(BitwiseAnd item)
SwitchFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpression()
A	withNewBitwiseOrExpression(Object left, Object right)
SwitchFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpressionLike(BitwiseOr item)
SwitchFluent.CastExpressionNested<A>	withNewCastExpression()
SwitchFluent.CastExpressionNested<A>	withNewCastExpressionLike(Cast item)
SwitchFluent.ConstructExpressionNested<A>	withNewConstructExpression()
SwitchFluent.ConstructExpressionNested<A>	withNewConstructExpressionLike(Construct item)
SwitchFluent.DeclareExpressionNested<A>	withNewDeclareExpression()
A	withNewDeclareExpression(Class type, String name)
A	withNewDeclareExpression(Class type, String name, Object value)
SwitchFluent.DeclareExpressionNested<A>	withNewDeclareExpressionLike(Declare item)
SwitchFluent.DefaultCaseNested<A>	withNewDefaultCase()
SwitchFluent.DefaultCaseNested<A>	withNewDefaultCaseLike(Block item)
SwitchFluent.DivideExpressionNested<A>	withNewDivideExpression()
A	withNewDivideExpression(Object left, Object right)
SwitchFluent.DivideExpressionNested<A>	withNewDivideExpressionLike(Divide item)
SwitchFluent.EnclosedExpressionNested<A>	withNewEnclosedExpression()
SwitchFluent.EnclosedExpressionNested<A>	withNewEnclosedExpressionLike(Enclosed item)
SwitchFluent.EqualsExpressionNested<A>	withNewEqualsExpression()
A	withNewEqualsExpression(Object left, Object right)
SwitchFluent.EqualsExpressionNested<A>	withNewEqualsExpressionLike(Equals item)
SwitchFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpression()
A	withNewGreaterThanExpression(Object left, Object right)
SwitchFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpressionLike(GreaterThan item)
SwitchFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpression()
A	withNewGreaterThanOrEqualExpression(Object left, Object right)
SwitchFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
SwitchFluent.IndexExpressionNested<A>	withNewIndexExpression()
SwitchFluent.IndexExpressionNested<A>	withNewIndexExpressionLike(Index item)
SwitchFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpression()
SwitchFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpressionLike(InstanceOf item)
SwitchFluent.InverseExpressionNested<A>	withNewInverseExpression()
SwitchFluent.InverseExpressionNested<A>	withNewInverseExpressionLike(Inverse item)
SwitchFluent.LambdaExpressionNested<A>	withNewLambdaExpression()
SwitchFluent.LambdaExpressionNested<A>	withNewLambdaExpressionLike(Lambda item)
SwitchFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpression()
A	withNewLeftShiftExpression(Object left, Object right)
SwitchFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpressionLike(LeftShift item)
SwitchFluent.LessThanExpressionNested<A>	withNewLessThanExpression()
A	withNewLessThanExpression(Object left, Object right)
SwitchFluent.LessThanExpressionNested<A>	withNewLessThanExpressionLike(LessThan item)
SwitchFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpression()
A	withNewLessThanOrEqualExpression(Object left, Object right)
SwitchFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
SwitchFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpression()
A	withNewLogicalAndExpression(Object left, Object right)
SwitchFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpressionLike(LogicalAnd item)
SwitchFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpression()
A	withNewLogicalOrExpression(Object left, Object right)
SwitchFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpressionLike(LogicalOr item)
SwitchFluent.MethodCallExpressionNested<A>	withNewMethodCallExpression()
SwitchFluent.MethodCallExpressionNested<A>	withNewMethodCallExpressionLike(MethodCall item)
SwitchFluent.MinusExpressionNested<A>	withNewMinusExpression()
A	withNewMinusExpression(Object left, Object right)
SwitchFluent.MinusExpressionNested<A>	withNewMinusExpressionLike(Minus item)
SwitchFluent.ModuloExpressionNested<A>	withNewModuloExpression()
A	withNewModuloExpression(Object left, Object right)
SwitchFluent.ModuloExpressionNested<A>	withNewModuloExpressionLike(Modulo item)
SwitchFluent.MultiplyExpressionNested<A>	withNewMultiplyExpression()
A	withNewMultiplyExpression(Object left, Object right)
SwitchFluent.MultiplyExpressionNested<A>	withNewMultiplyExpressionLike(Multiply item)
SwitchFluent.NegativeExpressionNested<A>	withNewNegativeExpression()
SwitchFluent.NegativeExpressionNested<A>	withNewNegativeExpressionLike(Negative item)
SwitchFluent.NewArrayExpressionNested<A>	withNewNewArrayExpression()
A	withNewNewArrayExpression(Class type, Integer[] sizes)
SwitchFluent.NewArrayExpressionNested<A>	withNewNewArrayExpressionLike(NewArray item)
SwitchFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpression()
A	withNewNotEqualsExpression(Object left, Object right)
SwitchFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpressionLike(NotEquals item)
SwitchFluent.NotExpressionNested<A>	withNewNotExpression()
SwitchFluent.NotExpressionNested<A>	withNewNotExpressionLike(Not item)
SwitchFluent.PlusExpressionNested<A>	withNewPlusExpression()
A	withNewPlusExpression(Object left, Object right)
SwitchFluent.PlusExpressionNested<A>	withNewPlusExpressionLike(Plus item)
SwitchFluent.PositiveExpressionNested<A>	withNewPositiveExpression()
SwitchFluent.PositiveExpressionNested<A>	withNewPositiveExpressionLike(Positive item)
SwitchFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpression()
SwitchFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpressionLike(PostDecrement item)
SwitchFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpression()
SwitchFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpressionLike(PostIncrement item)
SwitchFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpression()
SwitchFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpressionLike(PreDecrement item)
SwitchFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpression()
SwitchFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpressionLike(PreIncrement item)
SwitchFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpression()
SwitchFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpressionLike(PropertyRef item)
SwitchFluent.RightShiftExpressionNested<A>	withNewRightShiftExpression()
A	withNewRightShiftExpression(Object left, Object right)
SwitchFluent.RightShiftExpressionNested<A>	withNewRightShiftExpressionLike(RightShift item)
SwitchFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpression()
A	withNewRightUnsignedShiftExpression(Object left, Object right)
SwitchFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
SwitchFluent.TernaryExpressionNested<A>	withNewTernaryExpression()
SwitchFluent.TernaryExpressionNested<A>	withNewTernaryExpressionLike(Ternary item)
SwitchFluent.ThisExpressionNested<A>	withNewThisExpression()
SwitchFluent.ThisExpressionNested<A>	withNewThisExpressionLike(This item)
SwitchFluent.ValueRefExpressionNested<A>	withNewValueRefExpression()
A	withNewValueRefExpression(Object value)
SwitchFluent.ValueRefExpressionNested<A>	withNewValueRefExpressionLike(ValueRef item)
SwitchFluent.XorExpressionNested<A>	withNewXorExpression()
A	withNewXorExpression(Object left, Object right)
SwitchFluent.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 Detail

SwitchFluent

public SwitchFluent()

SwitchFluent

public SwitchFluent(Switch instance)

Method Detail

copyInstance

protected void copyInstance(Switch instance)

buildExpression

public Expression buildExpression()

withExpression

public A withExpression(Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public SwitchFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public SwitchFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public SwitchFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public SwitchFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public SwitchFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public SwitchFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public SwitchFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public SwitchFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public SwitchFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public SwitchFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public SwitchFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public SwitchFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public SwitchFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public SwitchFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public SwitchFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public SwitchFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public SwitchFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public SwitchFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

public SwitchFluent.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 SwitchFluent.CastExpressionNested<A> withNewCastExpression()

withNewCastExpressionLike

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

withNewModuloExpression

public SwitchFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public SwitchFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public SwitchFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public SwitchFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public SwitchFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public SwitchFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public SwitchFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public SwitchFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public SwitchFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public SwitchFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public SwitchFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public SwitchFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public SwitchFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public SwitchFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public SwitchFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public SwitchFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public SwitchFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public SwitchFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public SwitchFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public SwitchFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public SwitchFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public SwitchFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public SwitchFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

addToCases

public A addToCases(ValueRef key,
                    Block value)

addToCases

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

removeFromCases

public A removeFromCases(ValueRef key)

removeFromCases

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

getCases

public Map<ValueRef,Block> getCases()

withCases

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

hasCases

public boolean hasCases()

withDefaultCase

public A withDefaultCase(Optional<Block> defaultCase)

withDefaultCase

public A withDefaultCase(Block defaultCase)

buildDefaultCase

public Optional<Block> buildDefaultCase()

hasDefaultCase

public boolean hasDefaultCase()

withNewDefaultCase

public SwitchFluent.DefaultCaseNested<A> withNewDefaultCase()

withNewDefaultCaseLike

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

editDefaultCase

public SwitchFluent.DefaultCaseNested<A> editDefaultCase()

editOrNewDefaultCase

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

editOrNewDefaultCaseLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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