io.sundr.model.NewArrayFluent Maven / Gradle / Ivy
package io.sundr.model;
import java.util.ArrayList;
import java.lang.String;
import java.util.function.Predicate;
import java.util.List;
import java.lang.Class;
import java.lang.SuppressWarnings;
import java.util.Iterator;
import java.lang.Integer;
import io.sundr.builder.BaseFluent;
import java.lang.Object;
import io.sundr.builder.VisitableBuilder;
import java.util.Collection;
import io.sundr.builder.Nested;
/**
* Generated
*/
@SuppressWarnings("unchecked")
public class NewArrayFluent> extends BaseFluent{
public NewArrayFluent() {
}
public NewArrayFluent(NewArray instance) {
this.copyInstance(instance);
}
private VisitableBuilder type;
private ArrayList> expressions = new ArrayList>();
protected void copyInstance(NewArray instance) {
if (instance != null) {
this.withType(instance.getType());
this.withExpressions(instance.getExpressions());
}
}
public TypeRef buildType() {
return this.type!=null?this.type.build():null;
}
public A withType(TypeRef type) {
if (type==null){ this.type = null; _visitables.remove("type"); return (A) this;}
VisitableBuilder builder = builder(type); _visitables.get("type").clear();_visitables.get("type").add(builder);this.type = builder;
return (A) this;
}
public boolean hasType() {
return this.type != null;
}
public ClassRefTypeNested withNewClassRefType() {
return new ClassRefTypeNested(null);
}
public ClassRefTypeNested withNewClassRefTypeLike(ClassRef item) {
return new ClassRefTypeNested(item);
}
public PrimitiveRefTypeNested withNewPrimitiveRefType() {
return new PrimitiveRefTypeNested(null);
}
public PrimitiveRefTypeNested withNewPrimitiveRefTypeLike(PrimitiveRef item) {
return new PrimitiveRefTypeNested(item);
}
public VoidRefTypeNested withNewVoidRefType() {
return new VoidRefTypeNested(null);
}
public VoidRefTypeNested withNewVoidRefTypeLike(VoidRef item) {
return new VoidRefTypeNested(item);
}
public TypeParamRefTypeNested withNewTypeParamRefType() {
return new TypeParamRefTypeNested(null);
}
public TypeParamRefTypeNested withNewTypeParamRefTypeLike(TypeParamRef item) {
return new TypeParamRefTypeNested(item);
}
public WildcardRefTypeNested withNewWildcardRefType() {
return new WildcardRefTypeNested(null);
}
public WildcardRefTypeNested withNewWildcardRefTypeLike(WildcardRef item) {
return new WildcardRefTypeNested(item);
}
public A addToExpressions(VisitableBuilder builder) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
_visitables.get("expressions").add(builder);this.expressions.add(builder); return (A)this;
}
public A addToExpressions(int index,VisitableBuilder builder) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
if (index < 0 || index >= expressions.size()) { _visitables.get("expressions").add(builder); expressions.add(builder); } else { _visitables.get("expressions").add(index, builder); expressions.add(index, builder);}
return (A)this;
}
public A addToExpressions(int index,Expression item) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
VisitableBuilder builder = builder(item);
if (index < 0 || index >= expressions.size()) { _visitables.get("expressions").add(builder); expressions.add(builder); } else { _visitables.get("expressions").add(index, builder); expressions.add(index, builder);}
return (A)this;
}
public A setToExpressions(int index,Expression item) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
VisitableBuilder builder = builder(item);
if (index < 0 || index >= expressions.size()) { _visitables.get("expressions").add(builder); expressions.add(builder); } else { _visitables.get("expressions").set(index, builder); expressions.set(index, builder);}
return (A)this;
}
public A addToExpressions(io.sundr.model.Expression... items) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("expressions").add(builder);this.expressions.add(builder); }
return (A)this;
}
public A addAllToExpressions(Collection items) {
if (this.expressions == null) {this.expressions = new ArrayList>();}
for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("expressions").add(builder);this.expressions.add(builder); }
return (A)this;
}
public A removeFromExpressions(VisitableBuilder builder) {
if (this.expressions == null) return (A)this;
_visitables.get("expressions").remove(builder);this.expressions.remove(builder); return (A)this;
}
public A removeFromExpressions(io.sundr.model.Expression... items) {
if (this.expressions == null) return (A)this;
for (Expression item : items) {
VisitableBuilder builder = builder(item); _visitables.get("expressions").remove(builder);this.expressions.remove(builder);
} return (A)this;
}
public A removeAllFromExpressions(Collection items) {
if (this.expressions == null) return (A)this;
for (Expression item : items) {
VisitableBuilder builder = builder(item); _visitables.get("expressions").remove(builder);this.expressions.remove(builder);
} return (A)this;
}
public A removeMatchingFromExpressions(Predicate> predicate) {
if (expressions == null) return (A) this;
final Iterator> each = expressions.iterator();
final List visitables = _visitables.get("expressions");
while (each.hasNext()) {
VisitableBuilder builder = each.next();
if (predicate.test(builder)) {
visitables.remove(builder);
each.remove();
}
}
return (A)this;
}
public List buildExpressions() {
return build(expressions);
}
public Expression buildExpression(int index) {
return this.expressions.get(index).build();
}
public Expression buildFirstExpression() {
return this.expressions.get(0).build();
}
public Expression buildLastExpression() {
return this.expressions.get(expressions.size() - 1).build();
}
public Expression buildMatchingExpression(Predicate> predicate) {
for (VisitableBuilder item: expressions) { if(predicate.test(item)){ return item.build();} } return null;
}
public boolean hasMatchingExpression(Predicate> predicate) {
for (VisitableBuilder item: expressions) { if(predicate.test(item)){ return true;} } return false;
}
public A withExpressions(List expressions) {
if (expressions != null) {this.expressions = new ArrayList(); for (Expression item : expressions){this.addToExpressions(item);}} else { this.expressions = null;} return (A) this;
}
public A withExpressions(io.sundr.model.Expression... expressions) {
if (this.expressions != null) {this.expressions.clear(); _visitables.remove("expressions"); }
if (expressions != null) {for (Expression item :expressions){ this.addToExpressions(item);}} return (A) this;
}
public boolean hasExpressions() {
return expressions != null && !expressions.isEmpty();
}
public MultiplyExpressionsNested addNewMultiplyExpression() {
return new MultiplyExpressionsNested(-1, null);
}
public MultiplyExpressionsNested addNewMultiplyExpressionLike(Multiply item) {
return new MultiplyExpressionsNested(-1, item);
}
public A addNewMultiplyExpression(Object left,Object right) {
return (A)addToExpressions(new Multiply(left, right));
}
public MultiplyExpressionsNested setNewMultiplyExpressionLike(int index,Multiply item) {
return new MultiplyExpressionsNested(index, item);
}
public NewArrayExpressionsNested addNewNewArrayExpression() {
return new NewArrayExpressionsNested(-1, null);
}
public NewArrayExpressionsNested addNewNewArrayExpressionLike(NewArray item) {
return new NewArrayExpressionsNested(-1, item);
}
public A addNewNewArrayExpression(Class type,Integer[] sizes) {
return (A)addToExpressions(new NewArray(type, sizes));
}
public NewArrayExpressionsNested setNewNewArrayExpressionLike(int index,NewArray item) {
return new NewArrayExpressionsNested(index, item);
}
public InstanceOfExpressionsNested addNewInstanceOfExpression() {
return new InstanceOfExpressionsNested(-1, null);
}
public InstanceOfExpressionsNested addNewInstanceOfExpressionLike(InstanceOf item) {
return new InstanceOfExpressionsNested(-1, item);
}
public InstanceOfExpressionsNested setNewInstanceOfExpressionLike(int index,InstanceOf item) {
return new InstanceOfExpressionsNested(index, item);
}
public MethodCallExpressionsNested addNewMethodCallExpression() {
return new MethodCallExpressionsNested(-1, null);
}
public MethodCallExpressionsNested addNewMethodCallExpressionLike(MethodCall item) {
return new MethodCallExpressionsNested(-1, item);
}
public MethodCallExpressionsNested setNewMethodCallExpressionLike(int index,MethodCall item) {
return new MethodCallExpressionsNested(index, item);
}
public InverseExpressionsNested addNewInverseExpression() {
return new InverseExpressionsNested(-1, null);
}
public InverseExpressionsNested addNewInverseExpressionLike(Inverse item) {
return new InverseExpressionsNested(-1, item);
}
public InverseExpressionsNested setNewInverseExpressionLike(int index,Inverse item) {
return new InverseExpressionsNested(index, item);
}
public IndexExpressionsNested addNewIndexExpression() {
return new IndexExpressionsNested(-1, null);
}
public IndexExpressionsNested addNewIndexExpressionLike(Index item) {
return new IndexExpressionsNested(-1, item);
}
public IndexExpressionsNested setNewIndexExpressionLike(int index,Index item) {
return new IndexExpressionsNested(index, item);
}
public GreaterThanOrEqualExpressionsNested addNewGreaterThanOrEqualExpression() {
return new GreaterThanOrEqualExpressionsNested(-1, null);
}
public GreaterThanOrEqualExpressionsNested addNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item) {
return new GreaterThanOrEqualExpressionsNested(-1, item);
}
public A addNewGreaterThanOrEqualExpression(Object left,Object right) {
return (A)addToExpressions(new GreaterThanOrEqual(left, right));
}
public GreaterThanOrEqualExpressionsNested setNewGreaterThanOrEqualExpressionLike(int index,GreaterThanOrEqual item) {
return new GreaterThanOrEqualExpressionsNested(index, item);
}
public BitwiseAndExpressionsNested addNewBitwiseAndExpression() {
return new BitwiseAndExpressionsNested(-1, null);
}
public BitwiseAndExpressionsNested addNewBitwiseAndExpressionLike(BitwiseAnd item) {
return new BitwiseAndExpressionsNested(-1, item);
}
public A addNewBitwiseAndExpression(Object left,Object right) {
return (A)addToExpressions(new BitwiseAnd(left, right));
}
public BitwiseAndExpressionsNested setNewBitwiseAndExpressionLike(int index,BitwiseAnd item) {
return new BitwiseAndExpressionsNested(index, item);
}
public MinusExpressionsNested addNewMinusExpression() {
return new MinusExpressionsNested(-1, null);
}
public MinusExpressionsNested addNewMinusExpressionLike(Minus item) {
return new MinusExpressionsNested(-1, item);
}
public A addNewMinusExpression(Object left,Object right) {
return (A)addToExpressions(new Minus(left, right));
}
public MinusExpressionsNested setNewMinusExpressionLike(int index,Minus item) {
return new MinusExpressionsNested(index, item);
}
public LogicalOrExpressionsNested addNewLogicalOrExpression() {
return new LogicalOrExpressionsNested(-1, null);
}
public LogicalOrExpressionsNested addNewLogicalOrExpressionLike(LogicalOr item) {
return new LogicalOrExpressionsNested(-1, item);
}
public A addNewLogicalOrExpression(Object left,Object right) {
return (A)addToExpressions(new LogicalOr(left, right));
}
public LogicalOrExpressionsNested setNewLogicalOrExpressionLike(int index,LogicalOr item) {
return new LogicalOrExpressionsNested(index, item);
}
public NotEqualsExpressionsNested addNewNotEqualsExpression() {
return new NotEqualsExpressionsNested(-1, null);
}
public NotEqualsExpressionsNested addNewNotEqualsExpressionLike(NotEquals item) {
return new NotEqualsExpressionsNested(-1, item);
}
public A addNewNotEqualsExpression(Object left,Object right) {
return (A)addToExpressions(new NotEquals(left, right));
}
public NotEqualsExpressionsNested setNewNotEqualsExpressionLike(int index,NotEquals item) {
return new NotEqualsExpressionsNested(index, item);
}
public DivideExpressionsNested addNewDivideExpression() {
return new DivideExpressionsNested(-1, null);
}
public DivideExpressionsNested addNewDivideExpressionLike(Divide item) {
return new DivideExpressionsNested(-1, item);
}
public A addNewDivideExpression(Object left,Object right) {
return (A)addToExpressions(new Divide(left, right));
}
public DivideExpressionsNested setNewDivideExpressionLike(int index,Divide item) {
return new DivideExpressionsNested(index, item);
}
public LessThanExpressionsNested addNewLessThanExpression() {
return new LessThanExpressionsNested(-1, null);
}
public LessThanExpressionsNested addNewLessThanExpressionLike(LessThan item) {
return new LessThanExpressionsNested(-1, item);
}
public A addNewLessThanExpression(Object left,Object right) {
return (A)addToExpressions(new LessThan(left, right));
}
public LessThanExpressionsNested setNewLessThanExpressionLike(int index,LessThan item) {
return new LessThanExpressionsNested(index, item);
}
public BitwiseOrExpressionsNested addNewBitwiseOrExpression() {
return new BitwiseOrExpressionsNested(-1, null);
}
public BitwiseOrExpressionsNested addNewBitwiseOrExpressionLike(BitwiseOr item) {
return new BitwiseOrExpressionsNested(-1, item);
}
public A addNewBitwiseOrExpression(Object left,Object right) {
return (A)addToExpressions(new BitwiseOr(left, right));
}
public BitwiseOrExpressionsNested setNewBitwiseOrExpressionLike(int index,BitwiseOr item) {
return new BitwiseOrExpressionsNested(index, item);
}
public PropertyRefExpressionsNested addNewPropertyRefExpression() {
return new PropertyRefExpressionsNested(-1, null);
}
public PropertyRefExpressionsNested addNewPropertyRefExpressionLike(PropertyRef item) {
return new PropertyRefExpressionsNested(-1, item);
}
public PropertyRefExpressionsNested setNewPropertyRefExpressionLike(int index,PropertyRef item) {
return new PropertyRefExpressionsNested(index, item);
}
public RightShiftExpressionsNested addNewRightShiftExpression() {
return new RightShiftExpressionsNested(-1, null);
}
public RightShiftExpressionsNested addNewRightShiftExpressionLike(RightShift item) {
return new RightShiftExpressionsNested(-1, item);
}
public A addNewRightShiftExpression(Object left,Object right) {
return (A)addToExpressions(new RightShift(left, right));
}
public RightShiftExpressionsNested setNewRightShiftExpressionLike(int index,RightShift item) {
return new RightShiftExpressionsNested(index, item);
}
public GreaterThanExpressionsNested addNewGreaterThanExpression() {
return new GreaterThanExpressionsNested(-1, null);
}
public GreaterThanExpressionsNested addNewGreaterThanExpressionLike(GreaterThan item) {
return new GreaterThanExpressionsNested(-1, item);
}
public A addNewGreaterThanExpression(Object left,Object right) {
return (A)addToExpressions(new GreaterThan(left, right));
}
public GreaterThanExpressionsNested setNewGreaterThanExpressionLike(int index,GreaterThan item) {
return new GreaterThanExpressionsNested(index, item);
}
public DeclareExpressionsNested addNewDeclareExpression() {
return new DeclareExpressionsNested(-1, null);
}
public DeclareExpressionsNested addNewDeclareExpressionLike(Declare item) {
return new DeclareExpressionsNested(-1, item);
}
public A addNewDeclareExpression(Class type,String name) {
return (A)addToExpressions(new Declare(type, name));
}
public A addNewDeclareExpression(Class type,String name,Object value) {
return (A)addToExpressions(new Declare(type, name, value));
}
public DeclareExpressionsNested setNewDeclareExpressionLike(int index,Declare item) {
return new DeclareExpressionsNested(index, item);
}
public CastExpressionsNested addNewCastExpression() {
return new CastExpressionsNested(-1, null);
}
public CastExpressionsNested addNewCastExpressionLike(Cast item) {
return new CastExpressionsNested(-1, item);
}
public CastExpressionsNested setNewCastExpressionLike(int index,Cast item) {
return new CastExpressionsNested(index, item);
}
public ModuloExpressionsNested addNewModuloExpression() {
return new ModuloExpressionsNested(-1, null);
}
public ModuloExpressionsNested addNewModuloExpressionLike(Modulo item) {
return new ModuloExpressionsNested(-1, item);
}
public A addNewModuloExpression(Object left,Object right) {
return (A)addToExpressions(new Modulo(left, right));
}
public ModuloExpressionsNested setNewModuloExpressionLike(int index,Modulo item) {
return new ModuloExpressionsNested(index, item);
}
public ValueRefExpressionsNested addNewValueRefExpression() {
return new ValueRefExpressionsNested(-1, null);
}
public ValueRefExpressionsNested addNewValueRefExpressionLike(ValueRef item) {
return new ValueRefExpressionsNested(-1, item);
}
public A addNewValueRefExpression(Object value) {
return (A)addToExpressions(new ValueRef(value));
}
public ValueRefExpressionsNested setNewValueRefExpressionLike(int index,ValueRef item) {
return new ValueRefExpressionsNested(index, item);
}
public LeftShiftExpressionsNested addNewLeftShiftExpression() {
return new LeftShiftExpressionsNested(-1, null);
}
public LeftShiftExpressionsNested addNewLeftShiftExpressionLike(LeftShift item) {
return new LeftShiftExpressionsNested(-1, item);
}
public A addNewLeftShiftExpression(Object left,Object right) {
return (A)addToExpressions(new LeftShift(left, right));
}
public LeftShiftExpressionsNested setNewLeftShiftExpressionLike(int index,LeftShift item) {
return new LeftShiftExpressionsNested(index, item);
}
public TernaryExpressionsNested addNewTernaryExpression() {
return new TernaryExpressionsNested(-1, null);
}
public TernaryExpressionsNested addNewTernaryExpressionLike(Ternary item) {
return new TernaryExpressionsNested(-1, item);
}
public TernaryExpressionsNested setNewTernaryExpressionLike(int index,Ternary item) {
return new TernaryExpressionsNested(index, item);
}
public BinaryExpressionExpressionsNested addNewBinaryExpressionExpression() {
return new BinaryExpressionExpressionsNested(-1, null);
}
public BinaryExpressionExpressionsNested addNewBinaryExpressionExpressionLike(BinaryExpression item) {
return new BinaryExpressionExpressionsNested(-1, item);
}
public BinaryExpressionExpressionsNested setNewBinaryExpressionExpressionLike(int index,BinaryExpression item) {
return new BinaryExpressionExpressionsNested(index, item);
}
public EqualsExpressionsNested addNewEqualsExpression() {
return new EqualsExpressionsNested(-1, null);
}
public EqualsExpressionsNested addNewEqualsExpressionLike(Equals item) {
return new EqualsExpressionsNested(-1, item);
}
public A addNewEqualsExpression(Object left,Object right) {
return (A)addToExpressions(new Equals(left, right));
}
public EqualsExpressionsNested setNewEqualsExpressionLike(int index,Equals item) {
return new EqualsExpressionsNested(index, item);
}
public EnclosedExpressionsNested addNewEnclosedExpression() {
return new EnclosedExpressionsNested(-1, null);
}
public EnclosedExpressionsNested addNewEnclosedExpressionLike(Enclosed item) {
return new EnclosedExpressionsNested(-1, item);
}
public EnclosedExpressionsNested setNewEnclosedExpressionLike(int index,Enclosed item) {
return new EnclosedExpressionsNested(index, item);
}
public PreDecrementExpressionsNested addNewPreDecrementExpression() {
return new PreDecrementExpressionsNested(-1, null);
}
public PreDecrementExpressionsNested addNewPreDecrementExpressionLike(PreDecrement item) {
return new PreDecrementExpressionsNested(-1, item);
}
public PreDecrementExpressionsNested setNewPreDecrementExpressionLike(int index,PreDecrement item) {
return new PreDecrementExpressionsNested(index, item);
}
public PostDecrementExpressionsNested addNewPostDecrementExpression() {
return new PostDecrementExpressionsNested(-1, null);
}
public PostDecrementExpressionsNested addNewPostDecrementExpressionLike(PostDecrement item) {
return new PostDecrementExpressionsNested(-1, item);
}
public PostDecrementExpressionsNested setNewPostDecrementExpressionLike(int index,PostDecrement item) {
return new PostDecrementExpressionsNested(index, item);
}
public LambdaExpressionsNested addNewLambdaExpression() {
return new LambdaExpressionsNested(-1, null);
}
public LambdaExpressionsNested addNewLambdaExpressionLike(Lambda item) {
return new LambdaExpressionsNested(-1, item);
}
public LambdaExpressionsNested setNewLambdaExpressionLike(int index,Lambda item) {
return new LambdaExpressionsNested(index, item);
}
public NotExpressionsNested addNewNotExpression() {
return new NotExpressionsNested(-1, null);
}
public NotExpressionsNested addNewNotExpressionLike(Not item) {
return new NotExpressionsNested(-1, item);
}
public NotExpressionsNested setNewNotExpressionLike(int index,Not item) {
return new NotExpressionsNested(index, item);
}
public ThisExpressionsNested addNewThisExpression() {
return new ThisExpressionsNested(-1, null);
}
public ThisExpressionsNested addNewThisExpressionLike(This item) {
return new ThisExpressionsNested(-1, item);
}
public ThisExpressionsNested setNewThisExpressionLike(int index,This item) {
return new ThisExpressionsNested(index, item);
}
public NegativeExpressionsNested addNewNegativeExpression() {
return new NegativeExpressionsNested(-1, null);
}
public NegativeExpressionsNested addNewNegativeExpressionLike(Negative item) {
return new NegativeExpressionsNested(-1, item);
}
public NegativeExpressionsNested setNewNegativeExpressionLike(int index,Negative item) {
return new NegativeExpressionsNested(index, item);
}
public AssignExpressionsNested addNewAssignExpression() {
return new AssignExpressionsNested(-1, null);
}
public AssignExpressionsNested addNewAssignExpressionLike(Assign item) {
return new AssignExpressionsNested(-1, item);
}
public AssignExpressionsNested setNewAssignExpressionLike(int index,Assign item) {
return new AssignExpressionsNested(index, item);
}
public LogicalAndExpressionsNested addNewLogicalAndExpression() {
return new LogicalAndExpressionsNested(-1, null);
}
public LogicalAndExpressionsNested addNewLogicalAndExpressionLike(LogicalAnd item) {
return new LogicalAndExpressionsNested(-1, item);
}
public A addNewLogicalAndExpression(Object left,Object right) {
return (A)addToExpressions(new LogicalAnd(left, right));
}
public LogicalAndExpressionsNested setNewLogicalAndExpressionLike(int index,LogicalAnd item) {
return new LogicalAndExpressionsNested(index, item);
}
public PostIncrementExpressionsNested addNewPostIncrementExpression() {
return new PostIncrementExpressionsNested(-1, null);
}
public PostIncrementExpressionsNested addNewPostIncrementExpressionLike(PostIncrement item) {
return new PostIncrementExpressionsNested(-1, item);
}
public PostIncrementExpressionsNested setNewPostIncrementExpressionLike(int index,PostIncrement item) {
return new PostIncrementExpressionsNested(index, item);
}
public RightUnsignedShiftExpressionsNested addNewRightUnsignedShiftExpression() {
return new RightUnsignedShiftExpressionsNested(-1, null);
}
public RightUnsignedShiftExpressionsNested addNewRightUnsignedShiftExpressionLike(RightUnsignedShift item) {
return new RightUnsignedShiftExpressionsNested(-1, item);
}
public A addNewRightUnsignedShiftExpression(Object left,Object right) {
return (A)addToExpressions(new RightUnsignedShift(left, right));
}
public RightUnsignedShiftExpressionsNested setNewRightUnsignedShiftExpressionLike(int index,RightUnsignedShift item) {
return new RightUnsignedShiftExpressionsNested(index, item);
}
public PlusExpressionsNested addNewPlusExpression() {
return new PlusExpressionsNested(-1, null);
}
public PlusExpressionsNested addNewPlusExpressionLike(Plus item) {
return new PlusExpressionsNested(-1, item);
}
public A addNewPlusExpression(Object left,Object right) {
return (A)addToExpressions(new Plus(left, right));
}
public PlusExpressionsNested setNewPlusExpressionLike(int index,Plus item) {
return new PlusExpressionsNested(index, item);
}
public ConstructExpressionsNested addNewConstructExpression() {
return new ConstructExpressionsNested(-1, null);
}
public ConstructExpressionsNested addNewConstructExpressionLike(Construct item) {
return new ConstructExpressionsNested(-1, item);
}
public ConstructExpressionsNested setNewConstructExpressionLike(int index,Construct item) {
return new ConstructExpressionsNested(index, item);
}
public XorExpressionsNested addNewXorExpression() {
return new XorExpressionsNested(-1, null);
}
public XorExpressionsNested addNewXorExpressionLike(Xor item) {
return new XorExpressionsNested(-1, item);
}
public A addNewXorExpression(Object left,Object right) {
return (A)addToExpressions(new Xor(left, right));
}
public XorExpressionsNested setNewXorExpressionLike(int index,Xor item) {
return new XorExpressionsNested(index, item);
}
public PreIncrementExpressionsNested addNewPreIncrementExpression() {
return new PreIncrementExpressionsNested(-1, null);
}
public PreIncrementExpressionsNested addNewPreIncrementExpressionLike(PreIncrement item) {
return new PreIncrementExpressionsNested(-1, item);
}
public PreIncrementExpressionsNested setNewPreIncrementExpressionLike(int index,PreIncrement item) {
return new PreIncrementExpressionsNested(index, item);
}
public LessThanOrEqualExpressionsNested addNewLessThanOrEqualExpression() {
return new LessThanOrEqualExpressionsNested(-1, null);
}
public LessThanOrEqualExpressionsNested addNewLessThanOrEqualExpressionLike(LessThanOrEqual item) {
return new LessThanOrEqualExpressionsNested(-1, item);
}
public A addNewLessThanOrEqualExpression(Object left,Object right) {
return (A)addToExpressions(new LessThanOrEqual(left, right));
}
public LessThanOrEqualExpressionsNested setNewLessThanOrEqualExpressionLike(int index,LessThanOrEqual item) {
return new LessThanOrEqualExpressionsNested(index, item);
}
public PositiveExpressionsNested addNewPositiveExpression() {
return new PositiveExpressionsNested(-1, null);
}
public PositiveExpressionsNested addNewPositiveExpressionLike(Positive item) {
return new PositiveExpressionsNested(-1, item);
}
public PositiveExpressionsNested setNewPositiveExpressionLike(int index,Positive item) {
return new PositiveExpressionsNested(index, item);
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
NewArrayFluent that = (NewArrayFluent) o;
if (!java.util.Objects.equals(type, that.type)) return false;
if (!java.util.Objects.equals(expressions, that.expressions)) return false;
return true;
}
public int hashCode() {
return java.util.Objects.hash(type, expressions, super.hashCode());
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (type != null) { sb.append("type:"); sb.append(type + ","); }
if (expressions != null && !expressions.isEmpty()) { sb.append("expressions:"); sb.append(expressions); }
sb.append("}");
return sb.toString();
}
protected static VisitableBuilder builder(Object item) {
switch (item.getClass().getName()) {
case "io.sundr.model."+"ClassRef": return (VisitableBuilder)new ClassRefBuilder((ClassRef) item);
case "io.sundr.model."+"PrimitiveRef": return (VisitableBuilder)new PrimitiveRefBuilder((PrimitiveRef) item);
case "io.sundr.model."+"VoidRef": return (VisitableBuilder)new VoidRefBuilder((VoidRef) item);
case "io.sundr.model."+"TypeParamRef": return (VisitableBuilder)new TypeParamRefBuilder((TypeParamRef) item);
case "io.sundr.model."+"WildcardRef": return (VisitableBuilder)new WildcardRefBuilder((WildcardRef) item);
case "io.sundr.model."+"Multiply": return (VisitableBuilder)new MultiplyBuilder((Multiply) item);
case "io.sundr.model."+"NewArray": return (VisitableBuilder)new NewArrayBuilder((NewArray) item);
case "io.sundr.model."+"InstanceOf": return (VisitableBuilder)new InstanceOfBuilder((InstanceOf) item);
case "io.sundr.model."+"MethodCall": return (VisitableBuilder)new MethodCallBuilder((MethodCall) item);
case "io.sundr.model."+"Inverse": return (VisitableBuilder)new InverseBuilder((Inverse) item);
case "io.sundr.model."+"Index": return (VisitableBuilder)new IndexBuilder((Index) item);
case "io.sundr.model."+"GreaterThanOrEqual": return (VisitableBuilder)new GreaterThanOrEqualBuilder((GreaterThanOrEqual) item);
case "io.sundr.model."+"BitwiseAnd": return (VisitableBuilder)new BitwiseAndBuilder((BitwiseAnd) item);
case "io.sundr.model."+"Minus": return (VisitableBuilder)new MinusBuilder((Minus) item);
case "io.sundr.model."+"LogicalOr": return (VisitableBuilder)new LogicalOrBuilder((LogicalOr) item);
case "io.sundr.model."+"NotEquals": return (VisitableBuilder)new NotEqualsBuilder((NotEquals) item);
case "io.sundr.model."+"Divide": return (VisitableBuilder)new DivideBuilder((Divide) item);
case "io.sundr.model."+"LessThan": return (VisitableBuilder)new LessThanBuilder((LessThan) item);
case "io.sundr.model."+"BitwiseOr": return (VisitableBuilder)new BitwiseOrBuilder((BitwiseOr) item);
case "io.sundr.model."+"PropertyRef": return (VisitableBuilder)new PropertyRefBuilder((PropertyRef) item);
case "io.sundr.model."+"RightShift": return (VisitableBuilder)new RightShiftBuilder((RightShift) item);
case "io.sundr.model."+"GreaterThan": return (VisitableBuilder)new GreaterThanBuilder((GreaterThan) item);
case "io.sundr.model."+"Declare": return (VisitableBuilder)new DeclareBuilder((Declare) item);
case "io.sundr.model."+"Cast": return (VisitableBuilder)new CastBuilder((Cast) item);
case "io.sundr.model."+"Modulo": return (VisitableBuilder)new ModuloBuilder((Modulo) item);
case "io.sundr.model."+"ValueRef": return (VisitableBuilder)new ValueRefBuilder((ValueRef) item);
case "io.sundr.model."+"LeftShift": return (VisitableBuilder)new LeftShiftBuilder((LeftShift) item);
case "io.sundr.model."+"Ternary": return (VisitableBuilder)new TernaryBuilder((Ternary) item);
case "io.sundr.model."+"BinaryExpression": return (VisitableBuilder)new BinaryExpressionBuilder((BinaryExpression) item);
case "io.sundr.model."+"Equals": return (VisitableBuilder)new EqualsBuilder((Equals) item);
case "io.sundr.model."+"Enclosed": return (VisitableBuilder)new EnclosedBuilder((Enclosed) item);
case "io.sundr.model."+"PreDecrement": return (VisitableBuilder)new PreDecrementBuilder((PreDecrement) item);
case "io.sundr.model."+"PostDecrement": return (VisitableBuilder)new PostDecrementBuilder((PostDecrement) item);
case "io.sundr.model."+"Lambda": return (VisitableBuilder)new LambdaBuilder((Lambda) item);
case "io.sundr.model."+"Not": return (VisitableBuilder)new NotBuilder((Not) item);
case "io.sundr.model."+"This": return (VisitableBuilder)new ThisBuilder((This) item);
case "io.sundr.model."+"Negative": return (VisitableBuilder)new NegativeBuilder((Negative) item);
case "io.sundr.model."+"Assign": return (VisitableBuilder)new AssignBuilder((Assign) item);
case "io.sundr.model."+"LogicalAnd": return (VisitableBuilder)new LogicalAndBuilder((LogicalAnd) item);
case "io.sundr.model."+"PostIncrement": return (VisitableBuilder)new PostIncrementBuilder((PostIncrement) item);
case "io.sundr.model."+"RightUnsignedShift": return (VisitableBuilder)new RightUnsignedShiftBuilder((RightUnsignedShift) item);
case "io.sundr.model."+"Plus": return (VisitableBuilder)new PlusBuilder((Plus) item);
case "io.sundr.model."+"Construct": return (VisitableBuilder)new ConstructBuilder((Construct) item);
case "io.sundr.model."+"Xor": return (VisitableBuilder)new XorBuilder((Xor) item);
case "io.sundr.model."+"PreIncrement": return (VisitableBuilder)new PreIncrementBuilder((PreIncrement) item);
case "io.sundr.model."+"LessThanOrEqual": return (VisitableBuilder)new LessThanOrEqualBuilder((LessThanOrEqual) item);
case "io.sundr.model."+"Positive": return (VisitableBuilder)new PositiveBuilder((Positive) item);
}
return (VisitableBuilder)builderOf(item);
}
public class ClassRefTypeNested extends ClassRefFluent> implements Nested{
ClassRefTypeNested(ClassRef item) {
this.builder = new ClassRefBuilder(this, item);
}
ClassRefBuilder builder;
public N and() {
return (N) NewArrayFluent.this.withType(builder.build());
}
public N endClassRefType() {
return and();
}
}
public class PrimitiveRefTypeNested extends PrimitiveRefFluent> implements Nested{
PrimitiveRefTypeNested(PrimitiveRef item) {
this.builder = new PrimitiveRefBuilder(this, item);
}
PrimitiveRefBuilder builder;
public N and() {
return (N) NewArrayFluent.this.withType(builder.build());
}
public N endPrimitiveRefType() {
return and();
}
}
public class VoidRefTypeNested extends VoidRefFluent> implements Nested{
VoidRefTypeNested(VoidRef item) {
this.builder = new VoidRefBuilder(this, item);
}
VoidRefBuilder builder;
public N and() {
return (N) NewArrayFluent.this.withType(builder.build());
}
public N endVoidRefType() {
return and();
}
}
public class TypeParamRefTypeNested extends TypeParamRefFluent> implements Nested{
TypeParamRefTypeNested(TypeParamRef item) {
this.builder = new TypeParamRefBuilder(this, item);
}
TypeParamRefBuilder builder;
public N and() {
return (N) NewArrayFluent.this.withType(builder.build());
}
public N endTypeParamRefType() {
return and();
}
}
public class WildcardRefTypeNested extends WildcardRefFluent> implements Nested{
WildcardRefTypeNested(WildcardRef item) {
this.builder = new WildcardRefBuilder(this, item);
}
WildcardRefBuilder builder;
public N and() {
return (N) NewArrayFluent.this.withType(builder.build());
}
public N endWildcardRefType() {
return and();
}
}
public class MultiplyExpressionsNested extends MultiplyFluent> implements Nested{
MultiplyExpressionsNested(int index,Multiply item) {
this.index = index;
this.builder = new MultiplyBuilder(this, item);
}
MultiplyBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endMultiplyExpression() {
return and();
}
}
public class NewArrayExpressionsNested extends NewArrayFluent> implements Nested{
NewArrayExpressionsNested(int index,NewArray item) {
this.index = index;
this.builder = new NewArrayBuilder(this, item);
}
NewArrayBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endNewArrayExpression() {
return and();
}
}
public class InstanceOfExpressionsNested extends InstanceOfFluent> implements Nested{
InstanceOfExpressionsNested(int index,InstanceOf item) {
this.index = index;
this.builder = new InstanceOfBuilder(this, item);
}
InstanceOfBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endInstanceOfExpression() {
return and();
}
}
public class MethodCallExpressionsNested extends MethodCallFluent> implements Nested{
MethodCallExpressionsNested(int index,MethodCall item) {
this.index = index;
this.builder = new MethodCallBuilder(this, item);
}
MethodCallBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endMethodCallExpression() {
return and();
}
}
public class InverseExpressionsNested extends InverseFluent> implements Nested{
InverseExpressionsNested(int index,Inverse item) {
this.index = index;
this.builder = new InverseBuilder(this, item);
}
InverseBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endInverseExpression() {
return and();
}
}
public class IndexExpressionsNested extends IndexFluent> implements Nested{
IndexExpressionsNested(int index,Index item) {
this.index = index;
this.builder = new IndexBuilder(this, item);
}
IndexBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endIndexExpression() {
return and();
}
}
public class GreaterThanOrEqualExpressionsNested extends GreaterThanOrEqualFluent> implements Nested{
GreaterThanOrEqualExpressionsNested(int index,GreaterThanOrEqual item) {
this.index = index;
this.builder = new GreaterThanOrEqualBuilder(this, item);
}
GreaterThanOrEqualBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endGreaterThanOrEqualExpression() {
return and();
}
}
public class BitwiseAndExpressionsNested extends BitwiseAndFluent> implements Nested{
BitwiseAndExpressionsNested(int index,BitwiseAnd item) {
this.index = index;
this.builder = new BitwiseAndBuilder(this, item);
}
BitwiseAndBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endBitwiseAndExpression() {
return and();
}
}
public class MinusExpressionsNested extends MinusFluent> implements Nested{
MinusExpressionsNested(int index,Minus item) {
this.index = index;
this.builder = new MinusBuilder(this, item);
}
MinusBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endMinusExpression() {
return and();
}
}
public class LogicalOrExpressionsNested extends LogicalOrFluent> implements Nested{
LogicalOrExpressionsNested(int index,LogicalOr item) {
this.index = index;
this.builder = new LogicalOrBuilder(this, item);
}
LogicalOrBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLogicalOrExpression() {
return and();
}
}
public class NotEqualsExpressionsNested extends NotEqualsFluent> implements Nested{
NotEqualsExpressionsNested(int index,NotEquals item) {
this.index = index;
this.builder = new NotEqualsBuilder(this, item);
}
NotEqualsBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endNotEqualsExpression() {
return and();
}
}
public class DivideExpressionsNested extends DivideFluent> implements Nested{
DivideExpressionsNested(int index,Divide item) {
this.index = index;
this.builder = new DivideBuilder(this, item);
}
DivideBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endDivideExpression() {
return and();
}
}
public class LessThanExpressionsNested extends LessThanFluent> implements Nested{
LessThanExpressionsNested(int index,LessThan item) {
this.index = index;
this.builder = new LessThanBuilder(this, item);
}
LessThanBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLessThanExpression() {
return and();
}
}
public class BitwiseOrExpressionsNested extends BitwiseOrFluent> implements Nested{
BitwiseOrExpressionsNested(int index,BitwiseOr item) {
this.index = index;
this.builder = new BitwiseOrBuilder(this, item);
}
BitwiseOrBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endBitwiseOrExpression() {
return and();
}
}
public class PropertyRefExpressionsNested extends PropertyRefFluent> implements Nested{
PropertyRefExpressionsNested(int index,PropertyRef item) {
this.index = index;
this.builder = new PropertyRefBuilder(this, item);
}
PropertyRefBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPropertyRefExpression() {
return and();
}
}
public class RightShiftExpressionsNested extends RightShiftFluent> implements Nested{
RightShiftExpressionsNested(int index,RightShift item) {
this.index = index;
this.builder = new RightShiftBuilder(this, item);
}
RightShiftBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endRightShiftExpression() {
return and();
}
}
public class GreaterThanExpressionsNested extends GreaterThanFluent> implements Nested{
GreaterThanExpressionsNested(int index,GreaterThan item) {
this.index = index;
this.builder = new GreaterThanBuilder(this, item);
}
GreaterThanBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endGreaterThanExpression() {
return and();
}
}
public class DeclareExpressionsNested extends DeclareFluent> implements Nested{
DeclareExpressionsNested(int index,Declare item) {
this.index = index;
this.builder = new DeclareBuilder(this, item);
}
DeclareBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endDeclareExpression() {
return and();
}
}
public class CastExpressionsNested extends CastFluent> implements Nested{
CastExpressionsNested(int index,Cast item) {
this.index = index;
this.builder = new CastBuilder(this, item);
}
CastBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endCastExpression() {
return and();
}
}
public class ModuloExpressionsNested extends ModuloFluent> implements Nested{
ModuloExpressionsNested(int index,Modulo item) {
this.index = index;
this.builder = new ModuloBuilder(this, item);
}
ModuloBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endModuloExpression() {
return and();
}
}
public class ValueRefExpressionsNested extends ValueRefFluent> implements Nested{
ValueRefExpressionsNested(int index,ValueRef item) {
this.index = index;
this.builder = new ValueRefBuilder(this, item);
}
ValueRefBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endValueRefExpression() {
return and();
}
}
public class LeftShiftExpressionsNested extends LeftShiftFluent> implements Nested{
LeftShiftExpressionsNested(int index,LeftShift item) {
this.index = index;
this.builder = new LeftShiftBuilder(this, item);
}
LeftShiftBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLeftShiftExpression() {
return and();
}
}
public class TernaryExpressionsNested extends TernaryFluent> implements Nested{
TernaryExpressionsNested(int index,Ternary item) {
this.index = index;
this.builder = new TernaryBuilder(this, item);
}
TernaryBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endTernaryExpression() {
return and();
}
}
public class BinaryExpressionExpressionsNested extends BinaryExpressionFluent> implements Nested{
BinaryExpressionExpressionsNested(int index,BinaryExpression item) {
this.index = index;
this.builder = new BinaryExpressionBuilder(this, item);
}
BinaryExpressionBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endBinaryExpressionExpression() {
return and();
}
}
public class EqualsExpressionsNested extends EqualsFluent> implements Nested{
EqualsExpressionsNested(int index,Equals item) {
this.index = index;
this.builder = new EqualsBuilder(this, item);
}
EqualsBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endEqualsExpression() {
return and();
}
}
public class EnclosedExpressionsNested extends EnclosedFluent> implements Nested{
EnclosedExpressionsNested(int index,Enclosed item) {
this.index = index;
this.builder = new EnclosedBuilder(this, item);
}
EnclosedBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endEnclosedExpression() {
return and();
}
}
public class PreDecrementExpressionsNested extends PreDecrementFluent> implements Nested{
PreDecrementExpressionsNested(int index,PreDecrement item) {
this.index = index;
this.builder = new PreDecrementBuilder(this, item);
}
PreDecrementBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPreDecrementExpression() {
return and();
}
}
public class PostDecrementExpressionsNested extends PostDecrementFluent> implements Nested{
PostDecrementExpressionsNested(int index,PostDecrement item) {
this.index = index;
this.builder = new PostDecrementBuilder(this, item);
}
PostDecrementBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPostDecrementExpression() {
return and();
}
}
public class LambdaExpressionsNested extends LambdaFluent> implements Nested{
LambdaExpressionsNested(int index,Lambda item) {
this.index = index;
this.builder = new LambdaBuilder(this, item);
}
LambdaBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLambdaExpression() {
return and();
}
}
public class NotExpressionsNested extends NotFluent> implements Nested{
NotExpressionsNested(int index,Not item) {
this.index = index;
this.builder = new NotBuilder(this, item);
}
NotBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endNotExpression() {
return and();
}
}
public class ThisExpressionsNested extends ThisFluent> implements Nested{
ThisExpressionsNested(int index,This item) {
this.index = index;
this.builder = new ThisBuilder(this, item);
}
ThisBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endThisExpression() {
return and();
}
}
public class NegativeExpressionsNested extends NegativeFluent> implements Nested{
NegativeExpressionsNested(int index,Negative item) {
this.index = index;
this.builder = new NegativeBuilder(this, item);
}
NegativeBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endNegativeExpression() {
return and();
}
}
public class AssignExpressionsNested extends AssignFluent> implements Nested{
AssignExpressionsNested(int index,Assign item) {
this.index = index;
this.builder = new AssignBuilder(this, item);
}
AssignBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endAssignExpression() {
return and();
}
}
public class LogicalAndExpressionsNested extends LogicalAndFluent> implements Nested{
LogicalAndExpressionsNested(int index,LogicalAnd item) {
this.index = index;
this.builder = new LogicalAndBuilder(this, item);
}
LogicalAndBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLogicalAndExpression() {
return and();
}
}
public class PostIncrementExpressionsNested extends PostIncrementFluent> implements Nested{
PostIncrementExpressionsNested(int index,PostIncrement item) {
this.index = index;
this.builder = new PostIncrementBuilder(this, item);
}
PostIncrementBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPostIncrementExpression() {
return and();
}
}
public class RightUnsignedShiftExpressionsNested extends RightUnsignedShiftFluent> implements Nested{
RightUnsignedShiftExpressionsNested(int index,RightUnsignedShift item) {
this.index = index;
this.builder = new RightUnsignedShiftBuilder(this, item);
}
RightUnsignedShiftBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endRightUnsignedShiftExpression() {
return and();
}
}
public class PlusExpressionsNested extends PlusFluent> implements Nested{
PlusExpressionsNested(int index,Plus item) {
this.index = index;
this.builder = new PlusBuilder(this, item);
}
PlusBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPlusExpression() {
return and();
}
}
public class ConstructExpressionsNested extends ConstructFluent> implements Nested{
ConstructExpressionsNested(int index,Construct item) {
this.index = index;
this.builder = new ConstructBuilder(this, item);
}
ConstructBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endConstructExpression() {
return and();
}
}
public class XorExpressionsNested extends XorFluent> implements Nested{
XorExpressionsNested(int index,Xor item) {
this.index = index;
this.builder = new XorBuilder(this, item);
}
XorBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endXorExpression() {
return and();
}
}
public class PreIncrementExpressionsNested extends PreIncrementFluent> implements Nested{
PreIncrementExpressionsNested(int index,PreIncrement item) {
this.index = index;
this.builder = new PreIncrementBuilder(this, item);
}
PreIncrementBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPreIncrementExpression() {
return and();
}
}
public class LessThanOrEqualExpressionsNested extends LessThanOrEqualFluent> implements Nested{
LessThanOrEqualExpressionsNested(int index,LessThanOrEqual item) {
this.index = index;
this.builder = new LessThanOrEqualBuilder(this, item);
}
LessThanOrEqualBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endLessThanOrEqualExpression() {
return and();
}
}
public class PositiveExpressionsNested extends PositiveFluent> implements Nested{
PositiveExpressionsNested(int index,Positive item) {
this.index = index;
this.builder = new PositiveBuilder(this, item);
}
PositiveBuilder builder;
int index;
public N and() {
return (N) NewArrayFluent.this.setToExpressions(index,builder.build());
}
public N endPositiveExpression() {
return and();
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy