io.sundr.model.IndexFluent Maven / Gradle / Ivy
The newest version!
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 IndexFluent> extends BaseFluent{
public IndexFluent() {
}
public IndexFluent(Index instance) {
this.copyInstance(instance);
}
private VisitableBuilder scope;
private VisitableBuilder expression;
protected void copyInstance(Index instance) {
if (instance != null) {
this.withScope(instance.getScope());
this.withExpression(instance.getExpression());
}
}
public Expression buildScope() {
return this.scope!=null?this.scope.build():null;
}
public A withScope(Expression scope) {
if (scope==null){ this.scope = null; _visitables.remove("scope"); return (A) this;}
VisitableBuilder builder = builder(scope); _visitables.get("scope").clear();_visitables.get("scope").add(builder);this.scope = builder;
return (A) this;
}
public boolean hasScope() {
return this.scope != null;
}
public MultiplyScopeNested withNewMultiplyScope() {
return new MultiplyScopeNested(null);
}
public MultiplyScopeNested withNewMultiplyScopeLike(Multiply item) {
return new MultiplyScopeNested(item);
}
public A withNewMultiplyScope(Object left,Object right) {
return (A)withScope(new Multiply(left, right));
}
public NewArrayScopeNested withNewNewArrayScope() {
return new NewArrayScopeNested(null);
}
public NewArrayScopeNested withNewNewArrayScopeLike(NewArray item) {
return new NewArrayScopeNested(item);
}
public A withNewNewArrayScope(Class type,Integer[] sizes) {
return (A)withScope(new NewArray(type, sizes));
}
public InstanceOfScopeNested withNewInstanceOfScope() {
return new InstanceOfScopeNested(null);
}
public InstanceOfScopeNested withNewInstanceOfScopeLike(InstanceOf item) {
return new InstanceOfScopeNested(item);
}
public MethodCallScopeNested withNewMethodCallScope() {
return new MethodCallScopeNested(null);
}
public MethodCallScopeNested withNewMethodCallScopeLike(MethodCall item) {
return new MethodCallScopeNested(item);
}
public InverseScopeNested withNewInverseScope() {
return new InverseScopeNested(null);
}
public InverseScopeNested withNewInverseScopeLike(Inverse item) {
return new InverseScopeNested(item);
}
public IndexScopeNested withNewIndexScope() {
return new IndexScopeNested(null);
}
public IndexScopeNested withNewIndexScopeLike(Index item) {
return new IndexScopeNested(item);
}
public GreaterThanOrEqualScopeNested withNewGreaterThanOrEqualScope() {
return new GreaterThanOrEqualScopeNested(null);
}
public GreaterThanOrEqualScopeNested withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item) {
return new GreaterThanOrEqualScopeNested(item);
}
public A withNewGreaterThanOrEqualScope(Object left,Object right) {
return (A)withScope(new GreaterThanOrEqual(left, right));
}
public BitwiseAndScopeNested withNewBitwiseAndScope() {
return new BitwiseAndScopeNested(null);
}
public BitwiseAndScopeNested withNewBitwiseAndScopeLike(BitwiseAnd item) {
return new BitwiseAndScopeNested(item);
}
public A withNewBitwiseAndScope(Object left,Object right) {
return (A)withScope(new BitwiseAnd(left, right));
}
public MinusScopeNested withNewMinusScope() {
return new MinusScopeNested(null);
}
public MinusScopeNested withNewMinusScopeLike(Minus item) {
return new MinusScopeNested(item);
}
public A withNewMinusScope(Object left,Object right) {
return (A)withScope(new Minus(left, right));
}
public LogicalOrScopeNested withNewLogicalOrScope() {
return new LogicalOrScopeNested(null);
}
public LogicalOrScopeNested withNewLogicalOrScopeLike(LogicalOr item) {
return new LogicalOrScopeNested(item);
}
public A withNewLogicalOrScope(Object left,Object right) {
return (A)withScope(new LogicalOr(left, right));
}
public NotEqualsScopeNested withNewNotEqualsScope() {
return new NotEqualsScopeNested(null);
}
public NotEqualsScopeNested withNewNotEqualsScopeLike(NotEquals item) {
return new NotEqualsScopeNested(item);
}
public A withNewNotEqualsScope(Object left,Object right) {
return (A)withScope(new NotEquals(left, right));
}
public DivideScopeNested withNewDivideScope() {
return new DivideScopeNested(null);
}
public DivideScopeNested withNewDivideScopeLike(Divide item) {
return new DivideScopeNested(item);
}
public A withNewDivideScope(Object left,Object right) {
return (A)withScope(new Divide(left, right));
}
public LessThanScopeNested withNewLessThanScope() {
return new LessThanScopeNested(null);
}
public LessThanScopeNested withNewLessThanScopeLike(LessThan item) {
return new LessThanScopeNested(item);
}
public A withNewLessThanScope(Object left,Object right) {
return (A)withScope(new LessThan(left, right));
}
public BitwiseOrScopeNested withNewBitwiseOrScope() {
return new BitwiseOrScopeNested(null);
}
public BitwiseOrScopeNested withNewBitwiseOrScopeLike(BitwiseOr item) {
return new BitwiseOrScopeNested(item);
}
public A withNewBitwiseOrScope(Object left,Object right) {
return (A)withScope(new BitwiseOr(left, right));
}
public PropertyRefScopeNested withNewPropertyRefScope() {
return new PropertyRefScopeNested(null);
}
public PropertyRefScopeNested withNewPropertyRefScopeLike(PropertyRef item) {
return new PropertyRefScopeNested(item);
}
public RightShiftScopeNested withNewRightShiftScope() {
return new RightShiftScopeNested(null);
}
public RightShiftScopeNested withNewRightShiftScopeLike(RightShift item) {
return new RightShiftScopeNested(item);
}
public A withNewRightShiftScope(Object left,Object right) {
return (A)withScope(new RightShift(left, right));
}
public GreaterThanScopeNested withNewGreaterThanScope() {
return new GreaterThanScopeNested(null);
}
public GreaterThanScopeNested withNewGreaterThanScopeLike(GreaterThan item) {
return new GreaterThanScopeNested(item);
}
public A withNewGreaterThanScope(Object left,Object right) {
return (A)withScope(new GreaterThan(left, right));
}
public DeclareScopeNested withNewDeclareScope() {
return new DeclareScopeNested(null);
}
public DeclareScopeNested withNewDeclareScopeLike(Declare item) {
return new DeclareScopeNested(item);
}
public A withNewDeclareScope(Class type,String name) {
return (A)withScope(new Declare(type, name));
}
public A withNewDeclareScope(Class type,String name,Object value) {
return (A)withScope(new Declare(type, name, value));
}
public CastScopeNested withNewCastScope() {
return new CastScopeNested(null);
}
public CastScopeNested withNewCastScopeLike(Cast item) {
return new CastScopeNested(item);
}
public ModuloScopeNested withNewModuloScope() {
return new ModuloScopeNested(null);
}
public ModuloScopeNested withNewModuloScopeLike(Modulo item) {
return new ModuloScopeNested(item);
}
public A withNewModuloScope(Object left,Object right) {
return (A)withScope(new Modulo(left, right));
}
public ValueRefScopeNested withNewValueRefScope() {
return new ValueRefScopeNested(null);
}
public ValueRefScopeNested withNewValueRefScopeLike(ValueRef item) {
return new ValueRefScopeNested(item);
}
public A withNewValueRefScope(Object value) {
return (A)withScope(new ValueRef(value));
}
public LeftShiftScopeNested withNewLeftShiftScope() {
return new LeftShiftScopeNested(null);
}
public LeftShiftScopeNested withNewLeftShiftScopeLike(LeftShift item) {
return new LeftShiftScopeNested(item);
}
public A withNewLeftShiftScope(Object left,Object right) {
return (A)withScope(new LeftShift(left, right));
}
public TernaryScopeNested withNewTernaryScope() {
return new TernaryScopeNested(null);
}
public TernaryScopeNested withNewTernaryScopeLike(Ternary item) {
return new TernaryScopeNested(item);
}
public BinaryExpressionScopeNested withNewBinaryExpressionScope() {
return new BinaryExpressionScopeNested(null);
}
public BinaryExpressionScopeNested withNewBinaryExpressionScopeLike(BinaryExpression item) {
return new BinaryExpressionScopeNested(item);
}
public EqualsScopeNested withNewEqualsScope() {
return new EqualsScopeNested(null);
}
public EqualsScopeNested withNewEqualsScopeLike(Equals item) {
return new EqualsScopeNested(item);
}
public A withNewEqualsScope(Object left,Object right) {
return (A)withScope(new Equals(left, right));
}
public EnclosedScopeNested withNewEnclosedScope() {
return new EnclosedScopeNested(null);
}
public EnclosedScopeNested withNewEnclosedScopeLike(Enclosed item) {
return new EnclosedScopeNested(item);
}
public PreDecrementScopeNested withNewPreDecrementScope() {
return new PreDecrementScopeNested(null);
}
public PreDecrementScopeNested withNewPreDecrementScopeLike(PreDecrement item) {
return new PreDecrementScopeNested(item);
}
public PostDecrementScopeNested withNewPostDecrementScope() {
return new PostDecrementScopeNested(null);
}
public PostDecrementScopeNested withNewPostDecrementScopeLike(PostDecrement item) {
return new PostDecrementScopeNested(item);
}
public LambdaScopeNested withNewLambdaScope() {
return new LambdaScopeNested(null);
}
public LambdaScopeNested withNewLambdaScopeLike(Lambda item) {
return new LambdaScopeNested(item);
}
public NotScopeNested withNewNotScope() {
return new NotScopeNested(null);
}
public NotScopeNested withNewNotScopeLike(Not item) {
return new NotScopeNested(item);
}
public ThisScopeNested withNewThisScope() {
return new ThisScopeNested(null);
}
public ThisScopeNested withNewThisScopeLike(This item) {
return new ThisScopeNested(item);
}
public NegativeScopeNested withNewNegativeScope() {
return new NegativeScopeNested(null);
}
public NegativeScopeNested withNewNegativeScopeLike(Negative item) {
return new NegativeScopeNested(item);
}
public AssignScopeNested withNewAssignScope() {
return new AssignScopeNested(null);
}
public AssignScopeNested withNewAssignScopeLike(Assign item) {
return new AssignScopeNested(item);
}
public LogicalAndScopeNested withNewLogicalAndScope() {
return new LogicalAndScopeNested(null);
}
public LogicalAndScopeNested withNewLogicalAndScopeLike(LogicalAnd item) {
return new LogicalAndScopeNested(item);
}
public A withNewLogicalAndScope(Object left,Object right) {
return (A)withScope(new LogicalAnd(left, right));
}
public PostIncrementScopeNested withNewPostIncrementScope() {
return new PostIncrementScopeNested(null);
}
public PostIncrementScopeNested withNewPostIncrementScopeLike(PostIncrement item) {
return new PostIncrementScopeNested(item);
}
public RightUnsignedShiftScopeNested withNewRightUnsignedShiftScope() {
return new RightUnsignedShiftScopeNested(null);
}
public RightUnsignedShiftScopeNested withNewRightUnsignedShiftScopeLike(RightUnsignedShift item) {
return new RightUnsignedShiftScopeNested(item);
}
public A withNewRightUnsignedShiftScope(Object left,Object right) {
return (A)withScope(new RightUnsignedShift(left, right));
}
public PlusScopeNested withNewPlusScope() {
return new PlusScopeNested(null);
}
public PlusScopeNested withNewPlusScopeLike(Plus item) {
return new PlusScopeNested(item);
}
public A withNewPlusScope(Object left,Object right) {
return (A)withScope(new Plus(left, right));
}
public ConstructScopeNested withNewConstructScope() {
return new ConstructScopeNested(null);
}
public ConstructScopeNested withNewConstructScopeLike(Construct item) {
return new ConstructScopeNested(item);
}
public XorScopeNested withNewXorScope() {
return new XorScopeNested(null);
}
public XorScopeNested withNewXorScopeLike(Xor item) {
return new XorScopeNested(item);
}
public A withNewXorScope(Object left,Object right) {
return (A)withScope(new Xor(left, right));
}
public PreIncrementScopeNested withNewPreIncrementScope() {
return new PreIncrementScopeNested(null);
}
public PreIncrementScopeNested withNewPreIncrementScopeLike(PreIncrement item) {
return new PreIncrementScopeNested(item);
}
public LessThanOrEqualScopeNested withNewLessThanOrEqualScope() {
return new LessThanOrEqualScopeNested(null);
}
public LessThanOrEqualScopeNested withNewLessThanOrEqualScopeLike(LessThanOrEqual item) {
return new LessThanOrEqualScopeNested(item);
}
public A withNewLessThanOrEqualScope(Object left,Object right) {
return (A)withScope(new LessThanOrEqual(left, right));
}
public PositiveScopeNested withNewPositiveScope() {
return new PositiveScopeNested(null);
}
public PositiveScopeNested withNewPositiveScopeLike(Positive item) {
return new PositiveScopeNested(item);
}
public Expression buildExpression() {
return this.expression!=null?this.expression.build():null;
}
public A withExpression(Expression expression) {
if (expression==null){ this.expression = null; _visitables.remove("expression"); return (A) this;}
VisitableBuilder builder = builder(expression); _visitables.get("expression").clear();_visitables.get("expression").add(builder);this.expression = builder;
return (A) this;
}
public boolean hasExpression() {
return this.expression != null;
}
public MultiplyExpressionNested withNewMultiplyExpression() {
return new MultiplyExpressionNested(null);
}
public MultiplyExpressionNested withNewMultiplyExpressionLike(Multiply item) {
return new MultiplyExpressionNested(item);
}
public A withNewMultiplyExpression(Object left,Object right) {
return (A)withExpression(new Multiply(left, right));
}
public NewArrayExpressionNested withNewNewArrayExpression() {
return new NewArrayExpressionNested(null);
}
public NewArrayExpressionNested withNewNewArrayExpressionLike(NewArray item) {
return new NewArrayExpressionNested(item);
}
public A withNewNewArrayExpression(Class type,Integer[] sizes) {
return (A)withExpression(new NewArray(type, sizes));
}
public InstanceOfExpressionNested withNewInstanceOfExpression() {
return new InstanceOfExpressionNested(null);
}
public InstanceOfExpressionNested withNewInstanceOfExpressionLike(InstanceOf item) {
return new InstanceOfExpressionNested(item);
}
public MethodCallExpressionNested withNewMethodCallExpression() {
return new MethodCallExpressionNested(null);
}
public MethodCallExpressionNested withNewMethodCallExpressionLike(MethodCall item) {
return new MethodCallExpressionNested(item);
}
public InverseExpressionNested withNewInverseExpression() {
return new InverseExpressionNested(null);
}
public InverseExpressionNested withNewInverseExpressionLike(Inverse item) {
return new InverseExpressionNested(item);
}
public IndexExpressionNested withNewIndexExpression() {
return new IndexExpressionNested(null);
}
public IndexExpressionNested withNewIndexExpressionLike(Index item) {
return new IndexExpressionNested(item);
}
public GreaterThanOrEqualExpressionNested withNewGreaterThanOrEqualExpression() {
return new GreaterThanOrEqualExpressionNested(null);
}
public GreaterThanOrEqualExpressionNested withNewGreaterThanOrEqualExpressionLike(GreaterThanOrEqual item) {
return new GreaterThanOrEqualExpressionNested(item);
}
public A withNewGreaterThanOrEqualExpression(Object left,Object right) {
return (A)withExpression(new GreaterThanOrEqual(left, right));
}
public BitwiseAndExpressionNested withNewBitwiseAndExpression() {
return new BitwiseAndExpressionNested(null);
}
public BitwiseAndExpressionNested withNewBitwiseAndExpressionLike(BitwiseAnd item) {
return new BitwiseAndExpressionNested(item);
}
public A withNewBitwiseAndExpression(Object left,Object right) {
return (A)withExpression(new BitwiseAnd(left, right));
}
public MinusExpressionNested withNewMinusExpression() {
return new MinusExpressionNested(null);
}
public MinusExpressionNested withNewMinusExpressionLike(Minus item) {
return new MinusExpressionNested(item);
}
public A withNewMinusExpression(Object left,Object right) {
return (A)withExpression(new Minus(left, right));
}
public LogicalOrExpressionNested withNewLogicalOrExpression() {
return new LogicalOrExpressionNested(null);
}
public LogicalOrExpressionNested withNewLogicalOrExpressionLike(LogicalOr item) {
return new LogicalOrExpressionNested(item);
}
public A withNewLogicalOrExpression(Object left,Object right) {
return (A)withExpression(new LogicalOr(left, right));
}
public NotEqualsExpressionNested withNewNotEqualsExpression() {
return new NotEqualsExpressionNested(null);
}
public NotEqualsExpressionNested withNewNotEqualsExpressionLike(NotEquals item) {
return new NotEqualsExpressionNested(item);
}
public A withNewNotEqualsExpression(Object left,Object right) {
return (A)withExpression(new NotEquals(left, right));
}
public DivideExpressionNested withNewDivideExpression() {
return new DivideExpressionNested(null);
}
public DivideExpressionNested withNewDivideExpressionLike(Divide item) {
return new DivideExpressionNested(item);
}
public A withNewDivideExpression(Object left,Object right) {
return (A)withExpression(new Divide(left, right));
}
public LessThanExpressionNested withNewLessThanExpression() {
return new LessThanExpressionNested(null);
}
public LessThanExpressionNested withNewLessThanExpressionLike(LessThan item) {
return new LessThanExpressionNested(item);
}
public A withNewLessThanExpression(Object left,Object right) {
return (A)withExpression(new LessThan(left, right));
}
public BitwiseOrExpressionNested withNewBitwiseOrExpression() {
return new BitwiseOrExpressionNested(null);
}
public BitwiseOrExpressionNested withNewBitwiseOrExpressionLike(BitwiseOr item) {
return new BitwiseOrExpressionNested(item);
}
public A withNewBitwiseOrExpression(Object left,Object right) {
return (A)withExpression(new BitwiseOr(left, right));
}
public PropertyRefExpressionNested withNewPropertyRefExpression() {
return new PropertyRefExpressionNested(null);
}
public PropertyRefExpressionNested withNewPropertyRefExpressionLike(PropertyRef item) {
return new PropertyRefExpressionNested(item);
}
public RightShiftExpressionNested withNewRightShiftExpression() {
return new RightShiftExpressionNested(null);
}
public RightShiftExpressionNested withNewRightShiftExpressionLike(RightShift item) {
return new RightShiftExpressionNested(item);
}
public A withNewRightShiftExpression(Object left,Object right) {
return (A)withExpression(new RightShift(left, right));
}
public GreaterThanExpressionNested withNewGreaterThanExpression() {
return new GreaterThanExpressionNested(null);
}
public GreaterThanExpressionNested withNewGreaterThanExpressionLike(GreaterThan item) {
return new GreaterThanExpressionNested(item);
}
public A withNewGreaterThanExpression(Object left,Object right) {
return (A)withExpression(new GreaterThan(left, right));
}
public DeclareExpressionNested withNewDeclareExpression() {
return new DeclareExpressionNested(null);
}
public DeclareExpressionNested withNewDeclareExpressionLike(Declare item) {
return new DeclareExpressionNested(item);
}
public A withNewDeclareExpression(Class type,String name) {
return (A)withExpression(new Declare(type, name));
}
public A withNewDeclareExpression(Class type,String name,Object value) {
return (A)withExpression(new Declare(type, name, value));
}
public CastExpressionNested withNewCastExpression() {
return new CastExpressionNested(null);
}
public CastExpressionNested withNewCastExpressionLike(Cast item) {
return new CastExpressionNested(item);
}
public ModuloExpressionNested withNewModuloExpression() {
return new ModuloExpressionNested(null);
}
public ModuloExpressionNested withNewModuloExpressionLike(Modulo item) {
return new ModuloExpressionNested(item);
}
public A withNewModuloExpression(Object left,Object right) {
return (A)withExpression(new Modulo(left, right));
}
public ValueRefExpressionNested withNewValueRefExpression() {
return new ValueRefExpressionNested(null);
}
public ValueRefExpressionNested withNewValueRefExpressionLike(ValueRef item) {
return new ValueRefExpressionNested(item);
}
public A withNewValueRefExpression(Object value) {
return (A)withExpression(new ValueRef(value));
}
public LeftShiftExpressionNested withNewLeftShiftExpression() {
return new LeftShiftExpressionNested(null);
}
public LeftShiftExpressionNested withNewLeftShiftExpressionLike(LeftShift item) {
return new LeftShiftExpressionNested(item);
}
public A withNewLeftShiftExpression(Object left,Object right) {
return (A)withExpression(new LeftShift(left, right));
}
public TernaryExpressionNested withNewTernaryExpression() {
return new TernaryExpressionNested(null);
}
public TernaryExpressionNested withNewTernaryExpressionLike(Ternary item) {
return new TernaryExpressionNested(item);
}
public BinaryExpressionNested withNewBinaryExpression() {
return new BinaryExpressionNested(null);
}
public BinaryExpressionNested withNewBinaryExpressionLike(BinaryExpression item) {
return new BinaryExpressionNested(item);
}
public EqualsExpressionNested withNewEqualsExpression() {
return new EqualsExpressionNested(null);
}
public EqualsExpressionNested withNewEqualsExpressionLike(Equals item) {
return new EqualsExpressionNested(item);
}
public A withNewEqualsExpression(Object left,Object right) {
return (A)withExpression(new Equals(left, right));
}
public EnclosedExpressionNested withNewEnclosedExpression() {
return new EnclosedExpressionNested(null);
}
public EnclosedExpressionNested withNewEnclosedExpressionLike(Enclosed item) {
return new EnclosedExpressionNested(item);
}
public PreDecrementExpressionNested withNewPreDecrementExpression() {
return new PreDecrementExpressionNested(null);
}
public PreDecrementExpressionNested withNewPreDecrementExpressionLike(PreDecrement item) {
return new PreDecrementExpressionNested(item);
}
public PostDecrementExpressionNested withNewPostDecrementExpression() {
return new PostDecrementExpressionNested(null);
}
public PostDecrementExpressionNested withNewPostDecrementExpressionLike(PostDecrement item) {
return new PostDecrementExpressionNested(item);
}
public LambdaExpressionNested withNewLambdaExpression() {
return new LambdaExpressionNested(null);
}
public LambdaExpressionNested withNewLambdaExpressionLike(Lambda item) {
return new LambdaExpressionNested(item);
}
public NotExpressionNested withNewNotExpression() {
return new NotExpressionNested(null);
}
public NotExpressionNested withNewNotExpressionLike(Not item) {
return new NotExpressionNested(item);
}
public ThisExpressionNested withNewThisExpression() {
return new ThisExpressionNested(null);
}
public ThisExpressionNested withNewThisExpressionLike(This item) {
return new ThisExpressionNested(item);
}
public NegativeExpressionNested withNewNegativeExpression() {
return new NegativeExpressionNested(null);
}
public NegativeExpressionNested withNewNegativeExpressionLike(Negative item) {
return new NegativeExpressionNested(item);
}
public AssignExpressionNested withNewAssignExpression() {
return new AssignExpressionNested(null);
}
public AssignExpressionNested withNewAssignExpressionLike(Assign item) {
return new AssignExpressionNested(item);
}
public LogicalAndExpressionNested withNewLogicalAndExpression() {
return new LogicalAndExpressionNested(null);
}
public LogicalAndExpressionNested withNewLogicalAndExpressionLike(LogicalAnd item) {
return new LogicalAndExpressionNested(item);
}
public A withNewLogicalAndExpression(Object left,Object right) {
return (A)withExpression(new LogicalAnd(left, right));
}
public PostIncrementExpressionNested withNewPostIncrementExpression() {
return new PostIncrementExpressionNested(null);
}
public PostIncrementExpressionNested withNewPostIncrementExpressionLike(PostIncrement item) {
return new PostIncrementExpressionNested(item);
}
public RightUnsignedShiftExpressionNested withNewRightUnsignedShiftExpression() {
return new RightUnsignedShiftExpressionNested(null);
}
public RightUnsignedShiftExpressionNested withNewRightUnsignedShiftExpressionLike(RightUnsignedShift item) {
return new RightUnsignedShiftExpressionNested(item);
}
public A withNewRightUnsignedShiftExpression(Object left,Object right) {
return (A)withExpression(new RightUnsignedShift(left, right));
}
public PlusExpressionNested withNewPlusExpression() {
return new PlusExpressionNested(null);
}
public PlusExpressionNested withNewPlusExpressionLike(Plus item) {
return new PlusExpressionNested(item);
}
public A withNewPlusExpression(Object left,Object right) {
return (A)withExpression(new Plus(left, right));
}
public ConstructExpressionNested withNewConstructExpression() {
return new ConstructExpressionNested(null);
}
public ConstructExpressionNested withNewConstructExpressionLike(Construct item) {
return new ConstructExpressionNested(item);
}
public XorExpressionNested withNewXorExpression() {
return new XorExpressionNested(null);
}
public XorExpressionNested withNewXorExpressionLike(Xor item) {
return new XorExpressionNested(item);
}
public A withNewXorExpression(Object left,Object right) {
return (A)withExpression(new Xor(left, right));
}
public PreIncrementExpressionNested withNewPreIncrementExpression() {
return new PreIncrementExpressionNested(null);
}
public PreIncrementExpressionNested withNewPreIncrementExpressionLike(PreIncrement item) {
return new PreIncrementExpressionNested(item);
}
public LessThanOrEqualExpressionNested withNewLessThanOrEqualExpression() {
return new LessThanOrEqualExpressionNested(null);
}
public LessThanOrEqualExpressionNested withNewLessThanOrEqualExpressionLike(LessThanOrEqual item) {
return new LessThanOrEqualExpressionNested(item);
}
public A withNewLessThanOrEqualExpression(Object left,Object right) {
return (A)withExpression(new LessThanOrEqual(left, right));
}
public PositiveExpressionNested withNewPositiveExpression() {
return new PositiveExpressionNested(null);
}
public PositiveExpressionNested withNewPositiveExpressionLike(Positive item) {
return new PositiveExpressionNested(item);
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
IndexFluent that = (IndexFluent) o;
if (!java.util.Objects.equals(scope, that.scope)) return false;
if (!java.util.Objects.equals(expression, that.expression)) return false;
return true;
}
public int hashCode() {
return java.util.Objects.hash(scope, expression, super.hashCode());
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (scope != null) { sb.append("scope:"); sb.append(scope + ","); }
if (expression != null) { sb.append("expression:"); sb.append(expression); }
sb.append("}");
return sb.toString();
}
protected static VisitableBuilder builder(Object item) {
switch (item.getClass().getName()) {
case "io.sundr.model."+"Multiply": return (VisitableBuilder)new MultiplyBuilder((Multiply) item);
case "io.sundr.model."+"NewArray": return (VisitableBuilder)new NewArrayBuilder((NewArray) item);
case "io.sundr.model."+"InstanceOf": return (VisitableBuilder)new InstanceOfBuilder((InstanceOf) item);
case "io.sundr.model."+"MethodCall": return (VisitableBuilder)new MethodCallBuilder((MethodCall) item);
case "io.sundr.model."+"Inverse": return (VisitableBuilder)new InverseBuilder((Inverse) item);
case "io.sundr.model."+"Index": return (VisitableBuilder)new IndexBuilder((Index) item);
case "io.sundr.model."+"GreaterThanOrEqual": return (VisitableBuilder)new GreaterThanOrEqualBuilder((GreaterThanOrEqual) item);
case "io.sundr.model."+"BitwiseAnd": return (VisitableBuilder)new BitwiseAndBuilder((BitwiseAnd) item);
case "io.sundr.model."+"Minus": return (VisitableBuilder)new MinusBuilder((Minus) item);
case "io.sundr.model."+"LogicalOr": return (VisitableBuilder)new LogicalOrBuilder((LogicalOr) item);
case "io.sundr.model."+"NotEquals": return (VisitableBuilder)new NotEqualsBuilder((NotEquals) item);
case "io.sundr.model."+"Divide": return (VisitableBuilder)new DivideBuilder((Divide) item);
case "io.sundr.model."+"LessThan": return (VisitableBuilder)new LessThanBuilder((LessThan) item);
case "io.sundr.model."+"BitwiseOr": return (VisitableBuilder)new BitwiseOrBuilder((BitwiseOr) item);
case "io.sundr.model."+"PropertyRef": return (VisitableBuilder)new PropertyRefBuilder((PropertyRef) item);
case "io.sundr.model."+"RightShift": return (VisitableBuilder)new RightShiftBuilder((RightShift) item);
case "io.sundr.model."+"GreaterThan": return (VisitableBuilder)new GreaterThanBuilder((GreaterThan) item);
case "io.sundr.model."+"Declare": return (VisitableBuilder)new DeclareBuilder((Declare) item);
case "io.sundr.model."+"Cast": return (VisitableBuilder)new CastBuilder((Cast) item);
case "io.sundr.model."+"Modulo": return (VisitableBuilder)new ModuloBuilder((Modulo) item);
case "io.sundr.model."+"ValueRef": return (VisitableBuilder)new ValueRefBuilder((ValueRef) item);
case "io.sundr.model."+"LeftShift": return (VisitableBuilder)new LeftShiftBuilder((LeftShift) item);
case "io.sundr.model."+"Ternary": return (VisitableBuilder)new TernaryBuilder((Ternary) item);
case "io.sundr.model."+"BinaryExpression": return (VisitableBuilder)new BinaryExpressionBuilder((BinaryExpression) item);
case "io.sundr.model."+"Equals": return (VisitableBuilder)new EqualsBuilder((Equals) item);
case "io.sundr.model."+"Enclosed": return (VisitableBuilder)new EnclosedBuilder((Enclosed) item);
case "io.sundr.model."+"PreDecrement": return (VisitableBuilder)new PreDecrementBuilder((PreDecrement) item);
case "io.sundr.model."+"PostDecrement": return (VisitableBuilder)new PostDecrementBuilder((PostDecrement) item);
case "io.sundr.model."+"Lambda": return (VisitableBuilder)new LambdaBuilder((Lambda) item);
case "io.sundr.model."+"Not": return (VisitableBuilder)new NotBuilder((Not) item);
case "io.sundr.model."+"This": return (VisitableBuilder)new ThisBuilder((This) item);
case "io.sundr.model."+"Negative": return (VisitableBuilder)new NegativeBuilder((Negative) item);
case "io.sundr.model."+"Assign": return (VisitableBuilder)new AssignBuilder((Assign) item);
case "io.sundr.model."+"LogicalAnd": return (VisitableBuilder)new LogicalAndBuilder((LogicalAnd) item);
case "io.sundr.model."+"PostIncrement": return (VisitableBuilder)new PostIncrementBuilder((PostIncrement) item);
case "io.sundr.model."+"RightUnsignedShift": return (VisitableBuilder)new RightUnsignedShiftBuilder((RightUnsignedShift) item);
case "io.sundr.model."+"Plus": return (VisitableBuilder)new PlusBuilder((Plus) item);
case "io.sundr.model."+"Construct": return (VisitableBuilder)new ConstructBuilder((Construct) item);
case "io.sundr.model."+"Xor": return (VisitableBuilder)new XorBuilder((Xor) item);
case "io.sundr.model."+"PreIncrement": return (VisitableBuilder)new PreIncrementBuilder((PreIncrement) item);
case "io.sundr.model."+"LessThanOrEqual": return (VisitableBuilder)new LessThanOrEqualBuilder((LessThanOrEqual) item);
case "io.sundr.model."+"Positive": return (VisitableBuilder)new PositiveBuilder((Positive) item);
}
return (VisitableBuilder)builderOf(item);
}
public class MultiplyScopeNested extends MultiplyFluent> implements Nested{
MultiplyScopeNested(Multiply item) {
this.builder = new MultiplyBuilder(this, item);
}
MultiplyBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endMultiplyScope() {
return and();
}
}
public class NewArrayScopeNested extends NewArrayFluent> implements Nested{
NewArrayScopeNested(NewArray item) {
this.builder = new NewArrayBuilder(this, item);
}
NewArrayBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endNewArrayScope() {
return and();
}
}
public class InstanceOfScopeNested extends InstanceOfFluent> implements Nested{
InstanceOfScopeNested(InstanceOf item) {
this.builder = new InstanceOfBuilder(this, item);
}
InstanceOfBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endInstanceOfScope() {
return and();
}
}
public class MethodCallScopeNested extends MethodCallFluent> implements Nested{
MethodCallScopeNested(MethodCall item) {
this.builder = new MethodCallBuilder(this, item);
}
MethodCallBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endMethodCallScope() {
return and();
}
}
public class InverseScopeNested extends InverseFluent> implements Nested{
InverseScopeNested(Inverse item) {
this.builder = new InverseBuilder(this, item);
}
InverseBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endInverseScope() {
return and();
}
}
public class IndexScopeNested extends IndexFluent> implements Nested{
IndexScopeNested(Index item) {
this.builder = new IndexBuilder(this, item);
}
IndexBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endIndexScope() {
return and();
}
}
public class GreaterThanOrEqualScopeNested extends GreaterThanOrEqualFluent> implements Nested{
GreaterThanOrEqualScopeNested(GreaterThanOrEqual item) {
this.builder = new GreaterThanOrEqualBuilder(this, item);
}
GreaterThanOrEqualBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endGreaterThanOrEqualScope() {
return and();
}
}
public class BitwiseAndScopeNested extends BitwiseAndFluent> implements Nested{
BitwiseAndScopeNested(BitwiseAnd item) {
this.builder = new BitwiseAndBuilder(this, item);
}
BitwiseAndBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endBitwiseAndScope() {
return and();
}
}
public class MinusScopeNested extends MinusFluent> implements Nested{
MinusScopeNested(Minus item) {
this.builder = new MinusBuilder(this, item);
}
MinusBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endMinusScope() {
return and();
}
}
public class LogicalOrScopeNested extends LogicalOrFluent> implements Nested{
LogicalOrScopeNested(LogicalOr item) {
this.builder = new LogicalOrBuilder(this, item);
}
LogicalOrBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLogicalOrScope() {
return and();
}
}
public class NotEqualsScopeNested extends NotEqualsFluent> implements Nested{
NotEqualsScopeNested(NotEquals item) {
this.builder = new NotEqualsBuilder(this, item);
}
NotEqualsBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endNotEqualsScope() {
return and();
}
}
public class DivideScopeNested extends DivideFluent> implements Nested{
DivideScopeNested(Divide item) {
this.builder = new DivideBuilder(this, item);
}
DivideBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endDivideScope() {
return and();
}
}
public class LessThanScopeNested extends LessThanFluent> implements Nested{
LessThanScopeNested(LessThan item) {
this.builder = new LessThanBuilder(this, item);
}
LessThanBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLessThanScope() {
return and();
}
}
public class BitwiseOrScopeNested extends BitwiseOrFluent> implements Nested{
BitwiseOrScopeNested(BitwiseOr item) {
this.builder = new BitwiseOrBuilder(this, item);
}
BitwiseOrBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endBitwiseOrScope() {
return and();
}
}
public class PropertyRefScopeNested extends PropertyRefFluent> implements Nested{
PropertyRefScopeNested(PropertyRef item) {
this.builder = new PropertyRefBuilder(this, item);
}
PropertyRefBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPropertyRefScope() {
return and();
}
}
public class RightShiftScopeNested extends RightShiftFluent> implements Nested{
RightShiftScopeNested(RightShift item) {
this.builder = new RightShiftBuilder(this, item);
}
RightShiftBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endRightShiftScope() {
return and();
}
}
public class GreaterThanScopeNested extends GreaterThanFluent> implements Nested{
GreaterThanScopeNested(GreaterThan item) {
this.builder = new GreaterThanBuilder(this, item);
}
GreaterThanBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endGreaterThanScope() {
return and();
}
}
public class DeclareScopeNested extends DeclareFluent> implements Nested{
DeclareScopeNested(Declare item) {
this.builder = new DeclareBuilder(this, item);
}
DeclareBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endDeclareScope() {
return and();
}
}
public class CastScopeNested extends CastFluent> implements Nested{
CastScopeNested(Cast item) {
this.builder = new CastBuilder(this, item);
}
CastBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endCastScope() {
return and();
}
}
public class ModuloScopeNested extends ModuloFluent> implements Nested{
ModuloScopeNested(Modulo item) {
this.builder = new ModuloBuilder(this, item);
}
ModuloBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endModuloScope() {
return and();
}
}
public class ValueRefScopeNested extends ValueRefFluent> implements Nested{
ValueRefScopeNested(ValueRef item) {
this.builder = new ValueRefBuilder(this, item);
}
ValueRefBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endValueRefScope() {
return and();
}
}
public class LeftShiftScopeNested extends LeftShiftFluent> implements Nested{
LeftShiftScopeNested(LeftShift item) {
this.builder = new LeftShiftBuilder(this, item);
}
LeftShiftBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLeftShiftScope() {
return and();
}
}
public class TernaryScopeNested extends TernaryFluent> implements Nested{
TernaryScopeNested(Ternary item) {
this.builder = new TernaryBuilder(this, item);
}
TernaryBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endTernaryScope() {
return and();
}
}
public class BinaryExpressionScopeNested extends BinaryExpressionFluent> implements Nested{
BinaryExpressionScopeNested(BinaryExpression item) {
this.builder = new BinaryExpressionBuilder(this, item);
}
BinaryExpressionBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endBinaryExpressionScope() {
return and();
}
}
public class EqualsScopeNested extends EqualsFluent> implements Nested{
EqualsScopeNested(Equals item) {
this.builder = new EqualsBuilder(this, item);
}
EqualsBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endEqualsScope() {
return and();
}
}
public class EnclosedScopeNested extends EnclosedFluent> implements Nested{
EnclosedScopeNested(Enclosed item) {
this.builder = new EnclosedBuilder(this, item);
}
EnclosedBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endEnclosedScope() {
return and();
}
}
public class PreDecrementScopeNested extends PreDecrementFluent> implements Nested{
PreDecrementScopeNested(PreDecrement item) {
this.builder = new PreDecrementBuilder(this, item);
}
PreDecrementBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPreDecrementScope() {
return and();
}
}
public class PostDecrementScopeNested extends PostDecrementFluent> implements Nested{
PostDecrementScopeNested(PostDecrement item) {
this.builder = new PostDecrementBuilder(this, item);
}
PostDecrementBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPostDecrementScope() {
return and();
}
}
public class LambdaScopeNested extends LambdaFluent> implements Nested{
LambdaScopeNested(Lambda item) {
this.builder = new LambdaBuilder(this, item);
}
LambdaBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLambdaScope() {
return and();
}
}
public class NotScopeNested extends NotFluent> implements Nested{
NotScopeNested(Not item) {
this.builder = new NotBuilder(this, item);
}
NotBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endNotScope() {
return and();
}
}
public class ThisScopeNested extends ThisFluent> implements Nested{
ThisScopeNested(This item) {
this.builder = new ThisBuilder(this, item);
}
ThisBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endThisScope() {
return and();
}
}
public class NegativeScopeNested extends NegativeFluent> implements Nested{
NegativeScopeNested(Negative item) {
this.builder = new NegativeBuilder(this, item);
}
NegativeBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endNegativeScope() {
return and();
}
}
public class AssignScopeNested extends AssignFluent> implements Nested{
AssignScopeNested(Assign item) {
this.builder = new AssignBuilder(this, item);
}
AssignBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endAssignScope() {
return and();
}
}
public class LogicalAndScopeNested extends LogicalAndFluent> implements Nested{
LogicalAndScopeNested(LogicalAnd item) {
this.builder = new LogicalAndBuilder(this, item);
}
LogicalAndBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLogicalAndScope() {
return and();
}
}
public class PostIncrementScopeNested extends PostIncrementFluent> implements Nested{
PostIncrementScopeNested(PostIncrement item) {
this.builder = new PostIncrementBuilder(this, item);
}
PostIncrementBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPostIncrementScope() {
return and();
}
}
public class RightUnsignedShiftScopeNested extends RightUnsignedShiftFluent> implements Nested{
RightUnsignedShiftScopeNested(RightUnsignedShift item) {
this.builder = new RightUnsignedShiftBuilder(this, item);
}
RightUnsignedShiftBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endRightUnsignedShiftScope() {
return and();
}
}
public class PlusScopeNested extends PlusFluent> implements Nested{
PlusScopeNested(Plus item) {
this.builder = new PlusBuilder(this, item);
}
PlusBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPlusScope() {
return and();
}
}
public class ConstructScopeNested extends ConstructFluent> implements Nested{
ConstructScopeNested(Construct item) {
this.builder = new ConstructBuilder(this, item);
}
ConstructBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endConstructScope() {
return and();
}
}
public class XorScopeNested extends XorFluent> implements Nested{
XorScopeNested(Xor item) {
this.builder = new XorBuilder(this, item);
}
XorBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endXorScope() {
return and();
}
}
public class PreIncrementScopeNested extends PreIncrementFluent> implements Nested{
PreIncrementScopeNested(PreIncrement item) {
this.builder = new PreIncrementBuilder(this, item);
}
PreIncrementBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPreIncrementScope() {
return and();
}
}
public class LessThanOrEqualScopeNested extends LessThanOrEqualFluent> implements Nested{
LessThanOrEqualScopeNested(LessThanOrEqual item) {
this.builder = new LessThanOrEqualBuilder(this, item);
}
LessThanOrEqualBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endLessThanOrEqualScope() {
return and();
}
}
public class PositiveScopeNested extends PositiveFluent> implements Nested{
PositiveScopeNested(Positive item) {
this.builder = new PositiveBuilder(this, item);
}
PositiveBuilder builder;
public N and() {
return (N) IndexFluent.this.withScope(builder.build());
}
public N endPositiveScope() {
return and();
}
}
public class MultiplyExpressionNested extends MultiplyFluent> implements Nested{
MultiplyExpressionNested(Multiply item) {
this.builder = new MultiplyBuilder(this, item);
}
MultiplyBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endMultiplyExpression() {
return and();
}
}
public class NewArrayExpressionNested extends NewArrayFluent> implements Nested{
NewArrayExpressionNested(NewArray item) {
this.builder = new NewArrayBuilder(this, item);
}
NewArrayBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endNewArrayExpression() {
return and();
}
}
public class InstanceOfExpressionNested extends InstanceOfFluent> implements Nested{
InstanceOfExpressionNested(InstanceOf item) {
this.builder = new InstanceOfBuilder(this, item);
}
InstanceOfBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endInstanceOfExpression() {
return and();
}
}
public class MethodCallExpressionNested extends MethodCallFluent> implements Nested{
MethodCallExpressionNested(MethodCall item) {
this.builder = new MethodCallBuilder(this, item);
}
MethodCallBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endMethodCallExpression() {
return and();
}
}
public class InverseExpressionNested extends InverseFluent> implements Nested{
InverseExpressionNested(Inverse item) {
this.builder = new InverseBuilder(this, item);
}
InverseBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endInverseExpression() {
return and();
}
}
public class IndexExpressionNested extends IndexFluent> implements Nested{
IndexExpressionNested(Index item) {
this.builder = new IndexBuilder(this, item);
}
IndexBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endIndexExpression() {
return and();
}
}
public class GreaterThanOrEqualExpressionNested extends GreaterThanOrEqualFluent> implements Nested{
GreaterThanOrEqualExpressionNested(GreaterThanOrEqual item) {
this.builder = new GreaterThanOrEqualBuilder(this, item);
}
GreaterThanOrEqualBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endGreaterThanOrEqualExpression() {
return and();
}
}
public class BitwiseAndExpressionNested extends BitwiseAndFluent> implements Nested{
BitwiseAndExpressionNested(BitwiseAnd item) {
this.builder = new BitwiseAndBuilder(this, item);
}
BitwiseAndBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endBitwiseAndExpression() {
return and();
}
}
public class MinusExpressionNested extends MinusFluent> implements Nested{
MinusExpressionNested(Minus item) {
this.builder = new MinusBuilder(this, item);
}
MinusBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endMinusExpression() {
return and();
}
}
public class LogicalOrExpressionNested extends LogicalOrFluent> implements Nested{
LogicalOrExpressionNested(LogicalOr item) {
this.builder = new LogicalOrBuilder(this, item);
}
LogicalOrBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endLogicalOrExpression() {
return and();
}
}
public class NotEqualsExpressionNested extends NotEqualsFluent> implements Nested{
NotEqualsExpressionNested(NotEquals item) {
this.builder = new NotEqualsBuilder(this, item);
}
NotEqualsBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endNotEqualsExpression() {
return and();
}
}
public class DivideExpressionNested extends DivideFluent> implements Nested{
DivideExpressionNested(Divide item) {
this.builder = new DivideBuilder(this, item);
}
DivideBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endDivideExpression() {
return and();
}
}
public class LessThanExpressionNested extends LessThanFluent> implements Nested{
LessThanExpressionNested(LessThan item) {
this.builder = new LessThanBuilder(this, item);
}
LessThanBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endLessThanExpression() {
return and();
}
}
public class BitwiseOrExpressionNested extends BitwiseOrFluent> implements Nested{
BitwiseOrExpressionNested(BitwiseOr item) {
this.builder = new BitwiseOrBuilder(this, item);
}
BitwiseOrBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endBitwiseOrExpression() {
return and();
}
}
public class PropertyRefExpressionNested extends PropertyRefFluent> implements Nested{
PropertyRefExpressionNested(PropertyRef item) {
this.builder = new PropertyRefBuilder(this, item);
}
PropertyRefBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endPropertyRefExpression() {
return and();
}
}
public class RightShiftExpressionNested extends RightShiftFluent> implements Nested{
RightShiftExpressionNested(RightShift item) {
this.builder = new RightShiftBuilder(this, item);
}
RightShiftBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endRightShiftExpression() {
return and();
}
}
public class GreaterThanExpressionNested extends GreaterThanFluent> implements Nested{
GreaterThanExpressionNested(GreaterThan item) {
this.builder = new GreaterThanBuilder(this, item);
}
GreaterThanBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endGreaterThanExpression() {
return and();
}
}
public class DeclareExpressionNested extends DeclareFluent> implements Nested{
DeclareExpressionNested(Declare item) {
this.builder = new DeclareBuilder(this, item);
}
DeclareBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endDeclareExpression() {
return and();
}
}
public class CastExpressionNested extends CastFluent> implements Nested{
CastExpressionNested(Cast item) {
this.builder = new CastBuilder(this, item);
}
CastBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endCastExpression() {
return and();
}
}
public class ModuloExpressionNested extends ModuloFluent> implements Nested{
ModuloExpressionNested(Modulo item) {
this.builder = new ModuloBuilder(this, item);
}
ModuloBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endModuloExpression() {
return and();
}
}
public class ValueRefExpressionNested extends ValueRefFluent> implements Nested{
ValueRefExpressionNested(ValueRef item) {
this.builder = new ValueRefBuilder(this, item);
}
ValueRefBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endValueRefExpression() {
return and();
}
}
public class LeftShiftExpressionNested extends LeftShiftFluent> implements Nested{
LeftShiftExpressionNested(LeftShift item) {
this.builder = new LeftShiftBuilder(this, item);
}
LeftShiftBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endLeftShiftExpression() {
return and();
}
}
public class TernaryExpressionNested extends TernaryFluent> implements Nested{
TernaryExpressionNested(Ternary item) {
this.builder = new TernaryBuilder(this, item);
}
TernaryBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endTernaryExpression() {
return and();
}
}
public class BinaryExpressionNested extends BinaryExpressionFluent> implements Nested{
BinaryExpressionNested(BinaryExpression item) {
this.builder = new BinaryExpressionBuilder(this, item);
}
BinaryExpressionBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endBinaryExpression() {
return and();
}
}
public class EqualsExpressionNested extends EqualsFluent> implements Nested{
EqualsExpressionNested(Equals item) {
this.builder = new EqualsBuilder(this, item);
}
EqualsBuilder builder;
public N and() {
return (N) IndexFluent.this.withExpression(builder.build());
}
public N endEqualsExpression() {
return and();
}
}
public class EnclosedExpressionNested extends EnclosedFluent> implements Nested