Package io.sundr.model

Class IndexFluent<A extends IndexFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.IndexFluent<A>

Direct Known Subclasses:

AssignFluent.IndexTargetNested, AssignFluent.IndexValueNested, BinaryExpressionFluent.IndexLeftNested, BinaryExpressionFluent.IndexRightNested, CastFluent.IndexExpressionNested, ConstructFluent.IndexArgumentsNested, DoFluent.IndexConditionNested, EnclosedFluent.IndexExpresionNested, ForeachFluent.IndexExpressionNested, ForFluent.IndexCompareNested, ForFluent.IndexInitNested, ForFluent.IndexUpdateNested, IfFluent.IndexConditionNested, IndexBuilder, IndexFluent.IndexExpressionNested, IndexFluent.IndexScopeNested, InstanceOfFluent.IndexExpressionNested, InverseFluent.IndexExpresionNested, MethodCallFluent.IndexArgumentsNested, MethodCallFluent.IndexScopeNested, NegativeFluent.IndexExpresionNested, NewArrayFluent.IndexExpressionsNested, NotFluent.IndexExpresionNested, PositiveFluent.IndexExpresionNested, PostDecrementFluent.IndexExpressionNested, PostIncrementFluent.IndexExpressionNested, PreDecrementFluent.IndexExpressionNested, PreIncrementFluent.IndexExpressionNested, PropertyRefFluent.IndexScopeNested, ReturnFluent.IndexExpressionNested, SwitchFluent.IndexExpressionNested, TernaryFluent.IndexAlternativeNested, TernaryFluent.IndexConditionNested, TernaryFluent.IndexResultNested, WhileFluent.IndexConditionNested

public class IndexFluent<A extends IndexFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	IndexFluent.AssignExpressionNested<N>
class	IndexFluent.AssignScopeNested<N>
class	IndexFluent.BinaryExpressionNested<N>
class	IndexFluent.BinaryExpressionScopeNested<N>
class	IndexFluent.BitwiseAndExpressionNested<N>
class	IndexFluent.BitwiseAndScopeNested<N>
class	IndexFluent.BitwiseOrExpressionNested<N>
class	IndexFluent.BitwiseOrScopeNested<N>
class	IndexFluent.CastExpressionNested<N>
class	IndexFluent.CastScopeNested<N>
class	IndexFluent.ConstructExpressionNested<N>
class	IndexFluent.ConstructScopeNested<N>
class	IndexFluent.DeclareExpressionNested<N>
class	IndexFluent.DeclareScopeNested<N>
class	IndexFluent.DivideExpressionNested<N>
class	IndexFluent.DivideScopeNested<N>
class	IndexFluent.EnclosedExpressionNested<N>
class	IndexFluent.EnclosedScopeNested<N>
class	IndexFluent.EqualsExpressionNested<N>
class	IndexFluent.EqualsScopeNested<N>
class	IndexFluent.GreaterThanExpressionNested<N>
class	IndexFluent.GreaterThanOrEqualExpressionNested<N>
class	IndexFluent.GreaterThanOrEqualScopeNested<N>
class	IndexFluent.GreaterThanScopeNested<N>
class	IndexFluent.IndexExpressionNested<N>
class	IndexFluent.IndexScopeNested<N>
class	IndexFluent.InstanceOfExpressionNested<N>
class	IndexFluent.InstanceOfScopeNested<N>
class	IndexFluent.InverseExpressionNested<N>
class	IndexFluent.InverseScopeNested<N>
class	IndexFluent.LambdaExpressionNested<N>
class	IndexFluent.LambdaScopeNested<N>
class	IndexFluent.LeftShiftExpressionNested<N>
class	IndexFluent.LeftShiftScopeNested<N>
class	IndexFluent.LessThanExpressionNested<N>
class	IndexFluent.LessThanOrEqualExpressionNested<N>
class	IndexFluent.LessThanOrEqualScopeNested<N>
class	IndexFluent.LessThanScopeNested<N>
class	IndexFluent.LogicalAndExpressionNested<N>
class	IndexFluent.LogicalAndScopeNested<N>
class	IndexFluent.LogicalOrExpressionNested<N>
class	IndexFluent.LogicalOrScopeNested<N>
class	IndexFluent.MethodCallExpressionNested<N>
class	IndexFluent.MethodCallScopeNested<N>
class	IndexFluent.MinusExpressionNested<N>
class	IndexFluent.MinusScopeNested<N>
class	IndexFluent.ModuloExpressionNested<N>
class	IndexFluent.ModuloScopeNested<N>
class	IndexFluent.MultiplyExpressionNested<N>
class	IndexFluent.MultiplyScopeNested<N>
class	IndexFluent.NegativeExpressionNested<N>
class	IndexFluent.NegativeScopeNested<N>
class	IndexFluent.NewArrayExpressionNested<N>
class	IndexFluent.NewArrayScopeNested<N>
class	IndexFluent.NotEqualsExpressionNested<N>
class	IndexFluent.NotEqualsScopeNested<N>
class	IndexFluent.NotExpressionNested<N>
class	IndexFluent.NotScopeNested<N>
class	IndexFluent.PlusExpressionNested<N>
class	IndexFluent.PlusScopeNested<N>
class	IndexFluent.PositiveExpressionNested<N>
class	IndexFluent.PositiveScopeNested<N>
class	IndexFluent.PostDecrementExpressionNested<N>
class	IndexFluent.PostDecrementScopeNested<N>
class	IndexFluent.PostIncrementExpressionNested<N>
class	IndexFluent.PostIncrementScopeNested<N>
class	IndexFluent.PreDecrementExpressionNested<N>
class	IndexFluent.PreDecrementScopeNested<N>
class	IndexFluent.PreIncrementExpressionNested<N>
class	IndexFluent.PreIncrementScopeNested<N>
class	IndexFluent.PropertyRefExpressionNested<N>
class	IndexFluent.PropertyRefScopeNested<N>
class	IndexFluent.RightShiftExpressionNested<N>
class	IndexFluent.RightShiftScopeNested<N>
class	IndexFluent.RightUnsignedShiftExpressionNested<N>
class	IndexFluent.RightUnsignedShiftScopeNested<N>
class	IndexFluent.TernaryExpressionNested<N>
class	IndexFluent.TernaryScopeNested<N>
class	IndexFluent.ThisExpressionNested<N>
class	IndexFluent.ThisScopeNested<N>
class	IndexFluent.ValueRefExpressionNested<N>
class	IndexFluent.ValueRefScopeNested<N>
class	IndexFluent.XorExpressionNested<N>
class	IndexFluent.XorScopeNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
IndexFluent()
IndexFluent(Index instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildExpression()
Expression	buildScope()
protected void	copyInstance(Index instance)
boolean	equals(Object o)
boolean	hasExpression()
int	hashCode()
boolean	hasScope()
String	toString()
A	withExpression(Expression expression)
IndexFluent.AssignExpressionNested<A>	withNewAssignExpression()
IndexFluent.AssignExpressionNested<A>	withNewAssignExpressionLike(Assign item)
IndexFluent.AssignScopeNested<A>	withNewAssignScope()
IndexFluent.AssignScopeNested<A>	withNewAssignScopeLike(Assign item)
IndexFluent.BinaryExpressionNested<A>	withNewBinaryExpression()
IndexFluent.BinaryExpressionNested<A>	withNewBinaryExpressionLike(BinaryExpression item)
IndexFluent.BinaryExpressionScopeNested<A>	withNewBinaryExpressionScope()
IndexFluent.BinaryExpressionScopeNested<A>	withNewBinaryExpressionScopeLike(BinaryExpression item)
IndexFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpression()
A	withNewBitwiseAndExpression(Object left, Object right)
IndexFluent.BitwiseAndExpressionNested<A>	withNewBitwiseAndExpressionLike(BitwiseAnd item)
IndexFluent.BitwiseAndScopeNested<A>	withNewBitwiseAndScope()
A	withNewBitwiseAndScope(Object left, Object right)
IndexFluent.BitwiseAndScopeNested<A>	withNewBitwiseAndScopeLike(BitwiseAnd item)
IndexFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpression()
A	withNewBitwiseOrExpression(Object left, Object right)
IndexFluent.BitwiseOrExpressionNested<A>	withNewBitwiseOrExpressionLike(BitwiseOr item)
IndexFluent.BitwiseOrScopeNested<A>	withNewBitwiseOrScope()
A	withNewBitwiseOrScope(Object left, Object right)
IndexFluent.BitwiseOrScopeNested<A>	withNewBitwiseOrScopeLike(BitwiseOr item)
IndexFluent.CastExpressionNested<A>	withNewCastExpression()
IndexFluent.CastExpressionNested<A>	withNewCastExpressionLike(Cast item)
IndexFluent.CastScopeNested<A>	withNewCastScope()
IndexFluent.CastScopeNested<A>	withNewCastScopeLike(Cast item)
IndexFluent.ConstructExpressionNested<A>	withNewConstructExpression()
IndexFluent.ConstructExpressionNested<A>	withNewConstructExpressionLike(Construct item)
IndexFluent.ConstructScopeNested<A>	withNewConstructScope()
IndexFluent.ConstructScopeNested<A>	withNewConstructScopeLike(Construct item)
IndexFluent.DeclareExpressionNested<A>	withNewDeclareExpression()
A	withNewDeclareExpression(Class type, String name)
A	withNewDeclareExpression(Class type, String name, Object value)
IndexFluent.DeclareExpressionNested<A>	withNewDeclareExpressionLike(Declare item)
IndexFluent.DeclareScopeNested<A>	withNewDeclareScope()
A	withNewDeclareScope(Class type, String name)
A	withNewDeclareScope(Class type, String name, Object value)
IndexFluent.DeclareScopeNested<A>	withNewDeclareScopeLike(Declare item)
IndexFluent.DivideExpressionNested<A>	withNewDivideExpression()
A	withNewDivideExpression(Object left, Object right)
IndexFluent.DivideExpressionNested<A>	withNewDivideExpressionLike(Divide item)
IndexFluent.DivideScopeNested<A>	withNewDivideScope()
A	withNewDivideScope(Object left, Object right)
IndexFluent.DivideScopeNested<A>	withNewDivideScopeLike(Divide item)
IndexFluent.EnclosedExpressionNested<A>	withNewEnclosedExpression()
IndexFluent.EnclosedExpressionNested<A>	withNewEnclosedExpressionLike(Enclosed item)
IndexFluent.EnclosedScopeNested<A>	withNewEnclosedScope()
IndexFluent.EnclosedScopeNested<A>	withNewEnclosedScopeLike(Enclosed item)
IndexFluent.EqualsExpressionNested<A>	withNewEqualsExpression()
A	withNewEqualsExpression(Object left, Object right)
IndexFluent.EqualsExpressionNested<A>	withNewEqualsExpressionLike(Equals item)
IndexFluent.EqualsScopeNested<A>	withNewEqualsScope()
A	withNewEqualsScope(Object left, Object right)
IndexFluent.EqualsScopeNested<A>	withNewEqualsScopeLike(Equals item)
IndexFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpression()
A	withNewGreaterThanExpression(Object left, Object right)
IndexFluent.GreaterThanExpressionNested<A>	withNewGreaterThanExpressionLike(GreaterThan item)
IndexFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpression()
A	withNewGreaterThanOrEqualExpression(Object left, Object right)
IndexFluent.GreaterThanOrEqualExpressionNested<A>	withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
IndexFluent.GreaterThanOrEqualScopeNested<A>	withNewGreaterThanOrEqualScope()
A	withNewGreaterThanOrEqualScope(Object left, Object right)
IndexFluent.GreaterThanOrEqualScopeNested<A>	withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item)
IndexFluent.GreaterThanScopeNested<A>	withNewGreaterThanScope()
A	withNewGreaterThanScope(Object left, Object right)
IndexFluent.GreaterThanScopeNested<A>	withNewGreaterThanScopeLike(GreaterThan item)
IndexFluent.IndexExpressionNested<A>	withNewIndexExpression()
IndexFluent.IndexExpressionNested<A>	withNewIndexExpressionLike(Index item)
IndexFluent.IndexScopeNested<A>	withNewIndexScope()
IndexFluent.IndexScopeNested<A>	withNewIndexScopeLike(Index item)
IndexFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpression()
IndexFluent.InstanceOfExpressionNested<A>	withNewInstanceOfExpressionLike(InstanceOf item)
IndexFluent.InstanceOfScopeNested<A>	withNewInstanceOfScope()
IndexFluent.InstanceOfScopeNested<A>	withNewInstanceOfScopeLike(InstanceOf item)
IndexFluent.InverseExpressionNested<A>	withNewInverseExpression()
IndexFluent.InverseExpressionNested<A>	withNewInverseExpressionLike(Inverse item)
IndexFluent.InverseScopeNested<A>	withNewInverseScope()
IndexFluent.InverseScopeNested<A>	withNewInverseScopeLike(Inverse item)
IndexFluent.LambdaExpressionNested<A>	withNewLambdaExpression()
IndexFluent.LambdaExpressionNested<A>	withNewLambdaExpressionLike(Lambda item)
IndexFluent.LambdaScopeNested<A>	withNewLambdaScope()
IndexFluent.LambdaScopeNested<A>	withNewLambdaScopeLike(Lambda item)
IndexFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpression()
A	withNewLeftShiftExpression(Object left, Object right)
IndexFluent.LeftShiftExpressionNested<A>	withNewLeftShiftExpressionLike(LeftShift item)
IndexFluent.LeftShiftScopeNested<A>	withNewLeftShiftScope()
A	withNewLeftShiftScope(Object left, Object right)
IndexFluent.LeftShiftScopeNested<A>	withNewLeftShiftScopeLike(LeftShift item)
IndexFluent.LessThanExpressionNested<A>	withNewLessThanExpression()
A	withNewLessThanExpression(Object left, Object right)
IndexFluent.LessThanExpressionNested<A>	withNewLessThanExpressionLike(LessThan item)
IndexFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpression()
A	withNewLessThanOrEqualExpression(Object left, Object right)
IndexFluent.LessThanOrEqualExpressionNested<A>	withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
IndexFluent.LessThanOrEqualScopeNested<A>	withNewLessThanOrEqualScope()
A	withNewLessThanOrEqualScope(Object left, Object right)
IndexFluent.LessThanOrEqualScopeNested<A>	withNewLessThanOrEqualScopeLike(LessThanOrEqual item)
IndexFluent.LessThanScopeNested<A>	withNewLessThanScope()
A	withNewLessThanScope(Object left, Object right)
IndexFluent.LessThanScopeNested<A>	withNewLessThanScopeLike(LessThan item)
IndexFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpression()
A	withNewLogicalAndExpression(Object left, Object right)
IndexFluent.LogicalAndExpressionNested<A>	withNewLogicalAndExpressionLike(LogicalAnd item)
IndexFluent.LogicalAndScopeNested<A>	withNewLogicalAndScope()
A	withNewLogicalAndScope(Object left, Object right)
IndexFluent.LogicalAndScopeNested<A>	withNewLogicalAndScopeLike(LogicalAnd item)
IndexFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpression()
A	withNewLogicalOrExpression(Object left, Object right)
IndexFluent.LogicalOrExpressionNested<A>	withNewLogicalOrExpressionLike(LogicalOr item)
IndexFluent.LogicalOrScopeNested<A>	withNewLogicalOrScope()
A	withNewLogicalOrScope(Object left, Object right)
IndexFluent.LogicalOrScopeNested<A>	withNewLogicalOrScopeLike(LogicalOr item)
IndexFluent.MethodCallExpressionNested<A>	withNewMethodCallExpression()
IndexFluent.MethodCallExpressionNested<A>	withNewMethodCallExpressionLike(MethodCall item)
IndexFluent.MethodCallScopeNested<A>	withNewMethodCallScope()
IndexFluent.MethodCallScopeNested<A>	withNewMethodCallScopeLike(MethodCall item)
IndexFluent.MinusExpressionNested<A>	withNewMinusExpression()
A	withNewMinusExpression(Object left, Object right)
IndexFluent.MinusExpressionNested<A>	withNewMinusExpressionLike(Minus item)
IndexFluent.MinusScopeNested<A>	withNewMinusScope()
A	withNewMinusScope(Object left, Object right)
IndexFluent.MinusScopeNested<A>	withNewMinusScopeLike(Minus item)
IndexFluent.ModuloExpressionNested<A>	withNewModuloExpression()
A	withNewModuloExpression(Object left, Object right)
IndexFluent.ModuloExpressionNested<A>	withNewModuloExpressionLike(Modulo item)
IndexFluent.ModuloScopeNested<A>	withNewModuloScope()
A	withNewModuloScope(Object left, Object right)
IndexFluent.ModuloScopeNested<A>	withNewModuloScopeLike(Modulo item)
IndexFluent.MultiplyExpressionNested<A>	withNewMultiplyExpression()
A	withNewMultiplyExpression(Object left, Object right)
IndexFluent.MultiplyExpressionNested<A>	withNewMultiplyExpressionLike(Multiply item)
IndexFluent.MultiplyScopeNested<A>	withNewMultiplyScope()
A	withNewMultiplyScope(Object left, Object right)
IndexFluent.MultiplyScopeNested<A>	withNewMultiplyScopeLike(Multiply item)
IndexFluent.NegativeExpressionNested<A>	withNewNegativeExpression()
IndexFluent.NegativeExpressionNested<A>	withNewNegativeExpressionLike(Negative item)
IndexFluent.NegativeScopeNested<A>	withNewNegativeScope()
IndexFluent.NegativeScopeNested<A>	withNewNegativeScopeLike(Negative item)
IndexFluent.NewArrayExpressionNested<A>	withNewNewArrayExpression()
A	withNewNewArrayExpression(Class type, Integer[] sizes)
IndexFluent.NewArrayExpressionNested<A>	withNewNewArrayExpressionLike(NewArray item)
IndexFluent.NewArrayScopeNested<A>	withNewNewArrayScope()
A	withNewNewArrayScope(Class type, Integer[] sizes)
IndexFluent.NewArrayScopeNested<A>	withNewNewArrayScopeLike(NewArray item)
IndexFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpression()
A	withNewNotEqualsExpression(Object left, Object right)
IndexFluent.NotEqualsExpressionNested<A>	withNewNotEqualsExpressionLike(NotEquals item)
IndexFluent.NotEqualsScopeNested<A>	withNewNotEqualsScope()
A	withNewNotEqualsScope(Object left, Object right)
IndexFluent.NotEqualsScopeNested<A>	withNewNotEqualsScopeLike(NotEquals item)
IndexFluent.NotExpressionNested<A>	withNewNotExpression()
IndexFluent.NotExpressionNested<A>	withNewNotExpressionLike(Not item)
IndexFluent.NotScopeNested<A>	withNewNotScope()
IndexFluent.NotScopeNested<A>	withNewNotScopeLike(Not item)
IndexFluent.PlusExpressionNested<A>	withNewPlusExpression()
A	withNewPlusExpression(Object left, Object right)
IndexFluent.PlusExpressionNested<A>	withNewPlusExpressionLike(Plus item)
IndexFluent.PlusScopeNested<A>	withNewPlusScope()
A	withNewPlusScope(Object left, Object right)
IndexFluent.PlusScopeNested<A>	withNewPlusScopeLike(Plus item)
IndexFluent.PositiveExpressionNested<A>	withNewPositiveExpression()
IndexFluent.PositiveExpressionNested<A>	withNewPositiveExpressionLike(Positive item)
IndexFluent.PositiveScopeNested<A>	withNewPositiveScope()
IndexFluent.PositiveScopeNested<A>	withNewPositiveScopeLike(Positive item)
IndexFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpression()
IndexFluent.PostDecrementExpressionNested<A>	withNewPostDecrementExpressionLike(PostDecrement item)
IndexFluent.PostDecrementScopeNested<A>	withNewPostDecrementScope()
IndexFluent.PostDecrementScopeNested<A>	withNewPostDecrementScopeLike(PostDecrement item)
IndexFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpression()
IndexFluent.PostIncrementExpressionNested<A>	withNewPostIncrementExpressionLike(PostIncrement item)
IndexFluent.PostIncrementScopeNested<A>	withNewPostIncrementScope()
IndexFluent.PostIncrementScopeNested<A>	withNewPostIncrementScopeLike(PostIncrement item)
IndexFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpression()
IndexFluent.PreDecrementExpressionNested<A>	withNewPreDecrementExpressionLike(PreDecrement item)
IndexFluent.PreDecrementScopeNested<A>	withNewPreDecrementScope()
IndexFluent.PreDecrementScopeNested<A>	withNewPreDecrementScopeLike(PreDecrement item)
IndexFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpression()
IndexFluent.PreIncrementExpressionNested<A>	withNewPreIncrementExpressionLike(PreIncrement item)
IndexFluent.PreIncrementScopeNested<A>	withNewPreIncrementScope()
IndexFluent.PreIncrementScopeNested<A>	withNewPreIncrementScopeLike(PreIncrement item)
IndexFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpression()
IndexFluent.PropertyRefExpressionNested<A>	withNewPropertyRefExpressionLike(PropertyRef item)
IndexFluent.PropertyRefScopeNested<A>	withNewPropertyRefScope()
IndexFluent.PropertyRefScopeNested<A>	withNewPropertyRefScopeLike(PropertyRef item)
IndexFluent.RightShiftExpressionNested<A>	withNewRightShiftExpression()
A	withNewRightShiftExpression(Object left, Object right)
IndexFluent.RightShiftExpressionNested<A>	withNewRightShiftExpressionLike(RightShift item)
IndexFluent.RightShiftScopeNested<A>	withNewRightShiftScope()
A	withNewRightShiftScope(Object left, Object right)
IndexFluent.RightShiftScopeNested<A>	withNewRightShiftScopeLike(RightShift item)
IndexFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpression()
A	withNewRightUnsignedShiftExpression(Object left, Object right)
IndexFluent.RightUnsignedShiftExpressionNested<A>	withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
IndexFluent.RightUnsignedShiftScopeNested<A>	withNewRightUnsignedShiftScope()
A	withNewRightUnsignedShiftScope(Object left, Object right)
IndexFluent.RightUnsignedShiftScopeNested<A>	withNewRightUnsignedShiftScopeLike(RightUnsignedShift item)
IndexFluent.TernaryExpressionNested<A>	withNewTernaryExpression()
IndexFluent.TernaryExpressionNested<A>	withNewTernaryExpressionLike(Ternary item)
IndexFluent.TernaryScopeNested<A>	withNewTernaryScope()
IndexFluent.TernaryScopeNested<A>	withNewTernaryScopeLike(Ternary item)
IndexFluent.ThisExpressionNested<A>	withNewThisExpression()
IndexFluent.ThisExpressionNested<A>	withNewThisExpressionLike(This item)
IndexFluent.ThisScopeNested<A>	withNewThisScope()
IndexFluent.ThisScopeNested<A>	withNewThisScopeLike(This item)
IndexFluent.ValueRefExpressionNested<A>	withNewValueRefExpression()
A	withNewValueRefExpression(Object value)
IndexFluent.ValueRefExpressionNested<A>	withNewValueRefExpressionLike(ValueRef item)
IndexFluent.ValueRefScopeNested<A>	withNewValueRefScope()
A	withNewValueRefScope(Object value)
IndexFluent.ValueRefScopeNested<A>	withNewValueRefScopeLike(ValueRef item)
IndexFluent.XorExpressionNested<A>	withNewXorExpression()
A	withNewXorExpression(Object left, Object right)
IndexFluent.XorExpressionNested<A>	withNewXorExpressionLike(Xor item)
IndexFluent.XorScopeNested<A>	withNewXorScope()
A	withNewXorScope(Object left, Object right)
IndexFluent.XorScopeNested<A>	withNewXorScopeLike(Xor item)
A	withScope(Expression scope)

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

IndexFluent

public IndexFluent()

IndexFluent

public IndexFluent(Index instance)

Method Detail

copyInstance

protected void copyInstance(Index instance)

buildScope

public Expression buildScope()

withScope

public A withScope(Expression scope)

hasScope

public boolean hasScope()

withNewMultiplyScope

public IndexFluent.MultiplyScopeNested<A> withNewMultiplyScope()

withNewMultiplyScopeLike

public IndexFluent.MultiplyScopeNested<A> withNewMultiplyScopeLike(Multiply item)

withNewMultiplyScope

public A withNewMultiplyScope(Object left,
                              Object right)

withNewNewArrayScope

public IndexFluent.NewArrayScopeNested<A> withNewNewArrayScope()

withNewNewArrayScopeLike

public IndexFluent.NewArrayScopeNested<A> withNewNewArrayScopeLike(NewArray item)

withNewNewArrayScope

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

withNewInstanceOfScope

public IndexFluent.InstanceOfScopeNested<A> withNewInstanceOfScope()

withNewInstanceOfScopeLike

public IndexFluent.InstanceOfScopeNested<A> withNewInstanceOfScopeLike(InstanceOf item)

withNewMethodCallScope

public IndexFluent.MethodCallScopeNested<A> withNewMethodCallScope()

withNewMethodCallScopeLike

public IndexFluent.MethodCallScopeNested<A> withNewMethodCallScopeLike(MethodCall item)

withNewInverseScope

public IndexFluent.InverseScopeNested<A> withNewInverseScope()

withNewInverseScopeLike

public IndexFluent.InverseScopeNested<A> withNewInverseScopeLike(Inverse item)

withNewIndexScope

public IndexFluent.IndexScopeNested<A> withNewIndexScope()

withNewIndexScopeLike

public IndexFluent.IndexScopeNested<A> withNewIndexScopeLike(Index item)

withNewGreaterThanOrEqualScope

public IndexFluent.GreaterThanOrEqualScopeNested<A> withNewGreaterThanOrEqualScope()

withNewGreaterThanOrEqualScopeLike

public IndexFluent.GreaterThanOrEqualScopeNested<A> withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualScope

public A withNewGreaterThanOrEqualScope(Object left,
                                        Object right)

withNewBitwiseAndScope

public IndexFluent.BitwiseAndScopeNested<A> withNewBitwiseAndScope()

withNewBitwiseAndScopeLike

public IndexFluent.BitwiseAndScopeNested<A> withNewBitwiseAndScopeLike(BitwiseAnd item)

withNewBitwiseAndScope

public A withNewBitwiseAndScope(Object left,
                                Object right)

withNewMinusScope

public IndexFluent.MinusScopeNested<A> withNewMinusScope()

withNewMinusScopeLike

public IndexFluent.MinusScopeNested<A> withNewMinusScopeLike(Minus item)

withNewMinusScope

public A withNewMinusScope(Object left,
                           Object right)

withNewLogicalOrScope

public IndexFluent.LogicalOrScopeNested<A> withNewLogicalOrScope()

withNewLogicalOrScopeLike

public IndexFluent.LogicalOrScopeNested<A> withNewLogicalOrScopeLike(LogicalOr item)

withNewLogicalOrScope

public A withNewLogicalOrScope(Object left,
                               Object right)

withNewNotEqualsScope

public IndexFluent.NotEqualsScopeNested<A> withNewNotEqualsScope()

withNewNotEqualsScopeLike

public IndexFluent.NotEqualsScopeNested<A> withNewNotEqualsScopeLike(NotEquals item)

withNewNotEqualsScope

public A withNewNotEqualsScope(Object left,
                               Object right)

withNewDivideScope

public IndexFluent.DivideScopeNested<A> withNewDivideScope()

withNewDivideScopeLike

public IndexFluent.DivideScopeNested<A> withNewDivideScopeLike(Divide item)

withNewDivideScope

public A withNewDivideScope(Object left,
                            Object right)

withNewLessThanScope

public IndexFluent.LessThanScopeNested<A> withNewLessThanScope()

withNewLessThanScopeLike

public IndexFluent.LessThanScopeNested<A> withNewLessThanScopeLike(LessThan item)

withNewLessThanScope

public A withNewLessThanScope(Object left,
                              Object right)

withNewBitwiseOrScope

public IndexFluent.BitwiseOrScopeNested<A> withNewBitwiseOrScope()

withNewBitwiseOrScopeLike

public IndexFluent.BitwiseOrScopeNested<A> withNewBitwiseOrScopeLike(BitwiseOr item)

withNewBitwiseOrScope

public A withNewBitwiseOrScope(Object left,
                               Object right)

withNewPropertyRefScope

public IndexFluent.PropertyRefScopeNested<A> withNewPropertyRefScope()

withNewPropertyRefScopeLike

public IndexFluent.PropertyRefScopeNested<A> withNewPropertyRefScopeLike(PropertyRef item)

withNewRightShiftScope

public IndexFluent.RightShiftScopeNested<A> withNewRightShiftScope()

withNewRightShiftScopeLike

public IndexFluent.RightShiftScopeNested<A> withNewRightShiftScopeLike(RightShift item)

withNewRightShiftScope

public A withNewRightShiftScope(Object left,
                                Object right)

withNewGreaterThanScope

public IndexFluent.GreaterThanScopeNested<A> withNewGreaterThanScope()

withNewGreaterThanScopeLike

public IndexFluent.GreaterThanScopeNested<A> withNewGreaterThanScopeLike(GreaterThan item)

withNewGreaterThanScope

public A withNewGreaterThanScope(Object left,
                                 Object right)

withNewDeclareScope

public IndexFluent.DeclareScopeNested<A> withNewDeclareScope()

withNewDeclareScopeLike

public IndexFluent.DeclareScopeNested<A> withNewDeclareScopeLike(Declare item)

withNewDeclareScope

public A withNewDeclareScope(Class type,
                             String name)

withNewDeclareScope

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

withNewCastScope

public IndexFluent.CastScopeNested<A> withNewCastScope()

withNewCastScopeLike

public IndexFluent.CastScopeNested<A> withNewCastScopeLike(Cast item)

withNewModuloScope

public IndexFluent.ModuloScopeNested<A> withNewModuloScope()

withNewModuloScopeLike

public IndexFluent.ModuloScopeNested<A> withNewModuloScopeLike(Modulo item)

withNewModuloScope

public A withNewModuloScope(Object left,
                            Object right)

withNewValueRefScope

public IndexFluent.ValueRefScopeNested<A> withNewValueRefScope()

withNewValueRefScopeLike

public IndexFluent.ValueRefScopeNested<A> withNewValueRefScopeLike(ValueRef item)

withNewValueRefScope

public A withNewValueRefScope(Object value)

withNewLeftShiftScope

public IndexFluent.LeftShiftScopeNested<A> withNewLeftShiftScope()

withNewLeftShiftScopeLike

public IndexFluent.LeftShiftScopeNested<A> withNewLeftShiftScopeLike(LeftShift item)

withNewLeftShiftScope

public A withNewLeftShiftScope(Object left,
                               Object right)

withNewTernaryScope

public IndexFluent.TernaryScopeNested<A> withNewTernaryScope()

withNewTernaryScopeLike

public IndexFluent.TernaryScopeNested<A> withNewTernaryScopeLike(Ternary item)

withNewBinaryExpressionScope

public IndexFluent.BinaryExpressionScopeNested<A> withNewBinaryExpressionScope()

withNewBinaryExpressionScopeLike

public IndexFluent.BinaryExpressionScopeNested<A> withNewBinaryExpressionScopeLike(BinaryExpression item)

withNewEqualsScope

public IndexFluent.EqualsScopeNested<A> withNewEqualsScope()

withNewEqualsScopeLike

public IndexFluent.EqualsScopeNested<A> withNewEqualsScopeLike(Equals item)

withNewEqualsScope

public A withNewEqualsScope(Object left,
                            Object right)

withNewEnclosedScope

public IndexFluent.EnclosedScopeNested<A> withNewEnclosedScope()

withNewEnclosedScopeLike

public IndexFluent.EnclosedScopeNested<A> withNewEnclosedScopeLike(Enclosed item)

withNewPreDecrementScope

public IndexFluent.PreDecrementScopeNested<A> withNewPreDecrementScope()

withNewPreDecrementScopeLike

public IndexFluent.PreDecrementScopeNested<A> withNewPreDecrementScopeLike(PreDecrement item)

withNewPostDecrementScope

public IndexFluent.PostDecrementScopeNested<A> withNewPostDecrementScope()

withNewPostDecrementScopeLike

public IndexFluent.PostDecrementScopeNested<A> withNewPostDecrementScopeLike(PostDecrement item)

withNewLambdaScope

public IndexFluent.LambdaScopeNested<A> withNewLambdaScope()

withNewLambdaScopeLike

public IndexFluent.LambdaScopeNested<A> withNewLambdaScopeLike(Lambda item)

withNewNotScope

public IndexFluent.NotScopeNested<A> withNewNotScope()

withNewNotScopeLike

public IndexFluent.NotScopeNested<A> withNewNotScopeLike(Not item)

withNewAssignScope

public IndexFluent.AssignScopeNested<A> withNewAssignScope()

withNewAssignScopeLike

public IndexFluent.AssignScopeNested<A> withNewAssignScopeLike(Assign item)

withNewNegativeScope

public IndexFluent.NegativeScopeNested<A> withNewNegativeScope()

withNewNegativeScopeLike

public IndexFluent.NegativeScopeNested<A> withNewNegativeScopeLike(Negative item)

withNewThisScope

public IndexFluent.ThisScopeNested<A> withNewThisScope()

withNewThisScopeLike

public IndexFluent.ThisScopeNested<A> withNewThisScopeLike(This item)

withNewLogicalAndScope

public IndexFluent.LogicalAndScopeNested<A> withNewLogicalAndScope()

withNewLogicalAndScopeLike

public IndexFluent.LogicalAndScopeNested<A> withNewLogicalAndScopeLike(LogicalAnd item)

withNewLogicalAndScope

public A withNewLogicalAndScope(Object left,
                                Object right)

withNewPostIncrementScope

public IndexFluent.PostIncrementScopeNested<A> withNewPostIncrementScope()

withNewPostIncrementScopeLike

public IndexFluent.PostIncrementScopeNested<A> withNewPostIncrementScopeLike(PostIncrement item)

withNewRightUnsignedShiftScope

public IndexFluent.RightUnsignedShiftScopeNested<A> withNewRightUnsignedShiftScope()

withNewRightUnsignedShiftScopeLike

public IndexFluent.RightUnsignedShiftScopeNested<A> withNewRightUnsignedShiftScopeLike(RightUnsignedShift item)

withNewRightUnsignedShiftScope

public A withNewRightUnsignedShiftScope(Object left,
                                        Object right)

withNewPlusScope

public IndexFluent.PlusScopeNested<A> withNewPlusScope()

withNewPlusScopeLike

public IndexFluent.PlusScopeNested<A> withNewPlusScopeLike(Plus item)

withNewPlusScope

public A withNewPlusScope(Object left,
                          Object right)

withNewConstructScope

public IndexFluent.ConstructScopeNested<A> withNewConstructScope()

withNewConstructScopeLike

public IndexFluent.ConstructScopeNested<A> withNewConstructScopeLike(Construct item)

withNewXorScope

public IndexFluent.XorScopeNested<A> withNewXorScope()

withNewXorScopeLike

public IndexFluent.XorScopeNested<A> withNewXorScopeLike(Xor item)

withNewXorScope

public A withNewXorScope(Object left,
                         Object right)

withNewPreIncrementScope

public IndexFluent.PreIncrementScopeNested<A> withNewPreIncrementScope()

withNewPreIncrementScopeLike

public IndexFluent.PreIncrementScopeNested<A> withNewPreIncrementScopeLike(PreIncrement item)

withNewLessThanOrEqualScope

public IndexFluent.LessThanOrEqualScopeNested<A> withNewLessThanOrEqualScope()

withNewLessThanOrEqualScopeLike

public IndexFluent.LessThanOrEqualScopeNested<A> withNewLessThanOrEqualScopeLike(LessThanOrEqual item)

withNewLessThanOrEqualScope

public A withNewLessThanOrEqualScope(Object left,
                                     Object right)

withNewPositiveScope

public IndexFluent.PositiveScopeNested<A> withNewPositiveScope()

withNewPositiveScopeLike

public IndexFluent.PositiveScopeNested<A> withNewPositiveScopeLike(Positive item)

buildExpression

public Expression buildExpression()

withExpression

public A withExpression(Expression expression)

hasExpression

public boolean hasExpression()

withNewMultiplyExpression

public IndexFluent.MultiplyExpressionNested<A> withNewMultiplyExpression()

withNewMultiplyExpressionLike

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

withNewMultiplyExpression

public A withNewMultiplyExpression(Object left,
                                   Object right)

withNewNewArrayExpression

public IndexFluent.NewArrayExpressionNested<A> withNewNewArrayExpression()

withNewNewArrayExpressionLike

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

withNewNewArrayExpression

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

withNewInstanceOfExpression

public IndexFluent.InstanceOfExpressionNested<A> withNewInstanceOfExpression()

withNewInstanceOfExpressionLike

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

withNewMethodCallExpression

public IndexFluent.MethodCallExpressionNested<A> withNewMethodCallExpression()

withNewMethodCallExpressionLike

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

withNewInverseExpression

public IndexFluent.InverseExpressionNested<A> withNewInverseExpression()

withNewInverseExpressionLike

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

withNewIndexExpression

public IndexFluent.IndexExpressionNested<A> withNewIndexExpression()

withNewIndexExpressionLike

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

withNewGreaterThanOrEqualExpression

public IndexFluent.GreaterThanOrEqualExpressionNested<A> withNewGreaterThanOrEqualExpression()

withNewGreaterThanOrEqualExpressionLike

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

withNewGreaterThanOrEqualExpression

public A withNewGreaterThanOrEqualExpression(Object left,
                                             Object right)

withNewBitwiseAndExpression

public IndexFluent.BitwiseAndExpressionNested<A> withNewBitwiseAndExpression()

withNewBitwiseAndExpressionLike

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

withNewBitwiseAndExpression

public A withNewBitwiseAndExpression(Object left,
                                     Object right)

withNewMinusExpression

public IndexFluent.MinusExpressionNested<A> withNewMinusExpression()

withNewMinusExpressionLike

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

withNewMinusExpression

public A withNewMinusExpression(Object left,
                                Object right)

withNewLogicalOrExpression

public IndexFluent.LogicalOrExpressionNested<A> withNewLogicalOrExpression()

withNewLogicalOrExpressionLike

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

withNewLogicalOrExpression

public A withNewLogicalOrExpression(Object left,
                                    Object right)

withNewNotEqualsExpression

public IndexFluent.NotEqualsExpressionNested<A> withNewNotEqualsExpression()

withNewNotEqualsExpressionLike

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

withNewNotEqualsExpression

public A withNewNotEqualsExpression(Object left,
                                    Object right)

withNewDivideExpression

public IndexFluent.DivideExpressionNested<A> withNewDivideExpression()

withNewDivideExpressionLike

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

withNewDivideExpression

public A withNewDivideExpression(Object left,
                                 Object right)

withNewLessThanExpression

public IndexFluent.LessThanExpressionNested<A> withNewLessThanExpression()

withNewLessThanExpressionLike

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

withNewLessThanExpression

public A withNewLessThanExpression(Object left,
                                   Object right)

withNewBitwiseOrExpression

public IndexFluent.BitwiseOrExpressionNested<A> withNewBitwiseOrExpression()

withNewBitwiseOrExpressionLike

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

withNewBitwiseOrExpression

public A withNewBitwiseOrExpression(Object left,
                                    Object right)

withNewPropertyRefExpression

public IndexFluent.PropertyRefExpressionNested<A> withNewPropertyRefExpression()

withNewPropertyRefExpressionLike

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

withNewRightShiftExpression

public IndexFluent.RightShiftExpressionNested<A> withNewRightShiftExpression()

withNewRightShiftExpressionLike

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

withNewRightShiftExpression

public A withNewRightShiftExpression(Object left,
                                     Object right)

withNewGreaterThanExpression

public IndexFluent.GreaterThanExpressionNested<A> withNewGreaterThanExpression()

withNewGreaterThanExpressionLike

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

withNewGreaterThanExpression

public A withNewGreaterThanExpression(Object left,
                                      Object right)

withNewDeclareExpression

public IndexFluent.DeclareExpressionNested<A> withNewDeclareExpression()

withNewDeclareExpressionLike

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

withNewCastExpressionLike

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

withNewModuloExpression

public IndexFluent.ModuloExpressionNested<A> withNewModuloExpression()

withNewModuloExpressionLike

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

withNewModuloExpression

public A withNewModuloExpression(Object left,
                                 Object right)

withNewValueRefExpression

public IndexFluent.ValueRefExpressionNested<A> withNewValueRefExpression()

withNewValueRefExpressionLike

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

withNewValueRefExpression

public A withNewValueRefExpression(Object value)

withNewLeftShiftExpression

public IndexFluent.LeftShiftExpressionNested<A> withNewLeftShiftExpression()

withNewLeftShiftExpressionLike

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

withNewLeftShiftExpression

public A withNewLeftShiftExpression(Object left,
                                    Object right)

withNewTernaryExpression

public IndexFluent.TernaryExpressionNested<A> withNewTernaryExpression()

withNewTernaryExpressionLike

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

withNewBinaryExpression

public IndexFluent.BinaryExpressionNested<A> withNewBinaryExpression()

withNewBinaryExpressionLike

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

withNewEqualsExpression

public IndexFluent.EqualsExpressionNested<A> withNewEqualsExpression()

withNewEqualsExpressionLike

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

withNewEqualsExpression

public A withNewEqualsExpression(Object left,
                                 Object right)

withNewEnclosedExpression

public IndexFluent.EnclosedExpressionNested<A> withNewEnclosedExpression()

withNewEnclosedExpressionLike

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

withNewPreDecrementExpression

public IndexFluent.PreDecrementExpressionNested<A> withNewPreDecrementExpression()

withNewPreDecrementExpressionLike

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

withNewPostDecrementExpression

public IndexFluent.PostDecrementExpressionNested<A> withNewPostDecrementExpression()

withNewPostDecrementExpressionLike

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

withNewLambdaExpression

public IndexFluent.LambdaExpressionNested<A> withNewLambdaExpression()

withNewLambdaExpressionLike

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

withNewNotExpression

public IndexFluent.NotExpressionNested<A> withNewNotExpression()

withNewNotExpressionLike

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

withNewAssignExpression

public IndexFluent.AssignExpressionNested<A> withNewAssignExpression()

withNewAssignExpressionLike

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

withNewNegativeExpression

public IndexFluent.NegativeExpressionNested<A> withNewNegativeExpression()

withNewNegativeExpressionLike

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

withNewThisExpression

public IndexFluent.ThisExpressionNested<A> withNewThisExpression()

withNewThisExpressionLike

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

withNewLogicalAndExpression

public IndexFluent.LogicalAndExpressionNested<A> withNewLogicalAndExpression()

withNewLogicalAndExpressionLike

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

withNewLogicalAndExpression

public A withNewLogicalAndExpression(Object left,
                                     Object right)

withNewPostIncrementExpression

public IndexFluent.PostIncrementExpressionNested<A> withNewPostIncrementExpression()

withNewPostIncrementExpressionLike

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

withNewRightUnsignedShiftExpression

public IndexFluent.RightUnsignedShiftExpressionNested<A> withNewRightUnsignedShiftExpression()

withNewRightUnsignedShiftExpressionLike

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

withNewRightUnsignedShiftExpression

public A withNewRightUnsignedShiftExpression(Object left,
                                             Object right)

withNewPlusExpression

public IndexFluent.PlusExpressionNested<A> withNewPlusExpression()

withNewPlusExpressionLike

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

withNewPlusExpression

public A withNewPlusExpression(Object left,
                               Object right)

withNewConstructExpression

public IndexFluent.ConstructExpressionNested<A> withNewConstructExpression()

withNewConstructExpressionLike

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

withNewXorExpression

public IndexFluent.XorExpressionNested<A> withNewXorExpression()

withNewXorExpressionLike

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

withNewXorExpression

public A withNewXorExpression(Object left,
                              Object right)

withNewPreIncrementExpression

public IndexFluent.PreIncrementExpressionNested<A> withNewPreIncrementExpression()

withNewPreIncrementExpressionLike

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

withNewLessThanOrEqualExpression

public IndexFluent.LessThanOrEqualExpressionNested<A> withNewLessThanOrEqualExpression()

withNewLessThanOrEqualExpressionLike

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

withNewLessThanOrEqualExpression

public A withNewLessThanOrEqualExpression(Object left,
                                          Object right)

withNewPositiveExpression

public IndexFluent.PositiveExpressionNested<A> withNewPositiveExpression()

withNewPositiveExpressionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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