Package io.sundr.model

Class NotFluent<A extends NotFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.NotFluent<A>

Direct Known Subclasses:

AssignFluent.NotTargetNested, AssignFluent.NotValueNested, BinaryExpressionFluent.NotLeftNested, BinaryExpressionFluent.NotRightNested, CastFluent.NotExpressionNested, ConstructFluent.NotArgumentsNested, DoFluent.NotConditionNested, EnclosedFluent.NotExpresionNested, ForeachFluent.NotExpressionNested, ForFluent.NotCompareNested, ForFluent.NotInitNested, ForFluent.NotUpdateNested, IfFluent.NotConditionNested, IndexFluent.NotExpressionNested, IndexFluent.NotScopeNested, InstanceOfFluent.NotExpressionNested, InverseFluent.NotExpresionNested, MethodCallFluent.NotArgumentsNested, MethodCallFluent.NotScopeNested, NegativeFluent.NotExpresionNested, NewArrayFluent.NotExpressionsNested, NotBuilder, NotFluent.NotExpresionNested, PositiveFluent.NotExpresionNested, PostDecrementFluent.NotExpressionNested, PostIncrementFluent.NotExpressionNested, PreDecrementFluent.NotExpressionNested, PreIncrementFluent.NotExpressionNested, PropertyRefFluent.NotScopeNested, ReturnFluent.NotExpressionNested, SwitchFluent.NotExpressionNested, TernaryFluent.NotAlternativeNested, TernaryFluent.NotConditionNested, TernaryFluent.NotResultNested, WhileFluent.NotConditionNested

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

Generated

Nested Class Summary

Nested Classes

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

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

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

NotFluent

public NotFluent()

NotFluent

public NotFluent(io.sundr.model.Not instance)

Method Detail

copyInstance

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

buildExpresion

public io.sundr.model.Expression buildExpresion()

withExpresion

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

hasExpresion

public boolean hasExpresion()

withNewMultiplyExpresion

public NotFluent.MultiplyExpresionNested<A> withNewMultiplyExpresion()

withNewMultiplyExpresionLike

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

withNewMultiplyExpresion

public A withNewMultiplyExpresion(Object left,
                                  Object right)

withNewNewArrayExpresion

public NotFluent.NewArrayExpresionNested<A> withNewNewArrayExpresion()

withNewNewArrayExpresionLike

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

withNewNewArrayExpresion

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

withNewInstanceOfExpresion

public NotFluent.InstanceOfExpresionNested<A> withNewInstanceOfExpresion()

withNewInstanceOfExpresionLike

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

withNewMethodCallExpresion

public NotFluent.MethodCallExpresionNested<A> withNewMethodCallExpresion()

withNewMethodCallExpresionLike

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

withNewInverseExpresion

public NotFluent.InverseExpresionNested<A> withNewInverseExpresion()

withNewInverseExpresionLike

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

withNewIndexExpresion

public NotFluent.IndexExpresionNested<A> withNewIndexExpresion()

withNewIndexExpresionLike

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

withNewGreaterThanOrEqualExpresion

public NotFluent.GreaterThanOrEqualExpresionNested<A> withNewGreaterThanOrEqualExpresion()

withNewGreaterThanOrEqualExpresionLike

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

withNewGreaterThanOrEqualExpresion

public A withNewGreaterThanOrEqualExpresion(Object left,
                                            Object right)

withNewBitwiseAndExpresion

public NotFluent.BitwiseAndExpresionNested<A> withNewBitwiseAndExpresion()

withNewBitwiseAndExpresionLike

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

withNewBitwiseAndExpresion

public A withNewBitwiseAndExpresion(Object left,
                                    Object right)

withNewMinusExpresion

public NotFluent.MinusExpresionNested<A> withNewMinusExpresion()

withNewMinusExpresionLike

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

withNewMinusExpresion

public A withNewMinusExpresion(Object left,
                               Object right)

withNewLogicalOrExpresion

public NotFluent.LogicalOrExpresionNested<A> withNewLogicalOrExpresion()

withNewLogicalOrExpresionLike

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

withNewLogicalOrExpresion

public A withNewLogicalOrExpresion(Object left,
                                   Object right)

withNewNotEqualsExpresion

public NotFluent.NotEqualsExpresionNested<A> withNewNotEqualsExpresion()

withNewNotEqualsExpresionLike

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

withNewNotEqualsExpresion

public A withNewNotEqualsExpresion(Object left,
                                   Object right)

withNewDivideExpresion

public NotFluent.DivideExpresionNested<A> withNewDivideExpresion()

withNewDivideExpresionLike

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

withNewDivideExpresion

public A withNewDivideExpresion(Object left,
                                Object right)

withNewLessThanExpresion

public NotFluent.LessThanExpresionNested<A> withNewLessThanExpresion()

withNewLessThanExpresionLike

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

withNewLessThanExpresion

public A withNewLessThanExpresion(Object left,
                                  Object right)

withNewBitwiseOrExpresion

public NotFluent.BitwiseOrExpresionNested<A> withNewBitwiseOrExpresion()

withNewBitwiseOrExpresionLike

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

withNewBitwiseOrExpresion

public A withNewBitwiseOrExpresion(Object left,
                                   Object right)

withNewPropertyRefExpresion

public NotFluent.PropertyRefExpresionNested<A> withNewPropertyRefExpresion()

withNewPropertyRefExpresionLike

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

withNewRightShiftExpresion

public NotFluent.RightShiftExpresionNested<A> withNewRightShiftExpresion()

withNewRightShiftExpresionLike

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

withNewRightShiftExpresion

public A withNewRightShiftExpresion(Object left,
                                    Object right)

withNewGreaterThanExpresion

public NotFluent.GreaterThanExpresionNested<A> withNewGreaterThanExpresion()

withNewGreaterThanExpresionLike

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

withNewGreaterThanExpresion

public A withNewGreaterThanExpresion(Object left,
                                     Object right)

withNewDeclareExpresion

public NotFluent.DeclareExpresionNested<A> withNewDeclareExpresion()

withNewDeclareExpresionLike

public NotFluent.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 NotFluent.CastExpresionNested<A> withNewCastExpresion()

withNewCastExpresionLike

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

withNewModuloExpresion

public NotFluent.ModuloExpresionNested<A> withNewModuloExpresion()

withNewModuloExpresionLike

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

withNewModuloExpresion

public A withNewModuloExpresion(Object left,
                                Object right)

withNewValueRefExpresion

public NotFluent.ValueRefExpresionNested<A> withNewValueRefExpresion()

withNewValueRefExpresionLike

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

withNewValueRefExpresion

public A withNewValueRefExpresion(Object value)

withNewLeftShiftExpresion

public NotFluent.LeftShiftExpresionNested<A> withNewLeftShiftExpresion()

withNewLeftShiftExpresionLike

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

withNewLeftShiftExpresion

public A withNewLeftShiftExpresion(Object left,
                                   Object right)

withNewTernaryExpresion

public NotFluent.TernaryExpresionNested<A> withNewTernaryExpresion()

withNewTernaryExpresionLike

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

withNewBinaryExpressionExpresion

public NotFluent.BinaryExpressionExpresionNested<A> withNewBinaryExpressionExpresion()

withNewBinaryExpressionExpresionLike

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

withNewEqualsExpresion

public NotFluent.EqualsExpresionNested<A> withNewEqualsExpresion()

withNewEqualsExpresionLike

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

withNewEqualsExpresion

public A withNewEqualsExpresion(Object left,
                                Object right)

withNewEnclosedExpresion

public NotFluent.EnclosedExpresionNested<A> withNewEnclosedExpresion()

withNewEnclosedExpresionLike

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

withNewPreDecrementExpresion

public NotFluent.PreDecrementExpresionNested<A> withNewPreDecrementExpresion()

withNewPreDecrementExpresionLike

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

withNewPostDecrementExpresion

public NotFluent.PostDecrementExpresionNested<A> withNewPostDecrementExpresion()

withNewPostDecrementExpresionLike

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

withNewLambdaExpresion

public NotFluent.LambdaExpresionNested<A> withNewLambdaExpresion()

withNewLambdaExpresionLike

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

withNewNotExpresion

public NotFluent.NotExpresionNested<A> withNewNotExpresion()

withNewNotExpresionLike

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

withNewAssignExpresion

public NotFluent.AssignExpresionNested<A> withNewAssignExpresion()

withNewAssignExpresionLike

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

withNewNegativeExpresion

public NotFluent.NegativeExpresionNested<A> withNewNegativeExpresion()

withNewNegativeExpresionLike

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

withNewThisExpresion

public NotFluent.ThisExpresionNested<A> withNewThisExpresion()

withNewThisExpresionLike

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

withNewLogicalAndExpresion

public NotFluent.LogicalAndExpresionNested<A> withNewLogicalAndExpresion()

withNewLogicalAndExpresionLike

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

withNewLogicalAndExpresion

public A withNewLogicalAndExpresion(Object left,
                                    Object right)

withNewPostIncrementExpresion

public NotFluent.PostIncrementExpresionNested<A> withNewPostIncrementExpresion()

withNewPostIncrementExpresionLike

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

withNewRightUnsignedShiftExpresion

public NotFluent.RightUnsignedShiftExpresionNested<A> withNewRightUnsignedShiftExpresion()

withNewRightUnsignedShiftExpresionLike

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

withNewRightUnsignedShiftExpresion

public A withNewRightUnsignedShiftExpresion(Object left,
                                            Object right)

withNewPlusExpresion

public NotFluent.PlusExpresionNested<A> withNewPlusExpresion()

withNewPlusExpresionLike

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

withNewPlusExpresion

public A withNewPlusExpresion(Object left,
                              Object right)

withNewConstructExpresion

public NotFluent.ConstructExpresionNested<A> withNewConstructExpresion()

withNewConstructExpresionLike

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

withNewXorExpresion

public NotFluent.XorExpresionNested<A> withNewXorExpresion()

withNewXorExpresionLike

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

withNewXorExpresion

public A withNewXorExpresion(Object left,
                             Object right)

withNewPreIncrementExpresion

public NotFluent.PreIncrementExpresionNested<A> withNewPreIncrementExpresion()

withNewPreIncrementExpresionLike

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

withNewLessThanOrEqualExpresion

public NotFluent.LessThanOrEqualExpresionNested<A> withNewLessThanOrEqualExpresion()

withNewLessThanOrEqualExpresionLike

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

withNewLessThanOrEqualExpresion

public A withNewLessThanOrEqualExpresion(Object left,
                                         Object right)

withNewPositiveExpresion

public NotFluent.PositiveExpresionNested<A> withNewPositiveExpresion()

withNewPositiveExpresionLike

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

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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