Package io.sundr.model

Class NegativeFluent<A extends NegativeFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.NegativeFluent<A>

Direct Known Subclasses:

AssignFluent.NegativeTargetNested, AssignFluent.NegativeValueNested, BinaryExpressionFluent.NegativeLeftNested, BinaryExpressionFluent.NegativeRightNested, CastFluent.NegativeExpressionNested, ConstructFluent.NegativeArgumentsNested, DoFluent.NegativeConditionNested, EnclosedFluent.NegativeExpresionNested, ForeachFluent.NegativeExpressionNested, ForFluent.NegativeCompareNested, ForFluent.NegativeInitNested, ForFluent.NegativeUpdateNested, IfFluent.NegativeConditionNested, IndexFluent.NegativeExpressionNested, IndexFluent.NegativeScopeNested, InstanceOfFluent.NegativeExpressionNested, InverseFluent.NegativeExpresionNested, MethodCallFluent.NegativeArgumentsNested, MethodCallFluent.NegativeScopeNested, NegativeBuilder, NegativeFluent.NegativeExpresionNested, NewArrayFluent.NegativeExpressionsNested, NotFluent.NegativeExpresionNested, PositiveFluent.NegativeExpresionNested, PostDecrementFluent.NegativeExpressionNested, PostIncrementFluent.NegativeExpressionNested, PreDecrementFluent.NegativeExpressionNested, PreIncrementFluent.NegativeExpressionNested, PropertyRefFluent.NegativeScopeNested, ReturnFluent.NegativeExpressionNested, SwitchFluent.NegativeExpressionNested, TernaryFluent.NegativeAlternativeNested, TernaryFluent.NegativeConditionNested, TernaryFluent.NegativeResultNested, WhileFluent.NegativeConditionNested

public class NegativeFluent<A extends NegativeFluent<A>>
extends io.sundr.builder.BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	NegativeFluent.AssignExpresionNested<N>
class	NegativeFluent.BinaryExpressionExpresionNested<N>
class	NegativeFluent.BitwiseAndExpresionNested<N>
class	NegativeFluent.BitwiseOrExpresionNested<N>
class	NegativeFluent.CastExpresionNested<N>
class	NegativeFluent.ConstructExpresionNested<N>
class	NegativeFluent.DeclareExpresionNested<N>
class	NegativeFluent.DivideExpresionNested<N>
class	NegativeFluent.EnclosedExpresionNested<N>
class	NegativeFluent.EqualsExpresionNested<N>
class	NegativeFluent.GreaterThanExpresionNested<N>
class	NegativeFluent.GreaterThanOrEqualExpresionNested<N>
class	NegativeFluent.IndexExpresionNested<N>
class	NegativeFluent.InstanceOfExpresionNested<N>
class	NegativeFluent.InverseExpresionNested<N>
class	NegativeFluent.LambdaExpresionNested<N>
class	NegativeFluent.LeftShiftExpresionNested<N>
class	NegativeFluent.LessThanExpresionNested<N>
class	NegativeFluent.LessThanOrEqualExpresionNested<N>
class	NegativeFluent.LogicalAndExpresionNested<N>
class	NegativeFluent.LogicalOrExpresionNested<N>
class	NegativeFluent.MethodCallExpresionNested<N>
class	NegativeFluent.MinusExpresionNested<N>
class	NegativeFluent.ModuloExpresionNested<N>
class	NegativeFluent.MultiplyExpresionNested<N>
class	NegativeFluent.NegativeExpresionNested<N>
class	NegativeFluent.NewArrayExpresionNested<N>
class	NegativeFluent.NotEqualsExpresionNested<N>
class	NegativeFluent.NotExpresionNested<N>
class	NegativeFluent.PlusExpresionNested<N>
class	NegativeFluent.PositiveExpresionNested<N>
class	NegativeFluent.PostDecrementExpresionNested<N>
class	NegativeFluent.PostIncrementExpresionNested<N>
class	NegativeFluent.PreDecrementExpresionNested<N>
class	NegativeFluent.PreIncrementExpresionNested<N>
class	NegativeFluent.PropertyRefExpresionNested<N>
class	NegativeFluent.RightShiftExpresionNested<N>
class	NegativeFluent.RightUnsignedShiftExpresionNested<N>
class	NegativeFluent.TernaryExpresionNested<N>
class	NegativeFluent.ThisExpresionNested<N>
class	NegativeFluent.ValueRefExpresionNested<N>
class	NegativeFluent.XorExpresionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
NegativeFluent()
NegativeFluent(io.sundr.model.Negative instance)

Method Summary

Modifier and Type	Method	Description
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Expression	buildExpresion()
protected void	copyInstance(io.sundr.model.Negative instance)
boolean	equals(Object o)
boolean	hasExpresion()
int	hashCode()
String	toString()
A	withExpresion(io.sundr.model.Expression expresion)
NegativeFluent.AssignExpresionNested<A>	withNewAssignExpresion()
NegativeFluent.AssignExpresionNested<A>	withNewAssignExpresionLike(io.sundr.model.Assign item)
NegativeFluent.BinaryExpressionExpresionNested<A>	withNewBinaryExpressionExpresion()
NegativeFluent.BinaryExpressionExpresionNested<A>	withNewBinaryExpressionExpresionLike(io.sundr.model.BinaryExpression item)
NegativeFluent.BitwiseAndExpresionNested<A>	withNewBitwiseAndExpresion()
A	withNewBitwiseAndExpresion(Object left, Object right)
NegativeFluent.BitwiseAndExpresionNested<A>	withNewBitwiseAndExpresionLike(io.sundr.model.BitwiseAnd item)
NegativeFluent.BitwiseOrExpresionNested<A>	withNewBitwiseOrExpresion()
A	withNewBitwiseOrExpresion(Object left, Object right)
NegativeFluent.BitwiseOrExpresionNested<A>	withNewBitwiseOrExpresionLike(io.sundr.model.BitwiseOr item)
NegativeFluent.CastExpresionNested<A>	withNewCastExpresion()
NegativeFluent.CastExpresionNested<A>	withNewCastExpresionLike(io.sundr.model.Cast item)
NegativeFluent.ConstructExpresionNested<A>	withNewConstructExpresion()
NegativeFluent.ConstructExpresionNested<A>	withNewConstructExpresionLike(io.sundr.model.Construct item)
NegativeFluent.DeclareExpresionNested<A>	withNewDeclareExpresion()
A	withNewDeclareExpresion(Class type, String name)
A	withNewDeclareExpresion(Class type, String name, Object value)
NegativeFluent.DeclareExpresionNested<A>	withNewDeclareExpresionLike(io.sundr.model.Declare item)
NegativeFluent.DivideExpresionNested<A>	withNewDivideExpresion()
A	withNewDivideExpresion(Object left, Object right)
NegativeFluent.DivideExpresionNested<A>	withNewDivideExpresionLike(io.sundr.model.Divide item)
NegativeFluent.EnclosedExpresionNested<A>	withNewEnclosedExpresion()
NegativeFluent.EnclosedExpresionNested<A>	withNewEnclosedExpresionLike(io.sundr.model.Enclosed item)
NegativeFluent.EqualsExpresionNested<A>	withNewEqualsExpresion()
A	withNewEqualsExpresion(Object left, Object right)
NegativeFluent.EqualsExpresionNested<A>	withNewEqualsExpresionLike(io.sundr.model.Equals item)
NegativeFluent.GreaterThanExpresionNested<A>	withNewGreaterThanExpresion()
A	withNewGreaterThanExpresion(Object left, Object right)
NegativeFluent.GreaterThanExpresionNested<A>	withNewGreaterThanExpresionLike(io.sundr.model.GreaterThan item)
NegativeFluent.GreaterThanOrEqualExpresionNested<A>	withNewGreaterThanOrEqualExpresion()
A	withNewGreaterThanOrEqualExpresion(Object left, Object right)
NegativeFluent.GreaterThanOrEqualExpresionNested<A>	withNewGreaterThanOrEqualExpresionLike(io.sundr.model.GreaterThanOrEqual item)
NegativeFluent.IndexExpresionNested<A>	withNewIndexExpresion()
NegativeFluent.IndexExpresionNested<A>	withNewIndexExpresionLike(io.sundr.model.Index item)
NegativeFluent.InstanceOfExpresionNested<A>	withNewInstanceOfExpresion()
NegativeFluent.InstanceOfExpresionNested<A>	withNewInstanceOfExpresionLike(io.sundr.model.InstanceOf item)
NegativeFluent.InverseExpresionNested<A>	withNewInverseExpresion()
NegativeFluent.InverseExpresionNested<A>	withNewInverseExpresionLike(io.sundr.model.Inverse item)
NegativeFluent.LambdaExpresionNested<A>	withNewLambdaExpresion()
NegativeFluent.LambdaExpresionNested<A>	withNewLambdaExpresionLike(io.sundr.model.Lambda item)
NegativeFluent.LeftShiftExpresionNested<A>	withNewLeftShiftExpresion()
A	withNewLeftShiftExpresion(Object left, Object right)
NegativeFluent.LeftShiftExpresionNested<A>	withNewLeftShiftExpresionLike(io.sundr.model.LeftShift item)
NegativeFluent.LessThanExpresionNested<A>	withNewLessThanExpresion()
A	withNewLessThanExpresion(Object left, Object right)
NegativeFluent.LessThanExpresionNested<A>	withNewLessThanExpresionLike(io.sundr.model.LessThan item)
NegativeFluent.LessThanOrEqualExpresionNested<A>	withNewLessThanOrEqualExpresion()
A	withNewLessThanOrEqualExpresion(Object left, Object right)
NegativeFluent.LessThanOrEqualExpresionNested<A>	withNewLessThanOrEqualExpresionLike(io.sundr.model.LessThanOrEqual item)
NegativeFluent.LogicalAndExpresionNested<A>	withNewLogicalAndExpresion()
A	withNewLogicalAndExpresion(Object left, Object right)
NegativeFluent.LogicalAndExpresionNested<A>	withNewLogicalAndExpresionLike(io.sundr.model.LogicalAnd item)
NegativeFluent.LogicalOrExpresionNested<A>	withNewLogicalOrExpresion()
A	withNewLogicalOrExpresion(Object left, Object right)
NegativeFluent.LogicalOrExpresionNested<A>	withNewLogicalOrExpresionLike(io.sundr.model.LogicalOr item)
NegativeFluent.MethodCallExpresionNested<A>	withNewMethodCallExpresion()
NegativeFluent.MethodCallExpresionNested<A>	withNewMethodCallExpresionLike(io.sundr.model.MethodCall item)
NegativeFluent.MinusExpresionNested<A>	withNewMinusExpresion()
A	withNewMinusExpresion(Object left, Object right)
NegativeFluent.MinusExpresionNested<A>	withNewMinusExpresionLike(io.sundr.model.Minus item)
NegativeFluent.ModuloExpresionNested<A>	withNewModuloExpresion()
A	withNewModuloExpresion(Object left, Object right)
NegativeFluent.ModuloExpresionNested<A>	withNewModuloExpresionLike(io.sundr.model.Modulo item)
NegativeFluent.MultiplyExpresionNested<A>	withNewMultiplyExpresion()
A	withNewMultiplyExpresion(Object left, Object right)
NegativeFluent.MultiplyExpresionNested<A>	withNewMultiplyExpresionLike(io.sundr.model.Multiply item)
NegativeFluent.NegativeExpresionNested<A>	withNewNegativeExpresion()
NegativeFluent.NegativeExpresionNested<A>	withNewNegativeExpresionLike(io.sundr.model.Negative item)
NegativeFluent.NewArrayExpresionNested<A>	withNewNewArrayExpresion()
A	withNewNewArrayExpresion(Class type, Integer[] sizes)
NegativeFluent.NewArrayExpresionNested<A>	withNewNewArrayExpresionLike(io.sundr.model.NewArray item)
NegativeFluent.NotEqualsExpresionNested<A>	withNewNotEqualsExpresion()
A	withNewNotEqualsExpresion(Object left, Object right)
NegativeFluent.NotEqualsExpresionNested<A>	withNewNotEqualsExpresionLike(io.sundr.model.NotEquals item)
NegativeFluent.NotExpresionNested<A>	withNewNotExpresion()
NegativeFluent.NotExpresionNested<A>	withNewNotExpresionLike(io.sundr.model.Not item)
NegativeFluent.PlusExpresionNested<A>	withNewPlusExpresion()
A	withNewPlusExpresion(Object left, Object right)
NegativeFluent.PlusExpresionNested<A>	withNewPlusExpresionLike(io.sundr.model.Plus item)
NegativeFluent.PositiveExpresionNested<A>	withNewPositiveExpresion()
NegativeFluent.PositiveExpresionNested<A>	withNewPositiveExpresionLike(io.sundr.model.Positive item)
NegativeFluent.PostDecrementExpresionNested<A>	withNewPostDecrementExpresion()
NegativeFluent.PostDecrementExpresionNested<A>	withNewPostDecrementExpresionLike(io.sundr.model.PostDecrement item)
NegativeFluent.PostIncrementExpresionNested<A>	withNewPostIncrementExpresion()
NegativeFluent.PostIncrementExpresionNested<A>	withNewPostIncrementExpresionLike(io.sundr.model.PostIncrement item)
NegativeFluent.PreDecrementExpresionNested<A>	withNewPreDecrementExpresion()
NegativeFluent.PreDecrementExpresionNested<A>	withNewPreDecrementExpresionLike(io.sundr.model.PreDecrement item)
NegativeFluent.PreIncrementExpresionNested<A>	withNewPreIncrementExpresion()
NegativeFluent.PreIncrementExpresionNested<A>	withNewPreIncrementExpresionLike(io.sundr.model.PreIncrement item)
NegativeFluent.PropertyRefExpresionNested<A>	withNewPropertyRefExpresion()
NegativeFluent.PropertyRefExpresionNested<A>	withNewPropertyRefExpresionLike(io.sundr.model.PropertyRef item)
NegativeFluent.RightShiftExpresionNested<A>	withNewRightShiftExpresion()
A	withNewRightShiftExpresion(Object left, Object right)
NegativeFluent.RightShiftExpresionNested<A>	withNewRightShiftExpresionLike(io.sundr.model.RightShift item)
NegativeFluent.RightUnsignedShiftExpresionNested<A>	withNewRightUnsignedShiftExpresion()
A	withNewRightUnsignedShiftExpresion(Object left, Object right)
NegativeFluent.RightUnsignedShiftExpresionNested<A>	withNewRightUnsignedShiftExpresionLike(io.sundr.model.RightUnsignedShift item)
NegativeFluent.TernaryExpresionNested<A>	withNewTernaryExpresion()
NegativeFluent.TernaryExpresionNested<A>	withNewTernaryExpresionLike(io.sundr.model.Ternary item)
NegativeFluent.ThisExpresionNested<A>	withNewThisExpresion()
NegativeFluent.ThisExpresionNested<A>	withNewThisExpresionLike(io.sundr.model.This item)
NegativeFluent.ValueRefExpresionNested<A>	withNewValueRefExpresion()
A	withNewValueRefExpresion(Object value)
NegativeFluent.ValueRefExpresionNested<A>	withNewValueRefExpresionLike(io.sundr.model.ValueRef item)
NegativeFluent.XorExpresionNested<A>	withNewXorExpresion()
A	withNewXorExpresion(Object left, Object right)
NegativeFluent.XorExpresionNested<A>	withNewXorExpresionLike(io.sundr.model.Xor item)

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

NegativeFluent

public NegativeFluent()

NegativeFluent

public NegativeFluent(io.sundr.model.Negative instance)

Method Detail

copyInstance

protected void copyInstance(io.sundr.model.Negative instance)

buildExpresion

public io.sundr.model.Expression buildExpresion()

withExpresion

public A withExpresion(io.sundr.model.Expression expresion)

hasExpresion

public boolean hasExpresion()

withNewMultiplyExpresion

public NegativeFluent.MultiplyExpresionNested<A> withNewMultiplyExpresion()

withNewMultiplyExpresionLike

public NegativeFluent.MultiplyExpresionNested<A> withNewMultiplyExpresionLike(io.sundr.model.Multiply item)

withNewMultiplyExpresion

public A withNewMultiplyExpresion(Object left,
                                  Object right)

withNewNewArrayExpresion

public NegativeFluent.NewArrayExpresionNested<A> withNewNewArrayExpresion()

withNewNewArrayExpresionLike

public NegativeFluent.NewArrayExpresionNested<A> withNewNewArrayExpresionLike(io.sundr.model.NewArray item)

withNewNewArrayExpresion

public A withNewNewArrayExpresion(Class type,
                                  Integer[] sizes)

withNewInstanceOfExpresion

public NegativeFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresion()

withNewInstanceOfExpresionLike

public NegativeFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresionLike(io.sundr.model.InstanceOf item)

withNewMethodCallExpresion

public NegativeFluent.MethodCallExpresionNested<A> withNewMethodCallExpresion()

withNewMethodCallExpresionLike

public NegativeFluent.MethodCallExpresionNested<A> withNewMethodCallExpresionLike(io.sundr.model.MethodCall item)

withNewInverseExpresion

public NegativeFluent.InverseExpresionNested<A> withNewInverseExpresion()

withNewInverseExpresionLike

public NegativeFluent.InverseExpresionNested<A> withNewInverseExpresionLike(io.sundr.model.Inverse item)

withNewIndexExpresion

public NegativeFluent.IndexExpresionNested<A> withNewIndexExpresion()

withNewIndexExpresionLike

public NegativeFluent.IndexExpresionNested<A> withNewIndexExpresionLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualExpresion

public NegativeFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresion()

withNewGreaterThanOrEqualExpresionLike

public NegativeFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresionLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualExpresion

public A withNewGreaterThanOrEqualExpresion(Object left,
                                            Object right)

withNewBitwiseAndExpresion

public NegativeFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresion()

withNewBitwiseAndExpresionLike

public NegativeFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresionLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndExpresion

public A withNewBitwiseAndExpresion(Object left,
                                    Object right)

withNewMinusExpresion

public NegativeFluent.MinusExpresionNested<A> withNewMinusExpresion()

withNewMinusExpresionLike

public NegativeFluent.MinusExpresionNested<A> withNewMinusExpresionLike(io.sundr.model.Minus item)

withNewMinusExpresion

public A withNewMinusExpresion(Object left,
                               Object right)

withNewLogicalOrExpresion

public NegativeFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresion()

withNewLogicalOrExpresionLike

public NegativeFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresionLike(io.sundr.model.LogicalOr item)

withNewLogicalOrExpresion

public A withNewLogicalOrExpresion(Object left,
                                   Object right)

withNewNotEqualsExpresion

public NegativeFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresion()

withNewNotEqualsExpresionLike

public NegativeFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresionLike(io.sundr.model.NotEquals item)

withNewNotEqualsExpresion

public A withNewNotEqualsExpresion(Object left,
                                   Object right)

withNewDivideExpresion

public NegativeFluent.DivideExpresionNested<A> withNewDivideExpresion()

withNewDivideExpresionLike

public NegativeFluent.DivideExpresionNested<A> withNewDivideExpresionLike(io.sundr.model.Divide item)

withNewDivideExpresion

public A withNewDivideExpresion(Object left,
                                Object right)

withNewLessThanExpresion

public NegativeFluent.LessThanExpresionNested<A> withNewLessThanExpresion()

withNewLessThanExpresionLike

public NegativeFluent.LessThanExpresionNested<A> withNewLessThanExpresionLike(io.sundr.model.LessThan item)

withNewLessThanExpresion

public A withNewLessThanExpresion(Object left,
                                  Object right)

withNewBitwiseOrExpresion

public NegativeFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresion()

withNewBitwiseOrExpresionLike

public NegativeFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresionLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrExpresion

public A withNewBitwiseOrExpresion(Object left,
                                   Object right)

withNewPropertyRefExpresion

public NegativeFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresion()

withNewPropertyRefExpresionLike

public NegativeFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresionLike(io.sundr.model.PropertyRef item)

withNewRightShiftExpresion

public NegativeFluent.RightShiftExpresionNested<A> withNewRightShiftExpresion()

withNewRightShiftExpresionLike

public NegativeFluent.RightShiftExpresionNested<A> withNewRightShiftExpresionLike(io.sundr.model.RightShift item)

withNewRightShiftExpresion

public A withNewRightShiftExpresion(Object left,
                                    Object right)

withNewGreaterThanExpresion

public NegativeFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresion()

withNewGreaterThanExpresionLike

public NegativeFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresionLike(io.sundr.model.GreaterThan item)

withNewGreaterThanExpresion

public A withNewGreaterThanExpresion(Object left,
                                     Object right)

withNewDeclareExpresion

public NegativeFluent.DeclareExpresionNested<A> withNewDeclareExpresion()

withNewDeclareExpresionLike

public NegativeFluent.DeclareExpresionNested<A> withNewDeclareExpresionLike(io.sundr.model.Declare item)

withNewDeclareExpresion

public A withNewDeclareExpresion(Class type,
                                 String name)

withNewDeclareExpresion

public A withNewDeclareExpresion(Class type,
                                 String name,
                                 Object value)

withNewCastExpresion

public NegativeFluent.CastExpresionNested<A> withNewCastExpresion()

withNewCastExpresionLike

public NegativeFluent.CastExpresionNested<A> withNewCastExpresionLike(io.sundr.model.Cast item)

withNewModuloExpresion

public NegativeFluent.ModuloExpresionNested<A> withNewModuloExpresion()

withNewModuloExpresionLike

public NegativeFluent.ModuloExpresionNested<A> withNewModuloExpresionLike(io.sundr.model.Modulo item)

withNewModuloExpresion

public A withNewModuloExpresion(Object left,
                                Object right)

withNewValueRefExpresion

public NegativeFluent.ValueRefExpresionNested<A> withNewValueRefExpresion()

withNewValueRefExpresionLike

public NegativeFluent.ValueRefExpresionNested<A> withNewValueRefExpresionLike(io.sundr.model.ValueRef item)

withNewValueRefExpresion

public A withNewValueRefExpresion(Object value)

withNewLeftShiftExpresion

public NegativeFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresion()

withNewLeftShiftExpresionLike

public NegativeFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresionLike(io.sundr.model.LeftShift item)

withNewLeftShiftExpresion

public A withNewLeftShiftExpresion(Object left,
                                   Object right)

withNewTernaryExpresion

public NegativeFluent.TernaryExpresionNested<A> withNewTernaryExpresion()

withNewTernaryExpresionLike

public NegativeFluent.TernaryExpresionNested<A> withNewTernaryExpresionLike(io.sundr.model.Ternary item)

withNewBinaryExpressionExpresion

public NegativeFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresion()

withNewBinaryExpressionExpresionLike

public NegativeFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresionLike(io.sundr.model.BinaryExpression item)

withNewEqualsExpresion

public NegativeFluent.EqualsExpresionNested<A> withNewEqualsExpresion()

withNewEqualsExpresionLike

public NegativeFluent.EqualsExpresionNested<A> withNewEqualsExpresionLike(io.sundr.model.Equals item)

withNewEqualsExpresion

public A withNewEqualsExpresion(Object left,
                                Object right)

withNewEnclosedExpresion

public NegativeFluent.EnclosedExpresionNested<A> withNewEnclosedExpresion()

withNewEnclosedExpresionLike

public NegativeFluent.EnclosedExpresionNested<A> withNewEnclosedExpresionLike(io.sundr.model.Enclosed item)

withNewPreDecrementExpresion

public NegativeFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresion()

withNewPreDecrementExpresionLike

public NegativeFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresionLike(io.sundr.model.PreDecrement item)

withNewPostDecrementExpresion

public NegativeFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresion()

withNewPostDecrementExpresionLike

public NegativeFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresionLike(io.sundr.model.PostDecrement item)

withNewLambdaExpresion

public NegativeFluent.LambdaExpresionNested<A> withNewLambdaExpresion()

withNewLambdaExpresionLike

public NegativeFluent.LambdaExpresionNested<A> withNewLambdaExpresionLike(io.sundr.model.Lambda item)

withNewNotExpresion

public NegativeFluent.NotExpresionNested<A> withNewNotExpresion()

withNewNotExpresionLike

public NegativeFluent.NotExpresionNested<A> withNewNotExpresionLike(io.sundr.model.Not item)

withNewAssignExpresion

public NegativeFluent.AssignExpresionNested<A> withNewAssignExpresion()

withNewAssignExpresionLike

public NegativeFluent.AssignExpresionNested<A> withNewAssignExpresionLike(io.sundr.model.Assign item)

withNewNegativeExpresion

public NegativeFluent.NegativeExpresionNested<A> withNewNegativeExpresion()

withNewNegativeExpresionLike

public NegativeFluent.NegativeExpresionNested<A> withNewNegativeExpresionLike(io.sundr.model.Negative item)

withNewThisExpresion

public NegativeFluent.ThisExpresionNested<A> withNewThisExpresion()

withNewThisExpresionLike

public NegativeFluent.ThisExpresionNested<A> withNewThisExpresionLike(io.sundr.model.This item)

withNewLogicalAndExpresion

public NegativeFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresion()

withNewLogicalAndExpresionLike

public NegativeFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresionLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndExpresion

public A withNewLogicalAndExpresion(Object left,
                                    Object right)

withNewPostIncrementExpresion

public NegativeFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresion()

withNewPostIncrementExpresionLike

public NegativeFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresionLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftExpresion

public NegativeFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresion()

withNewRightUnsignedShiftExpresionLike

public NegativeFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresionLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftExpresion

public A withNewRightUnsignedShiftExpresion(Object left,
                                            Object right)

withNewPlusExpresion

public NegativeFluent.PlusExpresionNested<A> withNewPlusExpresion()

withNewPlusExpresionLike

public NegativeFluent.PlusExpresionNested<A> withNewPlusExpresionLike(io.sundr.model.Plus item)

withNewPlusExpresion

public A withNewPlusExpresion(Object left,
                              Object right)

withNewConstructExpresion

public NegativeFluent.ConstructExpresionNested<A> withNewConstructExpresion()

withNewConstructExpresionLike

public NegativeFluent.ConstructExpresionNested<A> withNewConstructExpresionLike(io.sundr.model.Construct item)

withNewXorExpresion

public NegativeFluent.XorExpresionNested<A> withNewXorExpresion()

withNewXorExpresionLike

public NegativeFluent.XorExpresionNested<A> withNewXorExpresionLike(io.sundr.model.Xor item)

withNewXorExpresion

public A withNewXorExpresion(Object left,
                             Object right)

withNewPreIncrementExpresion

public NegativeFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresion()

withNewPreIncrementExpresionLike

public NegativeFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresionLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualExpresion

public NegativeFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresion()

withNewLessThanOrEqualExpresionLike

public NegativeFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresionLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualExpresion

public A withNewLessThanOrEqualExpresion(Object left,
                                         Object right)

withNewPositiveExpresion

public NegativeFluent.PositiveExpresionNested<A> withNewPositiveExpresion()

withNewPositiveExpresionLike

public NegativeFluent.PositiveExpresionNested<A> withNewPositiveExpresionLike(io.sundr.model.Positive item)

equals

public boolean equals(Object o)

Overrides:

equals in class io.sundr.builder.BaseFluent<A extends NegativeFluent<A>>

hashCode

public int hashCode()

Overrides:

hashCode in class io.sundr.builder.BaseFluent<A extends NegativeFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

builder

protected static <T> io.sundr.builder.VisitableBuilder<T,?> builder(Object item)