Package io.sundr.model

Class NewArrayFluent<A extends NewArrayFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.NewArrayFluent<A>

Direct Known Subclasses:

AssignFluent.NewArrayTargetNested, AssignFluent.NewArrayValueNested, BinaryExpressionFluent.NewArrayLeftNested, BinaryExpressionFluent.NewArrayRightNested, CastFluent.NewArrayExpressionNested, ConstructFluent.NewArrayArgumentsNested, DeclareFluent.NewArrayValueNested, DoFluent.NewArrayConditionNested, EnclosedFluent.NewArrayExpresionNested, ForeachFluent.NewArrayExpressionNested, ForFluent.NewArrayCompareNested, ForFluent.NewArrayInitNested, ForFluent.NewArrayUpdateNested, IfDslConditionStepFluent.NewArrayConditionNested, IfDslThenStepFluent.NewArrayConditionNested, IfFluent.NewArrayConditionNested, IndexFluent.NewArrayExpressionNested, InstanceOfFluent.NewArrayExpressionNested, InverseFluent.NewArrayExpresionNested, MethodCallFluent.NewArrayArgumentsNested, NegativeFluent.NewArrayExpresionNested, NewArrayBuilder, NewArrayFluent.NewArrayExpressionsNested, NotFluent.NewArrayExpresionNested, PositiveFluent.NewArrayExpresionNested, PostDecrementFluent.NewArrayExpressionNested, PostIncrementFluent.NewArrayExpressionNested, PreDecrementFluent.NewArrayExpressionNested, PreIncrementFluent.NewArrayExpressionNested, PropertyFluent.NewArrayInitialValueNested, ReturnFluent.NewArrayExpressionNested, SwitchFluent.NewArrayExpressionNested, SynchronizedFluent.NewArrayLockExpressionNested, TernaryFluent.NewArrayAlternativeNested, TernaryFluent.NewArrayConditionNested, TernaryFluent.NewArrayResultNested, ThrowFluent.NewArrayExceptionNested, WhileFluent.NewArrayConditionNested, WithScopeFluent.NewArrayScopeNested

public class NewArrayFluent<A extends NewArrayFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	NewArrayFluent.AssignExpressionsNested<N>
class	NewArrayFluent.BinaryExpressionExpressionsNested<N>
class	NewArrayFluent.BitwiseAndExpressionsNested<N>
class	NewArrayFluent.BitwiseOrExpressionsNested<N>
class	NewArrayFluent.CastExpressionsNested<N>
class	NewArrayFluent.ClassRefExpressionsNested<N>
class	NewArrayFluent.ClassRefTypeNested<N>
class	NewArrayFluent.ConstructExpressionsNested<N>
class	NewArrayFluent.ContextRefExpressionsNested<N>
class	NewArrayFluent.DeclareExpressionsNested<N>
class	NewArrayFluent.DivideExpressionsNested<N>
class	NewArrayFluent.DotClassExpressionsNested<N>
class	NewArrayFluent.EmptyExpressionsNested<N>
class	NewArrayFluent.EnclosedExpressionsNested<N>
class	NewArrayFluent.EqualsExpressionsNested<N>
class	NewArrayFluent.GreaterThanExpressionsNested<N>
class	NewArrayFluent.GreaterThanOrEqualExpressionsNested<N>
class	NewArrayFluent.IndexExpressionsNested<N>
class	NewArrayFluent.InstanceOfExpressionsNested<N>
class	NewArrayFluent.InverseExpressionsNested<N>
class	NewArrayFluent.LambdaExpressionsNested<N>
class	NewArrayFluent.LeftShiftExpressionsNested<N>
class	NewArrayFluent.LessThanExpressionsNested<N>
class	NewArrayFluent.LessThanOrEqualExpressionsNested<N>
class	NewArrayFluent.LogicalAndExpressionsNested<N>
class	NewArrayFluent.LogicalOrExpressionsNested<N>
class	NewArrayFluent.MethodCallExpressionsNested<N>
class	NewArrayFluent.MinusExpressionsNested<N>
class	NewArrayFluent.ModuloExpressionsNested<N>
class	NewArrayFluent.MultiplyExpressionsNested<N>
class	NewArrayFluent.NegativeExpressionsNested<N>
class	NewArrayFluent.NewArrayExpressionsNested<N>
class	NewArrayFluent.NotEqualsExpressionsNested<N>
class	NewArrayFluent.NotExpressionsNested<N>
class	NewArrayFluent.PlusExpressionsNested<N>
class	NewArrayFluent.PositiveExpressionsNested<N>
class	NewArrayFluent.PostDecrementExpressionsNested<N>
class	NewArrayFluent.PostIncrementExpressionsNested<N>
class	NewArrayFluent.PreDecrementExpressionsNested<N>
class	NewArrayFluent.PreIncrementExpressionsNested<N>
class	NewArrayFluent.PrimitiveRefTypeNested<N>
class	NewArrayFluent.PropertyExpressionsNested<N>
class	NewArrayFluent.PropertyRefExpressionsNested<N>
class	NewArrayFluent.RightShiftExpressionsNested<N>
class	NewArrayFluent.RightUnsignedShiftExpressionsNested<N>
class	NewArrayFluent.SuperExpressionsNested<N>
class	NewArrayFluent.TernaryExpressionsNested<N>
class	NewArrayFluent.ThisExpressionsNested<N>
class	NewArrayFluent.TypeParamRefTypeNested<N>
class	NewArrayFluent.ValueRefExpressionsNested<N>
class	NewArrayFluent.VoidRefTypeNested<N>
class	NewArrayFluent.WildcardRefTypeNested<N>
class	NewArrayFluent.XorExpressionsNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
NewArrayFluent()
NewArrayFluent(NewArray instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToExpressions(Collection<Expression> items)
NewArrayFluent<A>.AssignExpressionsNested<A>	addNewAssignExpression()
NewArrayFluent<A>.AssignExpressionsNested<A>	addNewAssignExpressionLike(Assign item)
NewArrayFluent<A>.BinaryExpressionExpressionsNested<A>	addNewBinaryExpressionExpression()
NewArrayFluent<A>.BinaryExpressionExpressionsNested<A>	addNewBinaryExpressionExpressionLike(BinaryExpression item)
NewArrayFluent<A>.BitwiseAndExpressionsNested<A>	addNewBitwiseAndExpression()
A	addNewBitwiseAndExpression(Object left, Object right)
NewArrayFluent<A>.BitwiseAndExpressionsNested<A>	addNewBitwiseAndExpressionLike(BitwiseAnd item)
NewArrayFluent<A>.BitwiseOrExpressionsNested<A>	addNewBitwiseOrExpression()
A	addNewBitwiseOrExpression(Object left, Object right)
NewArrayFluent<A>.BitwiseOrExpressionsNested<A>	addNewBitwiseOrExpressionLike(BitwiseOr item)
NewArrayFluent<A>.CastExpressionsNested<A>	addNewCastExpression()
NewArrayFluent<A>.CastExpressionsNested<A>	addNewCastExpressionLike(Cast item)
NewArrayFluent<A>.ClassRefExpressionsNested<A>	addNewClassRefExpression()
NewArrayFluent<A>.ClassRefExpressionsNested<A>	addNewClassRefExpressionLike(ClassRef item)
NewArrayFluent<A>.ConstructExpressionsNested<A>	addNewConstructExpression()
NewArrayFluent<A>.ConstructExpressionsNested<A>	addNewConstructExpressionLike(Construct item)
NewArrayFluent<A>.ContextRefExpressionsNested<A>	addNewContextRefExpression()
A	addNewContextRefExpression(String name)
NewArrayFluent<A>.ContextRefExpressionsNested<A>	addNewContextRefExpressionLike(ContextRef item)
NewArrayFluent<A>.DeclareExpressionsNested<A>	addNewDeclareExpression()
A	addNewDeclareExpression(Class type, String name)
A	addNewDeclareExpression(Class type, String name, Object value)
NewArrayFluent<A>.DeclareExpressionsNested<A>	addNewDeclareExpressionLike(Declare item)
NewArrayFluent<A>.DivideExpressionsNested<A>	addNewDivideExpression()
A	addNewDivideExpression(Object left, Object right)
NewArrayFluent<A>.DivideExpressionsNested<A>	addNewDivideExpressionLike(Divide item)
NewArrayFluent<A>.DotClassExpressionsNested<A>	addNewDotClassExpression()
NewArrayFluent<A>.DotClassExpressionsNested<A>	addNewDotClassExpressionLike(DotClass item)
NewArrayFluent<A>.EmptyExpressionsNested<A>	addNewEmptyExpression()
NewArrayFluent<A>.EmptyExpressionsNested<A>	addNewEmptyExpressionLike(Empty item)
NewArrayFluent<A>.EnclosedExpressionsNested<A>	addNewEnclosedExpression()
NewArrayFluent<A>.EnclosedExpressionsNested<A>	addNewEnclosedExpressionLike(Enclosed item)
NewArrayFluent<A>.EqualsExpressionsNested<A>	addNewEqualsExpression()
A	addNewEqualsExpression(Object left, Object right)
NewArrayFluent<A>.EqualsExpressionsNested<A>	addNewEqualsExpressionLike(Equals item)
NewArrayFluent<A>.GreaterThanExpressionsNested<A>	addNewGreaterThanExpression()
A	addNewGreaterThanExpression(Object left, Object right)
NewArrayFluent<A>.GreaterThanExpressionsNested<A>	addNewGreaterThanExpressionLike(GreaterThan item)
NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A>	addNewGreaterThanOrEqualExpression()
A	addNewGreaterThanOrEqualExpression(Object left, Object right)
NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A>	addNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
NewArrayFluent<A>.IndexExpressionsNested<A>	addNewIndexExpression()
NewArrayFluent<A>.IndexExpressionsNested<A>	addNewIndexExpressionLike(Index item)
NewArrayFluent<A>.InstanceOfExpressionsNested<A>	addNewInstanceOfExpression()
NewArrayFluent<A>.InstanceOfExpressionsNested<A>	addNewInstanceOfExpressionLike(InstanceOf item)
NewArrayFluent<A>.InverseExpressionsNested<A>	addNewInverseExpression()
NewArrayFluent<A>.InverseExpressionsNested<A>	addNewInverseExpressionLike(Inverse item)
NewArrayFluent<A>.LambdaExpressionsNested<A>	addNewLambdaExpression()
NewArrayFluent<A>.LambdaExpressionsNested<A>	addNewLambdaExpressionLike(Lambda item)
NewArrayFluent<A>.LeftShiftExpressionsNested<A>	addNewLeftShiftExpression()
A	addNewLeftShiftExpression(Object left, Object right)
NewArrayFluent<A>.LeftShiftExpressionsNested<A>	addNewLeftShiftExpressionLike(LeftShift item)
NewArrayFluent<A>.LessThanExpressionsNested<A>	addNewLessThanExpression()
A	addNewLessThanExpression(Object left, Object right)
NewArrayFluent<A>.LessThanExpressionsNested<A>	addNewLessThanExpressionLike(LessThan item)
NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A>	addNewLessThanOrEqualExpression()
A	addNewLessThanOrEqualExpression(Object left, Object right)
NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A>	addNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
NewArrayFluent<A>.LogicalAndExpressionsNested<A>	addNewLogicalAndExpression()
A	addNewLogicalAndExpression(Object left, Object right)
NewArrayFluent<A>.LogicalAndExpressionsNested<A>	addNewLogicalAndExpressionLike(LogicalAnd item)
NewArrayFluent<A>.LogicalOrExpressionsNested<A>	addNewLogicalOrExpression()
A	addNewLogicalOrExpression(Object left, Object right)
NewArrayFluent<A>.LogicalOrExpressionsNested<A>	addNewLogicalOrExpressionLike(LogicalOr item)
NewArrayFluent<A>.MethodCallExpressionsNested<A>	addNewMethodCallExpression()
NewArrayFluent<A>.MethodCallExpressionsNested<A>	addNewMethodCallExpressionLike(MethodCall item)
NewArrayFluent<A>.MinusExpressionsNested<A>	addNewMinusExpression()
A	addNewMinusExpression(Object left, Object right)
NewArrayFluent<A>.MinusExpressionsNested<A>	addNewMinusExpressionLike(Minus item)
NewArrayFluent<A>.ModuloExpressionsNested<A>	addNewModuloExpression()
A	addNewModuloExpression(Object left, Object right)
NewArrayFluent<A>.ModuloExpressionsNested<A>	addNewModuloExpressionLike(Modulo item)
NewArrayFluent<A>.MultiplyExpressionsNested<A>	addNewMultiplyExpression()
A	addNewMultiplyExpression(Object left, Object right)
NewArrayFluent<A>.MultiplyExpressionsNested<A>	addNewMultiplyExpressionLike(Multiply item)
NewArrayFluent<A>.NegativeExpressionsNested<A>	addNewNegativeExpression()
NewArrayFluent<A>.NegativeExpressionsNested<A>	addNewNegativeExpressionLike(Negative item)
NewArrayFluent<A>.NewArrayExpressionsNested<A>	addNewNewArrayExpression()
A	addNewNewArrayExpression(Class type, Integer[] sizes)
NewArrayFluent<A>.NewArrayExpressionsNested<A>	addNewNewArrayExpressionLike(NewArray item)
NewArrayFluent<A>.NotEqualsExpressionsNested<A>	addNewNotEqualsExpression()
A	addNewNotEqualsExpression(Object left, Object right)
NewArrayFluent<A>.NotEqualsExpressionsNested<A>	addNewNotEqualsExpressionLike(NotEquals item)
NewArrayFluent<A>.NotExpressionsNested<A>	addNewNotExpression()
NewArrayFluent<A>.NotExpressionsNested<A>	addNewNotExpressionLike(Not item)
NewArrayFluent<A>.PlusExpressionsNested<A>	addNewPlusExpression()
A	addNewPlusExpression(Object left, Object right)
NewArrayFluent<A>.PlusExpressionsNested<A>	addNewPlusExpressionLike(Plus item)
NewArrayFluent<A>.PositiveExpressionsNested<A>	addNewPositiveExpression()
NewArrayFluent<A>.PositiveExpressionsNested<A>	addNewPositiveExpressionLike(Positive item)
NewArrayFluent<A>.PostDecrementExpressionsNested<A>	addNewPostDecrementExpression()
NewArrayFluent<A>.PostDecrementExpressionsNested<A>	addNewPostDecrementExpressionLike(PostDecrement item)
NewArrayFluent<A>.PostIncrementExpressionsNested<A>	addNewPostIncrementExpression()
NewArrayFluent<A>.PostIncrementExpressionsNested<A>	addNewPostIncrementExpressionLike(PostIncrement item)
NewArrayFluent<A>.PreDecrementExpressionsNested<A>	addNewPreDecrementExpression()
NewArrayFluent<A>.PreDecrementExpressionsNested<A>	addNewPreDecrementExpressionLike(PreDecrement item)
NewArrayFluent<A>.PreIncrementExpressionsNested<A>	addNewPreIncrementExpression()
NewArrayFluent<A>.PreIncrementExpressionsNested<A>	addNewPreIncrementExpressionLike(PreIncrement item)
NewArrayFluent<A>.PropertyExpressionsNested<A>	addNewPropertyExpression()
NewArrayFluent<A>.PropertyExpressionsNested<A>	addNewPropertyExpressionLike(Property item)
NewArrayFluent<A>.PropertyRefExpressionsNested<A>	addNewPropertyRefExpression()
NewArrayFluent<A>.PropertyRefExpressionsNested<A>	addNewPropertyRefExpressionLike(PropertyRef item)
NewArrayFluent<A>.RightShiftExpressionsNested<A>	addNewRightShiftExpression()
A	addNewRightShiftExpression(Object left, Object right)
NewArrayFluent<A>.RightShiftExpressionsNested<A>	addNewRightShiftExpressionLike(RightShift item)
NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A>	addNewRightUnsignedShiftExpression()
A	addNewRightUnsignedShiftExpression(Object left, Object right)
NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A>	addNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
NewArrayFluent<A>.SuperExpressionsNested<A>	addNewSuperExpression()
NewArrayFluent<A>.SuperExpressionsNested<A>	addNewSuperExpressionLike(Super item)
NewArrayFluent<A>.TernaryExpressionsNested<A>	addNewTernaryExpression()
NewArrayFluent<A>.TernaryExpressionsNested<A>	addNewTernaryExpressionLike(Ternary item)
NewArrayFluent<A>.ThisExpressionsNested<A>	addNewThisExpression()
NewArrayFluent<A>.ThisExpressionsNested<A>	addNewThisExpressionLike(This item)
NewArrayFluent<A>.ValueRefExpressionsNested<A>	addNewValueRefExpression()
A	addNewValueRefExpression(Object value)
NewArrayFluent<A>.ValueRefExpressionsNested<A>	addNewValueRefExpressionLike(ValueRef item)
NewArrayFluent<A>.XorExpressionsNested<A>	addNewXorExpression()
A	addNewXorExpression(Object left, Object right)
NewArrayFluent<A>.XorExpressionsNested<A>	addNewXorExpressionLike(Xor item)
A	addToExpressions(int index, VisitableBuilder<? extends Expression,?> builder)
A	addToExpressions(int index, Expression item)
A	addToExpressions(VisitableBuilder<? extends Expression,?> builder)
A	addToExpressions(Expression... items)
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildExpression(int index)
List<Expression>	buildExpressions()
Expression	buildFirstExpression()
Expression	buildLastExpression()
Expression	buildMatchingExpression(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
TypeRef	buildType()
protected void	copyInstance(NewArray instance)
boolean	equals(Object o)
boolean	hasExpressions()
int	hashCode()
boolean	hasMatchingExpression(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
boolean	hasType()
A	removeAllFromExpressions(Collection<Expression> items)
A	removeFromExpressions(VisitableBuilder<? extends Expression,?> builder)
A	removeFromExpressions(Expression... items)
A	removeMatchingFromExpressions(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
NewArrayFluent<A>.AssignExpressionsNested<A>	setNewAssignExpressionLike(int index, Assign item)
NewArrayFluent<A>.BinaryExpressionExpressionsNested<A>	setNewBinaryExpressionExpressionLike(int index, BinaryExpression item)
NewArrayFluent<A>.BitwiseAndExpressionsNested<A>	setNewBitwiseAndExpressionLike(int index, BitwiseAnd item)
NewArrayFluent<A>.BitwiseOrExpressionsNested<A>	setNewBitwiseOrExpressionLike(int index, BitwiseOr item)
NewArrayFluent<A>.CastExpressionsNested<A>	setNewCastExpressionLike(int index, Cast item)
NewArrayFluent<A>.ClassRefExpressionsNested<A>	setNewClassRefExpressionLike(int index, ClassRef item)
NewArrayFluent<A>.ConstructExpressionsNested<A>	setNewConstructExpressionLike(int index, Construct item)
NewArrayFluent<A>.ContextRefExpressionsNested<A>	setNewContextRefExpressionLike(int index, ContextRef item)
NewArrayFluent<A>.DeclareExpressionsNested<A>	setNewDeclareExpressionLike(int index, Declare item)
NewArrayFluent<A>.DivideExpressionsNested<A>	setNewDivideExpressionLike(int index, Divide item)
NewArrayFluent<A>.DotClassExpressionsNested<A>	setNewDotClassExpressionLike(int index, DotClass item)
NewArrayFluent<A>.EmptyExpressionsNested<A>	setNewEmptyExpressionLike(int index, Empty item)
NewArrayFluent<A>.EnclosedExpressionsNested<A>	setNewEnclosedExpressionLike(int index, Enclosed item)
NewArrayFluent<A>.EqualsExpressionsNested<A>	setNewEqualsExpressionLike(int index, Equals item)
NewArrayFluent<A>.GreaterThanExpressionsNested<A>	setNewGreaterThanExpressionLike(int index, GreaterThan item)
NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A>	setNewGreaterThanOrEqualExpressionLike(int index, GreaterThanOrEqual item)
NewArrayFluent<A>.IndexExpressionsNested<A>	setNewIndexExpressionLike(int index, Index item)
NewArrayFluent<A>.InstanceOfExpressionsNested<A>	setNewInstanceOfExpressionLike(int index, InstanceOf item)
NewArrayFluent<A>.InverseExpressionsNested<A>	setNewInverseExpressionLike(int index, Inverse item)
NewArrayFluent<A>.LambdaExpressionsNested<A>	setNewLambdaExpressionLike(int index, Lambda item)
NewArrayFluent<A>.LeftShiftExpressionsNested<A>	setNewLeftShiftExpressionLike(int index, LeftShift item)
NewArrayFluent<A>.LessThanExpressionsNested<A>	setNewLessThanExpressionLike(int index, LessThan item)
NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A>	setNewLessThanOrEqualExpressionLike(int index, LessThanOrEqual item)
NewArrayFluent<A>.LogicalAndExpressionsNested<A>	setNewLogicalAndExpressionLike(int index, LogicalAnd item)
NewArrayFluent<A>.LogicalOrExpressionsNested<A>	setNewLogicalOrExpressionLike(int index, LogicalOr item)
NewArrayFluent<A>.MethodCallExpressionsNested<A>	setNewMethodCallExpressionLike(int index, MethodCall item)
NewArrayFluent<A>.MinusExpressionsNested<A>	setNewMinusExpressionLike(int index, Minus item)
NewArrayFluent<A>.ModuloExpressionsNested<A>	setNewModuloExpressionLike(int index, Modulo item)
NewArrayFluent<A>.MultiplyExpressionsNested<A>	setNewMultiplyExpressionLike(int index, Multiply item)
NewArrayFluent<A>.NegativeExpressionsNested<A>	setNewNegativeExpressionLike(int index, Negative item)
NewArrayFluent<A>.NewArrayExpressionsNested<A>	setNewNewArrayExpressionLike(int index, NewArray item)
NewArrayFluent<A>.NotEqualsExpressionsNested<A>	setNewNotEqualsExpressionLike(int index, NotEquals item)
NewArrayFluent<A>.NotExpressionsNested<A>	setNewNotExpressionLike(int index, Not item)
NewArrayFluent<A>.PlusExpressionsNested<A>	setNewPlusExpressionLike(int index, Plus item)
NewArrayFluent<A>.PositiveExpressionsNested<A>	setNewPositiveExpressionLike(int index, Positive item)
NewArrayFluent<A>.PostDecrementExpressionsNested<A>	setNewPostDecrementExpressionLike(int index, PostDecrement item)
NewArrayFluent<A>.PostIncrementExpressionsNested<A>	setNewPostIncrementExpressionLike(int index, PostIncrement item)
NewArrayFluent<A>.PreDecrementExpressionsNested<A>	setNewPreDecrementExpressionLike(int index, PreDecrement item)
NewArrayFluent<A>.PreIncrementExpressionsNested<A>	setNewPreIncrementExpressionLike(int index, PreIncrement item)
NewArrayFluent<A>.PropertyExpressionsNested<A>	setNewPropertyExpressionLike(int index, Property item)
NewArrayFluent<A>.PropertyRefExpressionsNested<A>	setNewPropertyRefExpressionLike(int index, PropertyRef item)
NewArrayFluent<A>.RightShiftExpressionsNested<A>	setNewRightShiftExpressionLike(int index, RightShift item)
NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A>	setNewRightUnsignedShiftExpressionLike(int index, RightUnsignedShift item)
NewArrayFluent<A>.SuperExpressionsNested<A>	setNewSuperExpressionLike(int index, Super item)
NewArrayFluent<A>.TernaryExpressionsNested<A>	setNewTernaryExpressionLike(int index, Ternary item)
NewArrayFluent<A>.ThisExpressionsNested<A>	setNewThisExpressionLike(int index, This item)
NewArrayFluent<A>.ValueRefExpressionsNested<A>	setNewValueRefExpressionLike(int index, ValueRef item)
NewArrayFluent<A>.XorExpressionsNested<A>	setNewXorExpressionLike(int index, Xor item)
A	setToExpressions(int index, Expression item)
String	toString()
A	withExpressions(Expression... expressions)
A	withExpressions(List<Expression> expressions)
NewArrayFluent<A>.ClassRefTypeNested<A>	withNewClassRefType()
NewArrayFluent<A>.ClassRefTypeNested<A>	withNewClassRefTypeLike(ClassRef item)
NewArrayFluent<A>.PrimitiveRefTypeNested<A>	withNewPrimitiveRefType()
NewArrayFluent<A>.PrimitiveRefTypeNested<A>	withNewPrimitiveRefTypeLike(PrimitiveRef item)
NewArrayFluent<A>.TypeParamRefTypeNested<A>	withNewTypeParamRefType()
NewArrayFluent<A>.TypeParamRefTypeNested<A>	withNewTypeParamRefTypeLike(TypeParamRef item)
NewArrayFluent<A>.VoidRefTypeNested<A>	withNewVoidRefType()
NewArrayFluent<A>.VoidRefTypeNested<A>	withNewVoidRefTypeLike(VoidRef item)
NewArrayFluent<A>.WildcardRefTypeNested<A>	withNewWildcardRefType()
NewArrayFluent<A>.WildcardRefTypeNested<A>	withNewWildcardRefTypeLike(WildcardRef item)
A	withType(TypeRef type)

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Details

NewArrayFluent

public NewArrayFluent()

NewArrayFluent

public NewArrayFluent(NewArray instance)

Method Details

addAllToExpressions

public A addAllToExpressions(Collection<Expression> items)

addNewAssignExpression

public NewArrayFluent<A>.AssignExpressionsNested<A> addNewAssignExpression()

addNewAssignExpressionLike

public NewArrayFluent<A>.AssignExpressionsNested<A> addNewAssignExpressionLike(Assign item)

addNewBinaryExpressionExpression

public NewArrayFluent<A>.BinaryExpressionExpressionsNested<A> addNewBinaryExpressionExpression()

addNewBinaryExpressionExpressionLike

public NewArrayFluent<A>.BinaryExpressionExpressionsNested<A> addNewBinaryExpressionExpressionLike(BinaryExpression item)

addNewBitwiseAndExpression

public NewArrayFluent<A>.BitwiseAndExpressionsNested<A> addNewBitwiseAndExpression()

addNewBitwiseAndExpression

public A addNewBitwiseAndExpression(Object left,
 Object right)

addNewBitwiseAndExpressionLike

public NewArrayFluent<A>.BitwiseAndExpressionsNested<A> addNewBitwiseAndExpressionLike(BitwiseAnd item)

addNewBitwiseOrExpression

public NewArrayFluent<A>.BitwiseOrExpressionsNested<A> addNewBitwiseOrExpression()

addNewBitwiseOrExpression

public A addNewBitwiseOrExpression(Object left,
 Object right)

addNewBitwiseOrExpressionLike

public NewArrayFluent<A>.BitwiseOrExpressionsNested<A> addNewBitwiseOrExpressionLike(BitwiseOr item)

addNewCastExpression

public NewArrayFluent<A>.CastExpressionsNested<A> addNewCastExpression()

addNewCastExpressionLike

public NewArrayFluent<A>.CastExpressionsNested<A> addNewCastExpressionLike(Cast item)

addNewClassRefExpression

public NewArrayFluent<A>.ClassRefExpressionsNested<A> addNewClassRefExpression()

addNewClassRefExpressionLike

public NewArrayFluent<A>.ClassRefExpressionsNested<A> addNewClassRefExpressionLike(ClassRef item)

addNewConstructExpression

public NewArrayFluent<A>.ConstructExpressionsNested<A> addNewConstructExpression()

addNewConstructExpressionLike

public NewArrayFluent<A>.ConstructExpressionsNested<A> addNewConstructExpressionLike(Construct item)

addNewContextRefExpression

public NewArrayFluent<A>.ContextRefExpressionsNested<A> addNewContextRefExpression()

addNewContextRefExpression

public A addNewContextRefExpression(String name)

addNewContextRefExpressionLike

public NewArrayFluent<A>.ContextRefExpressionsNested<A> addNewContextRefExpressionLike(ContextRef item)

addNewDeclareExpression

public NewArrayFluent<A>.DeclareExpressionsNested<A> addNewDeclareExpression()

addNewDeclareExpression

public A addNewDeclareExpression(Class type,
 String name)

addNewDeclareExpression

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

addNewDeclareExpressionLike

public NewArrayFluent<A>.DeclareExpressionsNested<A> addNewDeclareExpressionLike(Declare item)

addNewDivideExpression

public NewArrayFluent<A>.DivideExpressionsNested<A> addNewDivideExpression()

addNewDivideExpression

public A addNewDivideExpression(Object left,
 Object right)

addNewDivideExpressionLike

public NewArrayFluent<A>.DivideExpressionsNested<A> addNewDivideExpressionLike(Divide item)

addNewDotClassExpression

public NewArrayFluent<A>.DotClassExpressionsNested<A> addNewDotClassExpression()

addNewDotClassExpressionLike

public NewArrayFluent<A>.DotClassExpressionsNested<A> addNewDotClassExpressionLike(DotClass item)

addNewEmptyExpression

public NewArrayFluent<A>.EmptyExpressionsNested<A> addNewEmptyExpression()

addNewEmptyExpressionLike

public NewArrayFluent<A>.EmptyExpressionsNested<A> addNewEmptyExpressionLike(Empty item)

addNewEnclosedExpression

public NewArrayFluent<A>.EnclosedExpressionsNested<A> addNewEnclosedExpression()

addNewEnclosedExpressionLike

public NewArrayFluent<A>.EnclosedExpressionsNested<A> addNewEnclosedExpressionLike(Enclosed item)

addNewEqualsExpression

public NewArrayFluent<A>.EqualsExpressionsNested<A> addNewEqualsExpression()

addNewEqualsExpression

public A addNewEqualsExpression(Object left,
 Object right)

addNewEqualsExpressionLike

public NewArrayFluent<A>.EqualsExpressionsNested<A> addNewEqualsExpressionLike(Equals item)

addNewGreaterThanExpression

public NewArrayFluent<A>.GreaterThanExpressionsNested<A> addNewGreaterThanExpression()

addNewGreaterThanExpression

public A addNewGreaterThanExpression(Object left,
 Object right)

addNewGreaterThanExpressionLike

public NewArrayFluent<A>.GreaterThanExpressionsNested<A> addNewGreaterThanExpressionLike(GreaterThan item)

addNewGreaterThanOrEqualExpression

public NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A> addNewGreaterThanOrEqualExpression()

addNewGreaterThanOrEqualExpression

public A addNewGreaterThanOrEqualExpression(Object left,
 Object right)

addNewGreaterThanOrEqualExpressionLike

public NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A> addNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)

addNewIndexExpression

public NewArrayFluent<A>.IndexExpressionsNested<A> addNewIndexExpression()

addNewIndexExpressionLike

public NewArrayFluent<A>.IndexExpressionsNested<A> addNewIndexExpressionLike(Index item)

addNewInstanceOfExpression

public NewArrayFluent<A>.InstanceOfExpressionsNested<A> addNewInstanceOfExpression()

addNewInstanceOfExpressionLike

public NewArrayFluent<A>.InstanceOfExpressionsNested<A> addNewInstanceOfExpressionLike(InstanceOf item)

addNewInverseExpression

public NewArrayFluent<A>.InverseExpressionsNested<A> addNewInverseExpression()

addNewInverseExpressionLike

public NewArrayFluent<A>.InverseExpressionsNested<A> addNewInverseExpressionLike(Inverse item)

addNewLambdaExpression

public NewArrayFluent<A>.LambdaExpressionsNested<A> addNewLambdaExpression()

addNewLambdaExpressionLike

public NewArrayFluent<A>.LambdaExpressionsNested<A> addNewLambdaExpressionLike(Lambda item)

addNewLeftShiftExpression

public NewArrayFluent<A>.LeftShiftExpressionsNested<A> addNewLeftShiftExpression()

addNewLeftShiftExpression

public A addNewLeftShiftExpression(Object left,
 Object right)

addNewLeftShiftExpressionLike

public NewArrayFluent<A>.LeftShiftExpressionsNested<A> addNewLeftShiftExpressionLike(LeftShift item)

addNewLessThanExpression

public NewArrayFluent<A>.LessThanExpressionsNested<A> addNewLessThanExpression()

addNewLessThanExpression

public A addNewLessThanExpression(Object left,
 Object right)

addNewLessThanExpressionLike

public NewArrayFluent<A>.LessThanExpressionsNested<A> addNewLessThanExpressionLike(LessThan item)

addNewLessThanOrEqualExpression

public NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A> addNewLessThanOrEqualExpression()

addNewLessThanOrEqualExpression

public A addNewLessThanOrEqualExpression(Object left,
 Object right)

addNewLessThanOrEqualExpressionLike

public NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A> addNewLessThanOrEqualExpressionLike(LessThanOrEqual item)

addNewLogicalAndExpression

public NewArrayFluent<A>.LogicalAndExpressionsNested<A> addNewLogicalAndExpression()

addNewLogicalAndExpression

public A addNewLogicalAndExpression(Object left,
 Object right)

addNewLogicalAndExpressionLike

public NewArrayFluent<A>.LogicalAndExpressionsNested<A> addNewLogicalAndExpressionLike(LogicalAnd item)

addNewLogicalOrExpression

public NewArrayFluent<A>.LogicalOrExpressionsNested<A> addNewLogicalOrExpression()

addNewLogicalOrExpression

public A addNewLogicalOrExpression(Object left,
 Object right)

addNewLogicalOrExpressionLike

public NewArrayFluent<A>.LogicalOrExpressionsNested<A> addNewLogicalOrExpressionLike(LogicalOr item)

addNewMethodCallExpression

public NewArrayFluent<A>.MethodCallExpressionsNested<A> addNewMethodCallExpression()

addNewMethodCallExpressionLike

public NewArrayFluent<A>.MethodCallExpressionsNested<A> addNewMethodCallExpressionLike(MethodCall item)

addNewMinusExpression

public NewArrayFluent<A>.MinusExpressionsNested<A> addNewMinusExpression()

addNewMinusExpression

public A addNewMinusExpression(Object left,
 Object right)

addNewMinusExpressionLike

public NewArrayFluent<A>.MinusExpressionsNested<A> addNewMinusExpressionLike(Minus item)

addNewModuloExpression

public NewArrayFluent<A>.ModuloExpressionsNested<A> addNewModuloExpression()

addNewModuloExpression

public A addNewModuloExpression(Object left,
 Object right)

addNewModuloExpressionLike

public NewArrayFluent<A>.ModuloExpressionsNested<A> addNewModuloExpressionLike(Modulo item)

addNewMultiplyExpression

public NewArrayFluent<A>.MultiplyExpressionsNested<A> addNewMultiplyExpression()

addNewMultiplyExpression

public A addNewMultiplyExpression(Object left,
 Object right)

addNewMultiplyExpressionLike

public NewArrayFluent<A>.MultiplyExpressionsNested<A> addNewMultiplyExpressionLike(Multiply item)

addNewNegativeExpression

public NewArrayFluent<A>.NegativeExpressionsNested<A> addNewNegativeExpression()

addNewNegativeExpressionLike

public NewArrayFluent<A>.NegativeExpressionsNested<A> addNewNegativeExpressionLike(Negative item)

addNewNewArrayExpression

public NewArrayFluent<A>.NewArrayExpressionsNested<A> addNewNewArrayExpression()

addNewNewArrayExpression

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

addNewNewArrayExpressionLike

public NewArrayFluent<A>.NewArrayExpressionsNested<A> addNewNewArrayExpressionLike(NewArray item)

addNewNotEqualsExpression

public NewArrayFluent<A>.NotEqualsExpressionsNested<A> addNewNotEqualsExpression()

addNewNotEqualsExpression

public A addNewNotEqualsExpression(Object left,
 Object right)

addNewNotEqualsExpressionLike

public NewArrayFluent<A>.NotEqualsExpressionsNested<A> addNewNotEqualsExpressionLike(NotEquals item)

addNewNotExpression

public NewArrayFluent<A>.NotExpressionsNested<A> addNewNotExpression()

addNewNotExpressionLike

public NewArrayFluent<A>.NotExpressionsNested<A> addNewNotExpressionLike(Not item)

addNewPlusExpression

public NewArrayFluent<A>.PlusExpressionsNested<A> addNewPlusExpression()

addNewPlusExpression

public A addNewPlusExpression(Object left,
 Object right)

addNewPlusExpressionLike

public NewArrayFluent<A>.PlusExpressionsNested<A> addNewPlusExpressionLike(Plus item)

addNewPositiveExpression

public NewArrayFluent<A>.PositiveExpressionsNested<A> addNewPositiveExpression()

addNewPositiveExpressionLike

public NewArrayFluent<A>.PositiveExpressionsNested<A> addNewPositiveExpressionLike(Positive item)

addNewPostDecrementExpression

public NewArrayFluent<A>.PostDecrementExpressionsNested<A> addNewPostDecrementExpression()

addNewPostDecrementExpressionLike

public NewArrayFluent<A>.PostDecrementExpressionsNested<A> addNewPostDecrementExpressionLike(PostDecrement item)

addNewPostIncrementExpression

public NewArrayFluent<A>.PostIncrementExpressionsNested<A> addNewPostIncrementExpression()

addNewPostIncrementExpressionLike

public NewArrayFluent<A>.PostIncrementExpressionsNested<A> addNewPostIncrementExpressionLike(PostIncrement item)

addNewPreDecrementExpression

public NewArrayFluent<A>.PreDecrementExpressionsNested<A> addNewPreDecrementExpression()

addNewPreDecrementExpressionLike

public NewArrayFluent<A>.PreDecrementExpressionsNested<A> addNewPreDecrementExpressionLike(PreDecrement item)

addNewPreIncrementExpression

public NewArrayFluent<A>.PreIncrementExpressionsNested<A> addNewPreIncrementExpression()

addNewPreIncrementExpressionLike

public NewArrayFluent<A>.PreIncrementExpressionsNested<A> addNewPreIncrementExpressionLike(PreIncrement item)

addNewPropertyExpression

public NewArrayFluent<A>.PropertyExpressionsNested<A> addNewPropertyExpression()

addNewPropertyExpressionLike

public NewArrayFluent<A>.PropertyExpressionsNested<A> addNewPropertyExpressionLike(Property item)

addNewPropertyRefExpression

public NewArrayFluent<A>.PropertyRefExpressionsNested<A> addNewPropertyRefExpression()

addNewPropertyRefExpressionLike

public NewArrayFluent<A>.PropertyRefExpressionsNested<A> addNewPropertyRefExpressionLike(PropertyRef item)

addNewRightShiftExpression

public NewArrayFluent<A>.RightShiftExpressionsNested<A> addNewRightShiftExpression()

addNewRightShiftExpression

public A addNewRightShiftExpression(Object left,
 Object right)

addNewRightShiftExpressionLike

public NewArrayFluent<A>.RightShiftExpressionsNested<A> addNewRightShiftExpressionLike(RightShift item)

addNewRightUnsignedShiftExpression

public NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A> addNewRightUnsignedShiftExpression()

addNewRightUnsignedShiftExpression

public A addNewRightUnsignedShiftExpression(Object left,
 Object right)

addNewRightUnsignedShiftExpressionLike

public NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A> addNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)

addNewSuperExpression

public NewArrayFluent<A>.SuperExpressionsNested<A> addNewSuperExpression()

addNewSuperExpressionLike

public NewArrayFluent<A>.SuperExpressionsNested<A> addNewSuperExpressionLike(Super item)

addNewTernaryExpression

public NewArrayFluent<A>.TernaryExpressionsNested<A> addNewTernaryExpression()

addNewTernaryExpressionLike

public NewArrayFluent<A>.TernaryExpressionsNested<A> addNewTernaryExpressionLike(Ternary item)

addNewThisExpression

public NewArrayFluent<A>.ThisExpressionsNested<A> addNewThisExpression()

addNewThisExpressionLike

public NewArrayFluent<A>.ThisExpressionsNested<A> addNewThisExpressionLike(This item)

addNewValueRefExpression

public NewArrayFluent<A>.ValueRefExpressionsNested<A> addNewValueRefExpression()

addNewValueRefExpression

public A addNewValueRefExpression(Object value)

addNewValueRefExpressionLike

public NewArrayFluent<A>.ValueRefExpressionsNested<A> addNewValueRefExpressionLike(ValueRef item)

addNewXorExpression

public NewArrayFluent<A>.XorExpressionsNested<A> addNewXorExpression()

addNewXorExpression

public A addNewXorExpression(Object left,
 Object right)

addNewXorExpressionLike

public NewArrayFluent<A>.XorExpressionsNested<A> addNewXorExpressionLike(Xor item)

addToExpressions

public A addToExpressions(VisitableBuilder<? extends Expression,?> builder)

addToExpressions

public A addToExpressions(Expression... items)

addToExpressions

public A addToExpressions(int index,
 VisitableBuilder<? extends Expression,?> builder)

addToExpressions

public A addToExpressions(int index,
 Expression item)

buildExpression

public Expression buildExpression(int index)

buildExpressions

public List<Expression> buildExpressions()

buildFirstExpression

public Expression buildFirstExpression()

buildLastExpression

public Expression buildLastExpression()

buildMatchingExpression

public Expression buildMatchingExpression(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

buildType

public TypeRef buildType()

builder

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

copyInstance

protected void copyInstance(NewArray instance)

equals

public boolean equals(Object o)

Overrides:

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

hasExpressions

public boolean hasExpressions()

hasMatchingExpression

public boolean hasMatchingExpression(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

hasType

public boolean hasType()

hashCode

public int hashCode()

Overrides:

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

removeAllFromExpressions

public A removeAllFromExpressions(Collection<Expression> items)

removeFromExpressions

public A removeFromExpressions(VisitableBuilder<? extends Expression,?> builder)

removeFromExpressions

public A removeFromExpressions(Expression... items)

removeMatchingFromExpressions

public A removeMatchingFromExpressions(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

setNewAssignExpressionLike

public NewArrayFluent<A>.AssignExpressionsNested<A> setNewAssignExpressionLike(int index,
 Assign item)

setNewBinaryExpressionExpressionLike

public NewArrayFluent<A>.BinaryExpressionExpressionsNested<A> setNewBinaryExpressionExpressionLike(int index,
 BinaryExpression item)

setNewBitwiseAndExpressionLike

public NewArrayFluent<A>.BitwiseAndExpressionsNested<A> setNewBitwiseAndExpressionLike(int index,
 BitwiseAnd item)

setNewBitwiseOrExpressionLike

public NewArrayFluent<A>.BitwiseOrExpressionsNested<A> setNewBitwiseOrExpressionLike(int index,
 BitwiseOr item)

setNewCastExpressionLike

public NewArrayFluent<A>.CastExpressionsNested<A> setNewCastExpressionLike(int index,
 Cast item)

setNewClassRefExpressionLike

public NewArrayFluent<A>.ClassRefExpressionsNested<A> setNewClassRefExpressionLike(int index,
 ClassRef item)

setNewConstructExpressionLike

public NewArrayFluent<A>.ConstructExpressionsNested<A> setNewConstructExpressionLike(int index,
 Construct item)

setNewContextRefExpressionLike

public NewArrayFluent<A>.ContextRefExpressionsNested<A> setNewContextRefExpressionLike(int index,
 ContextRef item)

setNewDeclareExpressionLike

public NewArrayFluent<A>.DeclareExpressionsNested<A> setNewDeclareExpressionLike(int index,
 Declare item)

setNewDivideExpressionLike

public NewArrayFluent<A>.DivideExpressionsNested<A> setNewDivideExpressionLike(int index,
 Divide item)

setNewDotClassExpressionLike

public NewArrayFluent<A>.DotClassExpressionsNested<A> setNewDotClassExpressionLike(int index,
 DotClass item)

setNewEmptyExpressionLike

public NewArrayFluent<A>.EmptyExpressionsNested<A> setNewEmptyExpressionLike(int index,
 Empty item)

setNewEnclosedExpressionLike

public NewArrayFluent<A>.EnclosedExpressionsNested<A> setNewEnclosedExpressionLike(int index,
 Enclosed item)

setNewEqualsExpressionLike

public NewArrayFluent<A>.EqualsExpressionsNested<A> setNewEqualsExpressionLike(int index,
 Equals item)

setNewGreaterThanExpressionLike

public NewArrayFluent<A>.GreaterThanExpressionsNested<A> setNewGreaterThanExpressionLike(int index,
 GreaterThan item)

setNewGreaterThanOrEqualExpressionLike

public NewArrayFluent<A>.GreaterThanOrEqualExpressionsNested<A> setNewGreaterThanOrEqualExpressionLike(int index,
 GreaterThanOrEqual item)

setNewIndexExpressionLike

public NewArrayFluent<A>.IndexExpressionsNested<A> setNewIndexExpressionLike(int index,
 Index item)

setNewInstanceOfExpressionLike

public NewArrayFluent<A>.InstanceOfExpressionsNested<A> setNewInstanceOfExpressionLike(int index,
 InstanceOf item)

setNewInverseExpressionLike

public NewArrayFluent<A>.InverseExpressionsNested<A> setNewInverseExpressionLike(int index,
 Inverse item)

setNewLambdaExpressionLike

public NewArrayFluent<A>.LambdaExpressionsNested<A> setNewLambdaExpressionLike(int index,
 Lambda item)

setNewLeftShiftExpressionLike

public NewArrayFluent<A>.LeftShiftExpressionsNested<A> setNewLeftShiftExpressionLike(int index,
 LeftShift item)

setNewLessThanExpressionLike

public NewArrayFluent<A>.LessThanExpressionsNested<A> setNewLessThanExpressionLike(int index,
 LessThan item)

setNewLessThanOrEqualExpressionLike

public NewArrayFluent<A>.LessThanOrEqualExpressionsNested<A> setNewLessThanOrEqualExpressionLike(int index,
 LessThanOrEqual item)

setNewLogicalAndExpressionLike

public NewArrayFluent<A>.LogicalAndExpressionsNested<A> setNewLogicalAndExpressionLike(int index,
 LogicalAnd item)

setNewLogicalOrExpressionLike

public NewArrayFluent<A>.LogicalOrExpressionsNested<A> setNewLogicalOrExpressionLike(int index,
 LogicalOr item)

setNewMethodCallExpressionLike

public NewArrayFluent<A>.MethodCallExpressionsNested<A> setNewMethodCallExpressionLike(int index,
 MethodCall item)

setNewMinusExpressionLike

public NewArrayFluent<A>.MinusExpressionsNested<A> setNewMinusExpressionLike(int index,
 Minus item)

setNewModuloExpressionLike

public NewArrayFluent<A>.ModuloExpressionsNested<A> setNewModuloExpressionLike(int index,
 Modulo item)

setNewMultiplyExpressionLike

public NewArrayFluent<A>.MultiplyExpressionsNested<A> setNewMultiplyExpressionLike(int index,
 Multiply item)

setNewNegativeExpressionLike

public NewArrayFluent<A>.NegativeExpressionsNested<A> setNewNegativeExpressionLike(int index,
 Negative item)

setNewNewArrayExpressionLike

public NewArrayFluent<A>.NewArrayExpressionsNested<A> setNewNewArrayExpressionLike(int index,
 NewArray item)

setNewNotEqualsExpressionLike

public NewArrayFluent<A>.NotEqualsExpressionsNested<A> setNewNotEqualsExpressionLike(int index,
 NotEquals item)

setNewNotExpressionLike

public NewArrayFluent<A>.NotExpressionsNested<A> setNewNotExpressionLike(int index,
 Not item)

setNewPlusExpressionLike

public NewArrayFluent<A>.PlusExpressionsNested<A> setNewPlusExpressionLike(int index,
 Plus item)

setNewPositiveExpressionLike

public NewArrayFluent<A>.PositiveExpressionsNested<A> setNewPositiveExpressionLike(int index,
 Positive item)

setNewPostDecrementExpressionLike

public NewArrayFluent<A>.PostDecrementExpressionsNested<A> setNewPostDecrementExpressionLike(int index,
 PostDecrement item)

setNewPostIncrementExpressionLike

public NewArrayFluent<A>.PostIncrementExpressionsNested<A> setNewPostIncrementExpressionLike(int index,
 PostIncrement item)

setNewPreDecrementExpressionLike

public NewArrayFluent<A>.PreDecrementExpressionsNested<A> setNewPreDecrementExpressionLike(int index,
 PreDecrement item)

setNewPreIncrementExpressionLike

public NewArrayFluent<A>.PreIncrementExpressionsNested<A> setNewPreIncrementExpressionLike(int index,
 PreIncrement item)

setNewPropertyExpressionLike

public NewArrayFluent<A>.PropertyExpressionsNested<A> setNewPropertyExpressionLike(int index,
 Property item)

setNewPropertyRefExpressionLike

public NewArrayFluent<A>.PropertyRefExpressionsNested<A> setNewPropertyRefExpressionLike(int index,
 PropertyRef item)

setNewRightShiftExpressionLike

public NewArrayFluent<A>.RightShiftExpressionsNested<A> setNewRightShiftExpressionLike(int index,
 RightShift item)

setNewRightUnsignedShiftExpressionLike

public NewArrayFluent<A>.RightUnsignedShiftExpressionsNested<A> setNewRightUnsignedShiftExpressionLike(int index,
 RightUnsignedShift item)

setNewSuperExpressionLike

public NewArrayFluent<A>.SuperExpressionsNested<A> setNewSuperExpressionLike(int index,
 Super item)

setNewTernaryExpressionLike

public NewArrayFluent<A>.TernaryExpressionsNested<A> setNewTernaryExpressionLike(int index,
 Ternary item)

setNewThisExpressionLike

public NewArrayFluent<A>.ThisExpressionsNested<A> setNewThisExpressionLike(int index,
 This item)

setNewValueRefExpressionLike

public NewArrayFluent<A>.ValueRefExpressionsNested<A> setNewValueRefExpressionLike(int index,
 ValueRef item)

setNewXorExpressionLike

public NewArrayFluent<A>.XorExpressionsNested<A> setNewXorExpressionLike(int index,
 Xor item)

setToExpressions

public A setToExpressions(int index,
 Expression item)

toString

public String toString()

Overrides:

toString in class Object

withExpressions

public A withExpressions(List<Expression> expressions)

withExpressions

public A withExpressions(Expression... expressions)

withNewClassRefType

public NewArrayFluent<A>.ClassRefTypeNested<A> withNewClassRefType()

withNewClassRefTypeLike

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

withNewPrimitiveRefType

public NewArrayFluent<A>.PrimitiveRefTypeNested<A> withNewPrimitiveRefType()

withNewPrimitiveRefTypeLike

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

withNewTypeParamRefType

public NewArrayFluent<A>.TypeParamRefTypeNested<A> withNewTypeParamRefType()

withNewTypeParamRefTypeLike

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

withNewVoidRefType

public NewArrayFluent<A>.VoidRefTypeNested<A> withNewVoidRefType()

withNewVoidRefTypeLike

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

withNewWildcardRefType

public NewArrayFluent<A>.WildcardRefTypeNested<A> withNewWildcardRefType()

withNewWildcardRefTypeLike

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

withType

public A withType(TypeRef type)