io.sundr.model.ForFluent Maven / Gradle / Ivy

Go to download
package io.sundr.model;

import java.util.ArrayList;
import java.lang.String;
import java.util.List;
import java.lang.SuppressWarnings;
import java.util.Collection;
import java.util.function.Predicate;
import java.lang.Class;
import java.util.Iterator;
import java.lang.Integer;
import io.sundr.builder.BaseFluent;
import java.lang.Object;
import io.sundr.builder.VisitableBuilder;
import io.sundr.builder.Nested;

/**
 * Generated
 */
@SuppressWarnings("unchecked")
public class ForFluent> extends BaseFluent{
  public ForFluent() {
  }
  
  public ForFluent(For instance) {
    this.copyInstance(instance);
  }
  private ArrayList> init = new ArrayList>();
  private VisitableBuilder compare;
  private ArrayList> update = new ArrayList>();
  private VisitableBuilder body;
  
  protected void copyInstance(For instance) {
    if (instance != null) {
          this.withInit(instance.getInit());
          this.withCompare(instance.getCompare());
          this.withUpdate(instance.getUpdate());
          this.withBody(instance.getBody());
        }
  }
  
  public A addToInit(VisitableBuilder builder) {
    if (this.init == null) {this.init = new ArrayList>();}
    _visitables.get("init").add(builder);this.init.add(builder); return (A)this;
  }
  
  public A addToInit(int index,VisitableBuilder builder) {
    if (this.init == null) {this.init = new ArrayList>();}
    if (index < 0 || index >= init.size()) { _visitables.get("init").add(builder); init.add(builder); } else { _visitables.get("init").add(index, builder); init.add(index, builder);}
    return (A)this;
  }
  
  public A addToInit(int index,Expression item) {
    if (this.init == null) {this.init = new ArrayList>();}
    VisitableBuilder builder = builder(item);
    if (index < 0 || index >= init.size()) { _visitables.get("init").add(builder); init.add(builder); } else { _visitables.get("init").add(index, builder); init.add(index, builder);}
    return (A)this;
  }
  
  public A setToInit(int index,Expression item) {
    if (this.init == null) {this.init = new ArrayList>();}
    VisitableBuilder builder = builder(item);
    if (index < 0 || index >= init.size()) { _visitables.get("init").add(builder); init.add(builder); } else { _visitables.get("init").set(index, builder); init.set(index, builder);}
    return (A)this;
  }
  
  public A addToInit(io.sundr.model.Expression... items) {
    if (this.init == null) {this.init = new ArrayList>();}
    for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("init").add(builder);this.init.add(builder); }
    return (A)this;
  }
  
  public A addAllToInit(Collection items) {
    if (this.init == null) {this.init = new ArrayList>();}
    for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("init").add(builder);this.init.add(builder); }
    return (A)this;
  }
  
  public A removeFromInit(VisitableBuilder builder) {
    if (this.init == null) return (A)this;
    _visitables.get("init").remove(builder);this.init.remove(builder); return (A)this;
  }
  
  public A removeFromInit(io.sundr.model.Expression... items) {
    if (this.init == null) return (A)this;
    for (Expression item : items) {
    VisitableBuilder builder = builder(item); _visitables.get("init").remove(builder);this.init.remove(builder);
    } return (A)this;
  }
  
  public A removeAllFromInit(Collection items) {
    if (this.init == null) return (A)this;
    for (Expression item : items) {
    VisitableBuilder builder = builder(item); _visitables.get("init").remove(builder);this.init.remove(builder);
    } return (A)this;
  }
  
  public A removeMatchingFromInit(Predicate> predicate) {
    if (init == null) return (A) this;
    final Iterator> each = init.iterator();
    final List visitables = _visitables.get("init");
    while (each.hasNext()) {
      VisitableBuilder builder = each.next();
      if (predicate.test(builder)) {
        visitables.remove(builder);
        each.remove();
      }
    }
    return (A)this;
  }
  
  public List buildInit() {
    return build(init);
  }
  
  public Expression buildInit(int index) {
    return this.init.get(index).build();
  }
  
  public Expression buildFirstInit() {
    return this.init.get(0).build();
  }
  
  public Expression buildLastInit() {
    return this.init.get(init.size() - 1).build();
  }
  
  public Expression buildMatchingInit(Predicate> predicate) {
    for (VisitableBuilder item: init) { if(predicate.test(item)){ return item.build();} } return null;
  }
  
  public boolean hasMatchingInit(Predicate> predicate) {
    for (VisitableBuilder item: init) { if(predicate.test(item)){ return true;} } return false;
  }
  
  public A withInit(List init) {
    if (init != null) {this.init = new ArrayList(); for (Expression item : init){this.addToInit(item);}} else { this.init = null;} return (A) this;
  }
  
  public A withInit(io.sundr.model.Expression... init) {
    if (this.init != null) {this.init.clear(); _visitables.remove("init"); }
    if (init != null) {for (Expression item :init){ this.addToInit(item);}} return (A) this;
  }
  
  public boolean hasInit() {
    return init != null && !init.isEmpty();
  }
  
  public MultiplyInitNested addNewMultiplyInit() {
    return new MultiplyInitNested(-1, null);
  }
  
  public MultiplyInitNested addNewMultiplyInitLike(Multiply item) {
    return new MultiplyInitNested(-1, item);
  }
  
  public A addNewMultiplyInit(Object left,Object right) {
    return (A)addToInit(new Multiply(left, right));
  }
  
  public MultiplyInitNested setNewMultiplyInitLike(int index,Multiply item) {
    return new MultiplyInitNested(index, item);
  }
  
  public NewArrayInitNested addNewNewArrayInit() {
    return new NewArrayInitNested(-1, null);
  }
  
  public NewArrayInitNested addNewNewArrayInitLike(NewArray item) {
    return new NewArrayInitNested(-1, item);
  }
  
  public A addNewNewArrayInit(Class type,Integer[] sizes) {
    return (A)addToInit(new NewArray(type, sizes));
  }
  
  public NewArrayInitNested setNewNewArrayInitLike(int index,NewArray item) {
    return new NewArrayInitNested(index, item);
  }
  
  public InstanceOfInitNested addNewInstanceOfInit() {
    return new InstanceOfInitNested(-1, null);
  }
  
  public InstanceOfInitNested addNewInstanceOfInitLike(InstanceOf item) {
    return new InstanceOfInitNested(-1, item);
  }
  
  public InstanceOfInitNested setNewInstanceOfInitLike(int index,InstanceOf item) {
    return new InstanceOfInitNested(index, item);
  }
  
  public MethodCallInitNested addNewMethodCallInit() {
    return new MethodCallInitNested(-1, null);
  }
  
  public MethodCallInitNested addNewMethodCallInitLike(MethodCall item) {
    return new MethodCallInitNested(-1, item);
  }
  
  public MethodCallInitNested setNewMethodCallInitLike(int index,MethodCall item) {
    return new MethodCallInitNested(index, item);
  }
  
  public InverseInitNested addNewInverseInit() {
    return new InverseInitNested(-1, null);
  }
  
  public InverseInitNested addNewInverseInitLike(Inverse item) {
    return new InverseInitNested(-1, item);
  }
  
  public InverseInitNested setNewInverseInitLike(int index,Inverse item) {
    return new InverseInitNested(index, item);
  }
  
  public IndexInitNested addNewIndexInit() {
    return new IndexInitNested(-1, null);
  }
  
  public IndexInitNested addNewIndexInitLike(Index item) {
    return new IndexInitNested(-1, item);
  }
  
  public IndexInitNested setNewIndexInitLike(int index,Index item) {
    return new IndexInitNested(index, item);
  }
  
  public GreaterThanOrEqualInitNested addNewGreaterThanOrEqualInit() {
    return new GreaterThanOrEqualInitNested(-1, null);
  }
  
  public GreaterThanOrEqualInitNested addNewGreaterThanOrEqualInitLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualInitNested(-1, item);
  }
  
  public A addNewGreaterThanOrEqualInit(Object left,Object right) {
    return (A)addToInit(new GreaterThanOrEqual(left, right));
  }
  
  public GreaterThanOrEqualInitNested setNewGreaterThanOrEqualInitLike(int index,GreaterThanOrEqual item) {
    return new GreaterThanOrEqualInitNested(index, item);
  }
  
  public BitwiseAndInitNested addNewBitwiseAndInit() {
    return new BitwiseAndInitNested(-1, null);
  }
  
  public BitwiseAndInitNested addNewBitwiseAndInitLike(BitwiseAnd item) {
    return new BitwiseAndInitNested(-1, item);
  }
  
  public A addNewBitwiseAndInit(Object left,Object right) {
    return (A)addToInit(new BitwiseAnd(left, right));
  }
  
  public BitwiseAndInitNested setNewBitwiseAndInitLike(int index,BitwiseAnd item) {
    return new BitwiseAndInitNested(index, item);
  }
  
  public MinusInitNested addNewMinusInit() {
    return new MinusInitNested(-1, null);
  }
  
  public MinusInitNested addNewMinusInitLike(Minus item) {
    return new MinusInitNested(-1, item);
  }
  
  public A addNewMinusInit(Object left,Object right) {
    return (A)addToInit(new Minus(left, right));
  }
  
  public MinusInitNested setNewMinusInitLike(int index,Minus item) {
    return new MinusInitNested(index, item);
  }
  
  public LogicalOrInitNested addNewLogicalOrInit() {
    return new LogicalOrInitNested(-1, null);
  }
  
  public LogicalOrInitNested addNewLogicalOrInitLike(LogicalOr item) {
    return new LogicalOrInitNested(-1, item);
  }
  
  public A addNewLogicalOrInit(Object left,Object right) {
    return (A)addToInit(new LogicalOr(left, right));
  }
  
  public LogicalOrInitNested setNewLogicalOrInitLike(int index,LogicalOr item) {
    return new LogicalOrInitNested(index, item);
  }
  
  public NotEqualsInitNested addNewNotEqualsInit() {
    return new NotEqualsInitNested(-1, null);
  }
  
  public NotEqualsInitNested addNewNotEqualsInitLike(NotEquals item) {
    return new NotEqualsInitNested(-1, item);
  }
  
  public A addNewNotEqualsInit(Object left,Object right) {
    return (A)addToInit(new NotEquals(left, right));
  }
  
  public NotEqualsInitNested setNewNotEqualsInitLike(int index,NotEquals item) {
    return new NotEqualsInitNested(index, item);
  }
  
  public DivideInitNested addNewDivideInit() {
    return new DivideInitNested(-1, null);
  }
  
  public DivideInitNested addNewDivideInitLike(Divide item) {
    return new DivideInitNested(-1, item);
  }
  
  public A addNewDivideInit(Object left,Object right) {
    return (A)addToInit(new Divide(left, right));
  }
  
  public DivideInitNested setNewDivideInitLike(int index,Divide item) {
    return new DivideInitNested(index, item);
  }
  
  public LessThanInitNested addNewLessThanInit() {
    return new LessThanInitNested(-1, null);
  }
  
  public LessThanInitNested addNewLessThanInitLike(LessThan item) {
    return new LessThanInitNested(-1, item);
  }
  
  public A addNewLessThanInit(Object left,Object right) {
    return (A)addToInit(new LessThan(left, right));
  }
  
  public LessThanInitNested setNewLessThanInitLike(int index,LessThan item) {
    return new LessThanInitNested(index, item);
  }
  
  public BitwiseOrInitNested addNewBitwiseOrInit() {
    return new BitwiseOrInitNested(-1, null);
  }
  
  public BitwiseOrInitNested addNewBitwiseOrInitLike(BitwiseOr item) {
    return new BitwiseOrInitNested(-1, item);
  }
  
  public A addNewBitwiseOrInit(Object left,Object right) {
    return (A)addToInit(new BitwiseOr(left, right));
  }
  
  public BitwiseOrInitNested setNewBitwiseOrInitLike(int index,BitwiseOr item) {
    return new BitwiseOrInitNested(index, item);
  }
  
  public PropertyRefInitNested addNewPropertyRefInit() {
    return new PropertyRefInitNested(-1, null);
  }
  
  public PropertyRefInitNested addNewPropertyRefInitLike(PropertyRef item) {
    return new PropertyRefInitNested(-1, item);
  }
  
  public PropertyRefInitNested setNewPropertyRefInitLike(int index,PropertyRef item) {
    return new PropertyRefInitNested(index, item);
  }
  
  public RightShiftInitNested addNewRightShiftInit() {
    return new RightShiftInitNested(-1, null);
  }
  
  public RightShiftInitNested addNewRightShiftInitLike(RightShift item) {
    return new RightShiftInitNested(-1, item);
  }
  
  public A addNewRightShiftInit(Object left,Object right) {
    return (A)addToInit(new RightShift(left, right));
  }
  
  public RightShiftInitNested setNewRightShiftInitLike(int index,RightShift item) {
    return new RightShiftInitNested(index, item);
  }
  
  public GreaterThanInitNested addNewGreaterThanInit() {
    return new GreaterThanInitNested(-1, null);
  }
  
  public GreaterThanInitNested addNewGreaterThanInitLike(GreaterThan item) {
    return new GreaterThanInitNested(-1, item);
  }
  
  public A addNewGreaterThanInit(Object left,Object right) {
    return (A)addToInit(new GreaterThan(left, right));
  }
  
  public GreaterThanInitNested setNewGreaterThanInitLike(int index,GreaterThan item) {
    return new GreaterThanInitNested(index, item);
  }
  
  public DeclareInitNested addNewDeclareInit() {
    return new DeclareInitNested(-1, null);
  }
  
  public DeclareInitNested addNewDeclareInitLike(Declare item) {
    return new DeclareInitNested(-1, item);
  }
  
  public A addNewDeclareInit(Class type,String name) {
    return (A)addToInit(new Declare(type, name));
  }
  
  public A addNewDeclareInit(Class type,String name,Object value) {
    return (A)addToInit(new Declare(type, name, value));
  }
  
  public DeclareInitNested setNewDeclareInitLike(int index,Declare item) {
    return new DeclareInitNested(index, item);
  }
  
  public CastInitNested addNewCastInit() {
    return new CastInitNested(-1, null);
  }
  
  public CastInitNested addNewCastInitLike(Cast item) {
    return new CastInitNested(-1, item);
  }
  
  public CastInitNested setNewCastInitLike(int index,Cast item) {
    return new CastInitNested(index, item);
  }
  
  public ModuloInitNested addNewModuloInit() {
    return new ModuloInitNested(-1, null);
  }
  
  public ModuloInitNested addNewModuloInitLike(Modulo item) {
    return new ModuloInitNested(-1, item);
  }
  
  public A addNewModuloInit(Object left,Object right) {
    return (A)addToInit(new Modulo(left, right));
  }
  
  public ModuloInitNested setNewModuloInitLike(int index,Modulo item) {
    return new ModuloInitNested(index, item);
  }
  
  public ValueRefInitNested addNewValueRefInit() {
    return new ValueRefInitNested(-1, null);
  }
  
  public ValueRefInitNested addNewValueRefInitLike(ValueRef item) {
    return new ValueRefInitNested(-1, item);
  }
  
  public A addNewValueRefInit(Object value) {
    return (A)addToInit(new ValueRef(value));
  }
  
  public ValueRefInitNested setNewValueRefInitLike(int index,ValueRef item) {
    return new ValueRefInitNested(index, item);
  }
  
  public LeftShiftInitNested addNewLeftShiftInit() {
    return new LeftShiftInitNested(-1, null);
  }
  
  public LeftShiftInitNested addNewLeftShiftInitLike(LeftShift item) {
    return new LeftShiftInitNested(-1, item);
  }
  
  public A addNewLeftShiftInit(Object left,Object right) {
    return (A)addToInit(new LeftShift(left, right));
  }
  
  public LeftShiftInitNested setNewLeftShiftInitLike(int index,LeftShift item) {
    return new LeftShiftInitNested(index, item);
  }
  
  public TernaryInitNested addNewTernaryInit() {
    return new TernaryInitNested(-1, null);
  }
  
  public TernaryInitNested addNewTernaryInitLike(Ternary item) {
    return new TernaryInitNested(-1, item);
  }
  
  public TernaryInitNested setNewTernaryInitLike(int index,Ternary item) {
    return new TernaryInitNested(index, item);
  }
  
  public BinaryExpressionInitNested addNewBinaryExpressionInit() {
    return new BinaryExpressionInitNested(-1, null);
  }
  
  public BinaryExpressionInitNested addNewBinaryExpressionInitLike(BinaryExpression item) {
    return new BinaryExpressionInitNested(-1, item);
  }
  
  public BinaryExpressionInitNested setNewBinaryExpressionInitLike(int index,BinaryExpression item) {
    return new BinaryExpressionInitNested(index, item);
  }
  
  public EqualsInitNested addNewEqualsInit() {
    return new EqualsInitNested(-1, null);
  }
  
  public EqualsInitNested addNewEqualsInitLike(Equals item) {
    return new EqualsInitNested(-1, item);
  }
  
  public A addNewEqualsInit(Object left,Object right) {
    return (A)addToInit(new Equals(left, right));
  }
  
  public EqualsInitNested setNewEqualsInitLike(int index,Equals item) {
    return new EqualsInitNested(index, item);
  }
  
  public EnclosedInitNested addNewEnclosedInit() {
    return new EnclosedInitNested(-1, null);
  }
  
  public EnclosedInitNested addNewEnclosedInitLike(Enclosed item) {
    return new EnclosedInitNested(-1, item);
  }
  
  public EnclosedInitNested setNewEnclosedInitLike(int index,Enclosed item) {
    return new EnclosedInitNested(index, item);
  }
  
  public PreDecrementInitNested addNewPreDecrementInit() {
    return new PreDecrementInitNested(-1, null);
  }
  
  public PreDecrementInitNested addNewPreDecrementInitLike(PreDecrement item) {
    return new PreDecrementInitNested(-1, item);
  }
  
  public PreDecrementInitNested setNewPreDecrementInitLike(int index,PreDecrement item) {
    return new PreDecrementInitNested(index, item);
  }
  
  public PostDecrementInitNested addNewPostDecrementInit() {
    return new PostDecrementInitNested(-1, null);
  }
  
  public PostDecrementInitNested addNewPostDecrementInitLike(PostDecrement item) {
    return new PostDecrementInitNested(-1, item);
  }
  
  public PostDecrementInitNested setNewPostDecrementInitLike(int index,PostDecrement item) {
    return new PostDecrementInitNested(index, item);
  }
  
  public LambdaInitNested addNewLambdaInit() {
    return new LambdaInitNested(-1, null);
  }
  
  public LambdaInitNested addNewLambdaInitLike(Lambda item) {
    return new LambdaInitNested(-1, item);
  }
  
  public LambdaInitNested setNewLambdaInitLike(int index,Lambda item) {
    return new LambdaInitNested(index, item);
  }
  
  public NotInitNested addNewNotInit() {
    return new NotInitNested(-1, null);
  }
  
  public NotInitNested addNewNotInitLike(Not item) {
    return new NotInitNested(-1, item);
  }
  
  public NotInitNested setNewNotInitLike(int index,Not item) {
    return new NotInitNested(index, item);
  }
  
  public ThisInitNested addNewThisInit() {
    return new ThisInitNested(-1, null);
  }
  
  public ThisInitNested addNewThisInitLike(This item) {
    return new ThisInitNested(-1, item);
  }
  
  public ThisInitNested setNewThisInitLike(int index,This item) {
    return new ThisInitNested(index, item);
  }
  
  public NegativeInitNested addNewNegativeInit() {
    return new NegativeInitNested(-1, null);
  }
  
  public NegativeInitNested addNewNegativeInitLike(Negative item) {
    return new NegativeInitNested(-1, item);
  }
  
  public NegativeInitNested setNewNegativeInitLike(int index,Negative item) {
    return new NegativeInitNested(index, item);
  }
  
  public AssignInitNested addNewAssignInit() {
    return new AssignInitNested(-1, null);
  }
  
  public AssignInitNested addNewAssignInitLike(Assign item) {
    return new AssignInitNested(-1, item);
  }
  
  public AssignInitNested setNewAssignInitLike(int index,Assign item) {
    return new AssignInitNested(index, item);
  }
  
  public LogicalAndInitNested addNewLogicalAndInit() {
    return new LogicalAndInitNested(-1, null);
  }
  
  public LogicalAndInitNested addNewLogicalAndInitLike(LogicalAnd item) {
    return new LogicalAndInitNested(-1, item);
  }
  
  public A addNewLogicalAndInit(Object left,Object right) {
    return (A)addToInit(new LogicalAnd(left, right));
  }
  
  public LogicalAndInitNested setNewLogicalAndInitLike(int index,LogicalAnd item) {
    return new LogicalAndInitNested(index, item);
  }
  
  public PostIncrementInitNested addNewPostIncrementInit() {
    return new PostIncrementInitNested(-1, null);
  }
  
  public PostIncrementInitNested addNewPostIncrementInitLike(PostIncrement item) {
    return new PostIncrementInitNested(-1, item);
  }
  
  public PostIncrementInitNested setNewPostIncrementInitLike(int index,PostIncrement item) {
    return new PostIncrementInitNested(index, item);
  }
  
  public RightUnsignedShiftInitNested addNewRightUnsignedShiftInit() {
    return new RightUnsignedShiftInitNested(-1, null);
  }
  
  public RightUnsignedShiftInitNested addNewRightUnsignedShiftInitLike(RightUnsignedShift item) {
    return new RightUnsignedShiftInitNested(-1, item);
  }
  
  public A addNewRightUnsignedShiftInit(Object left,Object right) {
    return (A)addToInit(new RightUnsignedShift(left, right));
  }
  
  public RightUnsignedShiftInitNested setNewRightUnsignedShiftInitLike(int index,RightUnsignedShift item) {
    return new RightUnsignedShiftInitNested(index, item);
  }
  
  public PlusInitNested addNewPlusInit() {
    return new PlusInitNested(-1, null);
  }
  
  public PlusInitNested addNewPlusInitLike(Plus item) {
    return new PlusInitNested(-1, item);
  }
  
  public A addNewPlusInit(Object left,Object right) {
    return (A)addToInit(new Plus(left, right));
  }
  
  public PlusInitNested setNewPlusInitLike(int index,Plus item) {
    return new PlusInitNested(index, item);
  }
  
  public ConstructInitNested addNewConstructInit() {
    return new ConstructInitNested(-1, null);
  }
  
  public ConstructInitNested addNewConstructInitLike(Construct item) {
    return new ConstructInitNested(-1, item);
  }
  
  public ConstructInitNested setNewConstructInitLike(int index,Construct item) {
    return new ConstructInitNested(index, item);
  }
  
  public XorInitNested addNewXorInit() {
    return new XorInitNested(-1, null);
  }
  
  public XorInitNested addNewXorInitLike(Xor item) {
    return new XorInitNested(-1, item);
  }
  
  public A addNewXorInit(Object left,Object right) {
    return (A)addToInit(new Xor(left, right));
  }
  
  public XorInitNested setNewXorInitLike(int index,Xor item) {
    return new XorInitNested(index, item);
  }
  
  public PreIncrementInitNested addNewPreIncrementInit() {
    return new PreIncrementInitNested(-1, null);
  }
  
  public PreIncrementInitNested addNewPreIncrementInitLike(PreIncrement item) {
    return new PreIncrementInitNested(-1, item);
  }
  
  public PreIncrementInitNested setNewPreIncrementInitLike(int index,PreIncrement item) {
    return new PreIncrementInitNested(index, item);
  }
  
  public LessThanOrEqualInitNested addNewLessThanOrEqualInit() {
    return new LessThanOrEqualInitNested(-1, null);
  }
  
  public LessThanOrEqualInitNested addNewLessThanOrEqualInitLike(LessThanOrEqual item) {
    return new LessThanOrEqualInitNested(-1, item);
  }
  
  public A addNewLessThanOrEqualInit(Object left,Object right) {
    return (A)addToInit(new LessThanOrEqual(left, right));
  }
  
  public LessThanOrEqualInitNested setNewLessThanOrEqualInitLike(int index,LessThanOrEqual item) {
    return new LessThanOrEqualInitNested(index, item);
  }
  
  public PositiveInitNested addNewPositiveInit() {
    return new PositiveInitNested(-1, null);
  }
  
  public PositiveInitNested addNewPositiveInitLike(Positive item) {
    return new PositiveInitNested(-1, item);
  }
  
  public PositiveInitNested setNewPositiveInitLike(int index,Positive item) {
    return new PositiveInitNested(index, item);
  }
  
  public Expression buildCompare() {
    return this.compare!=null?this.compare.build():null;
  }
  
  public A withCompare(Expression compare) {
    if (compare==null){ this.compare = null; _visitables.remove("compare"); return (A) this;}
    VisitableBuilder builder = builder(compare); _visitables.get("compare").clear();_visitables.get("compare").add(builder);this.compare = builder;
    return (A) this;
  }
  
  public boolean hasCompare() {
    return this.compare != null;
  }
  
  public MultiplyCompareNested withNewMultiplyCompare() {
    return new MultiplyCompareNested(null);
  }
  
  public MultiplyCompareNested withNewMultiplyCompareLike(Multiply item) {
    return new MultiplyCompareNested(item);
  }
  
  public A withNewMultiplyCompare(Object left,Object right) {
    return (A)withCompare(new Multiply(left, right));
  }
  
  public NewArrayCompareNested withNewNewArrayCompare() {
    return new NewArrayCompareNested(null);
  }
  
  public NewArrayCompareNested withNewNewArrayCompareLike(NewArray item) {
    return new NewArrayCompareNested(item);
  }
  
  public A withNewNewArrayCompare(Class type,Integer[] sizes) {
    return (A)withCompare(new NewArray(type, sizes));
  }
  
  public InstanceOfCompareNested withNewInstanceOfCompare() {
    return new InstanceOfCompareNested(null);
  }
  
  public InstanceOfCompareNested withNewInstanceOfCompareLike(InstanceOf item) {
    return new InstanceOfCompareNested(item);
  }
  
  public MethodCallCompareNested withNewMethodCallCompare() {
    return new MethodCallCompareNested(null);
  }
  
  public MethodCallCompareNested withNewMethodCallCompareLike(MethodCall item) {
    return new MethodCallCompareNested(item);
  }
  
  public InverseCompareNested withNewInverseCompare() {
    return new InverseCompareNested(null);
  }
  
  public InverseCompareNested withNewInverseCompareLike(Inverse item) {
    return new InverseCompareNested(item);
  }
  
  public IndexCompareNested withNewIndexCompare() {
    return new IndexCompareNested(null);
  }
  
  public IndexCompareNested withNewIndexCompareLike(Index item) {
    return new IndexCompareNested(item);
  }
  
  public GreaterThanOrEqualCompareNested withNewGreaterThanOrEqualCompare() {
    return new GreaterThanOrEqualCompareNested(null);
  }
  
  public GreaterThanOrEqualCompareNested withNewGreaterThanOrEqualCompareLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualCompareNested(item);
  }
  
  public A withNewGreaterThanOrEqualCompare(Object left,Object right) {
    return (A)withCompare(new GreaterThanOrEqual(left, right));
  }
  
  public BitwiseAndCompareNested withNewBitwiseAndCompare() {
    return new BitwiseAndCompareNested(null);
  }
  
  public BitwiseAndCompareNested withNewBitwiseAndCompareLike(BitwiseAnd item) {
    return new BitwiseAndCompareNested(item);
  }
  
  public A withNewBitwiseAndCompare(Object left,Object right) {
    return (A)withCompare(new BitwiseAnd(left, right));
  }
  
  public MinusCompareNested withNewMinusCompare() {
    return new MinusCompareNested(null);
  }
  
  public MinusCompareNested withNewMinusCompareLike(Minus item) {
    return new MinusCompareNested(item);
  }
  
  public A withNewMinusCompare(Object left,Object right) {
    return (A)withCompare(new Minus(left, right));
  }
  
  public LogicalOrCompareNested withNewLogicalOrCompare() {
    return new LogicalOrCompareNested(null);
  }
  
  public LogicalOrCompareNested withNewLogicalOrCompareLike(LogicalOr item) {
    return new LogicalOrCompareNested(item);
  }
  
  public A withNewLogicalOrCompare(Object left,Object right) {
    return (A)withCompare(new LogicalOr(left, right));
  }
  
  public NotEqualsCompareNested withNewNotEqualsCompare() {
    return new NotEqualsCompareNested(null);
  }
  
  public NotEqualsCompareNested withNewNotEqualsCompareLike(NotEquals item) {
    return new NotEqualsCompareNested(item);
  }
  
  public A withNewNotEqualsCompare(Object left,Object right) {
    return (A)withCompare(new NotEquals(left, right));
  }
  
  public DivideCompareNested withNewDivideCompare() {
    return new DivideCompareNested(null);
  }
  
  public DivideCompareNested withNewDivideCompareLike(Divide item) {
    return new DivideCompareNested(item);
  }
  
  public A withNewDivideCompare(Object left,Object right) {
    return (A)withCompare(new Divide(left, right));
  }
  
  public LessThanCompareNested withNewLessThanCompare() {
    return new LessThanCompareNested(null);
  }
  
  public LessThanCompareNested withNewLessThanCompareLike(LessThan item) {
    return new LessThanCompareNested(item);
  }
  
  public A withNewLessThanCompare(Object left,Object right) {
    return (A)withCompare(new LessThan(left, right));
  }
  
  public BitwiseOrCompareNested withNewBitwiseOrCompare() {
    return new BitwiseOrCompareNested(null);
  }
  
  public BitwiseOrCompareNested withNewBitwiseOrCompareLike(BitwiseOr item) {
    return new BitwiseOrCompareNested(item);
  }
  
  public A withNewBitwiseOrCompare(Object left,Object right) {
    return (A)withCompare(new BitwiseOr(left, right));
  }
  
  public PropertyRefCompareNested withNewPropertyRefCompare() {
    return new PropertyRefCompareNested(null);
  }
  
  public PropertyRefCompareNested withNewPropertyRefCompareLike(PropertyRef item) {
    return new PropertyRefCompareNested(item);
  }
  
  public RightShiftCompareNested withNewRightShiftCompare() {
    return new RightShiftCompareNested(null);
  }
  
  public RightShiftCompareNested withNewRightShiftCompareLike(RightShift item) {
    return new RightShiftCompareNested(item);
  }
  
  public A withNewRightShiftCompare(Object left,Object right) {
    return (A)withCompare(new RightShift(left, right));
  }
  
  public GreaterThanCompareNested withNewGreaterThanCompare() {
    return new GreaterThanCompareNested(null);
  }
  
  public GreaterThanCompareNested withNewGreaterThanCompareLike(GreaterThan item) {
    return new GreaterThanCompareNested(item);
  }
  
  public A withNewGreaterThanCompare(Object left,Object right) {
    return (A)withCompare(new GreaterThan(left, right));
  }
  
  public DeclareCompareNested withNewDeclareCompare() {
    return new DeclareCompareNested(null);
  }
  
  public DeclareCompareNested withNewDeclareCompareLike(Declare item) {
    return new DeclareCompareNested(item);
  }
  
  public A withNewDeclareCompare(Class type,String name) {
    return (A)withCompare(new Declare(type, name));
  }
  
  public A withNewDeclareCompare(Class type,String name,Object value) {
    return (A)withCompare(new Declare(type, name, value));
  }
  
  public CastCompareNested withNewCastCompare() {
    return new CastCompareNested(null);
  }
  
  public CastCompareNested withNewCastCompareLike(Cast item) {
    return new CastCompareNested(item);
  }
  
  public ModuloCompareNested withNewModuloCompare() {
    return new ModuloCompareNested(null);
  }
  
  public ModuloCompareNested withNewModuloCompareLike(Modulo item) {
    return new ModuloCompareNested(item);
  }
  
  public A withNewModuloCompare(Object left,Object right) {
    return (A)withCompare(new Modulo(left, right));
  }
  
  public ValueRefCompareNested withNewValueRefCompare() {
    return new ValueRefCompareNested(null);
  }
  
  public ValueRefCompareNested withNewValueRefCompareLike(ValueRef item) {
    return new ValueRefCompareNested(item);
  }
  
  public A withNewValueRefCompare(Object value) {
    return (A)withCompare(new ValueRef(value));
  }
  
  public LeftShiftCompareNested withNewLeftShiftCompare() {
    return new LeftShiftCompareNested(null);
  }
  
  public LeftShiftCompareNested withNewLeftShiftCompareLike(LeftShift item) {
    return new LeftShiftCompareNested(item);
  }
  
  public A withNewLeftShiftCompare(Object left,Object right) {
    return (A)withCompare(new LeftShift(left, right));
  }
  
  public TernaryCompareNested withNewTernaryCompare() {
    return new TernaryCompareNested(null);
  }
  
  public TernaryCompareNested withNewTernaryCompareLike(Ternary item) {
    return new TernaryCompareNested(item);
  }
  
  public BinaryExpressionCompareNested withNewBinaryExpressionCompare() {
    return new BinaryExpressionCompareNested(null);
  }
  
  public BinaryExpressionCompareNested withNewBinaryExpressionCompareLike(BinaryExpression item) {
    return new BinaryExpressionCompareNested(item);
  }
  
  public EqualsCompareNested withNewEqualsCompare() {
    return new EqualsCompareNested(null);
  }
  
  public EqualsCompareNested withNewEqualsCompareLike(Equals item) {
    return new EqualsCompareNested(item);
  }
  
  public A withNewEqualsCompare(Object left,Object right) {
    return (A)withCompare(new Equals(left, right));
  }
  
  public EnclosedCompareNested withNewEnclosedCompare() {
    return new EnclosedCompareNested(null);
  }
  
  public EnclosedCompareNested withNewEnclosedCompareLike(Enclosed item) {
    return new EnclosedCompareNested(item);
  }
  
  public PreDecrementCompareNested withNewPreDecrementCompare() {
    return new PreDecrementCompareNested(null);
  }
  
  public PreDecrementCompareNested withNewPreDecrementCompareLike(PreDecrement item) {
    return new PreDecrementCompareNested(item);
  }
  
  public PostDecrementCompareNested withNewPostDecrementCompare() {
    return new PostDecrementCompareNested(null);
  }
  
  public PostDecrementCompareNested withNewPostDecrementCompareLike(PostDecrement item) {
    return new PostDecrementCompareNested(item);
  }
  
  public LambdaCompareNested withNewLambdaCompare() {
    return new LambdaCompareNested(null);
  }
  
  public LambdaCompareNested withNewLambdaCompareLike(Lambda item) {
    return new LambdaCompareNested(item);
  }
  
  public NotCompareNested withNewNotCompare() {
    return new NotCompareNested(null);
  }
  
  public NotCompareNested withNewNotCompareLike(Not item) {
    return new NotCompareNested(item);
  }
  
  public ThisCompareNested withNewThisCompare() {
    return new ThisCompareNested(null);
  }
  
  public ThisCompareNested withNewThisCompareLike(This item) {
    return new ThisCompareNested(item);
  }
  
  public NegativeCompareNested withNewNegativeCompare() {
    return new NegativeCompareNested(null);
  }
  
  public NegativeCompareNested withNewNegativeCompareLike(Negative item) {
    return new NegativeCompareNested(item);
  }
  
  public AssignCompareNested withNewAssignCompare() {
    return new AssignCompareNested(null);
  }
  
  public AssignCompareNested withNewAssignCompareLike(Assign item) {
    return new AssignCompareNested(item);
  }
  
  public LogicalAndCompareNested withNewLogicalAndCompare() {
    return new LogicalAndCompareNested(null);
  }
  
  public LogicalAndCompareNested withNewLogicalAndCompareLike(LogicalAnd item) {
    return new LogicalAndCompareNested(item);
  }
  
  public A withNewLogicalAndCompare(Object left,Object right) {
    return (A)withCompare(new LogicalAnd(left, right));
  }
  
  public PostIncrementCompareNested withNewPostIncrementCompare() {
    return new PostIncrementCompareNested(null);
  }
  
  public PostIncrementCompareNested withNewPostIncrementCompareLike(PostIncrement item) {
    return new PostIncrementCompareNested(item);
  }
  
  public RightUnsignedShiftCompareNested withNewRightUnsignedShiftCompare() {
    return new RightUnsignedShiftCompareNested(null);
  }
  
  public RightUnsignedShiftCompareNested withNewRightUnsignedShiftCompareLike(RightUnsignedShift item) {
    return new RightUnsignedShiftCompareNested(item);
  }
  
  public A withNewRightUnsignedShiftCompare(Object left,Object right) {
    return (A)withCompare(new RightUnsignedShift(left, right));
  }
  
  public PlusCompareNested withNewPlusCompare() {
    return new PlusCompareNested(null);
  }
  
  public PlusCompareNested withNewPlusCompareLike(Plus item) {
    return new PlusCompareNested(item);
  }
  
  public A withNewPlusCompare(Object left,Object right) {
    return (A)withCompare(new Plus(left, right));
  }
  
  public ConstructCompareNested withNewConstructCompare() {
    return new ConstructCompareNested(null);
  }
  
  public ConstructCompareNested withNewConstructCompareLike(Construct item) {
    return new ConstructCompareNested(item);
  }
  
  public XorCompareNested withNewXorCompare() {
    return new XorCompareNested(null);
  }
  
  public XorCompareNested withNewXorCompareLike(Xor item) {
    return new XorCompareNested(item);
  }
  
  public A withNewXorCompare(Object left,Object right) {
    return (A)withCompare(new Xor(left, right));
  }
  
  public PreIncrementCompareNested withNewPreIncrementCompare() {
    return new PreIncrementCompareNested(null);
  }
  
  public PreIncrementCompareNested withNewPreIncrementCompareLike(PreIncrement item) {
    return new PreIncrementCompareNested(item);
  }
  
  public LessThanOrEqualCompareNested withNewLessThanOrEqualCompare() {
    return new LessThanOrEqualCompareNested(null);
  }
  
  public LessThanOrEqualCompareNested withNewLessThanOrEqualCompareLike(LessThanOrEqual item) {
    return new LessThanOrEqualCompareNested(item);
  }
  
  public A withNewLessThanOrEqualCompare(Object left,Object right) {
    return (A)withCompare(new LessThanOrEqual(left, right));
  }
  
  public PositiveCompareNested withNewPositiveCompare() {
    return new PositiveCompareNested(null);
  }
  
  public PositiveCompareNested withNewPositiveCompareLike(Positive item) {
    return new PositiveCompareNested(item);
  }
  
  public A addToUpdate(VisitableBuilder builder) {
    if (this.update == null) {this.update = new ArrayList>();}
    _visitables.get("update").add(builder);this.update.add(builder); return (A)this;
  }
  
  public A addToUpdate(int index,VisitableBuilder builder) {
    if (this.update == null) {this.update = new ArrayList>();}
    if (index < 0 || index >= update.size()) { _visitables.get("update").add(builder); update.add(builder); } else { _visitables.get("update").add(index, builder); update.add(index, builder);}
    return (A)this;
  }
  
  public A addToUpdate(int index,Expression item) {
    if (this.update == null) {this.update = new ArrayList>();}
    VisitableBuilder builder = builder(item);
    if (index < 0 || index >= update.size()) { _visitables.get("update").add(builder); update.add(builder); } else { _visitables.get("update").add(index, builder); update.add(index, builder);}
    return (A)this;
  }
  
  public A setToUpdate(int index,Expression item) {
    if (this.update == null) {this.update = new ArrayList>();}
    VisitableBuilder builder = builder(item);
    if (index < 0 || index >= update.size()) { _visitables.get("update").add(builder); update.add(builder); } else { _visitables.get("update").set(index, builder); update.set(index, builder);}
    return (A)this;
  }
  
  public A addToUpdate(io.sundr.model.Expression... items) {
    if (this.update == null) {this.update = new ArrayList>();}
    for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("update").add(builder);this.update.add(builder); }
    return (A)this;
  }
  
  public A addAllToUpdate(Collection items) {
    if (this.update == null) {this.update = new ArrayList>();}
    for (Expression item : items) { VisitableBuilder builder = builder(item); _visitables.get("update").add(builder);this.update.add(builder); }
    return (A)this;
  }
  
  public A removeFromUpdate(VisitableBuilder builder) {
    if (this.update == null) return (A)this;
    _visitables.get("update").remove(builder);this.update.remove(builder); return (A)this;
  }
  
  public A removeFromUpdate(io.sundr.model.Expression... items) {
    if (this.update == null) return (A)this;
    for (Expression item : items) {
    VisitableBuilder builder = builder(item); _visitables.get("update").remove(builder);this.update.remove(builder);
    } return (A)this;
  }
  
  public A removeAllFromUpdate(Collection items) {
    if (this.update == null) return (A)this;
    for (Expression item : items) {
    VisitableBuilder builder = builder(item); _visitables.get("update").remove(builder);this.update.remove(builder);
    } return (A)this;
  }
  
  public A removeMatchingFromUpdate(Predicate> predicate) {
    if (update == null) return (A) this;
    final Iterator> each = update.iterator();
    final List visitables = _visitables.get("update");
    while (each.hasNext()) {
      VisitableBuilder builder = each.next();
      if (predicate.test(builder)) {
        visitables.remove(builder);
        each.remove();
      }
    }
    return (A)this;
  }
  
  public List buildUpdate() {
    return build(update);
  }
  
  public Expression buildUpdate(int index) {
    return this.update.get(index).build();
  }
  
  public Expression buildFirstUpdate() {
    return this.update.get(0).build();
  }
  
  public Expression buildLastUpdate() {
    return this.update.get(update.size() - 1).build();
  }
  
  public Expression buildMatchingUpdate(Predicate> predicate) {
    for (VisitableBuilder item: update) { if(predicate.test(item)){ return item.build();} } return null;
  }
  
  public boolean hasMatchingUpdate(Predicate> predicate) {
    for (VisitableBuilder item: update) { if(predicate.test(item)){ return true;} } return false;
  }
  
  public A withUpdate(List update) {
    if (update != null) {this.update = new ArrayList(); for (Expression item : update){this.addToUpdate(item);}} else { this.update = null;} return (A) this;
  }
  
  public A withUpdate(io.sundr.model.Expression... update) {
    if (this.update != null) {this.update.clear(); _visitables.remove("update"); }
    if (update != null) {for (Expression item :update){ this.addToUpdate(item);}} return (A) this;
  }
  
  public boolean hasUpdate() {
    return update != null && !update.isEmpty();
  }
  
  public MultiplyUpdateNested addNewMultiplyUpdate() {
    return new MultiplyUpdateNested(-1, null);
  }
  
  public MultiplyUpdateNested addNewMultiplyUpdateLike(Multiply item) {
    return new MultiplyUpdateNested(-1, item);
  }
  
  public A addNewMultiplyUpdate(Object left,Object right) {
    return (A)addToUpdate(new Multiply(left, right));
  }
  
  public MultiplyUpdateNested setNewMultiplyUpdateLike(int index,Multiply item) {
    return new MultiplyUpdateNested(index, item);
  }
  
  public NewArrayUpdateNested addNewNewArrayUpdate() {
    return new NewArrayUpdateNested(-1, null);
  }
  
  public NewArrayUpdateNested addNewNewArrayUpdateLike(NewArray item) {
    return new NewArrayUpdateNested(-1, item);
  }
  
  public A addNewNewArrayUpdate(Class type,Integer[] sizes) {
    return (A)addToUpdate(new NewArray(type, sizes));
  }
  
  public NewArrayUpdateNested setNewNewArrayUpdateLike(int index,NewArray item) {
    return new NewArrayUpdateNested(index, item);
  }
  
  public InstanceOfUpdateNested addNewInstanceOfUpdate() {
    return new InstanceOfUpdateNested(-1, null);
  }
  
  public InstanceOfUpdateNested addNewInstanceOfUpdateLike(InstanceOf item) {
    return new InstanceOfUpdateNested(-1, item);
  }
  
  public InstanceOfUpdateNested setNewInstanceOfUpdateLike(int index,InstanceOf item) {
    return new InstanceOfUpdateNested(index, item);
  }
  
  public MethodCallUpdateNested addNewMethodCallUpdate() {
    return new MethodCallUpdateNested(-1, null);
  }
  
  public MethodCallUpdateNested addNewMethodCallUpdateLike(MethodCall item) {
    return new MethodCallUpdateNested(-1, item);
  }
  
  public MethodCallUpdateNested setNewMethodCallUpdateLike(int index,MethodCall item) {
    return new MethodCallUpdateNested(index, item);
  }
  
  public InverseUpdateNested addNewInverseUpdate() {
    return new InverseUpdateNested(-1, null);
  }
  
  public InverseUpdateNested addNewInverseUpdateLike(Inverse item) {
    return new InverseUpdateNested(-1, item);
  }
  
  public InverseUpdateNested setNewInverseUpdateLike(int index,Inverse item) {
    return new InverseUpdateNested(index, item);
  }
  
  public IndexUpdateNested addNewIndexUpdate() {
    return new IndexUpdateNested(-1, null);
  }
  
  public IndexUpdateNested addNewIndexUpdateLike(Index item) {
    return new IndexUpdateNested(-1, item);
  }
  
  public IndexUpdateNested setNewIndexUpdateLike(int index,Index item) {
    return new IndexUpdateNested(index, item);
  }
  
  public GreaterThanOrEqualUpdateNested addNewGreaterThanOrEqualUpdate() {
    return new GreaterThanOrEqualUpdateNested(-1, null);
  }
  
  public GreaterThanOrEqualUpdateNested addNewGreaterThanOrEqualUpdateLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualUpdateNested(-1, item);
  }
  
  public A addNewGreaterThanOrEqualUpdate(Object left,Object right) {
    return (A)addToUpdate(new GreaterThanOrEqual(left, right));
  }
  
  public GreaterThanOrEqualUpdateNested setNewGreaterThanOrEqualUpdateLike(int index,GreaterThanOrEqual item) {
    return new GreaterThanOrEqualUpdateNested(index, item);
  }
  
  public BitwiseAndUpdateNested addNewBitwiseAndUpdate() {
    return new BitwiseAndUpdateNested(-1, null);
  }
  
  public BitwiseAndUpdateNested addNewBitwiseAndUpdateLike(BitwiseAnd item) {
    return new BitwiseAndUpdateNested(-1, item);
  }
  
  public A addNewBitwiseAndUpdate(Object left,Object right) {
    return (A)addToUpdate(new BitwiseAnd(left, right));
  }
  
  public BitwiseAndUpdateNested setNewBitwiseAndUpdateLike(int index,BitwiseAnd item) {
    return new BitwiseAndUpdateNested(index, item);
  }
  
  public MinusUpdateNested addNewMinusUpdate() {
    return new MinusUpdateNested(-1, null);
  }
  
  public MinusUpdateNested addNewMinusUpdateLike(Minus item) {
    return new MinusUpdateNested(-1, item);
  }
  
  public A addNewMinusUpdate(Object left,Object right) {
    return (A)addToUpdate(new Minus(left, right));
  }
  
  public MinusUpdateNested setNewMinusUpdateLike(int index,Minus item) {
    return new MinusUpdateNested(index, item);
  }
  
  public LogicalOrUpdateNested addNewLogicalOrUpdate() {
    return new LogicalOrUpdateNested(-1, null);
  }
  
  public LogicalOrUpdateNested addNewLogicalOrUpdateLike(LogicalOr item) {
    return new LogicalOrUpdateNested(-1, item);
  }
  
  public A addNewLogicalOrUpdate(Object left,Object right) {
    return (A)addToUpdate(new LogicalOr(left, right));
  }
  
  public LogicalOrUpdateNested setNewLogicalOrUpdateLike(int index,LogicalOr item) {
    return new LogicalOrUpdateNested(index, item);
  }
  
  public NotEqualsUpdateNested addNewNotEqualsUpdate() {
    return new NotEqualsUpdateNested(-1, null);
  }
  
  public NotEqualsUpdateNested addNewNotEqualsUpdateLike(NotEquals item) {
    return new NotEqualsUpdateNested(-1, item);
  }
  
  public A addNewNotEqualsUpdate(Object left,Object right) {
    return (A)addToUpdate(new NotEquals(left, right));
  }
  
  public NotEqualsUpdateNested setNewNotEqualsUpdateLike(int index,NotEquals item) {
    return new NotEqualsUpdateNested(index, item);
  }
  
  public DivideUpdateNested addNewDivideUpdate() {
    return new DivideUpdateNested(-1, null);
  }
  
  public DivideUpdateNested addNewDivideUpdateLike(Divide item) {
    return new DivideUpdateNested(-1, item);
  }
  
  public A addNewDivideUpdate(Object left,Object right) {
    return (A)addToUpdate(new Divide(left, right));
  }
  
  public DivideUpdateNested setNewDivideUpdateLike(int index,Divide item) {
    return new DivideUpdateNested(index, item);
  }
  
  public LessThanUpdateNested addNewLessThanUpdate() {
    return new LessThanUpdateNested(-1, null);
  }
  
  public LessThanUpdateNested addNewLessThanUpdateLike(LessThan item) {
    return new LessThanUpdateNested(-1, item);
  }
  
  public A addNewLessThanUpdate(Object left,Object right) {
    return (A)addToUpdate(new LessThan(left, right));
  }
  
  public LessThanUpdateNested setNewLessThanUpdateLike(int index,LessThan item) {
    return new LessThanUpdateNested(index, item);
  }
  
  public BitwiseOrUpdateNested addNewBitwiseOrUpdate() {
    return new BitwiseOrUpdateNested(-1, null);
  }
  
  public BitwiseOrUpdateNested addNewBitwiseOrUpdateLike(BitwiseOr item) {
    return new BitwiseOrUpdateNested(-1, item);
  }
  
  public A addNewBitwiseOrUpdate(Object left,Object right) {
    return (A)addToUpdate(new BitwiseOr(left, right));
  }
  
  public BitwiseOrUpdateNested setNewBitwiseOrUpdateLike(int index,BitwiseOr item) {
    return new BitwiseOrUpdateNested(index, item);
  }
  
  public PropertyRefUpdateNested addNewPropertyRefUpdate() {
    return new PropertyRefUpdateNested(-1, null);
  }
  
  public PropertyRefUpdateNested addNewPropertyRefUpdateLike(PropertyRef item) {
    return new PropertyRefUpdateNested(-1, item);
  }
  
  public PropertyRefUpdateNested setNewPropertyRefUpdateLike(int index,PropertyRef item) {
    return new PropertyRefUpdateNested(index, item);
  }
  
  public RightShiftUpdateNested addNewRightShiftUpdate() {
    return new RightShiftUpdateNested(-1, null);
  }
  
  public RightShiftUpdateNested addNewRightShiftUpdateLike(RightShift item) {
    return new RightShiftUpdateNested(-1, item);
  }
  
  public A addNewRightShiftUpdate(Object left,Object right) {
    return (A)addToUpdate(new RightShift(left, right));
  }
  
  public RightShiftUpdateNested setNewRightShiftUpdateLike(int index,RightShift item) {
    return new RightShiftUpdateNested(index, item);
  }
  
  public GreaterThanUpdateNested addNewGreaterThanUpdate() {
    return new GreaterThanUpdateNested(-1, null);
  }
  
  public GreaterThanUpdateNested addNewGreaterThanUpdateLike(GreaterThan item) {
    return new GreaterThanUpdateNested(-1, item);
  }
  
  public A addNewGreaterThanUpdate(Object left,Object right) {
    return (A)addToUpdate(new GreaterThan(left, right));
  }
  
  public GreaterThanUpdateNested setNewGreaterThanUpdateLike(int index,GreaterThan item) {
    return new GreaterThanUpdateNested(index, item);
  }
  
  public DeclareUpdateNested addNewDeclareUpdate() {
    return new DeclareUpdateNested(-1, null);
  }
  
  public DeclareUpdateNested addNewDeclareUpdateLike(Declare item) {
    return new DeclareUpdateNested(-1, item);
  }
  
  public A addNewDeclareUpdate(Class type,String name) {
    return (A)addToUpdate(new Declare(type, name));
  }
  
  public A addNewDeclareUpdate(Class type,String name,Object value) {
    return (A)addToUpdate(new Declare(type, name, value));
  }
  
  public DeclareUpdateNested setNewDeclareUpdateLike(int index,Declare item) {
    return new DeclareUpdateNested(index, item);
  }
  
  public CastUpdateNested addNewCastUpdate() {
    return new CastUpdateNested(-1, null);
  }
  
  public CastUpdateNested addNewCastUpdateLike(Cast item) {
    return new CastUpdateNested(-1, item);
  }
  
  public CastUpdateNested setNewCastUpdateLike(int index,Cast item) {
    return new CastUpdateNested(index, item);
  }
  
  public ModuloUpdateNested addNewModuloUpdate() {
    return new ModuloUpdateNested(-1, null);
  }
  
  public ModuloUpdateNested addNewModuloUpdateLike(Modulo item) {
    return new ModuloUpdateNested(-1, item);
  }
  
  public A addNewModuloUpdate(Object left,Object right) {
    return (A)addToUpdate(new Modulo(left, right));
  }
  
  public ModuloUpdateNested setNewModuloUpdateLike(int index,Modulo item) {
    return new ModuloUpdateNested(index, item);
  }
  
  public ValueRefUpdateNested addNewValueRefUpdate() {
    return new ValueRefUpdateNested(-1, null);
  }
  
  public ValueRefUpdateNested addNewValueRefUpdateLike(ValueRef item) {
    return new ValueRefUpdateNested(-1, item);
  }
  
  public A addNewValueRefUpdate(Object value) {
    return (A)addToUpdate(new ValueRef(value));
  }
  
  public ValueRefUpdateNested setNewValueRefUpdateLike(int index,ValueRef item) {
    return new ValueRefUpdateNested(index, item);
  }
  
  public LeftShiftUpdateNested addNewLeftShiftUpdate() {
    return new LeftShiftUpdateNested(-1, null);
  }
  
  public LeftShiftUpdateNested addNewLeftShiftUpdateLike(LeftShift item) {
    return new LeftShiftUpdateNested(-1, item);
  }
  
  public A addNewLeftShiftUpdate(Object left,Object right) {
    return (A)addToUpdate(new LeftShift(left, right));
  }
  
  public LeftShiftUpdateNested setNewLeftShiftUpdateLike(int index,LeftShift item) {
    return new LeftShiftUpdateNested(index, item);
  }
  
  public TernaryUpdateNested addNewTernaryUpdate() {
    return new TernaryUpdateNested(-1, null);
  }
  
  public TernaryUpdateNested addNewTernaryUpdateLike(Ternary item) {
    return new TernaryUpdateNested(-1, item);
  }
  
  public TernaryUpdateNested setNewTernaryUpdateLike(int index,Ternary item) {
    return new TernaryUpdateNested(index, item);
  }
  
  public BinaryExpressionUpdateNested addNewBinaryExpressionUpdate() {
    return new BinaryExpressionUpdateNested(-1, null);
  }
  
  public BinaryExpressionUpdateNested addNewBinaryExpressionUpdateLike(BinaryExpression item) {
    return new BinaryExpressionUpdateNested(-1, item);
  }
  
  public BinaryExpressionUpdateNested setNewBinaryExpressionUpdateLike(int index,BinaryExpression item) {
    return new BinaryExpressionUpdateNested(index, item);
  }
  
  public EqualsUpdateNested addNewEqualsUpdate() {
    return new EqualsUpdateNested(-1, null);
  }
  
  public EqualsUpdateNested addNewEqualsUpdateLike(Equals item) {
    return new EqualsUpdateNested(-1, item);
  }
  
  public A addNewEqualsUpdate(Object left,Object right) {
    return (A)addToUpdate(new Equals(left, right));
  }
  
  public EqualsUpdateNested setNewEqualsUpdateLike(int index,Equals item) {
    return new EqualsUpdateNested(index, item);
  }
  
  public EnclosedUpdateNested addNewEnclosedUpdate() {
    return new EnclosedUpdateNested(-1, null);
  }
  
  public EnclosedUpdateNested addNewEnclosedUpdateLike(Enclosed item) {
    return new EnclosedUpdateNested(-1, item);
  }
  
  public EnclosedUpdateNested setNewEnclosedUpdateLike(int index,Enclosed item) {
    return new EnclosedUpdateNested(index, item);
  }
  
  public PreDecrementUpdateNested addNewPreDecrementUpdate() {
    return new PreDecrementUpdateNested(-1, null);
  }
  
  public PreDecrementUpdateNested addNewPreDecrementUpdateLike(PreDecrement item) {
    return new PreDecrementUpdateNested(-1, item);
  }
  
  public PreDecrementUpdateNested setNewPreDecrementUpdateLike(int index,PreDecrement item) {
    return new PreDecrementUpdateNested(index, item);
  }
  
  public PostDecrementUpdateNested addNewPostDecrementUpdate() {
    return new PostDecrementUpdateNested(-1, null);
  }
  
  public PostDecrementUpdateNested addNewPostDecrementUpdateLike(PostDecrement item) {
    return new PostDecrementUpdateNested(-1, item);
  }
  
  public PostDecrementUpdateNested setNewPostDecrementUpdateLike(int index,PostDecrement item) {
    return new PostDecrementUpdateNested(index, item);
  }
  
  public LambdaUpdateNested addNewLambdaUpdate() {
    return new LambdaUpdateNested(-1, null);
  }
  
  public LambdaUpdateNested addNewLambdaUpdateLike(Lambda item) {
    return new LambdaUpdateNested(-1, item);
  }
  
  public LambdaUpdateNested setNewLambdaUpdateLike(int index,Lambda item) {
    return new LambdaUpdateNested(index, item);
  }
  
  public NotUpdateNested addNewNotUpdate() {
    return new NotUpdateNested(-1, null);
  }
  
  public NotUpdateNested addNewNotUpdateLike(Not item) {
    return new NotUpdateNested(-1, item);
  }
  
  public NotUpdateNested setNewNotUpdateLike(int index,Not item) {
    return new NotUpdateNested(index, item);
  }
  
  public ThisUpdateNested addNewThisUpdate() {
    return new ThisUpdateNested(-1, null);
  }
  
  public ThisUpdateNested addNewThisUpdateLike(This item) {
    return new ThisUpdateNested(-1, item);
  }
  
  public ThisUpdateNested setNewThisUpdateLike(int index,This item) {
    return new ThisUpdateNested(index, item);
  }
  
  public NegativeUpdateNested addNewNegativeUpdate() {
    return new NegativeUpdateNested(-1, null);
  }
  
  public NegativeUpdateNested addNewNegativeUpdateLike(Negative item) {
    return new NegativeUpdateNested(-1, item);
  }
  
  public NegativeUpdateNested setNewNegativeUpdateLike(int index,Negative item) {
    return new NegativeUpdateNested(index, item);
  }
  
  public AssignUpdateNested addNewAssignUpdate() {
    return new AssignUpdateNested(-1, null);
  }
  
  public AssignUpdateNested addNewAssignUpdateLike(Assign item) {
    return new AssignUpdateNested(-1, item);
  }
  
  public AssignUpdateNested setNewAssignUpdateLike(int index,Assign item) {
    return new AssignUpdateNested(index, item);
  }
  
  public LogicalAndUpdateNested addNewLogicalAndUpdate() {
    return new LogicalAndUpdateNested(-1, null);
  }
  
  public LogicalAndUpdateNested addNewLogicalAndUpdateLike(LogicalAnd item) {
    return new LogicalAndUpdateNested(-1, item);
  }
  
  public A addNewLogicalAndUpdate(Object left,Object right) {
    return (A)addToUpdate(new LogicalAnd(left, right));
  }
  
  public LogicalAndUpdateNested setNewLogicalAndUpdateLike(int index,LogicalAnd item) {
    return new LogicalAndUpdateNested(index, item);
  }
  
  public PostIncrementUpdateNested addNewPostIncrementUpdate() {
    return new PostIncrementUpdateNested(-1, null);
  }
  
  public PostIncrementUpdateNested addNewPostIncrementUpdateLike(PostIncrement item) {
    return new PostIncrementUpdateNested(-1, item);
  }
  
  public PostIncrementUpdateNested setNewPostIncrementUpdateLike(int index,PostIncrement item) {
    return new PostIncrementUpdateNested(index, item);
  }
  
  public RightUnsignedShiftUpdateNested addNewRightUnsignedShiftUpdate() {
    return new RightUnsignedShiftUpdateNested(-1, null);
  }
  
  public RightUnsignedShiftUpdateNested addNewRightUnsignedShiftUpdateLike(RightUnsignedShift item) {
    return new RightUnsignedShiftUpdateNested(-1, item);
  }
  
  public A addNewRightUnsignedShiftUpdate(Object left,Object right) {
    return (A)addToUpdate(new RightUnsignedShift(left, right));
  }
  
  public RightUnsignedShiftUpdateNested setNewRightUnsignedShiftUpdateLike(int index,RightUnsignedShift item) {
    return new RightUnsignedShiftUpdateNested(index, item);
  }
  
  public PlusUpdateNested addNewPlusUpdate() {
    return new PlusUpdateNested(-1, null);
  }
  
  public PlusUpdateNested addNewPlusUpdateLike(Plus item) {
    return new PlusUpdateNested(-1, item);
  }
  
  public A addNewPlusUpdate(Object left,Object right) {
    return (A)addToUpdate(new Plus(left, right));
  }
  
  public PlusUpdateNested setNewPlusUpdateLike(int index,Plus item) {
    return new PlusUpdateNested(index, item);
  }
  
  public ConstructUpdateNested addNewConstructUpdate() {
    return new ConstructUpdateNested(-1, null);
  }
  
  public ConstructUpdateNested addNewConstructUpdateLike(Construct item) {
    return new ConstructUpdateNested(-1, item);
  }
  
  public ConstructUpdateNested setNewConstructUpdateLike(int index,Construct item) {
    return new ConstructUpdateNested(index, item);
  }
  
  public XorUpdateNested addNewXorUpdate() {
    return new XorUpdateNested(-1, null);
  }
  
  public XorUpdateNested addNewXorUpdateLike(Xor item) {
    return new XorUpdateNested(-1, item);
  }
  
  public A addNewXorUpdate(Object left,Object right) {
    return (A)addToUpdate(new Xor(left, right));
  }
  
  public XorUpdateNested setNewXorUpdateLike(int index,Xor item) {
    return new XorUpdateNested(index, item);
  }
  
  public PreIncrementUpdateNested addNewPreIncrementUpdate() {
    return new PreIncrementUpdateNested(-1, null);
  }
  
  public PreIncrementUpdateNested addNewPreIncrementUpdateLike(PreIncrement item) {
    return new PreIncrementUpdateNested(-1, item);
  }
  
  public PreIncrementUpdateNested setNewPreIncrementUpdateLike(int index,PreIncrement item) {
    return new PreIncrementUpdateNested(index, item);
  }
  
  public LessThanOrEqualUpdateNested addNewLessThanOrEqualUpdate() {
    return new LessThanOrEqualUpdateNested(-1, null);
  }
  
  public LessThanOrEqualUpdateNested addNewLessThanOrEqualUpdateLike(LessThanOrEqual item) {
    return new LessThanOrEqualUpdateNested(-1, item);
  }
  
  public A addNewLessThanOrEqualUpdate(Object left,Object right) {
    return (A)addToUpdate(new LessThanOrEqual(left, right));
  }
  
  public LessThanOrEqualUpdateNested setNewLessThanOrEqualUpdateLike(int index,LessThanOrEqual item) {
    return new LessThanOrEqualUpdateNested(index, item);
  }
  
  public PositiveUpdateNested addNewPositiveUpdate() {
    return new PositiveUpdateNested(-1, null);
  }
  
  public PositiveUpdateNested addNewPositiveUpdateLike(Positive item) {
    return new PositiveUpdateNested(-1, item);
  }
  
  public PositiveUpdateNested setNewPositiveUpdateLike(int index,Positive item) {
    return new PositiveUpdateNested(index, item);
  }
  
  public Statement buildBody() {
    return this.body!=null?this.body.build():null;
  }
  
  public A withBody(Statement body) {
    if (body==null){ this.body = null; _visitables.remove("body"); return (A) this;}
    VisitableBuilder builder = builder(body); _visitables.get("body").clear();_visitables.get("body").add(builder);this.body = builder;
    return (A) this;
  }
  
  public boolean hasBody() {
    return this.body != null;
  }
  
  public MethodCallBodyNested withNewMethodCallBody() {
    return new MethodCallBodyNested(null);
  }
  
  public MethodCallBodyNested withNewMethodCallBodyLike(MethodCall item) {
    return new MethodCallBodyNested(item);
  }
  
  public SwitchBodyNested withNewSwitchBody() {
    return new SwitchBodyNested(null);
  }
  
  public SwitchBodyNested withNewSwitchBodyLike(Switch item) {
    return new SwitchBodyNested(item);
  }
  
  public BreakBodyNested withNewBreakBody() {
    return new BreakBodyNested(null);
  }
  
  public BreakBodyNested withNewBreakBodyLike(Break item) {
    return new BreakBodyNested(item);
  }
  
  public DeclareBodyNested withNewDeclareBody() {
    return new DeclareBodyNested(null);
  }
  
  public DeclareBodyNested withNewDeclareBodyLike(Declare item) {
    return new DeclareBodyNested(item);
  }
  
  public A withNewDeclareBody(Class type,String name) {
    return (A)withBody(new Declare(type, name));
  }
  
  public A withNewDeclareBody(Class type,String name,Object value) {
    return (A)withBody(new Declare(type, name, value));
  }
  
  public WhileBodyNested withNewWhileBody() {
    return new WhileBodyNested(null);
  }
  
  public WhileBodyNested withNewWhileBodyLike(While item) {
    return new WhileBodyNested(item);
  }
  
  public ContinueBodyNested withNewContinueBody() {
    return new ContinueBodyNested(null);
  }
  
  public ContinueBodyNested withNewContinueBodyLike(Continue item) {
    return new ContinueBodyNested(item);
  }
  
  public StringStatementBodyNested withNewStringStatementBody() {
    return new StringStatementBodyNested(null);
  }
  
  public StringStatementBodyNested withNewStringStatementBodyLike(StringStatement item) {
    return new StringStatementBodyNested(item);
  }
  
  public A withNewStringStatementBody(String data) {
    return (A)withBody(new StringStatement(data));
  }
  
  public A withNewStringStatementBody(String data,Object[] parameters) {
    return (A)withBody(new StringStatement(data, parameters));
  }
  
  public DoBodyNested withNewDoBody() {
    return new DoBodyNested(null);
  }
  
  public DoBodyNested withNewDoBodyLike(Do item) {
    return new DoBodyNested(item);
  }
  
  public ForeachBodyNested withNewForeachBody() {
    return new ForeachBodyNested(null);
  }
  
  public ForeachBodyNested withNewForeachBodyLike(Foreach item) {
    return new ForeachBodyNested(item);
  }
  
  public BlockBodyNested withNewBlockBody() {
    return new BlockBodyNested(null);
  }
  
  public BlockBodyNested withNewBlockBodyLike(Block item) {
    return new BlockBodyNested(item);
  }
  
  public IfBodyNested withNewIfBody() {
    return new IfBodyNested(null);
  }
  
  public IfBodyNested withNewIfBodyLike(If item) {
    return new IfBodyNested(item);
  }
  
  public LambdaBodyNested withNewLambdaBody() {
    return new LambdaBodyNested(null);
  }
  
  public LambdaBodyNested withNewLambdaBodyLike(Lambda item) {
    return new LambdaBodyNested(item);
  }
  
  public ReturnBodyNested withNewReturnBody() {
    return new ReturnBodyNested(null);
  }
  
  public ReturnBodyNested withNewReturnBodyLike(Return item) {
    return new ReturnBodyNested(item);
  }
  
  public A withNewReturnBody(Object object) {
    return (A)withBody(new Return(object));
  }
  
  public AssignBodyNested withNewAssignBody() {
    return new AssignBodyNested(null);
  }
  
  public AssignBodyNested withNewAssignBodyLike(Assign item) {
    return new AssignBodyNested(item);
  }
  
  public ForBodyNested withNewForBody() {
    return new ForBodyNested(null);
  }
  
  public ForBodyNested withNewForBodyLike(For item) {
    return new ForBodyNested(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;
    ForFluent that = (ForFluent) o;
    if (!java.util.Objects.equals(init, that.init)) return false;
    if (!java.util.Objects.equals(compare, that.compare)) return false;
    if (!java.util.Objects.equals(update, that.update)) return false;
    if (!java.util.Objects.equals(body, that.body)) return false;
    return true;
  }
  
  public int hashCode() {
    return java.util.Objects.hash(init,  compare,  update,  body,  super.hashCode());
  }
  
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    if (init != null && !init.isEmpty()) { sb.append("init:"); sb.append(init + ","); }
    if (compare != null) { sb.append("compare:"); sb.append(compare + ","); }
    if (update != null && !update.isEmpty()) { sb.append("update:"); sb.append(update + ","); }
    if (body != null) { sb.append("body:"); sb.append(body); }
    sb.append("}");
    return sb.toString();
  }
  
  protected static VisitableBuilder builder(Object item) {
    switch (item.getClass().getName()) {
    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);
    case "io.sundr.model."+"Switch": return (VisitableBuilder)new SwitchBuilder((Switch) item);
    case "io.sundr.model."+"Break": return (VisitableBuilder)new BreakBuilder((Break) item);
    case "io.sundr.model."+"While": return (VisitableBuilder)new WhileBuilder((While) item);
    case "io.sundr.model."+"Continue": return (VisitableBuilder)new ContinueBuilder((Continue) item);
    case "io.sundr.model."+"StringStatement": return (VisitableBuilder)new StringStatementBuilder((StringStatement) item);
    case "io.sundr.model."+"Do": return (VisitableBuilder)new DoBuilder((Do) item);
    case "io.sundr.model."+"Foreach": return (VisitableBuilder)new ForeachBuilder((Foreach) item);
    case "io.sundr.model."+"Block": return (VisitableBuilder)new BlockBuilder((Block) item);
    case "io.sundr.model."+"If": return (VisitableBuilder)new IfBuilder((If) item);
    case "io.sundr.model."+"Return": return (VisitableBuilder)new ReturnBuilder((Return) item);
    case "io.sundr.model."+"For": return (VisitableBuilder)new ForBuilder((For) item);
    }
     return (VisitableBuilder)builderOf(item);
  }
  public class MultiplyInitNested extends MultiplyFluent> implements Nested{
    MultiplyInitNested(int index,Multiply item) {
      this.index = index;
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endMultiplyInit() {
      return and();
    }
    
  
  }
  public class NewArrayInitNested extends NewArrayFluent> implements Nested{
    NewArrayInitNested(int index,NewArray item) {
      this.index = index;
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endNewArrayInit() {
      return and();
    }
    
  
  }
  public class InstanceOfInitNested extends InstanceOfFluent> implements Nested{
    InstanceOfInitNested(int index,InstanceOf item) {
      this.index = index;
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endInstanceOfInit() {
      return and();
    }
    
  
  }
  public class MethodCallInitNested extends MethodCallFluent> implements Nested{
    MethodCallInitNested(int index,MethodCall item) {
      this.index = index;
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endMethodCallInit() {
      return and();
    }
    
  
  }
  public class InverseInitNested extends InverseFluent> implements Nested{
    InverseInitNested(int index,Inverse item) {
      this.index = index;
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endInverseInit() {
      return and();
    }
    
  
  }
  public class IndexInitNested extends IndexFluent> implements Nested{
    IndexInitNested(int index,Index item) {
      this.index = index;
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endIndexInit() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualInitNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualInitNested(int index,GreaterThanOrEqual item) {
      this.index = index;
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endGreaterThanOrEqualInit() {
      return and();
    }
    
  
  }
  public class BitwiseAndInitNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndInitNested(int index,BitwiseAnd item) {
      this.index = index;
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endBitwiseAndInit() {
      return and();
    }
    
  
  }
  public class MinusInitNested extends MinusFluent> implements Nested{
    MinusInitNested(int index,Minus item) {
      this.index = index;
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endMinusInit() {
      return and();
    }
    
  
  }
  public class LogicalOrInitNested extends LogicalOrFluent> implements Nested{
    LogicalOrInitNested(int index,LogicalOr item) {
      this.index = index;
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLogicalOrInit() {
      return and();
    }
    
  
  }
  public class NotEqualsInitNested extends NotEqualsFluent> implements Nested{
    NotEqualsInitNested(int index,NotEquals item) {
      this.index = index;
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endNotEqualsInit() {
      return and();
    }
    
  
  }
  public class DivideInitNested extends DivideFluent> implements Nested{
    DivideInitNested(int index,Divide item) {
      this.index = index;
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endDivideInit() {
      return and();
    }
    
  
  }
  public class LessThanInitNested extends LessThanFluent> implements Nested{
    LessThanInitNested(int index,LessThan item) {
      this.index = index;
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLessThanInit() {
      return and();
    }
    
  
  }
  public class BitwiseOrInitNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrInitNested(int index,BitwiseOr item) {
      this.index = index;
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endBitwiseOrInit() {
      return and();
    }
    
  
  }
  public class PropertyRefInitNested extends PropertyRefFluent> implements Nested{
    PropertyRefInitNested(int index,PropertyRef item) {
      this.index = index;
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPropertyRefInit() {
      return and();
    }
    
  
  }
  public class RightShiftInitNested extends RightShiftFluent> implements Nested{
    RightShiftInitNested(int index,RightShift item) {
      this.index = index;
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endRightShiftInit() {
      return and();
    }
    
  
  }
  public class GreaterThanInitNested extends GreaterThanFluent> implements Nested{
    GreaterThanInitNested(int index,GreaterThan item) {
      this.index = index;
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endGreaterThanInit() {
      return and();
    }
    
  
  }
  public class DeclareInitNested extends DeclareFluent> implements Nested{
    DeclareInitNested(int index,Declare item) {
      this.index = index;
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endDeclareInit() {
      return and();
    }
    
  
  }
  public class CastInitNested extends CastFluent> implements Nested{
    CastInitNested(int index,Cast item) {
      this.index = index;
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endCastInit() {
      return and();
    }
    
  
  }
  public class ModuloInitNested extends ModuloFluent> implements Nested{
    ModuloInitNested(int index,Modulo item) {
      this.index = index;
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endModuloInit() {
      return and();
    }
    
  
  }
  public class ValueRefInitNested extends ValueRefFluent> implements Nested{
    ValueRefInitNested(int index,ValueRef item) {
      this.index = index;
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endValueRefInit() {
      return and();
    }
    
  
  }
  public class LeftShiftInitNested extends LeftShiftFluent> implements Nested{
    LeftShiftInitNested(int index,LeftShift item) {
      this.index = index;
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLeftShiftInit() {
      return and();
    }
    
  
  }
  public class TernaryInitNested extends TernaryFluent> implements Nested{
    TernaryInitNested(int index,Ternary item) {
      this.index = index;
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endTernaryInit() {
      return and();
    }
    
  
  }
  public class BinaryExpressionInitNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionInitNested(int index,BinaryExpression item) {
      this.index = index;
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endBinaryExpressionInit() {
      return and();
    }
    
  
  }
  public class EqualsInitNested extends EqualsFluent> implements Nested{
    EqualsInitNested(int index,Equals item) {
      this.index = index;
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endEqualsInit() {
      return and();
    }
    
  
  }
  public class EnclosedInitNested extends EnclosedFluent> implements Nested{
    EnclosedInitNested(int index,Enclosed item) {
      this.index = index;
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endEnclosedInit() {
      return and();
    }
    
  
  }
  public class PreDecrementInitNested extends PreDecrementFluent> implements Nested{
    PreDecrementInitNested(int index,PreDecrement item) {
      this.index = index;
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPreDecrementInit() {
      return and();
    }
    
  
  }
  public class PostDecrementInitNested extends PostDecrementFluent> implements Nested{
    PostDecrementInitNested(int index,PostDecrement item) {
      this.index = index;
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPostDecrementInit() {
      return and();
    }
    
  
  }
  public class LambdaInitNested extends LambdaFluent> implements Nested{
    LambdaInitNested(int index,Lambda item) {
      this.index = index;
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLambdaInit() {
      return and();
    }
    
  
  }
  public class NotInitNested extends NotFluent> implements Nested{
    NotInitNested(int index,Not item) {
      this.index = index;
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endNotInit() {
      return and();
    }
    
  
  }
  public class ThisInitNested extends ThisFluent> implements Nested{
    ThisInitNested(int index,This item) {
      this.index = index;
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endThisInit() {
      return and();
    }
    
  
  }
  public class NegativeInitNested extends NegativeFluent> implements Nested{
    NegativeInitNested(int index,Negative item) {
      this.index = index;
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endNegativeInit() {
      return and();
    }
    
  
  }
  public class AssignInitNested extends AssignFluent> implements Nested{
    AssignInitNested(int index,Assign item) {
      this.index = index;
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endAssignInit() {
      return and();
    }
    
  
  }
  public class LogicalAndInitNested extends LogicalAndFluent> implements Nested{
    LogicalAndInitNested(int index,LogicalAnd item) {
      this.index = index;
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLogicalAndInit() {
      return and();
    }
    
  
  }
  public class PostIncrementInitNested extends PostIncrementFluent> implements Nested{
    PostIncrementInitNested(int index,PostIncrement item) {
      this.index = index;
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPostIncrementInit() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftInitNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftInitNested(int index,RightUnsignedShift item) {
      this.index = index;
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endRightUnsignedShiftInit() {
      return and();
    }
    
  
  }
  public class PlusInitNested extends PlusFluent> implements Nested{
    PlusInitNested(int index,Plus item) {
      this.index = index;
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPlusInit() {
      return and();
    }
    
  
  }
  public class ConstructInitNested extends ConstructFluent> implements Nested{
    ConstructInitNested(int index,Construct item) {
      this.index = index;
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endConstructInit() {
      return and();
    }
    
  
  }
  public class XorInitNested extends XorFluent> implements Nested{
    XorInitNested(int index,Xor item) {
      this.index = index;
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endXorInit() {
      return and();
    }
    
  
  }
  public class PreIncrementInitNested extends PreIncrementFluent> implements Nested{
    PreIncrementInitNested(int index,PreIncrement item) {
      this.index = index;
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPreIncrementInit() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualInitNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualInitNested(int index,LessThanOrEqual item) {
      this.index = index;
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endLessThanOrEqualInit() {
      return and();
    }
    
  
  }
  public class PositiveInitNested extends PositiveFluent> implements Nested{
    PositiveInitNested(int index,Positive item) {
      this.index = index;
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToInit(index,builder.build());
    }
    
    public N endPositiveInit() {
      return and();
    }
    
  
  }
  public class MultiplyCompareNested extends MultiplyFluent> implements Nested{
    MultiplyCompareNested(Multiply item) {
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endMultiplyCompare() {
      return and();
    }
    
  
  }
  public class NewArrayCompareNested extends NewArrayFluent> implements Nested{
    NewArrayCompareNested(NewArray item) {
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endNewArrayCompare() {
      return and();
    }
    
  
  }
  public class InstanceOfCompareNested extends InstanceOfFluent> implements Nested{
    InstanceOfCompareNested(InstanceOf item) {
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endInstanceOfCompare() {
      return and();
    }
    
  
  }
  public class MethodCallCompareNested extends MethodCallFluent> implements Nested{
    MethodCallCompareNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endMethodCallCompare() {
      return and();
    }
    
  
  }
  public class InverseCompareNested extends InverseFluent> implements Nested{
    InverseCompareNested(Inverse item) {
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endInverseCompare() {
      return and();
    }
    
  
  }
  public class IndexCompareNested extends IndexFluent> implements Nested{
    IndexCompareNested(Index item) {
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endIndexCompare() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualCompareNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualCompareNested(GreaterThanOrEqual item) {
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endGreaterThanOrEqualCompare() {
      return and();
    }
    
  
  }
  public class BitwiseAndCompareNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndCompareNested(BitwiseAnd item) {
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endBitwiseAndCompare() {
      return and();
    }
    
  
  }
  public class MinusCompareNested extends MinusFluent> implements Nested{
    MinusCompareNested(Minus item) {
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endMinusCompare() {
      return and();
    }
    
  
  }
  public class LogicalOrCompareNested extends LogicalOrFluent> implements Nested{
    LogicalOrCompareNested(LogicalOr item) {
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLogicalOrCompare() {
      return and();
    }
    
  
  }
  public class NotEqualsCompareNested extends NotEqualsFluent> implements Nested{
    NotEqualsCompareNested(NotEquals item) {
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endNotEqualsCompare() {
      return and();
    }
    
  
  }
  public class DivideCompareNested extends DivideFluent> implements Nested{
    DivideCompareNested(Divide item) {
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endDivideCompare() {
      return and();
    }
    
  
  }
  public class LessThanCompareNested extends LessThanFluent> implements Nested{
    LessThanCompareNested(LessThan item) {
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLessThanCompare() {
      return and();
    }
    
  
  }
  public class BitwiseOrCompareNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrCompareNested(BitwiseOr item) {
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endBitwiseOrCompare() {
      return and();
    }
    
  
  }
  public class PropertyRefCompareNested extends PropertyRefFluent> implements Nested{
    PropertyRefCompareNested(PropertyRef item) {
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPropertyRefCompare() {
      return and();
    }
    
  
  }
  public class RightShiftCompareNested extends RightShiftFluent> implements Nested{
    RightShiftCompareNested(RightShift item) {
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endRightShiftCompare() {
      return and();
    }
    
  
  }
  public class GreaterThanCompareNested extends GreaterThanFluent> implements Nested{
    GreaterThanCompareNested(GreaterThan item) {
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endGreaterThanCompare() {
      return and();
    }
    
  
  }
  public class DeclareCompareNested extends DeclareFluent> implements Nested{
    DeclareCompareNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endDeclareCompare() {
      return and();
    }
    
  
  }
  public class CastCompareNested extends CastFluent> implements Nested{
    CastCompareNested(Cast item) {
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endCastCompare() {
      return and();
    }
    
  
  }
  public class ModuloCompareNested extends ModuloFluent> implements Nested{
    ModuloCompareNested(Modulo item) {
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endModuloCompare() {
      return and();
    }
    
  
  }
  public class ValueRefCompareNested extends ValueRefFluent> implements Nested{
    ValueRefCompareNested(ValueRef item) {
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endValueRefCompare() {
      return and();
    }
    
  
  }
  public class LeftShiftCompareNested extends LeftShiftFluent> implements Nested{
    LeftShiftCompareNested(LeftShift item) {
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLeftShiftCompare() {
      return and();
    }
    
  
  }
  public class TernaryCompareNested extends TernaryFluent> implements Nested{
    TernaryCompareNested(Ternary item) {
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endTernaryCompare() {
      return and();
    }
    
  
  }
  public class BinaryExpressionCompareNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionCompareNested(BinaryExpression item) {
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endBinaryExpressionCompare() {
      return and();
    }
    
  
  }
  public class EqualsCompareNested extends EqualsFluent> implements Nested{
    EqualsCompareNested(Equals item) {
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endEqualsCompare() {
      return and();
    }
    
  
  }
  public class EnclosedCompareNested extends EnclosedFluent> implements Nested{
    EnclosedCompareNested(Enclosed item) {
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endEnclosedCompare() {
      return and();
    }
    
  
  }
  public class PreDecrementCompareNested extends PreDecrementFluent> implements Nested{
    PreDecrementCompareNested(PreDecrement item) {
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPreDecrementCompare() {
      return and();
    }
    
  
  }
  public class PostDecrementCompareNested extends PostDecrementFluent> implements Nested{
    PostDecrementCompareNested(PostDecrement item) {
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPostDecrementCompare() {
      return and();
    }
    
  
  }
  public class LambdaCompareNested extends LambdaFluent> implements Nested{
    LambdaCompareNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLambdaCompare() {
      return and();
    }
    
  
  }
  public class NotCompareNested extends NotFluent> implements Nested{
    NotCompareNested(Not item) {
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endNotCompare() {
      return and();
    }
    
  
  }
  public class ThisCompareNested extends ThisFluent> implements Nested{
    ThisCompareNested(This item) {
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endThisCompare() {
      return and();
    }
    
  
  }
  public class NegativeCompareNested extends NegativeFluent> implements Nested{
    NegativeCompareNested(Negative item) {
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endNegativeCompare() {
      return and();
    }
    
  
  }
  public class AssignCompareNested extends AssignFluent> implements Nested{
    AssignCompareNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endAssignCompare() {
      return and();
    }
    
  
  }
  public class LogicalAndCompareNested extends LogicalAndFluent> implements Nested{
    LogicalAndCompareNested(LogicalAnd item) {
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLogicalAndCompare() {
      return and();
    }
    
  
  }
  public class PostIncrementCompareNested extends PostIncrementFluent> implements Nested{
    PostIncrementCompareNested(PostIncrement item) {
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPostIncrementCompare() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftCompareNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftCompareNested(RightUnsignedShift item) {
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endRightUnsignedShiftCompare() {
      return and();
    }
    
  
  }
  public class PlusCompareNested extends PlusFluent> implements Nested{
    PlusCompareNested(Plus item) {
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPlusCompare() {
      return and();
    }
    
  
  }
  public class ConstructCompareNested extends ConstructFluent> implements Nested{
    ConstructCompareNested(Construct item) {
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endConstructCompare() {
      return and();
    }
    
  
  }
  public class XorCompareNested extends XorFluent> implements Nested{
    XorCompareNested(Xor item) {
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endXorCompare() {
      return and();
    }
    
  
  }
  public class PreIncrementCompareNested extends PreIncrementFluent> implements Nested{
    PreIncrementCompareNested(PreIncrement item) {
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPreIncrementCompare() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualCompareNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualCompareNested(LessThanOrEqual item) {
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endLessThanOrEqualCompare() {
      return and();
    }
    
  
  }
  public class PositiveCompareNested extends PositiveFluent> implements Nested{
    PositiveCompareNested(Positive item) {
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withCompare(builder.build());
    }
    
    public N endPositiveCompare() {
      return and();
    }
    
  
  }
  public class MultiplyUpdateNested extends MultiplyFluent> implements Nested{
    MultiplyUpdateNested(int index,Multiply item) {
      this.index = index;
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endMultiplyUpdate() {
      return and();
    }
    
  
  }
  public class NewArrayUpdateNested extends NewArrayFluent> implements Nested{
    NewArrayUpdateNested(int index,NewArray item) {
      this.index = index;
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endNewArrayUpdate() {
      return and();
    }
    
  
  }
  public class InstanceOfUpdateNested extends InstanceOfFluent> implements Nested{
    InstanceOfUpdateNested(int index,InstanceOf item) {
      this.index = index;
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endInstanceOfUpdate() {
      return and();
    }
    
  
  }
  public class MethodCallUpdateNested extends MethodCallFluent> implements Nested{
    MethodCallUpdateNested(int index,MethodCall item) {
      this.index = index;
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endMethodCallUpdate() {
      return and();
    }
    
  
  }
  public class InverseUpdateNested extends InverseFluent> implements Nested{
    InverseUpdateNested(int index,Inverse item) {
      this.index = index;
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endInverseUpdate() {
      return and();
    }
    
  
  }
  public class IndexUpdateNested extends IndexFluent> implements Nested{
    IndexUpdateNested(int index,Index item) {
      this.index = index;
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endIndexUpdate() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualUpdateNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualUpdateNested(int index,GreaterThanOrEqual item) {
      this.index = index;
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endGreaterThanOrEqualUpdate() {
      return and();
    }
    
  
  }
  public class BitwiseAndUpdateNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndUpdateNested(int index,BitwiseAnd item) {
      this.index = index;
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endBitwiseAndUpdate() {
      return and();
    }
    
  
  }
  public class MinusUpdateNested extends MinusFluent> implements Nested{
    MinusUpdateNested(int index,Minus item) {
      this.index = index;
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endMinusUpdate() {
      return and();
    }
    
  
  }
  public class LogicalOrUpdateNested extends LogicalOrFluent> implements Nested{
    LogicalOrUpdateNested(int index,LogicalOr item) {
      this.index = index;
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLogicalOrUpdate() {
      return and();
    }
    
  
  }
  public class NotEqualsUpdateNested extends NotEqualsFluent> implements Nested{
    NotEqualsUpdateNested(int index,NotEquals item) {
      this.index = index;
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endNotEqualsUpdate() {
      return and();
    }
    
  
  }
  public class DivideUpdateNested extends DivideFluent> implements Nested{
    DivideUpdateNested(int index,Divide item) {
      this.index = index;
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endDivideUpdate() {
      return and();
    }
    
  
  }
  public class LessThanUpdateNested extends LessThanFluent> implements Nested{
    LessThanUpdateNested(int index,LessThan item) {
      this.index = index;
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLessThanUpdate() {
      return and();
    }
    
  
  }
  public class BitwiseOrUpdateNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrUpdateNested(int index,BitwiseOr item) {
      this.index = index;
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endBitwiseOrUpdate() {
      return and();
    }
    
  
  }
  public class PropertyRefUpdateNested extends PropertyRefFluent> implements Nested{
    PropertyRefUpdateNested(int index,PropertyRef item) {
      this.index = index;
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPropertyRefUpdate() {
      return and();
    }
    
  
  }
  public class RightShiftUpdateNested extends RightShiftFluent> implements Nested{
    RightShiftUpdateNested(int index,RightShift item) {
      this.index = index;
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endRightShiftUpdate() {
      return and();
    }
    
  
  }
  public class GreaterThanUpdateNested extends GreaterThanFluent> implements Nested{
    GreaterThanUpdateNested(int index,GreaterThan item) {
      this.index = index;
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endGreaterThanUpdate() {
      return and();
    }
    
  
  }
  public class DeclareUpdateNested extends DeclareFluent> implements Nested{
    DeclareUpdateNested(int index,Declare item) {
      this.index = index;
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endDeclareUpdate() {
      return and();
    }
    
  
  }
  public class CastUpdateNested extends CastFluent> implements Nested{
    CastUpdateNested(int index,Cast item) {
      this.index = index;
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endCastUpdate() {
      return and();
    }
    
  
  }
  public class ModuloUpdateNested extends ModuloFluent> implements Nested{
    ModuloUpdateNested(int index,Modulo item) {
      this.index = index;
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endModuloUpdate() {
      return and();
    }
    
  
  }
  public class ValueRefUpdateNested extends ValueRefFluent> implements Nested{
    ValueRefUpdateNested(int index,ValueRef item) {
      this.index = index;
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endValueRefUpdate() {
      return and();
    }
    
  
  }
  public class LeftShiftUpdateNested extends LeftShiftFluent> implements Nested{
    LeftShiftUpdateNested(int index,LeftShift item) {
      this.index = index;
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLeftShiftUpdate() {
      return and();
    }
    
  
  }
  public class TernaryUpdateNested extends TernaryFluent> implements Nested{
    TernaryUpdateNested(int index,Ternary item) {
      this.index = index;
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endTernaryUpdate() {
      return and();
    }
    
  
  }
  public class BinaryExpressionUpdateNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionUpdateNested(int index,BinaryExpression item) {
      this.index = index;
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endBinaryExpressionUpdate() {
      return and();
    }
    
  
  }
  public class EqualsUpdateNested extends EqualsFluent> implements Nested{
    EqualsUpdateNested(int index,Equals item) {
      this.index = index;
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endEqualsUpdate() {
      return and();
    }
    
  
  }
  public class EnclosedUpdateNested extends EnclosedFluent> implements Nested{
    EnclosedUpdateNested(int index,Enclosed item) {
      this.index = index;
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endEnclosedUpdate() {
      return and();
    }
    
  
  }
  public class PreDecrementUpdateNested extends PreDecrementFluent> implements Nested{
    PreDecrementUpdateNested(int index,PreDecrement item) {
      this.index = index;
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPreDecrementUpdate() {
      return and();
    }
    
  
  }
  public class PostDecrementUpdateNested extends PostDecrementFluent> implements Nested{
    PostDecrementUpdateNested(int index,PostDecrement item) {
      this.index = index;
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPostDecrementUpdate() {
      return and();
    }
    
  
  }
  public class LambdaUpdateNested extends LambdaFluent> implements Nested{
    LambdaUpdateNested(int index,Lambda item) {
      this.index = index;
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLambdaUpdate() {
      return and();
    }
    
  
  }
  public class NotUpdateNested extends NotFluent> implements Nested{
    NotUpdateNested(int index,Not item) {
      this.index = index;
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endNotUpdate() {
      return and();
    }
    
  
  }
  public class ThisUpdateNested extends ThisFluent> implements Nested{
    ThisUpdateNested(int index,This item) {
      this.index = index;
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endThisUpdate() {
      return and();
    }
    
  
  }
  public class NegativeUpdateNested extends NegativeFluent> implements Nested{
    NegativeUpdateNested(int index,Negative item) {
      this.index = index;
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endNegativeUpdate() {
      return and();
    }
    
  
  }
  public class AssignUpdateNested extends AssignFluent> implements Nested{
    AssignUpdateNested(int index,Assign item) {
      this.index = index;
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endAssignUpdate() {
      return and();
    }
    
  
  }
  public class LogicalAndUpdateNested extends LogicalAndFluent> implements Nested{
    LogicalAndUpdateNested(int index,LogicalAnd item) {
      this.index = index;
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLogicalAndUpdate() {
      return and();
    }
    
  
  }
  public class PostIncrementUpdateNested extends PostIncrementFluent> implements Nested{
    PostIncrementUpdateNested(int index,PostIncrement item) {
      this.index = index;
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPostIncrementUpdate() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftUpdateNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftUpdateNested(int index,RightUnsignedShift item) {
      this.index = index;
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endRightUnsignedShiftUpdate() {
      return and();
    }
    
  
  }
  public class PlusUpdateNested extends PlusFluent> implements Nested{
    PlusUpdateNested(int index,Plus item) {
      this.index = index;
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPlusUpdate() {
      return and();
    }
    
  
  }
  public class ConstructUpdateNested extends ConstructFluent> implements Nested{
    ConstructUpdateNested(int index,Construct item) {
      this.index = index;
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endConstructUpdate() {
      return and();
    }
    
  
  }
  public class XorUpdateNested extends XorFluent> implements Nested{
    XorUpdateNested(int index,Xor item) {
      this.index = index;
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endXorUpdate() {
      return and();
    }
    
  
  }
  public class PreIncrementUpdateNested extends PreIncrementFluent> implements Nested{
    PreIncrementUpdateNested(int index,PreIncrement item) {
      this.index = index;
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPreIncrementUpdate() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualUpdateNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualUpdateNested(int index,LessThanOrEqual item) {
      this.index = index;
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endLessThanOrEqualUpdate() {
      return and();
    }
    
  
  }
  public class PositiveUpdateNested extends PositiveFluent> implements Nested{
    PositiveUpdateNested(int index,Positive item) {
      this.index = index;
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    int index;
    
    public N and() {
      return (N) ForFluent.this.setToUpdate(index,builder.build());
    }
    
    public N endPositiveUpdate() {
      return and();
    }
    
  
  }
  public class MethodCallBodyNested extends MethodCallFluent> implements Nested{
    MethodCallBodyNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endMethodCallBody() {
      return and();
    }
    
  
  }
  public class SwitchBodyNested extends SwitchFluent> implements Nested{
    SwitchBodyNested(Switch item) {
      this.builder = new SwitchBuilder(this, item);
    }
    SwitchBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endSwitchBody() {
      return and();
    }
    
  
  }
  public class BreakBodyNested extends BreakFluent> implements Nested{
    BreakBodyNested(Break item) {
      this.builder = new BreakBuilder(this, item);
    }
    BreakBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endBreakBody() {
      return and();
    }
    
  
  }
  public class DeclareBodyNested extends DeclareFluent> implements Nested{
    DeclareBodyNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endDeclareBody() {
      return and();
    }
    
  
  }
  public class WhileBodyNested extends WhileFluent> implements Nested{
    WhileBodyNested(While item) {
      this.builder = new WhileBuilder(this, item);
    }
    WhileBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endWhileBody() {
      return and();
    }
    
  
  }
  public class ContinueBodyNested extends ContinueFluent> implements Nested{
    ContinueBodyNested(Continue item) {
      this.builder = new ContinueBuilder(this, item);
    }
    ContinueBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endContinueBody() {
      return and();
    }
    
  
  }
  public class StringStatementBodyNested extends StringStatementFluent> implements Nested{
    StringStatementBodyNested(StringStatement item) {
      this.builder = new StringStatementBuilder(this, item);
    }
    StringStatementBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endStringStatementBody() {
      return and();
    }
    
  
  }
  public class DoBodyNested extends DoFluent> implements Nested{
    DoBodyNested(Do item) {
      this.builder = new DoBuilder(this, item);
    }
    DoBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endDoBody() {
      return and();
    }
    
  
  }
  public class ForeachBodyNested extends ForeachFluent> implements Nested{
    ForeachBodyNested(Foreach item) {
      this.builder = new ForeachBuilder(this, item);
    }
    ForeachBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endForeachBody() {
      return and();
    }
    
  
  }
  public class BlockBodyNested extends BlockFluent> implements Nested{
    BlockBodyNested(Block item) {
      this.builder = new BlockBuilder(this, item);
    }
    BlockBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endBlockBody() {
      return and();
    }
    
  
  }
  public class IfBodyNested extends IfFluent> implements Nested{
    IfBodyNested(If item) {
      this.builder = new IfBuilder(this, item);
    }
    IfBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endIfBody() {
      return and();
    }
    
  
  }
  public class LambdaBodyNested extends LambdaFluent> implements Nested{
    LambdaBodyNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endLambdaBody() {
      return and();
    }
    
  
  }
  public class ReturnBodyNested extends ReturnFluent> implements Nested{
    ReturnBodyNested(Return item) {
      this.builder = new ReturnBuilder(this, item);
    }
    ReturnBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endReturnBody() {
      return and();
    }
    
  
  }
  public class AssignBodyNested extends AssignFluent> implements Nested{
    AssignBodyNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endAssignBody() {
      return and();
    }
    
  
  }
  public class ForBodyNested extends ForFluent> implements Nested{
    ForBodyNested(For item) {
      this.builder = new ForBuilder(this, item);
    }
    ForBuilder builder;
    
    public N and() {
      return (N) ForFluent.this.withBody(builder.build());
    }
    
    public N endForBody() {
      return and();
    }
    
  
  }

}