• Home
• io.sundr
• sundr-model-generator
• 0.200.0
• source code
• PropertyRefFluent.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

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 PropertyRefFluent> extends BaseFluent{
  public PropertyRefFluent() {
  }
  
  public PropertyRefFluent(PropertyRef instance) {
    this.copyInstance(instance);
  }
  private PropertyBuilder property;
  private VisitableBuilder scope;
  
  protected void copyInstance(PropertyRef instance) {
    if (instance != null) {
          this.withProperty(instance.getProperty());
          this.withScope(instance.getScope());
        }
  }
  
  public Property buildProperty() {
    return this.property!=null ?this.property.build():null;
  }
  
  public A withProperty(Property property) {
    _visitables.get("property").remove(this.property);
    if (property!=null){ this.property= new PropertyBuilder(property); _visitables.get("property").add(this.property);} else { this.property = null; _visitables.get("property").remove(this.property); } return (A) this;
  }
  
  public boolean hasProperty() {
    return this.property != null;
  }
  
  public PropertyNested withNewProperty() {
    return new PropertyNested(null);
  }
  
  public PropertyNested withNewPropertyLike(Property item) {
    return new PropertyNested(item);
  }
  
  public PropertyNested editProperty() {
    return withNewPropertyLike(java.util.Optional.ofNullable(buildProperty()).orElse(null));
  }
  
  public PropertyNested editOrNewProperty() {
    return withNewPropertyLike(java.util.Optional.ofNullable(buildProperty()).orElse(new PropertyBuilder().build()));
  }
  
  public PropertyNested editOrNewPropertyLike(Property item) {
    return withNewPropertyLike(java.util.Optional.ofNullable(buildProperty()).orElse(item));
  }
  
  public Expression buildScope() {
    return this.scope!=null?this.scope.build():null;
  }
  
  public A withScope(Expression scope) {
    if (scope==null){ this.scope = null; _visitables.remove("scope"); return (A) this;}
    VisitableBuilder builder = builder(scope); _visitables.get("scope").clear();_visitables.get("scope").add(builder);this.scope = builder;
    return (A) this;
  }
  
  public boolean hasScope() {
    return this.scope != null;
  }
  
  public MultiplyScopeNested withNewMultiplyScope() {
    return new MultiplyScopeNested(null);
  }
  
  public MultiplyScopeNested withNewMultiplyScopeLike(Multiply item) {
    return new MultiplyScopeNested(item);
  }
  
  public A withNewMultiplyScope(Object left,Object right) {
    return (A)withScope(new Multiply(left, right));
  }
  
  public NewArrayScopeNested withNewNewArrayScope() {
    return new NewArrayScopeNested(null);
  }
  
  public NewArrayScopeNested withNewNewArrayScopeLike(NewArray item) {
    return new NewArrayScopeNested(item);
  }
  
  public A withNewNewArrayScope(Class type,Integer[] sizes) {
    return (A)withScope(new NewArray(type, sizes));
  }
  
  public InstanceOfScopeNested withNewInstanceOfScope() {
    return new InstanceOfScopeNested(null);
  }
  
  public InstanceOfScopeNested withNewInstanceOfScopeLike(InstanceOf item) {
    return new InstanceOfScopeNested(item);
  }
  
  public MethodCallScopeNested withNewMethodCallScope() {
    return new MethodCallScopeNested(null);
  }
  
  public MethodCallScopeNested withNewMethodCallScopeLike(MethodCall item) {
    return new MethodCallScopeNested(item);
  }
  
  public InverseScopeNested withNewInverseScope() {
    return new InverseScopeNested(null);
  }
  
  public InverseScopeNested withNewInverseScopeLike(Inverse item) {
    return new InverseScopeNested(item);
  }
  
  public IndexScopeNested withNewIndexScope() {
    return new IndexScopeNested(null);
  }
  
  public IndexScopeNested withNewIndexScopeLike(Index item) {
    return new IndexScopeNested(item);
  }
  
  public GreaterThanOrEqualScopeNested withNewGreaterThanOrEqualScope() {
    return new GreaterThanOrEqualScopeNested(null);
  }
  
  public GreaterThanOrEqualScopeNested withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualScopeNested(item);
  }
  
  public A withNewGreaterThanOrEqualScope(Object left,Object right) {
    return (A)withScope(new GreaterThanOrEqual(left, right));
  }
  
  public BitwiseAndScopeNested withNewBitwiseAndScope() {
    return new BitwiseAndScopeNested(null);
  }
  
  public BitwiseAndScopeNested withNewBitwiseAndScopeLike(BitwiseAnd item) {
    return new BitwiseAndScopeNested(item);
  }
  
  public A withNewBitwiseAndScope(Object left,Object right) {
    return (A)withScope(new BitwiseAnd(left, right));
  }
  
  public MinusScopeNested withNewMinusScope() {
    return new MinusScopeNested(null);
  }
  
  public MinusScopeNested withNewMinusScopeLike(Minus item) {
    return new MinusScopeNested(item);
  }
  
  public A withNewMinusScope(Object left,Object right) {
    return (A)withScope(new Minus(left, right));
  }
  
  public LogicalOrScopeNested withNewLogicalOrScope() {
    return new LogicalOrScopeNested(null);
  }
  
  public LogicalOrScopeNested withNewLogicalOrScopeLike(LogicalOr item) {
    return new LogicalOrScopeNested(item);
  }
  
  public A withNewLogicalOrScope(Object left,Object right) {
    return (A)withScope(new LogicalOr(left, right));
  }
  
  public NotEqualsScopeNested withNewNotEqualsScope() {
    return new NotEqualsScopeNested(null);
  }
  
  public NotEqualsScopeNested withNewNotEqualsScopeLike(NotEquals item) {
    return new NotEqualsScopeNested(item);
  }
  
  public A withNewNotEqualsScope(Object left,Object right) {
    return (A)withScope(new NotEquals(left, right));
  }
  
  public DivideScopeNested withNewDivideScope() {
    return new DivideScopeNested(null);
  }
  
  public DivideScopeNested withNewDivideScopeLike(Divide item) {
    return new DivideScopeNested(item);
  }
  
  public A withNewDivideScope(Object left,Object right) {
    return (A)withScope(new Divide(left, right));
  }
  
  public LessThanScopeNested withNewLessThanScope() {
    return new LessThanScopeNested(null);
  }
  
  public LessThanScopeNested withNewLessThanScopeLike(LessThan item) {
    return new LessThanScopeNested(item);
  }
  
  public A withNewLessThanScope(Object left,Object right) {
    return (A)withScope(new LessThan(left, right));
  }
  
  public BitwiseOrScopeNested withNewBitwiseOrScope() {
    return new BitwiseOrScopeNested(null);
  }
  
  public BitwiseOrScopeNested withNewBitwiseOrScopeLike(BitwiseOr item) {
    return new BitwiseOrScopeNested(item);
  }
  
  public A withNewBitwiseOrScope(Object left,Object right) {
    return (A)withScope(new BitwiseOr(left, right));
  }
  
  public PropertyRefScopeNested withNewPropertyRefScope() {
    return new PropertyRefScopeNested(null);
  }
  
  public PropertyRefScopeNested withNewPropertyRefScopeLike(PropertyRef item) {
    return new PropertyRefScopeNested(item);
  }
  
  public RightShiftScopeNested withNewRightShiftScope() {
    return new RightShiftScopeNested(null);
  }
  
  public RightShiftScopeNested withNewRightShiftScopeLike(RightShift item) {
    return new RightShiftScopeNested(item);
  }
  
  public A withNewRightShiftScope(Object left,Object right) {
    return (A)withScope(new RightShift(left, right));
  }
  
  public GreaterThanScopeNested withNewGreaterThanScope() {
    return new GreaterThanScopeNested(null);
  }
  
  public GreaterThanScopeNested withNewGreaterThanScopeLike(GreaterThan item) {
    return new GreaterThanScopeNested(item);
  }
  
  public A withNewGreaterThanScope(Object left,Object right) {
    return (A)withScope(new GreaterThan(left, right));
  }
  
  public DeclareScopeNested withNewDeclareScope() {
    return new DeclareScopeNested(null);
  }
  
  public DeclareScopeNested withNewDeclareScopeLike(Declare item) {
    return new DeclareScopeNested(item);
  }
  
  public A withNewDeclareScope(Class type,String name) {
    return (A)withScope(new Declare(type, name));
  }
  
  public A withNewDeclareScope(Class type,String name,Object value) {
    return (A)withScope(new Declare(type, name, value));
  }
  
  public CastScopeNested withNewCastScope() {
    return new CastScopeNested(null);
  }
  
  public CastScopeNested withNewCastScopeLike(Cast item) {
    return new CastScopeNested(item);
  }
  
  public ModuloScopeNested withNewModuloScope() {
    return new ModuloScopeNested(null);
  }
  
  public ModuloScopeNested withNewModuloScopeLike(Modulo item) {
    return new ModuloScopeNested(item);
  }
  
  public A withNewModuloScope(Object left,Object right) {
    return (A)withScope(new Modulo(left, right));
  }
  
  public ValueRefScopeNested withNewValueRefScope() {
    return new ValueRefScopeNested(null);
  }
  
  public ValueRefScopeNested withNewValueRefScopeLike(ValueRef item) {
    return new ValueRefScopeNested(item);
  }
  
  public A withNewValueRefScope(Object value) {
    return (A)withScope(new ValueRef(value));
  }
  
  public LeftShiftScopeNested withNewLeftShiftScope() {
    return new LeftShiftScopeNested(null);
  }
  
  public LeftShiftScopeNested withNewLeftShiftScopeLike(LeftShift item) {
    return new LeftShiftScopeNested(item);
  }
  
  public A withNewLeftShiftScope(Object left,Object right) {
    return (A)withScope(new LeftShift(left, right));
  }
  
  public TernaryScopeNested withNewTernaryScope() {
    return new TernaryScopeNested(null);
  }
  
  public TernaryScopeNested withNewTernaryScopeLike(Ternary item) {
    return new TernaryScopeNested(item);
  }
  
  public BinaryExpressionScopeNested withNewBinaryExpressionScope() {
    return new BinaryExpressionScopeNested(null);
  }
  
  public BinaryExpressionScopeNested withNewBinaryExpressionScopeLike(BinaryExpression item) {
    return new BinaryExpressionScopeNested(item);
  }
  
  public EqualsScopeNested withNewEqualsScope() {
    return new EqualsScopeNested(null);
  }
  
  public EqualsScopeNested withNewEqualsScopeLike(Equals item) {
    return new EqualsScopeNested(item);
  }
  
  public A withNewEqualsScope(Object left,Object right) {
    return (A)withScope(new Equals(left, right));
  }
  
  public EnclosedScopeNested withNewEnclosedScope() {
    return new EnclosedScopeNested(null);
  }
  
  public EnclosedScopeNested withNewEnclosedScopeLike(Enclosed item) {
    return new EnclosedScopeNested(item);
  }
  
  public PreDecrementScopeNested withNewPreDecrementScope() {
    return new PreDecrementScopeNested(null);
  }
  
  public PreDecrementScopeNested withNewPreDecrementScopeLike(PreDecrement item) {
    return new PreDecrementScopeNested(item);
  }
  
  public PostDecrementScopeNested withNewPostDecrementScope() {
    return new PostDecrementScopeNested(null);
  }
  
  public PostDecrementScopeNested withNewPostDecrementScopeLike(PostDecrement item) {
    return new PostDecrementScopeNested(item);
  }
  
  public LambdaScopeNested withNewLambdaScope() {
    return new LambdaScopeNested(null);
  }
  
  public LambdaScopeNested withNewLambdaScopeLike(Lambda item) {
    return new LambdaScopeNested(item);
  }
  
  public NotScopeNested withNewNotScope() {
    return new NotScopeNested(null);
  }
  
  public NotScopeNested withNewNotScopeLike(Not item) {
    return new NotScopeNested(item);
  }
  
  public ThisScopeNested withNewThisScope() {
    return new ThisScopeNested(null);
  }
  
  public ThisScopeNested withNewThisScopeLike(This item) {
    return new ThisScopeNested(item);
  }
  
  public NegativeScopeNested withNewNegativeScope() {
    return new NegativeScopeNested(null);
  }
  
  public NegativeScopeNested withNewNegativeScopeLike(Negative item) {
    return new NegativeScopeNested(item);
  }
  
  public AssignScopeNested withNewAssignScope() {
    return new AssignScopeNested(null);
  }
  
  public AssignScopeNested withNewAssignScopeLike(Assign item) {
    return new AssignScopeNested(item);
  }
  
  public LogicalAndScopeNested withNewLogicalAndScope() {
    return new LogicalAndScopeNested(null);
  }
  
  public LogicalAndScopeNested withNewLogicalAndScopeLike(LogicalAnd item) {
    return new LogicalAndScopeNested(item);
  }
  
  public A withNewLogicalAndScope(Object left,Object right) {
    return (A)withScope(new LogicalAnd(left, right));
  }
  
  public PostIncrementScopeNested withNewPostIncrementScope() {
    return new PostIncrementScopeNested(null);
  }
  
  public PostIncrementScopeNested withNewPostIncrementScopeLike(PostIncrement item) {
    return new PostIncrementScopeNested(item);
  }
  
  public RightUnsignedShiftScopeNested withNewRightUnsignedShiftScope() {
    return new RightUnsignedShiftScopeNested(null);
  }
  
  public RightUnsignedShiftScopeNested withNewRightUnsignedShiftScopeLike(RightUnsignedShift item) {
    return new RightUnsignedShiftScopeNested(item);
  }
  
  public A withNewRightUnsignedShiftScope(Object left,Object right) {
    return (A)withScope(new RightUnsignedShift(left, right));
  }
  
  public PlusScopeNested withNewPlusScope() {
    return new PlusScopeNested(null);
  }
  
  public PlusScopeNested withNewPlusScopeLike(Plus item) {
    return new PlusScopeNested(item);
  }
  
  public A withNewPlusScope(Object left,Object right) {
    return (A)withScope(new Plus(left, right));
  }
  
  public ConstructScopeNested withNewConstructScope() {
    return new ConstructScopeNested(null);
  }
  
  public ConstructScopeNested withNewConstructScopeLike(Construct item) {
    return new ConstructScopeNested(item);
  }
  
  public XorScopeNested withNewXorScope() {
    return new XorScopeNested(null);
  }
  
  public XorScopeNested withNewXorScopeLike(Xor item) {
    return new XorScopeNested(item);
  }
  
  public A withNewXorScope(Object left,Object right) {
    return (A)withScope(new Xor(left, right));
  }
  
  public PreIncrementScopeNested withNewPreIncrementScope() {
    return new PreIncrementScopeNested(null);
  }
  
  public PreIncrementScopeNested withNewPreIncrementScopeLike(PreIncrement item) {
    return new PreIncrementScopeNested(item);
  }
  
  public LessThanOrEqualScopeNested withNewLessThanOrEqualScope() {
    return new LessThanOrEqualScopeNested(null);
  }
  
  public LessThanOrEqualScopeNested withNewLessThanOrEqualScopeLike(LessThanOrEqual item) {
    return new LessThanOrEqualScopeNested(item);
  }
  
  public A withNewLessThanOrEqualScope(Object left,Object right) {
    return (A)withScope(new LessThanOrEqual(left, right));
  }
  
  public PositiveScopeNested withNewPositiveScope() {
    return new PositiveScopeNested(null);
  }
  
  public PositiveScopeNested withNewPositiveScopeLike(Positive item) {
    return new PositiveScopeNested(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;
    PropertyRefFluent that = (PropertyRefFluent) o;
    if (!java.util.Objects.equals(property, that.property)) return false;
    if (!java.util.Objects.equals(scope, that.scope)) return false;
    return true;
  }
  
  public int hashCode() {
    return java.util.Objects.hash(property,  scope,  super.hashCode());
  }
  
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    if (property != null) { sb.append("property:"); sb.append(property + ","); }
    if (scope != null) { sb.append("scope:"); sb.append(scope); }
    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 PropertyNested extends PropertyFluent> implements Nested{
    PropertyNested(Property item) {
      this.builder = new PropertyBuilder(this, item);
    }
    PropertyBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withProperty(builder.build());
    }
    
    public N endProperty() {
      return and();
    }
    
  
  }
  public class MultiplyScopeNested extends MultiplyFluent> implements Nested{
    MultiplyScopeNested(Multiply item) {
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endMultiplyScope() {
      return and();
    }
    
  
  }
  public class NewArrayScopeNested extends NewArrayFluent> implements Nested{
    NewArrayScopeNested(NewArray item) {
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endNewArrayScope() {
      return and();
    }
    
  
  }
  public class InstanceOfScopeNested extends InstanceOfFluent> implements Nested{
    InstanceOfScopeNested(InstanceOf item) {
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endInstanceOfScope() {
      return and();
    }
    
  
  }
  public class MethodCallScopeNested extends MethodCallFluent> implements Nested{
    MethodCallScopeNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endMethodCallScope() {
      return and();
    }
    
  
  }
  public class InverseScopeNested extends InverseFluent> implements Nested{
    InverseScopeNested(Inverse item) {
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endInverseScope() {
      return and();
    }
    
  
  }
  public class IndexScopeNested extends IndexFluent> implements Nested{
    IndexScopeNested(Index item) {
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endIndexScope() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualScopeNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualScopeNested(GreaterThanOrEqual item) {
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endGreaterThanOrEqualScope() {
      return and();
    }
    
  
  }
  public class BitwiseAndScopeNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndScopeNested(BitwiseAnd item) {
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endBitwiseAndScope() {
      return and();
    }
    
  
  }
  public class MinusScopeNested extends MinusFluent> implements Nested{
    MinusScopeNested(Minus item) {
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endMinusScope() {
      return and();
    }
    
  
  }
  public class LogicalOrScopeNested extends LogicalOrFluent> implements Nested{
    LogicalOrScopeNested(LogicalOr item) {
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLogicalOrScope() {
      return and();
    }
    
  
  }
  public class NotEqualsScopeNested extends NotEqualsFluent> implements Nested{
    NotEqualsScopeNested(NotEquals item) {
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endNotEqualsScope() {
      return and();
    }
    
  
  }
  public class DivideScopeNested extends DivideFluent> implements Nested{
    DivideScopeNested(Divide item) {
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endDivideScope() {
      return and();
    }
    
  
  }
  public class LessThanScopeNested extends LessThanFluent> implements Nested{
    LessThanScopeNested(LessThan item) {
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLessThanScope() {
      return and();
    }
    
  
  }
  public class BitwiseOrScopeNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrScopeNested(BitwiseOr item) {
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endBitwiseOrScope() {
      return and();
    }
    
  
  }
  public class PropertyRefScopeNested extends PropertyRefFluent> implements Nested{
    PropertyRefScopeNested(PropertyRef item) {
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPropertyRefScope() {
      return and();
    }
    
  
  }
  public class RightShiftScopeNested extends RightShiftFluent> implements Nested{
    RightShiftScopeNested(RightShift item) {
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endRightShiftScope() {
      return and();
    }
    
  
  }
  public class GreaterThanScopeNested extends GreaterThanFluent> implements Nested{
    GreaterThanScopeNested(GreaterThan item) {
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endGreaterThanScope() {
      return and();
    }
    
  
  }
  public class DeclareScopeNested extends DeclareFluent> implements Nested{
    DeclareScopeNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endDeclareScope() {
      return and();
    }
    
  
  }
  public class CastScopeNested extends CastFluent> implements Nested{
    CastScopeNested(Cast item) {
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endCastScope() {
      return and();
    }
    
  
  }
  public class ModuloScopeNested extends ModuloFluent> implements Nested{
    ModuloScopeNested(Modulo item) {
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endModuloScope() {
      return and();
    }
    
  
  }
  public class ValueRefScopeNested extends ValueRefFluent> implements Nested{
    ValueRefScopeNested(ValueRef item) {
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endValueRefScope() {
      return and();
    }
    
  
  }
  public class LeftShiftScopeNested extends LeftShiftFluent> implements Nested{
    LeftShiftScopeNested(LeftShift item) {
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLeftShiftScope() {
      return and();
    }
    
  
  }
  public class TernaryScopeNested extends TernaryFluent> implements Nested{
    TernaryScopeNested(Ternary item) {
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endTernaryScope() {
      return and();
    }
    
  
  }
  public class BinaryExpressionScopeNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionScopeNested(BinaryExpression item) {
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endBinaryExpressionScope() {
      return and();
    }
    
  
  }
  public class EqualsScopeNested extends EqualsFluent> implements Nested{
    EqualsScopeNested(Equals item) {
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endEqualsScope() {
      return and();
    }
    
  
  }
  public class EnclosedScopeNested extends EnclosedFluent> implements Nested{
    EnclosedScopeNested(Enclosed item) {
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endEnclosedScope() {
      return and();
    }
    
  
  }
  public class PreDecrementScopeNested extends PreDecrementFluent> implements Nested{
    PreDecrementScopeNested(PreDecrement item) {
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPreDecrementScope() {
      return and();
    }
    
  
  }
  public class PostDecrementScopeNested extends PostDecrementFluent> implements Nested{
    PostDecrementScopeNested(PostDecrement item) {
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPostDecrementScope() {
      return and();
    }
    
  
  }
  public class LambdaScopeNested extends LambdaFluent> implements Nested{
    LambdaScopeNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLambdaScope() {
      return and();
    }
    
  
  }
  public class NotScopeNested extends NotFluent> implements Nested{
    NotScopeNested(Not item) {
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endNotScope() {
      return and();
    }
    
  
  }
  public class ThisScopeNested extends ThisFluent> implements Nested{
    ThisScopeNested(This item) {
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endThisScope() {
      return and();
    }
    
  
  }
  public class NegativeScopeNested extends NegativeFluent> implements Nested{
    NegativeScopeNested(Negative item) {
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endNegativeScope() {
      return and();
    }
    
  
  }
  public class AssignScopeNested extends AssignFluent> implements Nested{
    AssignScopeNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endAssignScope() {
      return and();
    }
    
  
  }
  public class LogicalAndScopeNested extends LogicalAndFluent> implements Nested{
    LogicalAndScopeNested(LogicalAnd item) {
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLogicalAndScope() {
      return and();
    }
    
  
  }
  public class PostIncrementScopeNested extends PostIncrementFluent> implements Nested{
    PostIncrementScopeNested(PostIncrement item) {
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPostIncrementScope() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftScopeNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftScopeNested(RightUnsignedShift item) {
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endRightUnsignedShiftScope() {
      return and();
    }
    
  
  }
  public class PlusScopeNested extends PlusFluent> implements Nested{
    PlusScopeNested(Plus item) {
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPlusScope() {
      return and();
    }
    
  
  }
  public class ConstructScopeNested extends ConstructFluent> implements Nested{
    ConstructScopeNested(Construct item) {
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endConstructScope() {
      return and();
    }
    
  
  }
  public class XorScopeNested extends XorFluent> implements Nested{
    XorScopeNested(Xor item) {
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endXorScope() {
      return and();
    }
    
  
  }
  public class PreIncrementScopeNested extends PreIncrementFluent> implements Nested{
    PreIncrementScopeNested(PreIncrement item) {
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPreIncrementScope() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualScopeNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualScopeNested(LessThanOrEqual item) {
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endLessThanOrEqualScope() {
      return and();
    }
    
  
  }
  public class PositiveScopeNested extends PositiveFluent> implements Nested{
    PositiveScopeNested(Positive item) {
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    
    public N and() {
      return (N) PropertyRefFluent.this.withScope(builder.build());
    }
    
    public N endPositiveScope() {
      return and();
    }
    
  
  }

}