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

Go to download
package io.sundr.model;

import java.lang.String;
import java.lang.Class;
import java.lang.SuppressWarnings;
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 PostIncrementFluent> extends BaseFluent{
  public PostIncrementFluent() {
  }
  
  public PostIncrementFluent(PostIncrement instance) {
    this.copyInstance(instance);
  }
  private VisitableBuilder expression;
  
  protected void copyInstance(PostIncrement instance) {
    if (instance != null) {
          this.withExpression(instance.getExpression());
        }
  }
  
  public Expression buildExpression() {
    return this.expression!=null?this.expression.build():null;
  }
  
  public A withExpression(Expression expression) {
    if (expression==null){ this.expression = null; _visitables.remove("expression"); return (A) this;}
    VisitableBuilder builder = builder(expression); _visitables.get("expression").clear();_visitables.get("expression").add(builder);this.expression = builder;
    return (A) this;
  }
  
  public boolean hasExpression() {
    return this.expression != null;
  }
  
  public MultiplyExpressionNested withNewMultiplyExpression() {
    return new MultiplyExpressionNested(null);
  }
  
  public MultiplyExpressionNested withNewMultiplyExpressionLike(Multiply item) {
    return new MultiplyExpressionNested(item);
  }
  
  public A withNewMultiplyExpression(Object left,Object right) {
    return (A)withExpression(new Multiply(left, right));
  }
  
  public NewArrayExpressionNested withNewNewArrayExpression() {
    return new NewArrayExpressionNested(null);
  }
  
  public NewArrayExpressionNested withNewNewArrayExpressionLike(NewArray item) {
    return new NewArrayExpressionNested(item);
  }
  
  public A withNewNewArrayExpression(Class type,Integer[] sizes) {
    return (A)withExpression(new NewArray(type, sizes));
  }
  
  public InstanceOfExpressionNested withNewInstanceOfExpression() {
    return new InstanceOfExpressionNested(null);
  }
  
  public InstanceOfExpressionNested withNewInstanceOfExpressionLike(InstanceOf item) {
    return new InstanceOfExpressionNested(item);
  }
  
  public MethodCallExpressionNested withNewMethodCallExpression() {
    return new MethodCallExpressionNested(null);
  }
  
  public MethodCallExpressionNested withNewMethodCallExpressionLike(MethodCall item) {
    return new MethodCallExpressionNested(item);
  }
  
  public InverseExpressionNested withNewInverseExpression() {
    return new InverseExpressionNested(null);
  }
  
  public InverseExpressionNested withNewInverseExpressionLike(Inverse item) {
    return new InverseExpressionNested(item);
  }
  
  public IndexExpressionNested withNewIndexExpression() {
    return new IndexExpressionNested(null);
  }
  
  public IndexExpressionNested withNewIndexExpressionLike(Index item) {
    return new IndexExpressionNested(item);
  }
  
  public GreaterThanOrEqualExpressionNested withNewGreaterThanOrEqualExpression() {
    return new GreaterThanOrEqualExpressionNested(null);
  }
  
  public GreaterThanOrEqualExpressionNested withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualExpressionNested(item);
  }
  
  public A withNewGreaterThanOrEqualExpression(Object left,Object right) {
    return (A)withExpression(new GreaterThanOrEqual(left, right));
  }
  
  public BitwiseAndExpressionNested withNewBitwiseAndExpression() {
    return new BitwiseAndExpressionNested(null);
  }
  
  public BitwiseAndExpressionNested withNewBitwiseAndExpressionLike(BitwiseAnd item) {
    return new BitwiseAndExpressionNested(item);
  }
  
  public A withNewBitwiseAndExpression(Object left,Object right) {
    return (A)withExpression(new BitwiseAnd(left, right));
  }
  
  public MinusExpressionNested withNewMinusExpression() {
    return new MinusExpressionNested(null);
  }
  
  public MinusExpressionNested withNewMinusExpressionLike(Minus item) {
    return new MinusExpressionNested(item);
  }
  
  public A withNewMinusExpression(Object left,Object right) {
    return (A)withExpression(new Minus(left, right));
  }
  
  public LogicalOrExpressionNested withNewLogicalOrExpression() {
    return new LogicalOrExpressionNested(null);
  }
  
  public LogicalOrExpressionNested withNewLogicalOrExpressionLike(LogicalOr item) {
    return new LogicalOrExpressionNested(item);
  }
  
  public A withNewLogicalOrExpression(Object left,Object right) {
    return (A)withExpression(new LogicalOr(left, right));
  }
  
  public NotEqualsExpressionNested withNewNotEqualsExpression() {
    return new NotEqualsExpressionNested(null);
  }
  
  public NotEqualsExpressionNested withNewNotEqualsExpressionLike(NotEquals item) {
    return new NotEqualsExpressionNested(item);
  }
  
  public A withNewNotEqualsExpression(Object left,Object right) {
    return (A)withExpression(new NotEquals(left, right));
  }
  
  public DivideExpressionNested withNewDivideExpression() {
    return new DivideExpressionNested(null);
  }
  
  public DivideExpressionNested withNewDivideExpressionLike(Divide item) {
    return new DivideExpressionNested(item);
  }
  
  public A withNewDivideExpression(Object left,Object right) {
    return (A)withExpression(new Divide(left, right));
  }
  
  public LessThanExpressionNested withNewLessThanExpression() {
    return new LessThanExpressionNested(null);
  }
  
  public LessThanExpressionNested withNewLessThanExpressionLike(LessThan item) {
    return new LessThanExpressionNested(item);
  }
  
  public A withNewLessThanExpression(Object left,Object right) {
    return (A)withExpression(new LessThan(left, right));
  }
  
  public BitwiseOrExpressionNested withNewBitwiseOrExpression() {
    return new BitwiseOrExpressionNested(null);
  }
  
  public BitwiseOrExpressionNested withNewBitwiseOrExpressionLike(BitwiseOr item) {
    return new BitwiseOrExpressionNested(item);
  }
  
  public A withNewBitwiseOrExpression(Object left,Object right) {
    return (A)withExpression(new BitwiseOr(left, right));
  }
  
  public PropertyRefExpressionNested withNewPropertyRefExpression() {
    return new PropertyRefExpressionNested(null);
  }
  
  public PropertyRefExpressionNested withNewPropertyRefExpressionLike(PropertyRef item) {
    return new PropertyRefExpressionNested(item);
  }
  
  public RightShiftExpressionNested withNewRightShiftExpression() {
    return new RightShiftExpressionNested(null);
  }
  
  public RightShiftExpressionNested withNewRightShiftExpressionLike(RightShift item) {
    return new RightShiftExpressionNested(item);
  }
  
  public A withNewRightShiftExpression(Object left,Object right) {
    return (A)withExpression(new RightShift(left, right));
  }
  
  public GreaterThanExpressionNested withNewGreaterThanExpression() {
    return new GreaterThanExpressionNested(null);
  }
  
  public GreaterThanExpressionNested withNewGreaterThanExpressionLike(GreaterThan item) {
    return new GreaterThanExpressionNested(item);
  }
  
  public A withNewGreaterThanExpression(Object left,Object right) {
    return (A)withExpression(new GreaterThan(left, right));
  }
  
  public DeclareExpressionNested withNewDeclareExpression() {
    return new DeclareExpressionNested(null);
  }
  
  public DeclareExpressionNested withNewDeclareExpressionLike(Declare item) {
    return new DeclareExpressionNested(item);
  }
  
  public A withNewDeclareExpression(Class type,String name) {
    return (A)withExpression(new Declare(type, name));
  }
  
  public A withNewDeclareExpression(Class type,String name,Object value) {
    return (A)withExpression(new Declare(type, name, value));
  }
  
  public CastExpressionNested withNewCastExpression() {
    return new CastExpressionNested(null);
  }
  
  public CastExpressionNested withNewCastExpressionLike(Cast item) {
    return new CastExpressionNested(item);
  }
  
  public ModuloExpressionNested withNewModuloExpression() {
    return new ModuloExpressionNested(null);
  }
  
  public ModuloExpressionNested withNewModuloExpressionLike(Modulo item) {
    return new ModuloExpressionNested(item);
  }
  
  public A withNewModuloExpression(Object left,Object right) {
    return (A)withExpression(new Modulo(left, right));
  }
  
  public ValueRefExpressionNested withNewValueRefExpression() {
    return new ValueRefExpressionNested(null);
  }
  
  public ValueRefExpressionNested withNewValueRefExpressionLike(ValueRef item) {
    return new ValueRefExpressionNested(item);
  }
  
  public A withNewValueRefExpression(Object value) {
    return (A)withExpression(new ValueRef(value));
  }
  
  public LeftShiftExpressionNested withNewLeftShiftExpression() {
    return new LeftShiftExpressionNested(null);
  }
  
  public LeftShiftExpressionNested withNewLeftShiftExpressionLike(LeftShift item) {
    return new LeftShiftExpressionNested(item);
  }
  
  public A withNewLeftShiftExpression(Object left,Object right) {
    return (A)withExpression(new LeftShift(left, right));
  }
  
  public TernaryExpressionNested withNewTernaryExpression() {
    return new TernaryExpressionNested(null);
  }
  
  public TernaryExpressionNested withNewTernaryExpressionLike(Ternary item) {
    return new TernaryExpressionNested(item);
  }
  
  public BinaryExpressionNested withNewBinaryExpression() {
    return new BinaryExpressionNested(null);
  }
  
  public BinaryExpressionNested withNewBinaryExpressionLike(BinaryExpression item) {
    return new BinaryExpressionNested(item);
  }
  
  public EqualsExpressionNested withNewEqualsExpression() {
    return new EqualsExpressionNested(null);
  }
  
  public EqualsExpressionNested withNewEqualsExpressionLike(Equals item) {
    return new EqualsExpressionNested(item);
  }
  
  public A withNewEqualsExpression(Object left,Object right) {
    return (A)withExpression(new Equals(left, right));
  }
  
  public EnclosedExpressionNested withNewEnclosedExpression() {
    return new EnclosedExpressionNested(null);
  }
  
  public EnclosedExpressionNested withNewEnclosedExpressionLike(Enclosed item) {
    return new EnclosedExpressionNested(item);
  }
  
  public PreDecrementExpressionNested withNewPreDecrementExpression() {
    return new PreDecrementExpressionNested(null);
  }
  
  public PreDecrementExpressionNested withNewPreDecrementExpressionLike(PreDecrement item) {
    return new PreDecrementExpressionNested(item);
  }
  
  public PostDecrementExpressionNested withNewPostDecrementExpression() {
    return new PostDecrementExpressionNested(null);
  }
  
  public PostDecrementExpressionNested withNewPostDecrementExpressionLike(PostDecrement item) {
    return new PostDecrementExpressionNested(item);
  }
  
  public LambdaExpressionNested withNewLambdaExpression() {
    return new LambdaExpressionNested(null);
  }
  
  public LambdaExpressionNested withNewLambdaExpressionLike(Lambda item) {
    return new LambdaExpressionNested(item);
  }
  
  public NotExpressionNested withNewNotExpression() {
    return new NotExpressionNested(null);
  }
  
  public NotExpressionNested withNewNotExpressionLike(Not item) {
    return new NotExpressionNested(item);
  }
  
  public ThisExpressionNested withNewThisExpression() {
    return new ThisExpressionNested(null);
  }
  
  public ThisExpressionNested withNewThisExpressionLike(This item) {
    return new ThisExpressionNested(item);
  }
  
  public NegativeExpressionNested withNewNegativeExpression() {
    return new NegativeExpressionNested(null);
  }
  
  public NegativeExpressionNested withNewNegativeExpressionLike(Negative item) {
    return new NegativeExpressionNested(item);
  }
  
  public AssignExpressionNested withNewAssignExpression() {
    return new AssignExpressionNested(null);
  }
  
  public AssignExpressionNested withNewAssignExpressionLike(Assign item) {
    return new AssignExpressionNested(item);
  }
  
  public LogicalAndExpressionNested withNewLogicalAndExpression() {
    return new LogicalAndExpressionNested(null);
  }
  
  public LogicalAndExpressionNested withNewLogicalAndExpressionLike(LogicalAnd item) {
    return new LogicalAndExpressionNested(item);
  }
  
  public A withNewLogicalAndExpression(Object left,Object right) {
    return (A)withExpression(new LogicalAnd(left, right));
  }
  
  public PostIncrementExpressionNested withNewPostIncrementExpression() {
    return new PostIncrementExpressionNested(null);
  }
  
  public PostIncrementExpressionNested withNewPostIncrementExpressionLike(PostIncrement item) {
    return new PostIncrementExpressionNested(item);
  }
  
  public RightUnsignedShiftExpressionNested withNewRightUnsignedShiftExpression() {
    return new RightUnsignedShiftExpressionNested(null);
  }
  
  public RightUnsignedShiftExpressionNested withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item) {
    return new RightUnsignedShiftExpressionNested(item);
  }
  
  public A withNewRightUnsignedShiftExpression(Object left,Object right) {
    return (A)withExpression(new RightUnsignedShift(left, right));
  }
  
  public PlusExpressionNested withNewPlusExpression() {
    return new PlusExpressionNested(null);
  }
  
  public PlusExpressionNested withNewPlusExpressionLike(Plus item) {
    return new PlusExpressionNested(item);
  }
  
  public A withNewPlusExpression(Object left,Object right) {
    return (A)withExpression(new Plus(left, right));
  }
  
  public ConstructExpressionNested withNewConstructExpression() {
    return new ConstructExpressionNested(null);
  }
  
  public ConstructExpressionNested withNewConstructExpressionLike(Construct item) {
    return new ConstructExpressionNested(item);
  }
  
  public XorExpressionNested withNewXorExpression() {
    return new XorExpressionNested(null);
  }
  
  public XorExpressionNested withNewXorExpressionLike(Xor item) {
    return new XorExpressionNested(item);
  }
  
  public A withNewXorExpression(Object left,Object right) {
    return (A)withExpression(new Xor(left, right));
  }
  
  public PreIncrementExpressionNested withNewPreIncrementExpression() {
    return new PreIncrementExpressionNested(null);
  }
  
  public PreIncrementExpressionNested withNewPreIncrementExpressionLike(PreIncrement item) {
    return new PreIncrementExpressionNested(item);
  }
  
  public LessThanOrEqualExpressionNested withNewLessThanOrEqualExpression() {
    return new LessThanOrEqualExpressionNested(null);
  }
  
  public LessThanOrEqualExpressionNested withNewLessThanOrEqualExpressionLike(LessThanOrEqual item) {
    return new LessThanOrEqualExpressionNested(item);
  }
  
  public A withNewLessThanOrEqualExpression(Object left,Object right) {
    return (A)withExpression(new LessThanOrEqual(left, right));
  }
  
  public PositiveExpressionNested withNewPositiveExpression() {
    return new PositiveExpressionNested(null);
  }
  
  public PositiveExpressionNested withNewPositiveExpressionLike(Positive item) {
    return new PositiveExpressionNested(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;
    PostIncrementFluent that = (PostIncrementFluent) o;
    if (!java.util.Objects.equals(expression, that.expression)) return false;
    return true;
  }
  
  public int hashCode() {
    return java.util.Objects.hash(expression,  super.hashCode());
  }
  
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    if (expression != null) { sb.append("expression:"); sb.append(expression); }
    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);
    }
     return (VisitableBuilder)builderOf(item);
  }
  public class MultiplyExpressionNested extends MultiplyFluent> implements Nested{
    MultiplyExpressionNested(Multiply item) {
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endMultiplyExpression() {
      return and();
    }
    
  
  }
  public class NewArrayExpressionNested extends NewArrayFluent> implements Nested{
    NewArrayExpressionNested(NewArray item) {
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endNewArrayExpression() {
      return and();
    }
    
  
  }
  public class InstanceOfExpressionNested extends InstanceOfFluent> implements Nested{
    InstanceOfExpressionNested(InstanceOf item) {
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endInstanceOfExpression() {
      return and();
    }
    
  
  }
  public class MethodCallExpressionNested extends MethodCallFluent> implements Nested{
    MethodCallExpressionNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endMethodCallExpression() {
      return and();
    }
    
  
  }
  public class InverseExpressionNested extends InverseFluent> implements Nested{
    InverseExpressionNested(Inverse item) {
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endInverseExpression() {
      return and();
    }
    
  
  }
  public class IndexExpressionNested extends IndexFluent> implements Nested{
    IndexExpressionNested(Index item) {
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endIndexExpression() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualExpressionNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualExpressionNested(GreaterThanOrEqual item) {
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endGreaterThanOrEqualExpression() {
      return and();
    }
    
  
  }
  public class BitwiseAndExpressionNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndExpressionNested(BitwiseAnd item) {
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endBitwiseAndExpression() {
      return and();
    }
    
  
  }
  public class MinusExpressionNested extends MinusFluent> implements Nested{
    MinusExpressionNested(Minus item) {
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endMinusExpression() {
      return and();
    }
    
  
  }
  public class LogicalOrExpressionNested extends LogicalOrFluent> implements Nested{
    LogicalOrExpressionNested(LogicalOr item) {
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLogicalOrExpression() {
      return and();
    }
    
  
  }
  public class NotEqualsExpressionNested extends NotEqualsFluent> implements Nested{
    NotEqualsExpressionNested(NotEquals item) {
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endNotEqualsExpression() {
      return and();
    }
    
  
  }
  public class DivideExpressionNested extends DivideFluent> implements Nested{
    DivideExpressionNested(Divide item) {
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endDivideExpression() {
      return and();
    }
    
  
  }
  public class LessThanExpressionNested extends LessThanFluent> implements Nested{
    LessThanExpressionNested(LessThan item) {
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLessThanExpression() {
      return and();
    }
    
  
  }
  public class BitwiseOrExpressionNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrExpressionNested(BitwiseOr item) {
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endBitwiseOrExpression() {
      return and();
    }
    
  
  }
  public class PropertyRefExpressionNested extends PropertyRefFluent> implements Nested{
    PropertyRefExpressionNested(PropertyRef item) {
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPropertyRefExpression() {
      return and();
    }
    
  
  }
  public class RightShiftExpressionNested extends RightShiftFluent> implements Nested{
    RightShiftExpressionNested(RightShift item) {
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endRightShiftExpression() {
      return and();
    }
    
  
  }
  public class GreaterThanExpressionNested extends GreaterThanFluent> implements Nested{
    GreaterThanExpressionNested(GreaterThan item) {
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endGreaterThanExpression() {
      return and();
    }
    
  
  }
  public class DeclareExpressionNested extends DeclareFluent> implements Nested{
    DeclareExpressionNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endDeclareExpression() {
      return and();
    }
    
  
  }
  public class CastExpressionNested extends CastFluent> implements Nested{
    CastExpressionNested(Cast item) {
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endCastExpression() {
      return and();
    }
    
  
  }
  public class ModuloExpressionNested extends ModuloFluent> implements Nested{
    ModuloExpressionNested(Modulo item) {
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endModuloExpression() {
      return and();
    }
    
  
  }
  public class ValueRefExpressionNested extends ValueRefFluent> implements Nested{
    ValueRefExpressionNested(ValueRef item) {
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endValueRefExpression() {
      return and();
    }
    
  
  }
  public class LeftShiftExpressionNested extends LeftShiftFluent> implements Nested{
    LeftShiftExpressionNested(LeftShift item) {
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLeftShiftExpression() {
      return and();
    }
    
  
  }
  public class TernaryExpressionNested extends TernaryFluent> implements Nested{
    TernaryExpressionNested(Ternary item) {
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endTernaryExpression() {
      return and();
    }
    
  
  }
  public class BinaryExpressionNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionNested(BinaryExpression item) {
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endBinaryExpression() {
      return and();
    }
    
  
  }
  public class EqualsExpressionNested extends EqualsFluent> implements Nested{
    EqualsExpressionNested(Equals item) {
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endEqualsExpression() {
      return and();
    }
    
  
  }
  public class EnclosedExpressionNested extends EnclosedFluent> implements Nested{
    EnclosedExpressionNested(Enclosed item) {
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endEnclosedExpression() {
      return and();
    }
    
  
  }
  public class PreDecrementExpressionNested extends PreDecrementFluent> implements Nested{
    PreDecrementExpressionNested(PreDecrement item) {
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPreDecrementExpression() {
      return and();
    }
    
  
  }
  public class PostDecrementExpressionNested extends PostDecrementFluent> implements Nested{
    PostDecrementExpressionNested(PostDecrement item) {
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPostDecrementExpression() {
      return and();
    }
    
  
  }
  public class LambdaExpressionNested extends LambdaFluent> implements Nested{
    LambdaExpressionNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLambdaExpression() {
      return and();
    }
    
  
  }
  public class NotExpressionNested extends NotFluent> implements Nested{
    NotExpressionNested(Not item) {
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endNotExpression() {
      return and();
    }
    
  
  }
  public class ThisExpressionNested extends ThisFluent> implements Nested{
    ThisExpressionNested(This item) {
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endThisExpression() {
      return and();
    }
    
  
  }
  public class NegativeExpressionNested extends NegativeFluent> implements Nested{
    NegativeExpressionNested(Negative item) {
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endNegativeExpression() {
      return and();
    }
    
  
  }
  public class AssignExpressionNested extends AssignFluent> implements Nested{
    AssignExpressionNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endAssignExpression() {
      return and();
    }
    
  
  }
  public class LogicalAndExpressionNested extends LogicalAndFluent> implements Nested{
    LogicalAndExpressionNested(LogicalAnd item) {
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLogicalAndExpression() {
      return and();
    }
    
  
  }
  public class PostIncrementExpressionNested extends PostIncrementFluent> implements Nested{
    PostIncrementExpressionNested(PostIncrement item) {
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPostIncrementExpression() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftExpressionNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftExpressionNested(RightUnsignedShift item) {
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endRightUnsignedShiftExpression() {
      return and();
    }
    
  
  }
  public class PlusExpressionNested extends PlusFluent> implements Nested{
    PlusExpressionNested(Plus item) {
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPlusExpression() {
      return and();
    }
    
  
  }
  public class ConstructExpressionNested extends ConstructFluent> implements Nested{
    ConstructExpressionNested(Construct item) {
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endConstructExpression() {
      return and();
    }
    
  
  }
  public class XorExpressionNested extends XorFluent> implements Nested{
    XorExpressionNested(Xor item) {
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endXorExpression() {
      return and();
    }
    
  
  }
  public class PreIncrementExpressionNested extends PreIncrementFluent> implements Nested{
    PreIncrementExpressionNested(PreIncrement item) {
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPreIncrementExpression() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualExpressionNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualExpressionNested(LessThanOrEqual item) {
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endLessThanOrEqualExpression() {
      return and();
    }
    
  
  }
  public class PositiveExpressionNested extends PositiveFluent> implements Nested{
    PositiveExpressionNested(Positive item) {
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    
    public N and() {
      return (N) PostIncrementFluent.this.withExpression(builder.build());
    }
    
    public N endPositiveExpression() {
      return and();
    }
    
  
  }

}