• Home
• io.sundr
• sundr-model-generator
• 0.200.0
• source code
• WhileFluent.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.WhileFluent 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 WhileFluent> extends BaseFluent{
  public WhileFluent() {
  }
  
  public WhileFluent(While instance) {
    this.copyInstance(instance);
  }
  private VisitableBuilder condition;
  private VisitableBuilder statement;
  
  protected void copyInstance(While instance) {
    if (instance != null) {
          this.withCondition(instance.getCondition());
          this.withStatement(instance.getStatement());
        }
  }
  
  public Expression buildCondition() {
    return this.condition!=null?this.condition.build():null;
  }
  
  public A withCondition(Expression condition) {
    if (condition==null){ this.condition = null; _visitables.remove("condition"); return (A) this;}
    VisitableBuilder builder = builder(condition); _visitables.get("condition").clear();_visitables.get("condition").add(builder);this.condition = builder;
    return (A) this;
  }
  
  public boolean hasCondition() {
    return this.condition != null;
  }
  
  public MultiplyConditionNested withNewMultiplyCondition() {
    return new MultiplyConditionNested(null);
  }
  
  public MultiplyConditionNested withNewMultiplyConditionLike(Multiply item) {
    return new MultiplyConditionNested(item);
  }
  
  public A withNewMultiplyCondition(Object left,Object right) {
    return (A)withCondition(new Multiply(left, right));
  }
  
  public NewArrayConditionNested withNewNewArrayCondition() {
    return new NewArrayConditionNested(null);
  }
  
  public NewArrayConditionNested withNewNewArrayConditionLike(NewArray item) {
    return new NewArrayConditionNested(item);
  }
  
  public A withNewNewArrayCondition(Class type,Integer[] sizes) {
    return (A)withCondition(new NewArray(type, sizes));
  }
  
  public InstanceOfConditionNested withNewInstanceOfCondition() {
    return new InstanceOfConditionNested(null);
  }
  
  public InstanceOfConditionNested withNewInstanceOfConditionLike(InstanceOf item) {
    return new InstanceOfConditionNested(item);
  }
  
  public MethodCallConditionNested withNewMethodCallCondition() {
    return new MethodCallConditionNested(null);
  }
  
  public MethodCallConditionNested withNewMethodCallConditionLike(MethodCall item) {
    return new MethodCallConditionNested(item);
  }
  
  public InverseConditionNested withNewInverseCondition() {
    return new InverseConditionNested(null);
  }
  
  public InverseConditionNested withNewInverseConditionLike(Inverse item) {
    return new InverseConditionNested(item);
  }
  
  public IndexConditionNested withNewIndexCondition() {
    return new IndexConditionNested(null);
  }
  
  public IndexConditionNested withNewIndexConditionLike(Index item) {
    return new IndexConditionNested(item);
  }
  
  public GreaterThanOrEqualConditionNested withNewGreaterThanOrEqualCondition() {
    return new GreaterThanOrEqualConditionNested(null);
  }
  
  public GreaterThanOrEqualConditionNested withNewGreaterThanOrEqualConditionLike(GreaterThanOrEqual item) {
    return new GreaterThanOrEqualConditionNested(item);
  }
  
  public A withNewGreaterThanOrEqualCondition(Object left,Object right) {
    return (A)withCondition(new GreaterThanOrEqual(left, right));
  }
  
  public BitwiseAndConditionNested withNewBitwiseAndCondition() {
    return new BitwiseAndConditionNested(null);
  }
  
  public BitwiseAndConditionNested withNewBitwiseAndConditionLike(BitwiseAnd item) {
    return new BitwiseAndConditionNested(item);
  }
  
  public A withNewBitwiseAndCondition(Object left,Object right) {
    return (A)withCondition(new BitwiseAnd(left, right));
  }
  
  public MinusConditionNested withNewMinusCondition() {
    return new MinusConditionNested(null);
  }
  
  public MinusConditionNested withNewMinusConditionLike(Minus item) {
    return new MinusConditionNested(item);
  }
  
  public A withNewMinusCondition(Object left,Object right) {
    return (A)withCondition(new Minus(left, right));
  }
  
  public LogicalOrConditionNested withNewLogicalOrCondition() {
    return new LogicalOrConditionNested(null);
  }
  
  public LogicalOrConditionNested withNewLogicalOrConditionLike(LogicalOr item) {
    return new LogicalOrConditionNested(item);
  }
  
  public A withNewLogicalOrCondition(Object left,Object right) {
    return (A)withCondition(new LogicalOr(left, right));
  }
  
  public NotEqualsConditionNested withNewNotEqualsCondition() {
    return new NotEqualsConditionNested(null);
  }
  
  public NotEqualsConditionNested withNewNotEqualsConditionLike(NotEquals item) {
    return new NotEqualsConditionNested(item);
  }
  
  public A withNewNotEqualsCondition(Object left,Object right) {
    return (A)withCondition(new NotEquals(left, right));
  }
  
  public DivideConditionNested withNewDivideCondition() {
    return new DivideConditionNested(null);
  }
  
  public DivideConditionNested withNewDivideConditionLike(Divide item) {
    return new DivideConditionNested(item);
  }
  
  public A withNewDivideCondition(Object left,Object right) {
    return (A)withCondition(new Divide(left, right));
  }
  
  public LessThanConditionNested withNewLessThanCondition() {
    return new LessThanConditionNested(null);
  }
  
  public LessThanConditionNested withNewLessThanConditionLike(LessThan item) {
    return new LessThanConditionNested(item);
  }
  
  public A withNewLessThanCondition(Object left,Object right) {
    return (A)withCondition(new LessThan(left, right));
  }
  
  public BitwiseOrConditionNested withNewBitwiseOrCondition() {
    return new BitwiseOrConditionNested(null);
  }
  
  public BitwiseOrConditionNested withNewBitwiseOrConditionLike(BitwiseOr item) {
    return new BitwiseOrConditionNested(item);
  }
  
  public A withNewBitwiseOrCondition(Object left,Object right) {
    return (A)withCondition(new BitwiseOr(left, right));
  }
  
  public PropertyRefConditionNested withNewPropertyRefCondition() {
    return new PropertyRefConditionNested(null);
  }
  
  public PropertyRefConditionNested withNewPropertyRefConditionLike(PropertyRef item) {
    return new PropertyRefConditionNested(item);
  }
  
  public RightShiftConditionNested withNewRightShiftCondition() {
    return new RightShiftConditionNested(null);
  }
  
  public RightShiftConditionNested withNewRightShiftConditionLike(RightShift item) {
    return new RightShiftConditionNested(item);
  }
  
  public A withNewRightShiftCondition(Object left,Object right) {
    return (A)withCondition(new RightShift(left, right));
  }
  
  public GreaterThanConditionNested withNewGreaterThanCondition() {
    return new GreaterThanConditionNested(null);
  }
  
  public GreaterThanConditionNested withNewGreaterThanConditionLike(GreaterThan item) {
    return new GreaterThanConditionNested(item);
  }
  
  public A withNewGreaterThanCondition(Object left,Object right) {
    return (A)withCondition(new GreaterThan(left, right));
  }
  
  public DeclareConditionNested withNewDeclareCondition() {
    return new DeclareConditionNested(null);
  }
  
  public DeclareConditionNested withNewDeclareConditionLike(Declare item) {
    return new DeclareConditionNested(item);
  }
  
  public A withNewDeclareCondition(Class type,String name) {
    return (A)withCondition(new Declare(type, name));
  }
  
  public A withNewDeclareCondition(Class type,String name,Object value) {
    return (A)withCondition(new Declare(type, name, value));
  }
  
  public CastConditionNested withNewCastCondition() {
    return new CastConditionNested(null);
  }
  
  public CastConditionNested withNewCastConditionLike(Cast item) {
    return new CastConditionNested(item);
  }
  
  public ModuloConditionNested withNewModuloCondition() {
    return new ModuloConditionNested(null);
  }
  
  public ModuloConditionNested withNewModuloConditionLike(Modulo item) {
    return new ModuloConditionNested(item);
  }
  
  public A withNewModuloCondition(Object left,Object right) {
    return (A)withCondition(new Modulo(left, right));
  }
  
  public ValueRefConditionNested withNewValueRefCondition() {
    return new ValueRefConditionNested(null);
  }
  
  public ValueRefConditionNested withNewValueRefConditionLike(ValueRef item) {
    return new ValueRefConditionNested(item);
  }
  
  public A withNewValueRefCondition(Object value) {
    return (A)withCondition(new ValueRef(value));
  }
  
  public LeftShiftConditionNested withNewLeftShiftCondition() {
    return new LeftShiftConditionNested(null);
  }
  
  public LeftShiftConditionNested withNewLeftShiftConditionLike(LeftShift item) {
    return new LeftShiftConditionNested(item);
  }
  
  public A withNewLeftShiftCondition(Object left,Object right) {
    return (A)withCondition(new LeftShift(left, right));
  }
  
  public TernaryConditionNested withNewTernaryCondition() {
    return new TernaryConditionNested(null);
  }
  
  public TernaryConditionNested withNewTernaryConditionLike(Ternary item) {
    return new TernaryConditionNested(item);
  }
  
  public BinaryExpressionConditionNested withNewBinaryExpressionCondition() {
    return new BinaryExpressionConditionNested(null);
  }
  
  public BinaryExpressionConditionNested withNewBinaryExpressionConditionLike(BinaryExpression item) {
    return new BinaryExpressionConditionNested(item);
  }
  
  public EqualsConditionNested withNewEqualsCondition() {
    return new EqualsConditionNested(null);
  }
  
  public EqualsConditionNested withNewEqualsConditionLike(Equals item) {
    return new EqualsConditionNested(item);
  }
  
  public A withNewEqualsCondition(Object left,Object right) {
    return (A)withCondition(new Equals(left, right));
  }
  
  public EnclosedConditionNested withNewEnclosedCondition() {
    return new EnclosedConditionNested(null);
  }
  
  public EnclosedConditionNested withNewEnclosedConditionLike(Enclosed item) {
    return new EnclosedConditionNested(item);
  }
  
  public PreDecrementConditionNested withNewPreDecrementCondition() {
    return new PreDecrementConditionNested(null);
  }
  
  public PreDecrementConditionNested withNewPreDecrementConditionLike(PreDecrement item) {
    return new PreDecrementConditionNested(item);
  }
  
  public PostDecrementConditionNested withNewPostDecrementCondition() {
    return new PostDecrementConditionNested(null);
  }
  
  public PostDecrementConditionNested withNewPostDecrementConditionLike(PostDecrement item) {
    return new PostDecrementConditionNested(item);
  }
  
  public LambdaConditionNested withNewLambdaCondition() {
    return new LambdaConditionNested(null);
  }
  
  public LambdaConditionNested withNewLambdaConditionLike(Lambda item) {
    return new LambdaConditionNested(item);
  }
  
  public NotConditionNested withNewNotCondition() {
    return new NotConditionNested(null);
  }
  
  public NotConditionNested withNewNotConditionLike(Not item) {
    return new NotConditionNested(item);
  }
  
  public ThisConditionNested withNewThisCondition() {
    return new ThisConditionNested(null);
  }
  
  public ThisConditionNested withNewThisConditionLike(This item) {
    return new ThisConditionNested(item);
  }
  
  public NegativeConditionNested withNewNegativeCondition() {
    return new NegativeConditionNested(null);
  }
  
  public NegativeConditionNested withNewNegativeConditionLike(Negative item) {
    return new NegativeConditionNested(item);
  }
  
  public AssignConditionNested withNewAssignCondition() {
    return new AssignConditionNested(null);
  }
  
  public AssignConditionNested withNewAssignConditionLike(Assign item) {
    return new AssignConditionNested(item);
  }
  
  public LogicalAndConditionNested withNewLogicalAndCondition() {
    return new LogicalAndConditionNested(null);
  }
  
  public LogicalAndConditionNested withNewLogicalAndConditionLike(LogicalAnd item) {
    return new LogicalAndConditionNested(item);
  }
  
  public A withNewLogicalAndCondition(Object left,Object right) {
    return (A)withCondition(new LogicalAnd(left, right));
  }
  
  public PostIncrementConditionNested withNewPostIncrementCondition() {
    return new PostIncrementConditionNested(null);
  }
  
  public PostIncrementConditionNested withNewPostIncrementConditionLike(PostIncrement item) {
    return new PostIncrementConditionNested(item);
  }
  
  public RightUnsignedShiftConditionNested withNewRightUnsignedShiftCondition() {
    return new RightUnsignedShiftConditionNested(null);
  }
  
  public RightUnsignedShiftConditionNested withNewRightUnsignedShiftConditionLike(RightUnsignedShift item) {
    return new RightUnsignedShiftConditionNested(item);
  }
  
  public A withNewRightUnsignedShiftCondition(Object left,Object right) {
    return (A)withCondition(new RightUnsignedShift(left, right));
  }
  
  public PlusConditionNested withNewPlusCondition() {
    return new PlusConditionNested(null);
  }
  
  public PlusConditionNested withNewPlusConditionLike(Plus item) {
    return new PlusConditionNested(item);
  }
  
  public A withNewPlusCondition(Object left,Object right) {
    return (A)withCondition(new Plus(left, right));
  }
  
  public ConstructConditionNested withNewConstructCondition() {
    return new ConstructConditionNested(null);
  }
  
  public ConstructConditionNested withNewConstructConditionLike(Construct item) {
    return new ConstructConditionNested(item);
  }
  
  public XorConditionNested withNewXorCondition() {
    return new XorConditionNested(null);
  }
  
  public XorConditionNested withNewXorConditionLike(Xor item) {
    return new XorConditionNested(item);
  }
  
  public A withNewXorCondition(Object left,Object right) {
    return (A)withCondition(new Xor(left, right));
  }
  
  public PreIncrementConditionNested withNewPreIncrementCondition() {
    return new PreIncrementConditionNested(null);
  }
  
  public PreIncrementConditionNested withNewPreIncrementConditionLike(PreIncrement item) {
    return new PreIncrementConditionNested(item);
  }
  
  public LessThanOrEqualConditionNested withNewLessThanOrEqualCondition() {
    return new LessThanOrEqualConditionNested(null);
  }
  
  public LessThanOrEqualConditionNested withNewLessThanOrEqualConditionLike(LessThanOrEqual item) {
    return new LessThanOrEqualConditionNested(item);
  }
  
  public A withNewLessThanOrEqualCondition(Object left,Object right) {
    return (A)withCondition(new LessThanOrEqual(left, right));
  }
  
  public PositiveConditionNested withNewPositiveCondition() {
    return new PositiveConditionNested(null);
  }
  
  public PositiveConditionNested withNewPositiveConditionLike(Positive item) {
    return new PositiveConditionNested(item);
  }
  
  public Statement buildStatement() {
    return this.statement!=null?this.statement.build():null;
  }
  
  public A withStatement(Statement statement) {
    if (statement==null){ this.statement = null; _visitables.remove("statement"); return (A) this;}
    VisitableBuilder builder = builder(statement); _visitables.get("statement").clear();_visitables.get("statement").add(builder);this.statement = builder;
    return (A) this;
  }
  
  public boolean hasStatement() {
    return this.statement != null;
  }
  
  public MethodCallStatementNested withNewMethodCallStatement() {
    return new MethodCallStatementNested(null);
  }
  
  public MethodCallStatementNested withNewMethodCallStatementLike(MethodCall item) {
    return new MethodCallStatementNested(item);
  }
  
  public SwitchStatementNested withNewSwitchStatement() {
    return new SwitchStatementNested(null);
  }
  
  public SwitchStatementNested withNewSwitchStatementLike(Switch item) {
    return new SwitchStatementNested(item);
  }
  
  public BreakStatementNested withNewBreakStatement() {
    return new BreakStatementNested(null);
  }
  
  public BreakStatementNested withNewBreakStatementLike(Break item) {
    return new BreakStatementNested(item);
  }
  
  public DeclareStatementNested withNewDeclareStatement() {
    return new DeclareStatementNested(null);
  }
  
  public DeclareStatementNested withNewDeclareStatementLike(Declare item) {
    return new DeclareStatementNested(item);
  }
  
  public A withNewDeclareStatement(Class type,String name) {
    return (A)withStatement(new Declare(type, name));
  }
  
  public A withNewDeclareStatement(Class type,String name,Object value) {
    return (A)withStatement(new Declare(type, name, value));
  }
  
  public WhileStatementNested withNewWhileStatement() {
    return new WhileStatementNested(null);
  }
  
  public WhileStatementNested withNewWhileStatementLike(While item) {
    return new WhileStatementNested(item);
  }
  
  public ContinueStatementNested withNewContinueStatement() {
    return new ContinueStatementNested(null);
  }
  
  public ContinueStatementNested withNewContinueStatementLike(Continue item) {
    return new ContinueStatementNested(item);
  }
  
  public StringStatementNested withNewStringStatement() {
    return new StringStatementNested(null);
  }
  
  public StringStatementNested withNewStringStatementLike(StringStatement item) {
    return new StringStatementNested(item);
  }
  
  public A withNewStringStatement(String data) {
    return (A)withStatement(new StringStatement(data));
  }
  
  public A withNewStringStatement(String data,Object[] parameters) {
    return (A)withStatement(new StringStatement(data, parameters));
  }
  
  public DoStatementNested withNewDoStatement() {
    return new DoStatementNested(null);
  }
  
  public DoStatementNested withNewDoStatementLike(Do item) {
    return new DoStatementNested(item);
  }
  
  public ForeachStatementNested withNewForeachStatement() {
    return new ForeachStatementNested(null);
  }
  
  public ForeachStatementNested withNewForeachStatementLike(Foreach item) {
    return new ForeachStatementNested(item);
  }
  
  public BlockStatementNested withNewBlockStatement() {
    return new BlockStatementNested(null);
  }
  
  public BlockStatementNested withNewBlockStatementLike(Block item) {
    return new BlockStatementNested(item);
  }
  
  public IfStatementNested withNewIfStatement() {
    return new IfStatementNested(null);
  }
  
  public IfStatementNested withNewIfStatementLike(If item) {
    return new IfStatementNested(item);
  }
  
  public LambdaStatementNested withNewLambdaStatement() {
    return new LambdaStatementNested(null);
  }
  
  public LambdaStatementNested withNewLambdaStatementLike(Lambda item) {
    return new LambdaStatementNested(item);
  }
  
  public ReturnStatementNested withNewReturnStatement() {
    return new ReturnStatementNested(null);
  }
  
  public ReturnStatementNested withNewReturnStatementLike(Return item) {
    return new ReturnStatementNested(item);
  }
  
  public A withNewReturnStatement(Object object) {
    return (A)withStatement(new Return(object));
  }
  
  public AssignStatementNested withNewAssignStatement() {
    return new AssignStatementNested(null);
  }
  
  public AssignStatementNested withNewAssignStatementLike(Assign item) {
    return new AssignStatementNested(item);
  }
  
  public ForStatementNested withNewForStatement() {
    return new ForStatementNested(null);
  }
  
  public ForStatementNested withNewForStatementLike(For item) {
    return new ForStatementNested(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;
    WhileFluent that = (WhileFluent) o;
    if (!java.util.Objects.equals(condition, that.condition)) return false;
    if (!java.util.Objects.equals(statement, that.statement)) return false;
    return true;
  }
  
  public int hashCode() {
    return java.util.Objects.hash(condition,  statement,  super.hashCode());
  }
  
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    if (condition != null) { sb.append("condition:"); sb.append(condition + ","); }
    if (statement != null) { sb.append("statement:"); sb.append(statement); }
    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 MultiplyConditionNested extends MultiplyFluent> implements Nested{
    MultiplyConditionNested(Multiply item) {
      this.builder = new MultiplyBuilder(this, item);
    }
    MultiplyBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endMultiplyCondition() {
      return and();
    }
    
  
  }
  public class NewArrayConditionNested extends NewArrayFluent> implements Nested{
    NewArrayConditionNested(NewArray item) {
      this.builder = new NewArrayBuilder(this, item);
    }
    NewArrayBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endNewArrayCondition() {
      return and();
    }
    
  
  }
  public class InstanceOfConditionNested extends InstanceOfFluent> implements Nested{
    InstanceOfConditionNested(InstanceOf item) {
      this.builder = new InstanceOfBuilder(this, item);
    }
    InstanceOfBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endInstanceOfCondition() {
      return and();
    }
    
  
  }
  public class MethodCallConditionNested extends MethodCallFluent> implements Nested{
    MethodCallConditionNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endMethodCallCondition() {
      return and();
    }
    
  
  }
  public class InverseConditionNested extends InverseFluent> implements Nested{
    InverseConditionNested(Inverse item) {
      this.builder = new InverseBuilder(this, item);
    }
    InverseBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endInverseCondition() {
      return and();
    }
    
  
  }
  public class IndexConditionNested extends IndexFluent> implements Nested{
    IndexConditionNested(Index item) {
      this.builder = new IndexBuilder(this, item);
    }
    IndexBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endIndexCondition() {
      return and();
    }
    
  
  }
  public class GreaterThanOrEqualConditionNested extends GreaterThanOrEqualFluent> implements Nested{
    GreaterThanOrEqualConditionNested(GreaterThanOrEqual item) {
      this.builder = new GreaterThanOrEqualBuilder(this, item);
    }
    GreaterThanOrEqualBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endGreaterThanOrEqualCondition() {
      return and();
    }
    
  
  }
  public class BitwiseAndConditionNested extends BitwiseAndFluent> implements Nested{
    BitwiseAndConditionNested(BitwiseAnd item) {
      this.builder = new BitwiseAndBuilder(this, item);
    }
    BitwiseAndBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endBitwiseAndCondition() {
      return and();
    }
    
  
  }
  public class MinusConditionNested extends MinusFluent> implements Nested{
    MinusConditionNested(Minus item) {
      this.builder = new MinusBuilder(this, item);
    }
    MinusBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endMinusCondition() {
      return and();
    }
    
  
  }
  public class LogicalOrConditionNested extends LogicalOrFluent> implements Nested{
    LogicalOrConditionNested(LogicalOr item) {
      this.builder = new LogicalOrBuilder(this, item);
    }
    LogicalOrBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLogicalOrCondition() {
      return and();
    }
    
  
  }
  public class NotEqualsConditionNested extends NotEqualsFluent> implements Nested{
    NotEqualsConditionNested(NotEquals item) {
      this.builder = new NotEqualsBuilder(this, item);
    }
    NotEqualsBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endNotEqualsCondition() {
      return and();
    }
    
  
  }
  public class DivideConditionNested extends DivideFluent> implements Nested{
    DivideConditionNested(Divide item) {
      this.builder = new DivideBuilder(this, item);
    }
    DivideBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endDivideCondition() {
      return and();
    }
    
  
  }
  public class LessThanConditionNested extends LessThanFluent> implements Nested{
    LessThanConditionNested(LessThan item) {
      this.builder = new LessThanBuilder(this, item);
    }
    LessThanBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLessThanCondition() {
      return and();
    }
    
  
  }
  public class BitwiseOrConditionNested extends BitwiseOrFluent> implements Nested{
    BitwiseOrConditionNested(BitwiseOr item) {
      this.builder = new BitwiseOrBuilder(this, item);
    }
    BitwiseOrBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endBitwiseOrCondition() {
      return and();
    }
    
  
  }
  public class PropertyRefConditionNested extends PropertyRefFluent> implements Nested{
    PropertyRefConditionNested(PropertyRef item) {
      this.builder = new PropertyRefBuilder(this, item);
    }
    PropertyRefBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPropertyRefCondition() {
      return and();
    }
    
  
  }
  public class RightShiftConditionNested extends RightShiftFluent> implements Nested{
    RightShiftConditionNested(RightShift item) {
      this.builder = new RightShiftBuilder(this, item);
    }
    RightShiftBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endRightShiftCondition() {
      return and();
    }
    
  
  }
  public class GreaterThanConditionNested extends GreaterThanFluent> implements Nested{
    GreaterThanConditionNested(GreaterThan item) {
      this.builder = new GreaterThanBuilder(this, item);
    }
    GreaterThanBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endGreaterThanCondition() {
      return and();
    }
    
  
  }
  public class DeclareConditionNested extends DeclareFluent> implements Nested{
    DeclareConditionNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endDeclareCondition() {
      return and();
    }
    
  
  }
  public class CastConditionNested extends CastFluent> implements Nested{
    CastConditionNested(Cast item) {
      this.builder = new CastBuilder(this, item);
    }
    CastBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endCastCondition() {
      return and();
    }
    
  
  }
  public class ModuloConditionNested extends ModuloFluent> implements Nested{
    ModuloConditionNested(Modulo item) {
      this.builder = new ModuloBuilder(this, item);
    }
    ModuloBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endModuloCondition() {
      return and();
    }
    
  
  }
  public class ValueRefConditionNested extends ValueRefFluent> implements Nested{
    ValueRefConditionNested(ValueRef item) {
      this.builder = new ValueRefBuilder(this, item);
    }
    ValueRefBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endValueRefCondition() {
      return and();
    }
    
  
  }
  public class LeftShiftConditionNested extends LeftShiftFluent> implements Nested{
    LeftShiftConditionNested(LeftShift item) {
      this.builder = new LeftShiftBuilder(this, item);
    }
    LeftShiftBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLeftShiftCondition() {
      return and();
    }
    
  
  }
  public class TernaryConditionNested extends TernaryFluent> implements Nested{
    TernaryConditionNested(Ternary item) {
      this.builder = new TernaryBuilder(this, item);
    }
    TernaryBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endTernaryCondition() {
      return and();
    }
    
  
  }
  public class BinaryExpressionConditionNested extends BinaryExpressionFluent> implements Nested{
    BinaryExpressionConditionNested(BinaryExpression item) {
      this.builder = new BinaryExpressionBuilder(this, item);
    }
    BinaryExpressionBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endBinaryExpressionCondition() {
      return and();
    }
    
  
  }
  public class EqualsConditionNested extends EqualsFluent> implements Nested{
    EqualsConditionNested(Equals item) {
      this.builder = new EqualsBuilder(this, item);
    }
    EqualsBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endEqualsCondition() {
      return and();
    }
    
  
  }
  public class EnclosedConditionNested extends EnclosedFluent> implements Nested{
    EnclosedConditionNested(Enclosed item) {
      this.builder = new EnclosedBuilder(this, item);
    }
    EnclosedBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endEnclosedCondition() {
      return and();
    }
    
  
  }
  public class PreDecrementConditionNested extends PreDecrementFluent> implements Nested{
    PreDecrementConditionNested(PreDecrement item) {
      this.builder = new PreDecrementBuilder(this, item);
    }
    PreDecrementBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPreDecrementCondition() {
      return and();
    }
    
  
  }
  public class PostDecrementConditionNested extends PostDecrementFluent> implements Nested{
    PostDecrementConditionNested(PostDecrement item) {
      this.builder = new PostDecrementBuilder(this, item);
    }
    PostDecrementBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPostDecrementCondition() {
      return and();
    }
    
  
  }
  public class LambdaConditionNested extends LambdaFluent> implements Nested{
    LambdaConditionNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLambdaCondition() {
      return and();
    }
    
  
  }
  public class NotConditionNested extends NotFluent> implements Nested{
    NotConditionNested(Not item) {
      this.builder = new NotBuilder(this, item);
    }
    NotBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endNotCondition() {
      return and();
    }
    
  
  }
  public class ThisConditionNested extends ThisFluent> implements Nested{
    ThisConditionNested(This item) {
      this.builder = new ThisBuilder(this, item);
    }
    ThisBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endThisCondition() {
      return and();
    }
    
  
  }
  public class NegativeConditionNested extends NegativeFluent> implements Nested{
    NegativeConditionNested(Negative item) {
      this.builder = new NegativeBuilder(this, item);
    }
    NegativeBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endNegativeCondition() {
      return and();
    }
    
  
  }
  public class AssignConditionNested extends AssignFluent> implements Nested{
    AssignConditionNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endAssignCondition() {
      return and();
    }
    
  
  }
  public class LogicalAndConditionNested extends LogicalAndFluent> implements Nested{
    LogicalAndConditionNested(LogicalAnd item) {
      this.builder = new LogicalAndBuilder(this, item);
    }
    LogicalAndBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLogicalAndCondition() {
      return and();
    }
    
  
  }
  public class PostIncrementConditionNested extends PostIncrementFluent> implements Nested{
    PostIncrementConditionNested(PostIncrement item) {
      this.builder = new PostIncrementBuilder(this, item);
    }
    PostIncrementBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPostIncrementCondition() {
      return and();
    }
    
  
  }
  public class RightUnsignedShiftConditionNested extends RightUnsignedShiftFluent> implements Nested{
    RightUnsignedShiftConditionNested(RightUnsignedShift item) {
      this.builder = new RightUnsignedShiftBuilder(this, item);
    }
    RightUnsignedShiftBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endRightUnsignedShiftCondition() {
      return and();
    }
    
  
  }
  public class PlusConditionNested extends PlusFluent> implements Nested{
    PlusConditionNested(Plus item) {
      this.builder = new PlusBuilder(this, item);
    }
    PlusBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPlusCondition() {
      return and();
    }
    
  
  }
  public class ConstructConditionNested extends ConstructFluent> implements Nested{
    ConstructConditionNested(Construct item) {
      this.builder = new ConstructBuilder(this, item);
    }
    ConstructBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endConstructCondition() {
      return and();
    }
    
  
  }
  public class XorConditionNested extends XorFluent> implements Nested{
    XorConditionNested(Xor item) {
      this.builder = new XorBuilder(this, item);
    }
    XorBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endXorCondition() {
      return and();
    }
    
  
  }
  public class PreIncrementConditionNested extends PreIncrementFluent> implements Nested{
    PreIncrementConditionNested(PreIncrement item) {
      this.builder = new PreIncrementBuilder(this, item);
    }
    PreIncrementBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPreIncrementCondition() {
      return and();
    }
    
  
  }
  public class LessThanOrEqualConditionNested extends LessThanOrEqualFluent> implements Nested{
    LessThanOrEqualConditionNested(LessThanOrEqual item) {
      this.builder = new LessThanOrEqualBuilder(this, item);
    }
    LessThanOrEqualBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endLessThanOrEqualCondition() {
      return and();
    }
    
  
  }
  public class PositiveConditionNested extends PositiveFluent> implements Nested{
    PositiveConditionNested(Positive item) {
      this.builder = new PositiveBuilder(this, item);
    }
    PositiveBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withCondition(builder.build());
    }
    
    public N endPositiveCondition() {
      return and();
    }
    
  
  }
  public class MethodCallStatementNested extends MethodCallFluent> implements Nested{
    MethodCallStatementNested(MethodCall item) {
      this.builder = new MethodCallBuilder(this, item);
    }
    MethodCallBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endMethodCallStatement() {
      return and();
    }
    
  
  }
  public class SwitchStatementNested extends SwitchFluent> implements Nested{
    SwitchStatementNested(Switch item) {
      this.builder = new SwitchBuilder(this, item);
    }
    SwitchBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endSwitchStatement() {
      return and();
    }
    
  
  }
  public class BreakStatementNested extends BreakFluent> implements Nested{
    BreakStatementNested(Break item) {
      this.builder = new BreakBuilder(this, item);
    }
    BreakBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endBreakStatement() {
      return and();
    }
    
  
  }
  public class DeclareStatementNested extends DeclareFluent> implements Nested{
    DeclareStatementNested(Declare item) {
      this.builder = new DeclareBuilder(this, item);
    }
    DeclareBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endDeclareStatement() {
      return and();
    }
    
  
  }
  public class WhileStatementNested extends WhileFluent> implements Nested{
    WhileStatementNested(While item) {
      this.builder = new WhileBuilder(this, item);
    }
    WhileBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endWhileStatement() {
      return and();
    }
    
  
  }
  public class ContinueStatementNested extends ContinueFluent> implements Nested{
    ContinueStatementNested(Continue item) {
      this.builder = new ContinueBuilder(this, item);
    }
    ContinueBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endContinueStatement() {
      return and();
    }
    
  
  }
  public class StringStatementNested extends StringStatementFluent> implements Nested{
    StringStatementNested(StringStatement item) {
      this.builder = new StringStatementBuilder(this, item);
    }
    StringStatementBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endStringStatement() {
      return and();
    }
    
  
  }
  public class DoStatementNested extends DoFluent> implements Nested{
    DoStatementNested(Do item) {
      this.builder = new DoBuilder(this, item);
    }
    DoBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endDoStatement() {
      return and();
    }
    
  
  }
  public class ForeachStatementNested extends ForeachFluent> implements Nested{
    ForeachStatementNested(Foreach item) {
      this.builder = new ForeachBuilder(this, item);
    }
    ForeachBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endForeachStatement() {
      return and();
    }
    
  
  }
  public class BlockStatementNested extends BlockFluent> implements Nested{
    BlockStatementNested(Block item) {
      this.builder = new BlockBuilder(this, item);
    }
    BlockBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endBlockStatement() {
      return and();
    }
    
  
  }
  public class IfStatementNested extends IfFluent> implements Nested{
    IfStatementNested(If item) {
      this.builder = new IfBuilder(this, item);
    }
    IfBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endIfStatement() {
      return and();
    }
    
  
  }
  public class LambdaStatementNested extends LambdaFluent> implements Nested{
    LambdaStatementNested(Lambda item) {
      this.builder = new LambdaBuilder(this, item);
    }
    LambdaBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endLambdaStatement() {
      return and();
    }
    
  
  }
  public class ReturnStatementNested extends ReturnFluent> implements Nested{
    ReturnStatementNested(Return item) {
      this.builder = new ReturnBuilder(this, item);
    }
    ReturnBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endReturnStatement() {
      return and();
    }
    
  
  }
  public class AssignStatementNested extends AssignFluent> implements Nested{
    AssignStatementNested(Assign item) {
      this.builder = new AssignBuilder(this, item);
    }
    AssignBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endAssignStatement() {
      return and();
    }
    
  
  }
  public class ForStatementNested extends ForFluent> implements Nested{
    ForStatementNested(For item) {
      this.builder = new ForBuilder(this, item);
    }
    ForBuilder builder;
    
    public N and() {
      return (N) WhileFluent.this.withStatement(builder.build());
    }
    
    public N endForStatement() {
      return and();
    }
    
  
  }

}