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, DoFluent.NewArrayConditionNested, EnclosedFluent.NewArrayExpresionNested, ForeachFluent.NewArrayExpressionNested, ForFluent.NewArrayCompareNested, ForFluent.NewArrayInitNested, ForFluent.NewArrayUpdateNested, IfFluent.NewArrayConditionNested, IndexFluent.NewArrayExpressionNested, IndexFluent.NewArrayScopeNested, InstanceOfFluent.NewArrayExpressionNested, InverseFluent.NewArrayExpresionNested, MethodCallFluent.NewArrayArgumentsNested, MethodCallFluent.NewArrayScopeNested, NegativeFluent.NewArrayExpresionNested, NewArrayBuilder, NewArrayFluent.NewArrayExpressionsNested, NotFluent.NewArrayExpresionNested, PositiveFluent.NewArrayExpresionNested, PostDecrementFluent.NewArrayExpressionNested, PostIncrementFluent.NewArrayExpressionNested, PreDecrementFluent.NewArrayExpressionNested, PreIncrementFluent.NewArrayExpressionNested, PropertyRefFluent.NewArrayScopeNested, ReturnFluent.NewArrayExpressionNested, SwitchFluent.NewArrayExpressionNested, TernaryFluent.NewArrayAlternativeNested, TernaryFluent.NewArrayConditionNested, TernaryFluent.NewArrayResultNested, WhileFluent.NewArrayConditionNested

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.ClassRefTypeNested<N>
class	NewArrayFluent.ConstructExpressionsNested<N>
class	NewArrayFluent.DeclareExpressionsNested<N>
class	NewArrayFluent.DivideExpressionsNested<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.PropertyRefExpressionsNested<N>
class	NewArrayFluent.RightShiftExpressionsNested<N>
class	NewArrayFluent.RightUnsignedShiftExpressionsNested<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.AssignExpressionsNested<A>	addNewAssignExpression()
NewArrayFluent.AssignExpressionsNested<A>	addNewAssignExpressionLike(Assign item)
NewArrayFluent.BinaryExpressionExpressionsNested<A>	addNewBinaryExpressionExpression()
NewArrayFluent.BinaryExpressionExpressionsNested<A>	addNewBinaryExpressionExpressionLike(BinaryExpression item)
NewArrayFluent.BitwiseAndExpressionsNested<A>	addNewBitwiseAndExpression()
A	addNewBitwiseAndExpression(Object left, Object right)
NewArrayFluent.BitwiseAndExpressionsNested<A>	addNewBitwiseAndExpressionLike(BitwiseAnd item)
NewArrayFluent.BitwiseOrExpressionsNested<A>	addNewBitwiseOrExpression()
A	addNewBitwiseOrExpression(Object left, Object right)
NewArrayFluent.BitwiseOrExpressionsNested<A>	addNewBitwiseOrExpressionLike(BitwiseOr item)
NewArrayFluent.CastExpressionsNested<A>	addNewCastExpression()
NewArrayFluent.CastExpressionsNested<A>	addNewCastExpressionLike(Cast item)
NewArrayFluent.ConstructExpressionsNested<A>	addNewConstructExpression()
NewArrayFluent.ConstructExpressionsNested<A>	addNewConstructExpressionLike(Construct item)
NewArrayFluent.DeclareExpressionsNested<A>	addNewDeclareExpression()
A	addNewDeclareExpression(Class type, String name)
A	addNewDeclareExpression(Class type, String name, Object value)
NewArrayFluent.DeclareExpressionsNested<A>	addNewDeclareExpressionLike(Declare item)
NewArrayFluent.DivideExpressionsNested<A>	addNewDivideExpression()
A	addNewDivideExpression(Object left, Object right)
NewArrayFluent.DivideExpressionsNested<A>	addNewDivideExpressionLike(Divide item)
NewArrayFluent.EnclosedExpressionsNested<A>	addNewEnclosedExpression()
NewArrayFluent.EnclosedExpressionsNested<A>	addNewEnclosedExpressionLike(Enclosed item)
NewArrayFluent.EqualsExpressionsNested<A>	addNewEqualsExpression()
A	addNewEqualsExpression(Object left, Object right)
NewArrayFluent.EqualsExpressionsNested<A>	addNewEqualsExpressionLike(Equals item)
NewArrayFluent.GreaterThanExpressionsNested<A>	addNewGreaterThanExpression()
A	addNewGreaterThanExpression(Object left, Object right)
NewArrayFluent.GreaterThanExpressionsNested<A>	addNewGreaterThanExpressionLike(GreaterThan item)
NewArrayFluent.GreaterThanOrEqualExpressionsNested<A>	addNewGreaterThanOrEqualExpression()
A	addNewGreaterThanOrEqualExpression(Object left, Object right)
NewArrayFluent.GreaterThanOrEqualExpressionsNested<A>	addNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item)
NewArrayFluent.IndexExpressionsNested<A>	addNewIndexExpression()
NewArrayFluent.IndexExpressionsNested<A>	addNewIndexExpressionLike(Index item)
NewArrayFluent.InstanceOfExpressionsNested<A>	addNewInstanceOfExpression()
NewArrayFluent.InstanceOfExpressionsNested<A>	addNewInstanceOfExpressionLike(InstanceOf item)
NewArrayFluent.InverseExpressionsNested<A>	addNewInverseExpression()
NewArrayFluent.InverseExpressionsNested<A>	addNewInverseExpressionLike(Inverse item)
NewArrayFluent.LambdaExpressionsNested<A>	addNewLambdaExpression()
NewArrayFluent.LambdaExpressionsNested<A>	addNewLambdaExpressionLike(Lambda item)
NewArrayFluent.LeftShiftExpressionsNested<A>	addNewLeftShiftExpression()
A	addNewLeftShiftExpression(Object left, Object right)
NewArrayFluent.LeftShiftExpressionsNested<A>	addNewLeftShiftExpressionLike(LeftShift item)
NewArrayFluent.LessThanExpressionsNested<A>	addNewLessThanExpression()
A	addNewLessThanExpression(Object left, Object right)
NewArrayFluent.LessThanExpressionsNested<A>	addNewLessThanExpressionLike(LessThan item)
NewArrayFluent.LessThanOrEqualExpressionsNested<A>	addNewLessThanOrEqualExpression()
A	addNewLessThanOrEqualExpression(Object left, Object right)
NewArrayFluent.LessThanOrEqualExpressionsNested<A>	addNewLessThanOrEqualExpressionLike(LessThanOrEqual item)
NewArrayFluent.LogicalAndExpressionsNested<A>	addNewLogicalAndExpression()
A	addNewLogicalAndExpression(Object left, Object right)
NewArrayFluent.LogicalAndExpressionsNested<A>	addNewLogicalAndExpressionLike(LogicalAnd item)
NewArrayFluent.LogicalOrExpressionsNested<A>	addNewLogicalOrExpression()
A	addNewLogicalOrExpression(Object left, Object right)
NewArrayFluent.LogicalOrExpressionsNested<A>	addNewLogicalOrExpressionLike(LogicalOr item)
NewArrayFluent.MethodCallExpressionsNested<A>	addNewMethodCallExpression()
NewArrayFluent.MethodCallExpressionsNested<A>	addNewMethodCallExpressionLike(MethodCall item)
NewArrayFluent.MinusExpressionsNested<A>	addNewMinusExpression()
A	addNewMinusExpression(Object left, Object right)
NewArrayFluent.MinusExpressionsNested<A>	addNewMinusExpressionLike(Minus item)
NewArrayFluent.ModuloExpressionsNested<A>	addNewModuloExpression()
A	addNewModuloExpression(Object left, Object right)
NewArrayFluent.ModuloExpressionsNested<A>	addNewModuloExpressionLike(Modulo item)
NewArrayFluent.MultiplyExpressionsNested<A>	addNewMultiplyExpression()
A	addNewMultiplyExpression(Object left, Object right)
NewArrayFluent.MultiplyExpressionsNested<A>	addNewMultiplyExpressionLike(Multiply item)
NewArrayFluent.NegativeExpressionsNested<A>	addNewNegativeExpression()
NewArrayFluent.NegativeExpressionsNested<A>	addNewNegativeExpressionLike(Negative item)
NewArrayFluent.NewArrayExpressionsNested<A>	addNewNewArrayExpression()
A	addNewNewArrayExpression(Class type, Integer[] sizes)
NewArrayFluent.NewArrayExpressionsNested<A>	addNewNewArrayExpressionLike(NewArray item)
NewArrayFluent.NotEqualsExpressionsNested<A>	addNewNotEqualsExpression()
A	addNewNotEqualsExpression(Object left, Object right)
NewArrayFluent.NotEqualsExpressionsNested<A>	addNewNotEqualsExpressionLike(NotEquals item)
NewArrayFluent.NotExpressionsNested<A>	addNewNotExpression()
NewArrayFluent.NotExpressionsNested<A>	addNewNotExpressionLike(Not item)
NewArrayFluent.PlusExpressionsNested<A>	addNewPlusExpression()
A	addNewPlusExpression(Object left, Object right)
NewArrayFluent.PlusExpressionsNested<A>	addNewPlusExpressionLike(Plus item)
NewArrayFluent.PositiveExpressionsNested<A>	addNewPositiveExpression()
NewArrayFluent.PositiveExpressionsNested<A>	addNewPositiveExpressionLike(Positive item)
NewArrayFluent.PostDecrementExpressionsNested<A>	addNewPostDecrementExpression()
NewArrayFluent.PostDecrementExpressionsNested<A>	addNewPostDecrementExpressionLike(PostDecrement item)
NewArrayFluent.PostIncrementExpressionsNested<A>	addNewPostIncrementExpression()
NewArrayFluent.PostIncrementExpressionsNested<A>	addNewPostIncrementExpressionLike(PostIncrement item)
NewArrayFluent.PreDecrementExpressionsNested<A>	addNewPreDecrementExpression()
NewArrayFluent.PreDecrementExpressionsNested<A>	addNewPreDecrementExpressionLike(PreDecrement item)
NewArrayFluent.PreIncrementExpressionsNested<A>	addNewPreIncrementExpression()
NewArrayFluent.PreIncrementExpressionsNested<A>	addNewPreIncrementExpressionLike(PreIncrement item)
NewArrayFluent.PropertyRefExpressionsNested<A>	addNewPropertyRefExpression()
NewArrayFluent.PropertyRefExpressionsNested<A>	addNewPropertyRefExpressionLike(PropertyRef item)
NewArrayFluent.RightShiftExpressionsNested<A>	addNewRightShiftExpression()
A	addNewRightShiftExpression(Object left, Object right)
NewArrayFluent.RightShiftExpressionsNested<A>	addNewRightShiftExpressionLike(RightShift item)
NewArrayFluent.RightUnsignedShiftExpressionsNested<A>	addNewRightUnsignedShiftExpression()
A	addNewRightUnsignedShiftExpression(Object left, Object right)
NewArrayFluent.RightUnsignedShiftExpressionsNested<A>	addNewRightUnsignedShiftExpressionLike(RightUnsignedShift item)
NewArrayFluent.TernaryExpressionsNested<A>	addNewTernaryExpression()
NewArrayFluent.TernaryExpressionsNested<A>	addNewTernaryExpressionLike(Ternary item)
NewArrayFluent.ThisExpressionsNested<A>	addNewThisExpression()
NewArrayFluent.ThisExpressionsNested<A>	addNewThisExpressionLike(This item)
NewArrayFluent.ValueRefExpressionsNested<A>	addNewValueRefExpression()
A	addNewValueRefExpression(Object value)
NewArrayFluent.ValueRefExpressionsNested<A>	addNewValueRefExpressionLike(ValueRef item)
NewArrayFluent.XorExpressionsNested<A>	addNewXorExpression()
A	addNewXorExpression(Object left, Object right)
NewArrayFluent.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.AssignExpressionsNested<A>	setNewAssignExpressionLike(int index, Assign item)
NewArrayFluent.BinaryExpressionExpressionsNested<A>	setNewBinaryExpressionExpressionLike(int index, BinaryExpression item)
NewArrayFluent.BitwiseAndExpressionsNested<A>	setNewBitwiseAndExpressionLike(int index, BitwiseAnd item)
NewArrayFluent.BitwiseOrExpressionsNested<A>	setNewBitwiseOrExpressionLike(int index, BitwiseOr item)
NewArrayFluent.CastExpressionsNested<A>	setNewCastExpressionLike(int index, Cast item)
NewArrayFluent.ConstructExpressionsNested<A>	setNewConstructExpressionLike(int index, Construct item)
NewArrayFluent.DeclareExpressionsNested<A>	setNewDeclareExpressionLike(int index, Declare item)
NewArrayFluent.DivideExpressionsNested<A>	setNewDivideExpressionLike(int index, Divide item)
NewArrayFluent.EnclosedExpressionsNested<A>	setNewEnclosedExpressionLike(int index, Enclosed item)
NewArrayFluent.EqualsExpressionsNested<A>	setNewEqualsExpressionLike(int index, Equals item)
NewArrayFluent.GreaterThanExpressionsNested<A>	setNewGreaterThanExpressionLike(int index, GreaterThan item)
NewArrayFluent.GreaterThanOrEqualExpressionsNested<A>	setNewGreaterThanOrEqualExpressionLike(int index, GreaterThanOrEqual item)
NewArrayFluent.IndexExpressionsNested<A>	setNewIndexExpressionLike(int index, Index item)
NewArrayFluent.InstanceOfExpressionsNested<A>	setNewInstanceOfExpressionLike(int index, InstanceOf item)
NewArrayFluent.InverseExpressionsNested<A>	setNewInverseExpressionLike(int index, Inverse item)
NewArrayFluent.LambdaExpressionsNested<A>	setNewLambdaExpressionLike(int index, Lambda item)
NewArrayFluent.LeftShiftExpressionsNested<A>	setNewLeftShiftExpressionLike(int index, LeftShift item)
NewArrayFluent.LessThanExpressionsNested<A>	setNewLessThanExpressionLike(int index, LessThan item)
NewArrayFluent.LessThanOrEqualExpressionsNested<A>	setNewLessThanOrEqualExpressionLike(int index, LessThanOrEqual item)
NewArrayFluent.LogicalAndExpressionsNested<A>	setNewLogicalAndExpressionLike(int index, LogicalAnd item)
NewArrayFluent.LogicalOrExpressionsNested<A>	setNewLogicalOrExpressionLike(int index, LogicalOr item)
NewArrayFluent.MethodCallExpressionsNested<A>	setNewMethodCallExpressionLike(int index, MethodCall item)
NewArrayFluent.MinusExpressionsNested<A>	setNewMinusExpressionLike(int index, Minus item)
NewArrayFluent.ModuloExpressionsNested<A>	setNewModuloExpressionLike(int index, Modulo item)
NewArrayFluent.MultiplyExpressionsNested<A>	setNewMultiplyExpressionLike(int index, Multiply item)
NewArrayFluent.NegativeExpressionsNested<A>	setNewNegativeExpressionLike(int index, Negative item)
NewArrayFluent.NewArrayExpressionsNested<A>	setNewNewArrayExpressionLike(int index, NewArray item)
NewArrayFluent.NotEqualsExpressionsNested<A>	setNewNotEqualsExpressionLike(int index, NotEquals item)
NewArrayFluent.NotExpressionsNested<A>	setNewNotExpressionLike(int index, Not item)
NewArrayFluent.PlusExpressionsNested<A>	setNewPlusExpressionLike(int index, Plus item)
NewArrayFluent.PositiveExpressionsNested<A>	setNewPositiveExpressionLike(int index, Positive item)
NewArrayFluent.PostDecrementExpressionsNested<A>	setNewPostDecrementExpressionLike(int index, PostDecrement item)
NewArrayFluent.PostIncrementExpressionsNested<A>	setNewPostIncrementExpressionLike(int index, PostIncrement item)
NewArrayFluent.PreDecrementExpressionsNested<A>	setNewPreDecrementExpressionLike(int index, PreDecrement item)
NewArrayFluent.PreIncrementExpressionsNested<A>	setNewPreIncrementExpressionLike(int index, PreIncrement item)
NewArrayFluent.PropertyRefExpressionsNested<A>	setNewPropertyRefExpressionLike(int index, PropertyRef item)
NewArrayFluent.RightShiftExpressionsNested<A>	setNewRightShiftExpressionLike(int index, RightShift item)
NewArrayFluent.RightUnsignedShiftExpressionsNested<A>	setNewRightUnsignedShiftExpressionLike(int index, RightUnsignedShift item)
NewArrayFluent.TernaryExpressionsNested<A>	setNewTernaryExpressionLike(int index, Ternary item)
NewArrayFluent.ThisExpressionsNested<A>	setNewThisExpressionLike(int index, This item)
NewArrayFluent.ValueRefExpressionsNested<A>	setNewValueRefExpressionLike(int index, ValueRef item)
NewArrayFluent.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.ClassRefTypeNested<A>	withNewClassRefType()
NewArrayFluent.ClassRefTypeNested<A>	withNewClassRefTypeLike(ClassRef item)
NewArrayFluent.PrimitiveRefTypeNested<A>	withNewPrimitiveRefType()
NewArrayFluent.PrimitiveRefTypeNested<A>	withNewPrimitiveRefTypeLike(PrimitiveRef item)
NewArrayFluent.TypeParamRefTypeNested<A>	withNewTypeParamRefType()
NewArrayFluent.TypeParamRefTypeNested<A>	withNewTypeParamRefTypeLike(TypeParamRef item)
NewArrayFluent.VoidRefTypeNested<A>	withNewVoidRefType()
NewArrayFluent.VoidRefTypeNested<A>	withNewVoidRefTypeLike(VoidRef item)
NewArrayFluent.WildcardRefTypeNested<A>	withNewWildcardRefType()
NewArrayFluent.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 Detail

NewArrayFluent

public NewArrayFluent()

NewArrayFluent

public NewArrayFluent(NewArray instance)

Method Detail

copyInstance

protected void copyInstance(NewArray instance)

buildType

public TypeRef buildType()

withType

public A withType(TypeRef type)

hasType

public boolean hasType()

withNewClassRefType

public NewArrayFluent.ClassRefTypeNested<A> withNewClassRefType()

withNewClassRefTypeLike

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

withNewPrimitiveRefType

public NewArrayFluent.PrimitiveRefTypeNested<A> withNewPrimitiveRefType()

withNewPrimitiveRefTypeLike

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

withNewVoidRefType

public NewArrayFluent.VoidRefTypeNested<A> withNewVoidRefType()

withNewVoidRefTypeLike

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

withNewTypeParamRefType

public NewArrayFluent.TypeParamRefTypeNested<A> withNewTypeParamRefType()

withNewTypeParamRefTypeLike

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

withNewWildcardRefType

public NewArrayFluent.WildcardRefTypeNested<A> withNewWildcardRefType()

withNewWildcardRefTypeLike

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

addToExpressions

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

addToExpressions

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

addToExpressions

public A addToExpressions(int index,
                          Expression item)

setToExpressions

public A setToExpressions(int index,
                          Expression item)

addToExpressions

public A addToExpressions(Expression... items)

addAllToExpressions

public A addAllToExpressions(Collection<Expression> items)

removeFromExpressions

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

removeFromExpressions

public A removeFromExpressions(Expression... items)

removeAllFromExpressions

public A removeAllFromExpressions(Collection<Expression> items)

removeMatchingFromExpressions

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

buildExpressions

public List<Expression> buildExpressions()

buildExpression

public Expression buildExpression(int index)

buildFirstExpression

public Expression buildFirstExpression()

buildLastExpression

public Expression buildLastExpression()

buildMatchingExpression

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

hasMatchingExpression

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

withExpressions

public A withExpressions(List<Expression> expressions)

withExpressions

public A withExpressions(Expression... expressions)

hasExpressions

public boolean hasExpressions()

addNewMultiplyExpression

public NewArrayFluent.MultiplyExpressionsNested<A> addNewMultiplyExpression()

addNewMultiplyExpressionLike

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

addNewMultiplyExpression

public A addNewMultiplyExpression(Object left,
                                  Object right)

setNewMultiplyExpressionLike

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

addNewNewArrayExpression

public NewArrayFluent.NewArrayExpressionsNested<A> addNewNewArrayExpression()

addNewNewArrayExpressionLike

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

addNewNewArrayExpression

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

setNewNewArrayExpressionLike

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

addNewInstanceOfExpression

public NewArrayFluent.InstanceOfExpressionsNested<A> addNewInstanceOfExpression()

addNewInstanceOfExpressionLike

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

setNewInstanceOfExpressionLike

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

addNewMethodCallExpression

public NewArrayFluent.MethodCallExpressionsNested<A> addNewMethodCallExpression()

addNewMethodCallExpressionLike

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

setNewMethodCallExpressionLike

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

addNewInverseExpression

public NewArrayFluent.InverseExpressionsNested<A> addNewInverseExpression()

addNewInverseExpressionLike

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

setNewInverseExpressionLike

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

addNewIndexExpression

public NewArrayFluent.IndexExpressionsNested<A> addNewIndexExpression()

addNewIndexExpressionLike

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

setNewIndexExpressionLike

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

addNewGreaterThanOrEqualExpression

public NewArrayFluent.GreaterThanOrEqualExpressionsNested<A> addNewGreaterThanOrEqualExpression()

addNewGreaterThanOrEqualExpressionLike

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

addNewGreaterThanOrEqualExpression

public A addNewGreaterThanOrEqualExpression(Object left,
                                            Object right)

setNewGreaterThanOrEqualExpressionLike

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

addNewBitwiseAndExpression

public NewArrayFluent.BitwiseAndExpressionsNested<A> addNewBitwiseAndExpression()

addNewBitwiseAndExpressionLike

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

addNewBitwiseAndExpression

public A addNewBitwiseAndExpression(Object left,
                                    Object right)

setNewBitwiseAndExpressionLike

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

addNewMinusExpression

public NewArrayFluent.MinusExpressionsNested<A> addNewMinusExpression()

addNewMinusExpressionLike

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

addNewMinusExpression

public A addNewMinusExpression(Object left,
                               Object right)

setNewMinusExpressionLike

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

addNewLogicalOrExpression

public NewArrayFluent.LogicalOrExpressionsNested<A> addNewLogicalOrExpression()

addNewLogicalOrExpressionLike

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

addNewLogicalOrExpression

public A addNewLogicalOrExpression(Object left,
                                   Object right)

setNewLogicalOrExpressionLike

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

addNewNotEqualsExpression

public NewArrayFluent.NotEqualsExpressionsNested<A> addNewNotEqualsExpression()

addNewNotEqualsExpressionLike

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

addNewNotEqualsExpression

public A addNewNotEqualsExpression(Object left,
                                   Object right)

setNewNotEqualsExpressionLike

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

addNewDivideExpression

public NewArrayFluent.DivideExpressionsNested<A> addNewDivideExpression()

addNewDivideExpressionLike

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

addNewDivideExpression

public A addNewDivideExpression(Object left,
                                Object right)

setNewDivideExpressionLike

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

addNewLessThanExpression

public NewArrayFluent.LessThanExpressionsNested<A> addNewLessThanExpression()

addNewLessThanExpressionLike

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

addNewLessThanExpression

public A addNewLessThanExpression(Object left,
                                  Object right)

setNewLessThanExpressionLike

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

addNewBitwiseOrExpression

public NewArrayFluent.BitwiseOrExpressionsNested<A> addNewBitwiseOrExpression()

addNewBitwiseOrExpressionLike

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

addNewBitwiseOrExpression

public A addNewBitwiseOrExpression(Object left,
                                   Object right)

setNewBitwiseOrExpressionLike

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

addNewPropertyRefExpression

public NewArrayFluent.PropertyRefExpressionsNested<A> addNewPropertyRefExpression()

addNewPropertyRefExpressionLike

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

setNewPropertyRefExpressionLike

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

addNewRightShiftExpression

public NewArrayFluent.RightShiftExpressionsNested<A> addNewRightShiftExpression()

addNewRightShiftExpressionLike

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

addNewRightShiftExpression

public A addNewRightShiftExpression(Object left,
                                    Object right)

setNewRightShiftExpressionLike

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

addNewGreaterThanExpression

public NewArrayFluent.GreaterThanExpressionsNested<A> addNewGreaterThanExpression()

addNewGreaterThanExpressionLike

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

addNewGreaterThanExpression

public A addNewGreaterThanExpression(Object left,
                                     Object right)

setNewGreaterThanExpressionLike

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

addNewDeclareExpression

public NewArrayFluent.DeclareExpressionsNested<A> addNewDeclareExpression()

addNewDeclareExpressionLike

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

addNewDeclareExpression

public A addNewDeclareExpression(Class type,
                                 String name)

addNewDeclareExpression

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

setNewDeclareExpressionLike

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

addNewCastExpression

public NewArrayFluent.CastExpressionsNested<A> addNewCastExpression()

addNewCastExpressionLike

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

setNewCastExpressionLike

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

addNewModuloExpression

public NewArrayFluent.ModuloExpressionsNested<A> addNewModuloExpression()

addNewModuloExpressionLike

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

addNewModuloExpression

public A addNewModuloExpression(Object left,
                                Object right)

setNewModuloExpressionLike

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

addNewValueRefExpression

public NewArrayFluent.ValueRefExpressionsNested<A> addNewValueRefExpression()

addNewValueRefExpressionLike

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

addNewValueRefExpression

public A addNewValueRefExpression(Object value)

setNewValueRefExpressionLike

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

addNewLeftShiftExpression

public NewArrayFluent.LeftShiftExpressionsNested<A> addNewLeftShiftExpression()

addNewLeftShiftExpressionLike

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

addNewLeftShiftExpression

public A addNewLeftShiftExpression(Object left,
                                   Object right)

setNewLeftShiftExpressionLike

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

addNewTernaryExpression

public NewArrayFluent.TernaryExpressionsNested<A> addNewTernaryExpression()

addNewTernaryExpressionLike

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

setNewTernaryExpressionLike

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

addNewBinaryExpressionExpression

public NewArrayFluent.BinaryExpressionExpressionsNested<A> addNewBinaryExpressionExpression()

addNewBinaryExpressionExpressionLike

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

setNewBinaryExpressionExpressionLike

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

addNewEqualsExpression

public NewArrayFluent.EqualsExpressionsNested<A> addNewEqualsExpression()

addNewEqualsExpressionLike

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

addNewEqualsExpression

public A addNewEqualsExpression(Object left,
                                Object right)

setNewEqualsExpressionLike

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

addNewEnclosedExpression

public NewArrayFluent.EnclosedExpressionsNested<A> addNewEnclosedExpression()

addNewEnclosedExpressionLike

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

setNewEnclosedExpressionLike

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

addNewPreDecrementExpression

public NewArrayFluent.PreDecrementExpressionsNested<A> addNewPreDecrementExpression()

addNewPreDecrementExpressionLike

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

setNewPreDecrementExpressionLike

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

addNewPostDecrementExpression

public NewArrayFluent.PostDecrementExpressionsNested<A> addNewPostDecrementExpression()

addNewPostDecrementExpressionLike

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

setNewPostDecrementExpressionLike

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

addNewLambdaExpression

public NewArrayFluent.LambdaExpressionsNested<A> addNewLambdaExpression()

addNewLambdaExpressionLike

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

setNewLambdaExpressionLike

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

addNewNotExpression

public NewArrayFluent.NotExpressionsNested<A> addNewNotExpression()

addNewNotExpressionLike

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

setNewNotExpressionLike

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

addNewAssignExpression

public NewArrayFluent.AssignExpressionsNested<A> addNewAssignExpression()

addNewAssignExpressionLike

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

setNewAssignExpressionLike

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

addNewNegativeExpression

public NewArrayFluent.NegativeExpressionsNested<A> addNewNegativeExpression()

addNewNegativeExpressionLike

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

setNewNegativeExpressionLike

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

addNewThisExpression

public NewArrayFluent.ThisExpressionsNested<A> addNewThisExpression()

addNewThisExpressionLike

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

setNewThisExpressionLike

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

addNewLogicalAndExpression

public NewArrayFluent.LogicalAndExpressionsNested<A> addNewLogicalAndExpression()

addNewLogicalAndExpressionLike

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

addNewLogicalAndExpression

public A addNewLogicalAndExpression(Object left,
                                    Object right)

setNewLogicalAndExpressionLike

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

addNewPostIncrementExpression

public NewArrayFluent.PostIncrementExpressionsNested<A> addNewPostIncrementExpression()

addNewPostIncrementExpressionLike

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

setNewPostIncrementExpressionLike

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

addNewRightUnsignedShiftExpression

public NewArrayFluent.RightUnsignedShiftExpressionsNested<A> addNewRightUnsignedShiftExpression()

addNewRightUnsignedShiftExpressionLike

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

addNewRightUnsignedShiftExpression

public A addNewRightUnsignedShiftExpression(Object left,
                                            Object right)

setNewRightUnsignedShiftExpressionLike

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

addNewPlusExpression

public NewArrayFluent.PlusExpressionsNested<A> addNewPlusExpression()

addNewPlusExpressionLike

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

addNewPlusExpression

public A addNewPlusExpression(Object left,
                              Object right)

setNewPlusExpressionLike

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

addNewConstructExpression

public NewArrayFluent.ConstructExpressionsNested<A> addNewConstructExpression()

addNewConstructExpressionLike

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

setNewConstructExpressionLike

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

addNewXorExpression

public NewArrayFluent.XorExpressionsNested<A> addNewXorExpression()

addNewXorExpressionLike

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

addNewXorExpression

public A addNewXorExpression(Object left,
                             Object right)

setNewXorExpressionLike

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

addNewPreIncrementExpression

public NewArrayFluent.PreIncrementExpressionsNested<A> addNewPreIncrementExpression()

addNewPreIncrementExpressionLike

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

setNewPreIncrementExpressionLike

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

addNewLessThanOrEqualExpression

public NewArrayFluent.LessThanOrEqualExpressionsNested<A> addNewLessThanOrEqualExpression()

addNewLessThanOrEqualExpressionLike

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

addNewLessThanOrEqualExpression

public A addNewLessThanOrEqualExpression(Object left,
                                         Object right)

setNewLessThanOrEqualExpressionLike

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

addNewPositiveExpression

public NewArrayFluent.PositiveExpressionsNested<A> addNewPositiveExpression()

addNewPositiveExpressionLike

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

setNewPositiveExpressionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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