io.sundr.model.TernaryFluent Maven / Gradle / Ivy
package io.sundr.model;
import java.lang.String;
import java.lang.SuppressWarnings;
import java.lang.Class;
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 TernaryFluent> extends BaseFluent{
public TernaryFluent() {
}
public TernaryFluent(Ternary instance) {
this.copyInstance(instance);
}
private VisitableBuilder condition;
private VisitableBuilder result;
private VisitableBuilder alternative;
protected void copyInstance(Ternary instance) {
if (instance != null) {
this.withCondition(instance.getCondition());
this.withResult(instance.getResult());
this.withAlternative(instance.getAlternative());
}
}
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 Expression buildResult() {
return this.result!=null?this.result.build():null;
}
public A withResult(Expression result) {
if (result==null){ this.result = null; _visitables.remove("result"); return (A) this;}
VisitableBuilder builder = builder(result); _visitables.get("result").clear();_visitables.get("result").add(builder);this.result = builder;
return (A) this;
}
public boolean hasResult() {
return this.result != null;
}
public MultiplyResultNested withNewMultiplyResult() {
return new MultiplyResultNested(null);
}
public MultiplyResultNested withNewMultiplyResultLike(Multiply item) {
return new MultiplyResultNested(item);
}
public A withNewMultiplyResult(Object left,Object right) {
return (A)withResult(new Multiply(left, right));
}
public NewArrayResultNested withNewNewArrayResult() {
return new NewArrayResultNested(null);
}
public NewArrayResultNested withNewNewArrayResultLike(NewArray item) {
return new NewArrayResultNested(item);
}
public A withNewNewArrayResult(Class type,Integer[] sizes) {
return (A)withResult(new NewArray(type, sizes));
}
public InstanceOfResultNested withNewInstanceOfResult() {
return new InstanceOfResultNested(null);
}
public InstanceOfResultNested withNewInstanceOfResultLike(InstanceOf item) {
return new InstanceOfResultNested(item);
}
public MethodCallResultNested withNewMethodCallResult() {
return new MethodCallResultNested(null);
}
public MethodCallResultNested withNewMethodCallResultLike(MethodCall item) {
return new MethodCallResultNested(item);
}
public InverseResultNested withNewInverseResult() {
return new InverseResultNested(null);
}
public InverseResultNested withNewInverseResultLike(Inverse item) {
return new InverseResultNested(item);
}
public IndexResultNested withNewIndexResult() {
return new IndexResultNested(null);
}
public IndexResultNested withNewIndexResultLike(Index item) {
return new IndexResultNested(item);
}
public GreaterThanOrEqualResultNested withNewGreaterThanOrEqualResult() {
return new GreaterThanOrEqualResultNested(null);
}
public GreaterThanOrEqualResultNested withNewGreaterThanOrEqualResultLike(GreaterThanOrEqual item) {
return new GreaterThanOrEqualResultNested(item);
}
public A withNewGreaterThanOrEqualResult(Object left,Object right) {
return (A)withResult(new GreaterThanOrEqual(left, right));
}
public BitwiseAndResultNested withNewBitwiseAndResult() {
return new BitwiseAndResultNested(null);
}
public BitwiseAndResultNested withNewBitwiseAndResultLike(BitwiseAnd item) {
return new BitwiseAndResultNested(item);
}
public A withNewBitwiseAndResult(Object left,Object right) {
return (A)withResult(new BitwiseAnd(left, right));
}
public MinusResultNested withNewMinusResult() {
return new MinusResultNested(null);
}
public MinusResultNested withNewMinusResultLike(Minus item) {
return new MinusResultNested(item);
}
public A withNewMinusResult(Object left,Object right) {
return (A)withResult(new Minus(left, right));
}
public LogicalOrResultNested withNewLogicalOrResult() {
return new LogicalOrResultNested(null);
}
public LogicalOrResultNested withNewLogicalOrResultLike(LogicalOr item) {
return new LogicalOrResultNested(item);
}
public A withNewLogicalOrResult(Object left,Object right) {
return (A)withResult(new LogicalOr(left, right));
}
public NotEqualsResultNested withNewNotEqualsResult() {
return new NotEqualsResultNested(null);
}
public NotEqualsResultNested withNewNotEqualsResultLike(NotEquals item) {
return new NotEqualsResultNested(item);
}
public A withNewNotEqualsResult(Object left,Object right) {
return (A)withResult(new NotEquals(left, right));
}
public DivideResultNested withNewDivideResult() {
return new DivideResultNested(null);
}
public DivideResultNested withNewDivideResultLike(Divide item) {
return new DivideResultNested(item);
}
public A withNewDivideResult(Object left,Object right) {
return (A)withResult(new Divide(left, right));
}
public LessThanResultNested withNewLessThanResult() {
return new LessThanResultNested(null);
}
public LessThanResultNested withNewLessThanResultLike(LessThan item) {
return new LessThanResultNested(item);
}
public A withNewLessThanResult(Object left,Object right) {
return (A)withResult(new LessThan(left, right));
}
public BitwiseOrResultNested withNewBitwiseOrResult() {
return new BitwiseOrResultNested(null);
}
public BitwiseOrResultNested withNewBitwiseOrResultLike(BitwiseOr item) {
return new BitwiseOrResultNested(item);
}
public A withNewBitwiseOrResult(Object left,Object right) {
return (A)withResult(new BitwiseOr(left, right));
}
public PropertyRefResultNested withNewPropertyRefResult() {
return new PropertyRefResultNested(null);
}
public PropertyRefResultNested withNewPropertyRefResultLike(PropertyRef item) {
return new PropertyRefResultNested(item);
}
public RightShiftResultNested withNewRightShiftResult() {
return new RightShiftResultNested(null);
}
public RightShiftResultNested withNewRightShiftResultLike(RightShift item) {
return new RightShiftResultNested(item);
}
public A withNewRightShiftResult(Object left,Object right) {
return (A)withResult(new RightShift(left, right));
}
public GreaterThanResultNested withNewGreaterThanResult() {
return new GreaterThanResultNested(null);
}
public GreaterThanResultNested withNewGreaterThanResultLike(GreaterThan item) {
return new GreaterThanResultNested(item);
}
public A withNewGreaterThanResult(Object left,Object right) {
return (A)withResult(new GreaterThan(left, right));
}
public DeclareResultNested withNewDeclareResult() {
return new DeclareResultNested(null);
}
public DeclareResultNested withNewDeclareResultLike(Declare item) {
return new DeclareResultNested(item);
}
public A withNewDeclareResult(Class type,String name) {
return (A)withResult(new Declare(type, name));
}
public A withNewDeclareResult(Class type,String name,Object value) {
return (A)withResult(new Declare(type, name, value));
}
public CastResultNested withNewCastResult() {
return new CastResultNested(null);
}
public CastResultNested withNewCastResultLike(Cast item) {
return new CastResultNested(item);
}
public ModuloResultNested withNewModuloResult() {
return new ModuloResultNested(null);
}
public ModuloResultNested withNewModuloResultLike(Modulo item) {
return new ModuloResultNested(item);
}
public A withNewModuloResult(Object left,Object right) {
return (A)withResult(new Modulo(left, right));
}
public ValueRefResultNested withNewValueRefResult() {
return new ValueRefResultNested(null);
}
public ValueRefResultNested withNewValueRefResultLike(ValueRef item) {
return new ValueRefResultNested(item);
}
public A withNewValueRefResult(Object value) {
return (A)withResult(new ValueRef(value));
}
public LeftShiftResultNested withNewLeftShiftResult() {
return new LeftShiftResultNested(null);
}
public LeftShiftResultNested withNewLeftShiftResultLike(LeftShift item) {
return new LeftShiftResultNested(item);
}
public A withNewLeftShiftResult(Object left,Object right) {
return (A)withResult(new LeftShift(left, right));
}
public TernaryResultNested withNewTernaryResult() {
return new TernaryResultNested(null);
}
public TernaryResultNested withNewTernaryResultLike(Ternary item) {
return new TernaryResultNested(item);
}
public BinaryExpressionResultNested withNewBinaryExpressionResult() {
return new BinaryExpressionResultNested(null);
}
public BinaryExpressionResultNested withNewBinaryExpressionResultLike(BinaryExpression item) {
return new BinaryExpressionResultNested(item);
}
public EqualsResultNested withNewEqualsResult() {
return new EqualsResultNested(null);
}
public EqualsResultNested withNewEqualsResultLike(Equals item) {
return new EqualsResultNested(item);
}
public A withNewEqualsResult(Object left,Object right) {
return (A)withResult(new Equals(left, right));
}
public EnclosedResultNested withNewEnclosedResult() {
return new EnclosedResultNested(null);
}
public EnclosedResultNested withNewEnclosedResultLike(Enclosed item) {
return new EnclosedResultNested(item);
}
public PreDecrementResultNested withNewPreDecrementResult() {
return new PreDecrementResultNested(null);
}
public PreDecrementResultNested withNewPreDecrementResultLike(PreDecrement item) {
return new PreDecrementResultNested(item);
}
public PostDecrementResultNested withNewPostDecrementResult() {
return new PostDecrementResultNested(null);
}
public PostDecrementResultNested withNewPostDecrementResultLike(PostDecrement item) {
return new PostDecrementResultNested(item);
}
public LambdaResultNested withNewLambdaResult() {
return new LambdaResultNested(null);
}
public LambdaResultNested withNewLambdaResultLike(Lambda item) {
return new LambdaResultNested(item);
}
public NotResultNested withNewNotResult() {
return new NotResultNested(null);
}
public NotResultNested withNewNotResultLike(Not item) {
return new NotResultNested(item);
}
public ThisResultNested withNewThisResult() {
return new ThisResultNested(null);
}
public ThisResultNested withNewThisResultLike(This item) {
return new ThisResultNested(item);
}
public NegativeResultNested withNewNegativeResult() {
return new NegativeResultNested(null);
}
public NegativeResultNested withNewNegativeResultLike(Negative item) {
return new NegativeResultNested(item);
}
public AssignResultNested withNewAssignResult() {
return new AssignResultNested(null);
}
public AssignResultNested withNewAssignResultLike(Assign item) {
return new AssignResultNested(item);
}
public LogicalAndResultNested withNewLogicalAndResult() {
return new LogicalAndResultNested(null);
}
public LogicalAndResultNested withNewLogicalAndResultLike(LogicalAnd item) {
return new LogicalAndResultNested(item);
}
public A withNewLogicalAndResult(Object left,Object right) {
return (A)withResult(new LogicalAnd(left, right));
}
public PostIncrementResultNested withNewPostIncrementResult() {
return new PostIncrementResultNested(null);
}
public PostIncrementResultNested withNewPostIncrementResultLike(PostIncrement item) {
return new PostIncrementResultNested(item);
}
public RightUnsignedShiftResultNested withNewRightUnsignedShiftResult() {
return new RightUnsignedShiftResultNested(null);
}
public RightUnsignedShiftResultNested withNewRightUnsignedShiftResultLike(RightUnsignedShift item) {
return new RightUnsignedShiftResultNested(item);
}
public A withNewRightUnsignedShiftResult(Object left,Object right) {
return (A)withResult(new RightUnsignedShift(left, right));
}
public PlusResultNested withNewPlusResult() {
return new PlusResultNested(null);
}
public PlusResultNested withNewPlusResultLike(Plus item) {
return new PlusResultNested(item);
}
public A withNewPlusResult(Object left,Object right) {
return (A)withResult(new Plus(left, right));
}
public ConstructResultNested withNewConstructResult() {
return new ConstructResultNested(null);
}
public ConstructResultNested withNewConstructResultLike(Construct item) {
return new ConstructResultNested(item);
}
public XorResultNested withNewXorResult() {
return new XorResultNested(null);
}
public XorResultNested withNewXorResultLike(Xor item) {
return new XorResultNested(item);
}
public A withNewXorResult(Object left,Object right) {
return (A)withResult(new Xor(left, right));
}
public PreIncrementResultNested withNewPreIncrementResult() {
return new PreIncrementResultNested(null);
}
public PreIncrementResultNested withNewPreIncrementResultLike(PreIncrement item) {
return new PreIncrementResultNested(item);
}
public LessThanOrEqualResultNested withNewLessThanOrEqualResult() {
return new LessThanOrEqualResultNested(null);
}
public LessThanOrEqualResultNested withNewLessThanOrEqualResultLike(LessThanOrEqual item) {
return new LessThanOrEqualResultNested(item);
}
public A withNewLessThanOrEqualResult(Object left,Object right) {
return (A)withResult(new LessThanOrEqual(left, right));
}
public PositiveResultNested withNewPositiveResult() {
return new PositiveResultNested(null);
}
public PositiveResultNested withNewPositiveResultLike(Positive item) {
return new PositiveResultNested(item);
}
public Expression buildAlternative() {
return this.alternative!=null?this.alternative.build():null;
}
public A withAlternative(Expression alternative) {
if (alternative==null){ this.alternative = null; _visitables.remove("alternative"); return (A) this;}
VisitableBuilder builder = builder(alternative); _visitables.get("alternative").clear();_visitables.get("alternative").add(builder);this.alternative = builder;
return (A) this;
}
public boolean hasAlternative() {
return this.alternative != null;
}
public MultiplyAlternativeNested withNewMultiplyAlternative() {
return new MultiplyAlternativeNested(null);
}
public MultiplyAlternativeNested withNewMultiplyAlternativeLike(Multiply item) {
return new MultiplyAlternativeNested(item);
}
public A withNewMultiplyAlternative(Object left,Object right) {
return (A)withAlternative(new Multiply(left, right));
}
public NewArrayAlternativeNested withNewNewArrayAlternative() {
return new NewArrayAlternativeNested(null);
}
public NewArrayAlternativeNested withNewNewArrayAlternativeLike(NewArray item) {
return new NewArrayAlternativeNested(item);
}
public A withNewNewArrayAlternative(Class type,Integer[] sizes) {
return (A)withAlternative(new NewArray(type, sizes));
}
public InstanceOfAlternativeNested withNewInstanceOfAlternative() {
return new InstanceOfAlternativeNested(null);
}
public InstanceOfAlternativeNested withNewInstanceOfAlternativeLike(InstanceOf item) {
return new InstanceOfAlternativeNested(item);
}
public MethodCallAlternativeNested withNewMethodCallAlternative() {
return new MethodCallAlternativeNested(null);
}
public MethodCallAlternativeNested withNewMethodCallAlternativeLike(MethodCall item) {
return new MethodCallAlternativeNested(item);
}
public InverseAlternativeNested withNewInverseAlternative() {
return new InverseAlternativeNested(null);
}
public InverseAlternativeNested withNewInverseAlternativeLike(Inverse item) {
return new InverseAlternativeNested(item);
}
public IndexAlternativeNested withNewIndexAlternative() {
return new IndexAlternativeNested(null);
}
public IndexAlternativeNested withNewIndexAlternativeLike(Index item) {
return new IndexAlternativeNested(item);
}
public GreaterThanOrEqualAlternativeNested withNewGreaterThanOrEqualAlternative() {
return new GreaterThanOrEqualAlternativeNested(null);
}
public GreaterThanOrEqualAlternativeNested withNewGreaterThanOrEqualAlternativeLike(GreaterThanOrEqual item) {
return new GreaterThanOrEqualAlternativeNested(item);
}
public A withNewGreaterThanOrEqualAlternative(Object left,Object right) {
return (A)withAlternative(new GreaterThanOrEqual(left, right));
}
public BitwiseAndAlternativeNested withNewBitwiseAndAlternative() {
return new BitwiseAndAlternativeNested(null);
}
public BitwiseAndAlternativeNested withNewBitwiseAndAlternativeLike(BitwiseAnd item) {
return new BitwiseAndAlternativeNested(item);
}
public A withNewBitwiseAndAlternative(Object left,Object right) {
return (A)withAlternative(new BitwiseAnd(left, right));
}
public MinusAlternativeNested withNewMinusAlternative() {
return new MinusAlternativeNested(null);
}
public MinusAlternativeNested withNewMinusAlternativeLike(Minus item) {
return new MinusAlternativeNested(item);
}
public A withNewMinusAlternative(Object left,Object right) {
return (A)withAlternative(new Minus(left, right));
}
public LogicalOrAlternativeNested withNewLogicalOrAlternative() {
return new LogicalOrAlternativeNested(null);
}
public LogicalOrAlternativeNested withNewLogicalOrAlternativeLike(LogicalOr item) {
return new LogicalOrAlternativeNested(item);
}
public A withNewLogicalOrAlternative(Object left,Object right) {
return (A)withAlternative(new LogicalOr(left, right));
}
public NotEqualsAlternativeNested withNewNotEqualsAlternative() {
return new NotEqualsAlternativeNested(null);
}
public NotEqualsAlternativeNested withNewNotEqualsAlternativeLike(NotEquals item) {
return new NotEqualsAlternativeNested(item);
}
public A withNewNotEqualsAlternative(Object left,Object right) {
return (A)withAlternative(new NotEquals(left, right));
}
public DivideAlternativeNested withNewDivideAlternative() {
return new DivideAlternativeNested(null);
}
public DivideAlternativeNested withNewDivideAlternativeLike(Divide item) {
return new DivideAlternativeNested(item);
}
public A withNewDivideAlternative(Object left,Object right) {
return (A)withAlternative(new Divide(left, right));
}
public LessThanAlternativeNested withNewLessThanAlternative() {
return new LessThanAlternativeNested(null);
}
public LessThanAlternativeNested withNewLessThanAlternativeLike(LessThan item) {
return new LessThanAlternativeNested(item);
}
public A withNewLessThanAlternative(Object left,Object right) {
return (A)withAlternative(new LessThan(left, right));
}
public BitwiseOrAlternativeNested withNewBitwiseOrAlternative() {
return new BitwiseOrAlternativeNested(null);
}
public BitwiseOrAlternativeNested withNewBitwiseOrAlternativeLike(BitwiseOr item) {
return new BitwiseOrAlternativeNested(item);
}
public A withNewBitwiseOrAlternative(Object left,Object right) {
return (A)withAlternative(new BitwiseOr(left, right));
}
public PropertyRefAlternativeNested withNewPropertyRefAlternative() {
return new PropertyRefAlternativeNested(null);
}
public PropertyRefAlternativeNested withNewPropertyRefAlternativeLike(PropertyRef item) {
return new PropertyRefAlternativeNested(item);
}
public RightShiftAlternativeNested withNewRightShiftAlternative() {
return new RightShiftAlternativeNested(null);
}
public RightShiftAlternativeNested withNewRightShiftAlternativeLike(RightShift item) {
return new RightShiftAlternativeNested(item);
}
public A withNewRightShiftAlternative(Object left,Object right) {
return (A)withAlternative(new RightShift(left, right));
}
public GreaterThanAlternativeNested withNewGreaterThanAlternative() {
return new GreaterThanAlternativeNested(null);
}
public GreaterThanAlternativeNested withNewGreaterThanAlternativeLike(GreaterThan item) {
return new GreaterThanAlternativeNested(item);
}
public A withNewGreaterThanAlternative(Object left,Object right) {
return (A)withAlternative(new GreaterThan(left, right));
}
public DeclareAlternativeNested withNewDeclareAlternative() {
return new DeclareAlternativeNested(null);
}
public DeclareAlternativeNested withNewDeclareAlternativeLike(Declare item) {
return new DeclareAlternativeNested(item);
}
public A withNewDeclareAlternative(Class type,String name) {
return (A)withAlternative(new Declare(type, name));
}
public A withNewDeclareAlternative(Class type,String name,Object value) {
return (A)withAlternative(new Declare(type, name, value));
}
public CastAlternativeNested withNewCastAlternative() {
return new CastAlternativeNested(null);
}
public CastAlternativeNested withNewCastAlternativeLike(Cast item) {
return new CastAlternativeNested(item);
}
public ModuloAlternativeNested withNewModuloAlternative() {
return new ModuloAlternativeNested(null);
}
public ModuloAlternativeNested withNewModuloAlternativeLike(Modulo item) {
return new ModuloAlternativeNested(item);
}
public A withNewModuloAlternative(Object left,Object right) {
return (A)withAlternative(new Modulo(left, right));
}
public ValueRefAlternativeNested withNewValueRefAlternative() {
return new ValueRefAlternativeNested(null);
}
public ValueRefAlternativeNested withNewValueRefAlternativeLike(ValueRef item) {
return new ValueRefAlternativeNested(item);
}
public A withNewValueRefAlternative(Object value) {
return (A)withAlternative(new ValueRef(value));
}
public LeftShiftAlternativeNested withNewLeftShiftAlternative() {
return new LeftShiftAlternativeNested(null);
}
public LeftShiftAlternativeNested withNewLeftShiftAlternativeLike(LeftShift item) {
return new LeftShiftAlternativeNested(item);
}
public A withNewLeftShiftAlternative(Object left,Object right) {
return (A)withAlternative(new LeftShift(left, right));
}
public TernaryAlternativeNested withNewTernaryAlternative() {
return new TernaryAlternativeNested(null);
}
public TernaryAlternativeNested withNewTernaryAlternativeLike(Ternary item) {
return new TernaryAlternativeNested(item);
}
public BinaryExpressionAlternativeNested withNewBinaryExpressionAlternative() {
return new BinaryExpressionAlternativeNested(null);
}
public BinaryExpressionAlternativeNested withNewBinaryExpressionAlternativeLike(BinaryExpression item) {
return new BinaryExpressionAlternativeNested(item);
}
public EqualsAlternativeNested withNewEqualsAlternative() {
return new EqualsAlternativeNested(null);
}
public EqualsAlternativeNested withNewEqualsAlternativeLike(Equals item) {
return new EqualsAlternativeNested(item);
}
public A withNewEqualsAlternative(Object left,Object right) {
return (A)withAlternative(new Equals(left, right));
}
public EnclosedAlternativeNested withNewEnclosedAlternative() {
return new EnclosedAlternativeNested(null);
}
public EnclosedAlternativeNested withNewEnclosedAlternativeLike(Enclosed item) {
return new EnclosedAlternativeNested(item);
}
public PreDecrementAlternativeNested withNewPreDecrementAlternative() {
return new PreDecrementAlternativeNested(null);
}
public PreDecrementAlternativeNested withNewPreDecrementAlternativeLike(PreDecrement item) {
return new PreDecrementAlternativeNested(item);
}
public PostDecrementAlternativeNested withNewPostDecrementAlternative() {
return new PostDecrementAlternativeNested(null);
}
public PostDecrementAlternativeNested withNewPostDecrementAlternativeLike(PostDecrement item) {
return new PostDecrementAlternativeNested(item);
}
public LambdaAlternativeNested withNewLambdaAlternative() {
return new LambdaAlternativeNested(null);
}
public LambdaAlternativeNested withNewLambdaAlternativeLike(Lambda item) {
return new LambdaAlternativeNested(item);
}
public NotAlternativeNested withNewNotAlternative() {
return new NotAlternativeNested(null);
}
public NotAlternativeNested withNewNotAlternativeLike(Not item) {
return new NotAlternativeNested(item);
}
public ThisAlternativeNested withNewThisAlternative() {
return new ThisAlternativeNested(null);
}
public ThisAlternativeNested withNewThisAlternativeLike(This item) {
return new ThisAlternativeNested(item);
}
public NegativeAlternativeNested withNewNegativeAlternative() {
return new NegativeAlternativeNested(null);
}
public NegativeAlternativeNested withNewNegativeAlternativeLike(Negative item) {
return new NegativeAlternativeNested(item);
}
public AssignAlternativeNested withNewAssignAlternative() {
return new AssignAlternativeNested(null);
}
public AssignAlternativeNested withNewAssignAlternativeLike(Assign item) {
return new AssignAlternativeNested(item);
}
public LogicalAndAlternativeNested withNewLogicalAndAlternative() {
return new LogicalAndAlternativeNested(null);
}
public LogicalAndAlternativeNested withNewLogicalAndAlternativeLike(LogicalAnd item) {
return new LogicalAndAlternativeNested(item);
}
public A withNewLogicalAndAlternative(Object left,Object right) {
return (A)withAlternative(new LogicalAnd(left, right));
}
public PostIncrementAlternativeNested withNewPostIncrementAlternative() {
return new PostIncrementAlternativeNested(null);
}
public PostIncrementAlternativeNested withNewPostIncrementAlternativeLike(PostIncrement item) {
return new PostIncrementAlternativeNested(item);
}
public RightUnsignedShiftAlternativeNested withNewRightUnsignedShiftAlternative() {
return new RightUnsignedShiftAlternativeNested(null);
}
public RightUnsignedShiftAlternativeNested withNewRightUnsignedShiftAlternativeLike(RightUnsignedShift item) {
return new RightUnsignedShiftAlternativeNested(item);
}
public A withNewRightUnsignedShiftAlternative(Object left,Object right) {
return (A)withAlternative(new RightUnsignedShift(left, right));
}
public PlusAlternativeNested withNewPlusAlternative() {
return new PlusAlternativeNested(null);
}
public PlusAlternativeNested withNewPlusAlternativeLike(Plus item) {
return new PlusAlternativeNested(item);
}
public A withNewPlusAlternative(Object left,Object right) {
return (A)withAlternative(new Plus(left, right));
}
public ConstructAlternativeNested withNewConstructAlternative() {
return new ConstructAlternativeNested(null);
}
public ConstructAlternativeNested withNewConstructAlternativeLike(Construct item) {
return new ConstructAlternativeNested(item);
}
public XorAlternativeNested withNewXorAlternative() {
return new XorAlternativeNested(null);
}
public XorAlternativeNested withNewXorAlternativeLike(Xor item) {
return new XorAlternativeNested(item);
}
public A withNewXorAlternative(Object left,Object right) {
return (A)withAlternative(new Xor(left, right));
}
public PreIncrementAlternativeNested withNewPreIncrementAlternative() {
return new PreIncrementAlternativeNested(null);
}
public PreIncrementAlternativeNested withNewPreIncrementAlternativeLike(PreIncrement item) {
return new PreIncrementAlternativeNested(item);
}
public LessThanOrEqualAlternativeNested withNewLessThanOrEqualAlternative() {
return new LessThanOrEqualAlternativeNested(null);
}
public LessThanOrEqualAlternativeNested withNewLessThanOrEqualAlternativeLike(LessThanOrEqual item) {
return new LessThanOrEqualAlternativeNested(item);
}
public A withNewLessThanOrEqualAlternative(Object left,Object right) {
return (A)withAlternative(new LessThanOrEqual(left, right));
}
public PositiveAlternativeNested withNewPositiveAlternative() {
return new PositiveAlternativeNested(null);
}
public PositiveAlternativeNested withNewPositiveAlternativeLike(Positive item) {
return new PositiveAlternativeNested(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;
TernaryFluent that = (TernaryFluent) o;
if (!java.util.Objects.equals(condition, that.condition)) return false;
if (!java.util.Objects.equals(result, that.result)) return false;
if (!java.util.Objects.equals(alternative, that.alternative)) return false;
return true;
}
public int hashCode() {
return java.util.Objects.hash(condition, result, alternative, super.hashCode());
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (condition != null) { sb.append("condition:"); sb.append(condition + ","); }
if (result != null) { sb.append("result:"); sb.append(result + ","); }
if (alternative != null) { sb.append("alternative:"); sb.append(alternative); }
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 MultiplyConditionNested extends MultiplyFluent> implements Nested{
MultiplyConditionNested(Multiply item) {
this.builder = new MultiplyBuilder(this, item);
}
MultiplyBuilder builder;
public N and() {
return (N) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.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) TernaryFluent.this.withCondition(builder.build());
}
public N endPositiveCondition() {
return and();
}
}
public class MultiplyResultNested extends MultiplyFluent> implements Nested{
MultiplyResultNested(Multiply item) {
this.builder = new MultiplyBuilder(this, item);
}
MultiplyBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endMultiplyResult() {
return and();
}
}
public class NewArrayResultNested extends NewArrayFluent> implements Nested{
NewArrayResultNested(NewArray item) {
this.builder = new NewArrayBuilder(this, item);
}
NewArrayBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endNewArrayResult() {
return and();
}
}
public class InstanceOfResultNested extends InstanceOfFluent> implements Nested{
InstanceOfResultNested(InstanceOf item) {
this.builder = new InstanceOfBuilder(this, item);
}
InstanceOfBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endInstanceOfResult() {
return and();
}
}
public class MethodCallResultNested extends MethodCallFluent> implements Nested{
MethodCallResultNested(MethodCall item) {
this.builder = new MethodCallBuilder(this, item);
}
MethodCallBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endMethodCallResult() {
return and();
}
}
public class InverseResultNested extends InverseFluent> implements Nested{
InverseResultNested(Inverse item) {
this.builder = new InverseBuilder(this, item);
}
InverseBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endInverseResult() {
return and();
}
}
public class IndexResultNested extends IndexFluent> implements Nested{
IndexResultNested(Index item) {
this.builder = new IndexBuilder(this, item);
}
IndexBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endIndexResult() {
return and();
}
}
public class GreaterThanOrEqualResultNested extends GreaterThanOrEqualFluent> implements Nested{
GreaterThanOrEqualResultNested(GreaterThanOrEqual item) {
this.builder = new GreaterThanOrEqualBuilder(this, item);
}
GreaterThanOrEqualBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endGreaterThanOrEqualResult() {
return and();
}
}
public class BitwiseAndResultNested extends BitwiseAndFluent> implements Nested{
BitwiseAndResultNested(BitwiseAnd item) {
this.builder = new BitwiseAndBuilder(this, item);
}
BitwiseAndBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endBitwiseAndResult() {
return and();
}
}
public class MinusResultNested extends MinusFluent> implements Nested{
MinusResultNested(Minus item) {
this.builder = new MinusBuilder(this, item);
}
MinusBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endMinusResult() {
return and();
}
}
public class LogicalOrResultNested extends LogicalOrFluent> implements Nested{
LogicalOrResultNested(LogicalOr item) {
this.builder = new LogicalOrBuilder(this, item);
}
LogicalOrBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endLogicalOrResult() {
return and();
}
}
public class NotEqualsResultNested extends NotEqualsFluent> implements Nested{
NotEqualsResultNested(NotEquals item) {
this.builder = new NotEqualsBuilder(this, item);
}
NotEqualsBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endNotEqualsResult() {
return and();
}
}
public class DivideResultNested extends DivideFluent> implements Nested{
DivideResultNested(Divide item) {
this.builder = new DivideBuilder(this, item);
}
DivideBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endDivideResult() {
return and();
}
}
public class LessThanResultNested extends LessThanFluent> implements Nested{
LessThanResultNested(LessThan item) {
this.builder = new LessThanBuilder(this, item);
}
LessThanBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endLessThanResult() {
return and();
}
}
public class BitwiseOrResultNested extends BitwiseOrFluent> implements Nested{
BitwiseOrResultNested(BitwiseOr item) {
this.builder = new BitwiseOrBuilder(this, item);
}
BitwiseOrBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endBitwiseOrResult() {
return and();
}
}
public class PropertyRefResultNested extends PropertyRefFluent> implements Nested{
PropertyRefResultNested(PropertyRef item) {
this.builder = new PropertyRefBuilder(this, item);
}
PropertyRefBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endPropertyRefResult() {
return and();
}
}
public class RightShiftResultNested extends RightShiftFluent> implements Nested{
RightShiftResultNested(RightShift item) {
this.builder = new RightShiftBuilder(this, item);
}
RightShiftBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endRightShiftResult() {
return and();
}
}
public class GreaterThanResultNested extends GreaterThanFluent> implements Nested{
GreaterThanResultNested(GreaterThan item) {
this.builder = new GreaterThanBuilder(this, item);
}
GreaterThanBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endGreaterThanResult() {
return and();
}
}
public class DeclareResultNested extends DeclareFluent> implements Nested{
DeclareResultNested(Declare item) {
this.builder = new DeclareBuilder(this, item);
}
DeclareBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endDeclareResult() {
return and();
}
}
public class CastResultNested extends CastFluent> implements Nested{
CastResultNested(Cast item) {
this.builder = new CastBuilder(this, item);
}
CastBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endCastResult() {
return and();
}
}
public class ModuloResultNested extends ModuloFluent> implements Nested{
ModuloResultNested(Modulo item) {
this.builder = new ModuloBuilder(this, item);
}
ModuloBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endModuloResult() {
return and();
}
}
public class ValueRefResultNested extends ValueRefFluent> implements Nested{
ValueRefResultNested(ValueRef item) {
this.builder = new ValueRefBuilder(this, item);
}
ValueRefBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endValueRefResult() {
return and();
}
}
public class LeftShiftResultNested extends LeftShiftFluent> implements Nested{
LeftShiftResultNested(LeftShift item) {
this.builder = new LeftShiftBuilder(this, item);
}
LeftShiftBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endLeftShiftResult() {
return and();
}
}
public class TernaryResultNested extends TernaryFluent> implements Nested{
TernaryResultNested(Ternary item) {
this.builder = new TernaryBuilder(this, item);
}
TernaryBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endTernaryResult() {
return and();
}
}
public class BinaryExpressionResultNested extends BinaryExpressionFluent> implements Nested{
BinaryExpressionResultNested(BinaryExpression item) {
this.builder = new BinaryExpressionBuilder(this, item);
}
BinaryExpressionBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endBinaryExpressionResult() {
return and();
}
}
public class EqualsResultNested extends EqualsFluent> implements Nested{
EqualsResultNested(Equals item) {
this.builder = new EqualsBuilder(this, item);
}
EqualsBuilder builder;
public N and() {
return (N) TernaryFluent.this.withResult(builder.build());
}
public N endEqualsResult() {
return and();
}
}
public class EnclosedResultNested extends EnclosedFluent> implements Nested