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<A>.AssignExpressionNested<A>

withNewAssignExpression()

IndexFluent<A>.AssignExpressionNested<A>

withNewAssignExpressionLike(Assign item)

IndexFluent<A>.AssignScopeNested<A>

withNewAssignScope()

IndexFluent<A>.AssignScopeNested<A>

withNewAssignScopeLike(Assign item)

IndexFluent<A>.BinaryExpressionNested<A>

withNewBinaryExpression()

IndexFluent<A>.BinaryExpressionNested<A>

withNewBinaryExpressionLike(BinaryExpression item)

IndexFluent<A>.BinaryExpressionScopeNested<A>

withNewBinaryExpressionScope()

IndexFluent<A>.BinaryExpressionScopeNested<A>

withNewBinaryExpressionScopeLike(BinaryExpression item)

IndexFluent<A>.BitwiseAndExpressionNested<A>

withNewBitwiseAndExpression()

A

withNewBitwiseAndExpression(Object left, Object right)

IndexFluent<A>.BitwiseAndExpressionNested<A>

withNewBitwiseAndExpressionLike(BitwiseAnd item)

IndexFluent<A>.BitwiseAndScopeNested<A>

withNewBitwiseAndScope()

A

withNewBitwiseAndScope(Object left, Object right)

IndexFluent<A>.BitwiseAndScopeNested<A>

withNewBitwiseAndScopeLike(BitwiseAnd item)

IndexFluent<A>.BitwiseOrExpressionNested<A>

withNewBitwiseOrExpression()

A

withNewBitwiseOrExpression(Object left, Object right)

IndexFluent<A>.BitwiseOrExpressionNested<A>

withNewBitwiseOrExpressionLike(BitwiseOr item)

IndexFluent<A>.BitwiseOrScopeNested<A>

withNewBitwiseOrScope()

A

withNewBitwiseOrScope(Object left, Object right)

IndexFluent<A>.BitwiseOrScopeNested<A>

withNewBitwiseOrScopeLike(BitwiseOr item)

IndexFluent<A>.CastExpressionNested<A>

withNewCastExpression()

IndexFluent<A>.CastExpressionNested<A>

withNewCastExpressionLike(Cast item)

IndexFluent<A>.CastScopeNested<A>

withNewCastScope()

IndexFluent<A>.CastScopeNested<A>

withNewCastScopeLike(Cast item)

IndexFluent<A>.ConstructExpressionNested<A>

withNewConstructExpression()

IndexFluent<A>.ConstructExpressionNested<A>

withNewConstructExpressionLike(Construct item)

IndexFluent<A>.ConstructScopeNested<A>

withNewConstructScope()

IndexFluent<A>.ConstructScopeNested<A>

withNewConstructScopeLike(Construct item)

IndexFluent<A>.DeclareExpressionNested<A>

withNewDeclareExpression()

A

withNewDeclareExpression(Class type, String name)

A

withNewDeclareExpression(Class type, String name, Object value)

IndexFluent<A>.DeclareExpressionNested<A>

withNewDeclareExpressionLike(Declare item)

IndexFluent<A>.DeclareScopeNested<A>

withNewDeclareScope()

A

withNewDeclareScope(Class type, String name)

A

withNewDeclareScope(Class type, String name, Object value)

IndexFluent<A>.DeclareScopeNested<A>

withNewDeclareScopeLike(Declare item)

IndexFluent<A>.DivideExpressionNested<A>

withNewDivideExpression()

A

withNewDivideExpression(Object left, Object right)

IndexFluent<A>.DivideExpressionNested<A>

withNewDivideExpressionLike(Divide item)

IndexFluent<A>.DivideScopeNested<A>

withNewDivideScope()

A

withNewDivideScope(Object left, Object right)

IndexFluent<A>.DivideScopeNested<A>

withNewDivideScopeLike(Divide item)

IndexFluent<A>.EnclosedExpressionNested<A>

withNewEnclosedExpression()

IndexFluent<A>.EnclosedExpressionNested<A>

withNewEnclosedExpressionLike(Enclosed item)

IndexFluent<A>.EnclosedScopeNested<A>

withNewEnclosedScope()

IndexFluent<A>.EnclosedScopeNested<A>

withNewEnclosedScopeLike(Enclosed item)

IndexFluent<A>.EqualsExpressionNested<A>

withNewEqualsExpression()

A

withNewEqualsExpression(Object left, Object right)

IndexFluent<A>.EqualsExpressionNested<A>

withNewEqualsExpressionLike(Equals item)

IndexFluent<A>.EqualsScopeNested<A>

withNewEqualsScope()

A

withNewEqualsScope(Object left, Object right)

IndexFluent<A>.EqualsScopeNested<A>

withNewEqualsScopeLike(Equals item)

IndexFluent<A>.GreaterThanExpressionNested<A>

withNewGreaterThanExpression()

A

withNewGreaterThanExpression(Object left, Object right)

IndexFluent<A>.GreaterThanExpressionNested<A>

withNewGreaterThanExpressionLike(GreaterThan item)

IndexFluent<A>.GreaterThanOrEqualExpressionNested<A>

withNewGreaterThanOrEqualExpression()

A

withNewGreaterThanOrEqualExpression(Object left, Object right)

IndexFluent<A>.GreaterThanOrEqualExpressionNested<A>

withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)

IndexFluent<A>.GreaterThanOrEqualScopeNested<A>

withNewGreaterThanOrEqualScope()

A

withNewGreaterThanOrEqualScope(Object left, Object right)

IndexFluent<A>.GreaterThanOrEqualScopeNested<A>

withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item)

IndexFluent<A>.GreaterThanScopeNested<A>

withNewGreaterThanScope()

A

withNewGreaterThanScope(Object left, Object right)

IndexFluent<A>.GreaterThanScopeNested<A>

withNewGreaterThanScopeLike(GreaterThan item)

IndexFluent<A>.IndexExpressionNested<A>

withNewIndexExpression()

IndexFluent<A>.IndexExpressionNested<A>

withNewIndexExpressionLike(Index item)

IndexFluent<A>.IndexScopeNested<A>

withNewIndexScope()

IndexFluent<A>.IndexScopeNested<A>

withNewIndexScopeLike(Index item)

IndexFluent<A>.InstanceOfExpressionNested<A>

withNewInstanceOfExpression()

IndexFluent<A>.InstanceOfExpressionNested<A>

withNewInstanceOfExpressionLike(InstanceOf item)

IndexFluent<A>.InstanceOfScopeNested<A>

withNewInstanceOfScope()

IndexFluent<A>.InstanceOfScopeNested<A>

withNewInstanceOfScopeLike(InstanceOf item)

IndexFluent<A>.InverseExpressionNested<A>

withNewInverseExpression()

IndexFluent<A>.InverseExpressionNested<A>

withNewInverseExpressionLike(Inverse item)

IndexFluent<A>.InverseScopeNested<A>

withNewInverseScope()

IndexFluent<A>.InverseScopeNested<A>

withNewInverseScopeLike(Inverse item)

IndexFluent<A>.LambdaExpressionNested<A>

withNewLambdaExpression()

IndexFluent<A>.LambdaExpressionNested<A>

withNewLambdaExpressionLike(Lambda item)

IndexFluent<A>.LambdaScopeNested<A>

withNewLambdaScope()

IndexFluent<A>.LambdaScopeNested<A>

withNewLambdaScopeLike(Lambda item)

IndexFluent<A>.LeftShiftExpressionNested<A>

withNewLeftShiftExpression()

A

withNewLeftShiftExpression(Object left, Object right)

IndexFluent<A>.LeftShiftExpressionNested<A>

withNewLeftShiftExpressionLike(LeftShift item)

IndexFluent<A>.LeftShiftScopeNested<A>

withNewLeftShiftScope()

A

withNewLeftShiftScope(Object left, Object right)

IndexFluent<A>.LeftShiftScopeNested<A>

withNewLeftShiftScopeLike(LeftShift item)

IndexFluent<A>.LessThanExpressionNested<A>

withNewLessThanExpression()

A

withNewLessThanExpression(Object left, Object right)

IndexFluent<A>.LessThanExpressionNested<A>

withNewLessThanExpressionLike(LessThan item)

IndexFluent<A>.LessThanOrEqualExpressionNested<A>

withNewLessThanOrEqualExpression()

A

withNewLessThanOrEqualExpression(Object left, Object right)

IndexFluent<A>.LessThanOrEqualExpressionNested<A>

withNewLessThanOrEqualExpressionLike(LessThanOrEqual item)

IndexFluent<A>.LessThanOrEqualScopeNested<A>

withNewLessThanOrEqualScope()

A

withNewLessThanOrEqualScope(Object left, Object right)

IndexFluent<A>.LessThanOrEqualScopeNested<A>

withNewLessThanOrEqualScopeLike(LessThanOrEqual item)

IndexFluent<A>.LessThanScopeNested<A>

withNewLessThanScope()

A

withNewLessThanScope(Object left, Object right)

IndexFluent<A>.LessThanScopeNested<A>

withNewLessThanScopeLike(LessThan item)

IndexFluent<A>.LogicalAndExpressionNested<A>

withNewLogicalAndExpression()

A

withNewLogicalAndExpression(Object left, Object right)

IndexFluent<A>.LogicalAndExpressionNested<A>

withNewLogicalAndExpressionLike(LogicalAnd item)

IndexFluent<A>.LogicalAndScopeNested<A>

withNewLogicalAndScope()

A

withNewLogicalAndScope(Object left, Object right)

IndexFluent<A>.LogicalAndScopeNested<A>

withNewLogicalAndScopeLike(LogicalAnd item)

IndexFluent<A>.LogicalOrExpressionNested<A>

withNewLogicalOrExpression()

A

withNewLogicalOrExpression(Object left, Object right)

IndexFluent<A>.LogicalOrExpressionNested<A>

withNewLogicalOrExpressionLike(LogicalOr item)

IndexFluent<A>.LogicalOrScopeNested<A>

withNewLogicalOrScope()

A

withNewLogicalOrScope(Object left, Object right)

IndexFluent<A>.LogicalOrScopeNested<A>

withNewLogicalOrScopeLike(LogicalOr item)

IndexFluent<A>.MethodCallExpressionNested<A>

withNewMethodCallExpression()

IndexFluent<A>.MethodCallExpressionNested<A>

withNewMethodCallExpressionLike(MethodCall item)

IndexFluent<A>.MethodCallScopeNested<A>

withNewMethodCallScope()

IndexFluent<A>.MethodCallScopeNested<A>

withNewMethodCallScopeLike(MethodCall item)

IndexFluent<A>.MinusExpressionNested<A>

withNewMinusExpression()

A

withNewMinusExpression(Object left, Object right)

IndexFluent<A>.MinusExpressionNested<A>

withNewMinusExpressionLike(Minus item)

IndexFluent<A>.MinusScopeNested<A>

withNewMinusScope()

A

withNewMinusScope(Object left, Object right)

IndexFluent<A>.MinusScopeNested<A>

withNewMinusScopeLike(Minus item)

IndexFluent<A>.ModuloExpressionNested<A>

withNewModuloExpression()

A

withNewModuloExpression(Object left, Object right)

IndexFluent<A>.ModuloExpressionNested<A>

withNewModuloExpressionLike(Modulo item)

IndexFluent<A>.ModuloScopeNested<A>

withNewModuloScope()

A

withNewModuloScope(Object left, Object right)

IndexFluent<A>.ModuloScopeNested<A>

withNewModuloScopeLike(Modulo item)

IndexFluent<A>.MultiplyExpressionNested<A>

withNewMultiplyExpression()

A

withNewMultiplyExpression(Object left, Object right)

IndexFluent<A>.MultiplyExpressionNested<A>

withNewMultiplyExpressionLike(Multiply item)

IndexFluent<A>.MultiplyScopeNested<A>

withNewMultiplyScope()

A

withNewMultiplyScope(Object left, Object right)

IndexFluent<A>.MultiplyScopeNested<A>

withNewMultiplyScopeLike(Multiply item)

IndexFluent<A>.NegativeExpressionNested<A>

withNewNegativeExpression()

IndexFluent<A>.NegativeExpressionNested<A>

withNewNegativeExpressionLike(Negative item)

IndexFluent<A>.NegativeScopeNested<A>

withNewNegativeScope()

IndexFluent<A>.NegativeScopeNested<A>

withNewNegativeScopeLike(Negative item)

IndexFluent<A>.NewArrayExpressionNested<A>

withNewNewArrayExpression()

A

withNewNewArrayExpression(Class type, Integer[] sizes)

IndexFluent<A>.NewArrayExpressionNested<A>

withNewNewArrayExpressionLike(NewArray item)

IndexFluent<A>.NewArrayScopeNested<A>

withNewNewArrayScope()

A

withNewNewArrayScope(Class type, Integer[] sizes)

IndexFluent<A>.NewArrayScopeNested<A>

withNewNewArrayScopeLike(NewArray item)

IndexFluent<A>.NotEqualsExpressionNested<A>

withNewNotEqualsExpression()

A

withNewNotEqualsExpression(Object left, Object right)

IndexFluent<A>.NotEqualsExpressionNested<A>

withNewNotEqualsExpressionLike(NotEquals item)

IndexFluent<A>.NotEqualsScopeNested<A>

withNewNotEqualsScope()

A

withNewNotEqualsScope(Object left, Object right)

IndexFluent<A>.NotEqualsScopeNested<A>

withNewNotEqualsScopeLike(NotEquals item)

IndexFluent<A>.NotExpressionNested<A>

withNewNotExpression()

IndexFluent<A>.NotExpressionNested<A>

withNewNotExpressionLike(Not item)

IndexFluent<A>.NotScopeNested<A>

withNewNotScope()

IndexFluent<A>.NotScopeNested<A>

withNewNotScopeLike(Not item)

IndexFluent<A>.PlusExpressionNested<A>

withNewPlusExpression()

A

withNewPlusExpression(Object left, Object right)

IndexFluent<A>.PlusExpressionNested<A>

withNewPlusExpressionLike(Plus item)

IndexFluent<A>.PlusScopeNested<A>

withNewPlusScope()

A

withNewPlusScope(Object left, Object right)

IndexFluent<A>.PlusScopeNested<A>

withNewPlusScopeLike(Plus item)

IndexFluent<A>.PositiveExpressionNested<A>

withNewPositiveExpression()

IndexFluent<A>.PositiveExpressionNested<A>

withNewPositiveExpressionLike(Positive item)

IndexFluent<A>.PositiveScopeNested<A>

withNewPositiveScope()

IndexFluent<A>.PositiveScopeNested<A>

withNewPositiveScopeLike(Positive item)

IndexFluent<A>.PostDecrementExpressionNested<A>

withNewPostDecrementExpression()

IndexFluent<A>.PostDecrementExpressionNested<A>

withNewPostDecrementExpressionLike(PostDecrement item)

IndexFluent<A>.PostDecrementScopeNested<A>

withNewPostDecrementScope()

IndexFluent<A>.PostDecrementScopeNested<A>

withNewPostDecrementScopeLike(PostDecrement item)

IndexFluent<A>.PostIncrementExpressionNested<A>

withNewPostIncrementExpression()

IndexFluent<A>.PostIncrementExpressionNested<A>

withNewPostIncrementExpressionLike(PostIncrement item)

IndexFluent<A>.PostIncrementScopeNested<A>

withNewPostIncrementScope()

IndexFluent<A>.PostIncrementScopeNested<A>

withNewPostIncrementScopeLike(PostIncrement item)

IndexFluent<A>.PreDecrementExpressionNested<A>

withNewPreDecrementExpression()

IndexFluent<A>.PreDecrementExpressionNested<A>

withNewPreDecrementExpressionLike(PreDecrement item)

IndexFluent<A>.PreDecrementScopeNested<A>

withNewPreDecrementScope()

IndexFluent<A>.PreDecrementScopeNested<A>

withNewPreDecrementScopeLike(PreDecrement item)

IndexFluent<A>.PreIncrementExpressionNested<A>

withNewPreIncrementExpression()

IndexFluent<A>.PreIncrementExpressionNested<A>

withNewPreIncrementExpressionLike(PreIncrement item)

IndexFluent<A>.PreIncrementScopeNested<A>

withNewPreIncrementScope()

IndexFluent<A>.PreIncrementScopeNested<A>

withNewPreIncrementScopeLike(PreIncrement item)

IndexFluent<A>.PropertyRefExpressionNested<A>

withNewPropertyRefExpression()

IndexFluent<A>.PropertyRefExpressionNested<A>

withNewPropertyRefExpressionLike(PropertyRef item)

IndexFluent<A>.PropertyRefScopeNested<A>

withNewPropertyRefScope()

IndexFluent<A>.PropertyRefScopeNested<A>

withNewPropertyRefScopeLike(PropertyRef item)

IndexFluent<A>.RightShiftExpressionNested<A>

withNewRightShiftExpression()

A

withNewRightShiftExpression(Object left, Object right)

IndexFluent<A>.RightShiftExpressionNested<A>

withNewRightShiftExpressionLike(RightShift item)

IndexFluent<A>.RightShiftScopeNested<A>

withNewRightShiftScope()

A

withNewRightShiftScope(Object left, Object right)

IndexFluent<A>.RightShiftScopeNested<A>

withNewRightShiftScopeLike(RightShift item)

IndexFluent<A>.RightUnsignedShiftExpressionNested<A>

withNewRightUnsignedShiftExpression()

A

withNewRightUnsignedShiftExpression(Object left, Object right)

IndexFluent<A>.RightUnsignedShiftExpressionNested<A>

withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)

IndexFluent<A>.RightUnsignedShiftScopeNested<A>

withNewRightUnsignedShiftScope()

A

withNewRightUnsignedShiftScope(Object left, Object right)

IndexFluent<A>.RightUnsignedShiftScopeNested<A>

withNewRightUnsignedShiftScopeLike(RightUnsignedShift item)

IndexFluent<A>.TernaryExpressionNested<A>

withNewTernaryExpression()

IndexFluent<A>.TernaryExpressionNested<A>

withNewTernaryExpressionLike(Ternary item)

IndexFluent<A>.TernaryScopeNested<A>

withNewTernaryScope()

IndexFluent<A>.TernaryScopeNested<A>

withNewTernaryScopeLike(Ternary item)

IndexFluent<A>.ThisExpressionNested<A>

withNewThisExpression()

IndexFluent<A>.ThisExpressionNested<A>

withNewThisExpressionLike(This item)

IndexFluent<A>.ThisScopeNested<A>

withNewThisScope()

IndexFluent<A>.ThisScopeNested<A>

withNewThisScopeLike(This item)

IndexFluent<A>.ValueRefExpressionNested<A>

withNewValueRefExpression()

A

withNewValueRefExpression(Object value)

IndexFluent<A>.ValueRefExpressionNested<A>

withNewValueRefExpressionLike(ValueRef item)

IndexFluent<A>.ValueRefScopeNested<A>

withNewValueRefScope()

A

withNewValueRefScope(Object value)

IndexFluent<A>.ValueRefScopeNested<A>

withNewValueRefScopeLike(ValueRef item)

IndexFluent<A>.XorExpressionNested<A>

withNewXorExpression()

A

withNewXorExpression(Object left, Object right)

IndexFluent<A>.XorExpressionNested<A>

withNewXorExpressionLike(Xor item)

IndexFluent<A>.XorScopeNested<A>

withNewXorScope()

A

withNewXorScope(Object left, Object right)

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

Class IndexFluent<A extends IndexFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.sundr.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Details

IndexFluent

IndexFluent

Method Details

copyInstance

buildScope

withScope

hasScope

withNewMultiplyScope

withNewMultiplyScopeLike

withNewMultiplyScope

withNewNewArrayScope

withNewNewArrayScopeLike

withNewNewArrayScope

withNewInstanceOfScope

withNewInstanceOfScopeLike

withNewMethodCallScope

withNewMethodCallScopeLike

withNewInverseScope

withNewInverseScopeLike

withNewIndexScope

withNewIndexScopeLike

withNewGreaterThanOrEqualScope

withNewGreaterThanOrEqualScopeLike

withNewGreaterThanOrEqualScope

withNewBitwiseAndScope

withNewBitwiseAndScopeLike

withNewBitwiseAndScope

withNewMinusScope

withNewMinusScopeLike

withNewMinusScope

withNewLogicalOrScope

withNewLogicalOrScopeLike

withNewLogicalOrScope

withNewNotEqualsScope

withNewNotEqualsScopeLike

withNewNotEqualsScope

withNewDivideScope

withNewDivideScopeLike

withNewDivideScope

withNewLessThanScope

withNewLessThanScopeLike

withNewLessThanScope

withNewBitwiseOrScope

withNewBitwiseOrScopeLike

withNewBitwiseOrScope

withNewPropertyRefScope

withNewPropertyRefScopeLike

withNewRightShiftScope

withNewRightShiftScopeLike

withNewRightShiftScope

withNewGreaterThanScope

withNewGreaterThanScopeLike

withNewGreaterThanScope

withNewDeclareScope

withNewDeclareScopeLike

withNewDeclareScope

withNewDeclareScope

withNewCastScope

withNewCastScopeLike

withNewModuloScope

withNewModuloScopeLike

withNewModuloScope

withNewValueRefScope

withNewValueRefScopeLike

withNewValueRefScope

withNewLeftShiftScope

withNewLeftShiftScopeLike

withNewLeftShiftScope

withNewTernaryScope

withNewTernaryScopeLike

withNewBinaryExpressionScope