Package io.sundr.model

Class TernaryFluent<A extends TernaryFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.TernaryFluent<A>

Direct Known Subclasses:

AssignFluent.TernaryTargetNested, AssignFluent.TernaryValueNested, BinaryExpressionFluent.TernaryLeftNested, BinaryExpressionFluent.TernaryRightNested, CastFluent.TernaryExpressionNested, ConstructFluent.TernaryArgumentsNested, DoFluent.TernaryConditionNested, EnclosedFluent.TernaryExpresionNested, ForeachFluent.TernaryExpressionNested, ForFluent.TernaryCompareNested, ForFluent.TernaryInitNested, ForFluent.TernaryUpdateNested, IfFluent.TernaryConditionNested, IndexFluent.TernaryExpressionNested, IndexFluent.TernaryScopeNested, InstanceOfFluent.TernaryExpressionNested, InverseFluent.TernaryExpresionNested, MethodCallFluent.TernaryArgumentsNested, MethodCallFluent.TernaryScopeNested, NegativeFluent.TernaryExpresionNested, NewArrayFluent.TernaryExpressionsNested, NotFluent.TernaryExpresionNested, PositiveFluent.TernaryExpresionNested, PostDecrementFluent.TernaryExpressionNested, PostIncrementFluent.TernaryExpressionNested, PreDecrementFluent.TernaryExpressionNested, PreIncrementFluent.TernaryExpressionNested, PropertyRefFluent.TernaryScopeNested, ReturnFluent.TernaryExpressionNested, SwitchFluent.TernaryExpressionNested, TernaryBuilder, TernaryFluent.TernaryAlternativeNested, TernaryFluent.TernaryConditionNested, TernaryFluent.TernaryResultNested, WhileFluent.TernaryConditionNested

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

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	TernaryFluent.AssignAlternativeNested<N>
class	TernaryFluent.AssignConditionNested<N>
class	TernaryFluent.AssignResultNested<N>
class	TernaryFluent.BinaryExpressionAlternativeNested<N>
class	TernaryFluent.BinaryExpressionConditionNested<N>
class	TernaryFluent.BinaryExpressionResultNested<N>
class	TernaryFluent.BitwiseAndAlternativeNested<N>
class	TernaryFluent.BitwiseAndConditionNested<N>
class	TernaryFluent.BitwiseAndResultNested<N>
class	TernaryFluent.BitwiseOrAlternativeNested<N>
class	TernaryFluent.BitwiseOrConditionNested<N>
class	TernaryFluent.BitwiseOrResultNested<N>
class	TernaryFluent.CastAlternativeNested<N>
class	TernaryFluent.CastConditionNested<N>
class	TernaryFluent.CastResultNested<N>
class	TernaryFluent.ConstructAlternativeNested<N>
class	TernaryFluent.ConstructConditionNested<N>
class	TernaryFluent.ConstructResultNested<N>
class	TernaryFluent.DeclareAlternativeNested<N>
class	TernaryFluent.DeclareConditionNested<N>
class	TernaryFluent.DeclareResultNested<N>
class	TernaryFluent.DivideAlternativeNested<N>
class	TernaryFluent.DivideConditionNested<N>
class	TernaryFluent.DivideResultNested<N>
class	TernaryFluent.EnclosedAlternativeNested<N>
class	TernaryFluent.EnclosedConditionNested<N>
class	TernaryFluent.EnclosedResultNested<N>
class	TernaryFluent.EqualsAlternativeNested<N>
class	TernaryFluent.EqualsConditionNested<N>
class	TernaryFluent.EqualsResultNested<N>
class	TernaryFluent.GreaterThanAlternativeNested<N>
class	TernaryFluent.GreaterThanConditionNested<N>
class	TernaryFluent.GreaterThanOrEqualAlternativeNested<N>
class	TernaryFluent.GreaterThanOrEqualConditionNested<N>
class	TernaryFluent.GreaterThanOrEqualResultNested<N>
class	TernaryFluent.GreaterThanResultNested<N>
class	TernaryFluent.IndexAlternativeNested<N>
class	TernaryFluent.IndexConditionNested<N>
class	TernaryFluent.IndexResultNested<N>
class	TernaryFluent.InstanceOfAlternativeNested<N>
class	TernaryFluent.InstanceOfConditionNested<N>
class	TernaryFluent.InstanceOfResultNested<N>
class	TernaryFluent.InverseAlternativeNested<N>
class	TernaryFluent.InverseConditionNested<N>
class	TernaryFluent.InverseResultNested<N>
class	TernaryFluent.LambdaAlternativeNested<N>
class	TernaryFluent.LambdaConditionNested<N>
class	TernaryFluent.LambdaResultNested<N>
class	TernaryFluent.LeftShiftAlternativeNested<N>
class	TernaryFluent.LeftShiftConditionNested<N>
class	TernaryFluent.LeftShiftResultNested<N>
class	TernaryFluent.LessThanAlternativeNested<N>
class	TernaryFluent.LessThanConditionNested<N>
class	TernaryFluent.LessThanOrEqualAlternativeNested<N>
class	TernaryFluent.LessThanOrEqualConditionNested<N>
class	TernaryFluent.LessThanOrEqualResultNested<N>
class	TernaryFluent.LessThanResultNested<N>
class	TernaryFluent.LogicalAndAlternativeNested<N>
class	TernaryFluent.LogicalAndConditionNested<N>
class	TernaryFluent.LogicalAndResultNested<N>
class	TernaryFluent.LogicalOrAlternativeNested<N>
class	TernaryFluent.LogicalOrConditionNested<N>
class	TernaryFluent.LogicalOrResultNested<N>
class	TernaryFluent.MethodCallAlternativeNested<N>
class	TernaryFluent.MethodCallConditionNested<N>
class	TernaryFluent.MethodCallResultNested<N>
class	TernaryFluent.MinusAlternativeNested<N>
class	TernaryFluent.MinusConditionNested<N>
class	TernaryFluent.MinusResultNested<N>
class	TernaryFluent.ModuloAlternativeNested<N>
class	TernaryFluent.ModuloConditionNested<N>
class	TernaryFluent.ModuloResultNested<N>
class	TernaryFluent.MultiplyAlternativeNested<N>
class	TernaryFluent.MultiplyConditionNested<N>
class	TernaryFluent.MultiplyResultNested<N>
class	TernaryFluent.NegativeAlternativeNested<N>
class	TernaryFluent.NegativeConditionNested<N>
class	TernaryFluent.NegativeResultNested<N>
class	TernaryFluent.NewArrayAlternativeNested<N>
class	TernaryFluent.NewArrayConditionNested<N>
class	TernaryFluent.NewArrayResultNested<N>
class	TernaryFluent.NotAlternativeNested<N>
class	TernaryFluent.NotConditionNested<N>
class	TernaryFluent.NotEqualsAlternativeNested<N>
class	TernaryFluent.NotEqualsConditionNested<N>
class	TernaryFluent.NotEqualsResultNested<N>
class	TernaryFluent.NotResultNested<N>
class	TernaryFluent.PlusAlternativeNested<N>
class	TernaryFluent.PlusConditionNested<N>
class	TernaryFluent.PlusResultNested<N>
class	TernaryFluent.PositiveAlternativeNested<N>
class	TernaryFluent.PositiveConditionNested<N>
class	TernaryFluent.PositiveResultNested<N>
class	TernaryFluent.PostDecrementAlternativeNested<N>
class	TernaryFluent.PostDecrementConditionNested<N>
class	TernaryFluent.PostDecrementResultNested<N>
class	TernaryFluent.PostIncrementAlternativeNested<N>
class	TernaryFluent.PostIncrementConditionNested<N>
class	TernaryFluent.PostIncrementResultNested<N>
class	TernaryFluent.PreDecrementAlternativeNested<N>
class	TernaryFluent.PreDecrementConditionNested<N>
class	TernaryFluent.PreDecrementResultNested<N>
class	TernaryFluent.PreIncrementAlternativeNested<N>
class	TernaryFluent.PreIncrementConditionNested<N>
class	TernaryFluent.PreIncrementResultNested<N>
class	TernaryFluent.PropertyRefAlternativeNested<N>
class	TernaryFluent.PropertyRefConditionNested<N>
class	TernaryFluent.PropertyRefResultNested<N>
class	TernaryFluent.RightShiftAlternativeNested<N>
class	TernaryFluent.RightShiftConditionNested<N>
class	TernaryFluent.RightShiftResultNested<N>
class	TernaryFluent.RightUnsignedShiftAlternativeNested<N>
class	TernaryFluent.RightUnsignedShiftConditionNested<N>
class	TernaryFluent.RightUnsignedShiftResultNested<N>
class	TernaryFluent.TernaryAlternativeNested<N>
class	TernaryFluent.TernaryConditionNested<N>
class	TernaryFluent.TernaryResultNested<N>
class	TernaryFluent.ThisAlternativeNested<N>
class	TernaryFluent.ThisConditionNested<N>
class	TernaryFluent.ThisResultNested<N>
class	TernaryFluent.ValueRefAlternativeNested<N>
class	TernaryFluent.ValueRefConditionNested<N>
class	TernaryFluent.ValueRefResultNested<N>
class	TernaryFluent.XorAlternativeNested<N>
class	TernaryFluent.XorConditionNested<N>
class	TernaryFluent.XorResultNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
TernaryFluent()
TernaryFluent(io.sundr.model.Ternary instance)

Method Summary

Modifier and Type	Method	Description
io.sundr.model.Expression	buildAlternative()
io.sundr.model.Expression	buildCondition()
protected static <T> io.sundr.builder.VisitableBuilder<T,?>	builder(Object item)
io.sundr.model.Expression	buildResult()
protected void	copyInstance(io.sundr.model.Ternary instance)
boolean	equals(Object o)
boolean	hasAlternative()
boolean	hasCondition()
int	hashCode()
boolean	hasResult()
String	toString()
A	withAlternative(io.sundr.model.Expression alternative)
A	withCondition(io.sundr.model.Expression condition)
TernaryFluent.AssignAlternativeNested<A>	withNewAssignAlternative()
TernaryFluent.AssignAlternativeNested<A>	withNewAssignAlternativeLike(io.sundr.model.Assign item)
TernaryFluent.AssignConditionNested<A>	withNewAssignCondition()
TernaryFluent.AssignConditionNested<A>	withNewAssignConditionLike(io.sundr.model.Assign item)
TernaryFluent.AssignResultNested<A>	withNewAssignResult()
TernaryFluent.AssignResultNested<A>	withNewAssignResultLike(io.sundr.model.Assign item)
TernaryFluent.BinaryExpressionAlternativeNested<A>	withNewBinaryExpressionAlternative()
TernaryFluent.BinaryExpressionAlternativeNested<A>	withNewBinaryExpressionAlternativeLike(io.sundr.model.BinaryExpression item)
TernaryFluent.BinaryExpressionConditionNested<A>	withNewBinaryExpressionCondition()
TernaryFluent.BinaryExpressionConditionNested<A>	withNewBinaryExpressionConditionLike(io.sundr.model.BinaryExpression item)
TernaryFluent.BinaryExpressionResultNested<A>	withNewBinaryExpressionResult()
TernaryFluent.BinaryExpressionResultNested<A>	withNewBinaryExpressionResultLike(io.sundr.model.BinaryExpression item)
TernaryFluent.BitwiseAndAlternativeNested<A>	withNewBitwiseAndAlternative()
A	withNewBitwiseAndAlternative(Object left, Object right)
TernaryFluent.BitwiseAndAlternativeNested<A>	withNewBitwiseAndAlternativeLike(io.sundr.model.BitwiseAnd item)
TernaryFluent.BitwiseAndConditionNested<A>	withNewBitwiseAndCondition()
A	withNewBitwiseAndCondition(Object left, Object right)
TernaryFluent.BitwiseAndConditionNested<A>	withNewBitwiseAndConditionLike(io.sundr.model.BitwiseAnd item)
TernaryFluent.BitwiseAndResultNested<A>	withNewBitwiseAndResult()
A	withNewBitwiseAndResult(Object left, Object right)
TernaryFluent.BitwiseAndResultNested<A>	withNewBitwiseAndResultLike(io.sundr.model.BitwiseAnd item)
TernaryFluent.BitwiseOrAlternativeNested<A>	withNewBitwiseOrAlternative()
A	withNewBitwiseOrAlternative(Object left, Object right)
TernaryFluent.BitwiseOrAlternativeNested<A>	withNewBitwiseOrAlternativeLike(io.sundr.model.BitwiseOr item)
TernaryFluent.BitwiseOrConditionNested<A>	withNewBitwiseOrCondition()
A	withNewBitwiseOrCondition(Object left, Object right)
TernaryFluent.BitwiseOrConditionNested<A>	withNewBitwiseOrConditionLike(io.sundr.model.BitwiseOr item)
TernaryFluent.BitwiseOrResultNested<A>	withNewBitwiseOrResult()
A	withNewBitwiseOrResult(Object left, Object right)
TernaryFluent.BitwiseOrResultNested<A>	withNewBitwiseOrResultLike(io.sundr.model.BitwiseOr item)
TernaryFluent.CastAlternativeNested<A>	withNewCastAlternative()
TernaryFluent.CastAlternativeNested<A>	withNewCastAlternativeLike(io.sundr.model.Cast item)
TernaryFluent.CastConditionNested<A>	withNewCastCondition()
TernaryFluent.CastConditionNested<A>	withNewCastConditionLike(io.sundr.model.Cast item)
TernaryFluent.CastResultNested<A>	withNewCastResult()
TernaryFluent.CastResultNested<A>	withNewCastResultLike(io.sundr.model.Cast item)
TernaryFluent.ConstructAlternativeNested<A>	withNewConstructAlternative()
TernaryFluent.ConstructAlternativeNested<A>	withNewConstructAlternativeLike(io.sundr.model.Construct item)
TernaryFluent.ConstructConditionNested<A>	withNewConstructCondition()
TernaryFluent.ConstructConditionNested<A>	withNewConstructConditionLike(io.sundr.model.Construct item)
TernaryFluent.ConstructResultNested<A>	withNewConstructResult()
TernaryFluent.ConstructResultNested<A>	withNewConstructResultLike(io.sundr.model.Construct item)
TernaryFluent.DeclareAlternativeNested<A>	withNewDeclareAlternative()
A	withNewDeclareAlternative(Class type, String name)
A	withNewDeclareAlternative(Class type, String name, Object value)
TernaryFluent.DeclareAlternativeNested<A>	withNewDeclareAlternativeLike(io.sundr.model.Declare item)
TernaryFluent.DeclareConditionNested<A>	withNewDeclareCondition()
A	withNewDeclareCondition(Class type, String name)
A	withNewDeclareCondition(Class type, String name, Object value)
TernaryFluent.DeclareConditionNested<A>	withNewDeclareConditionLike(io.sundr.model.Declare item)
TernaryFluent.DeclareResultNested<A>	withNewDeclareResult()
A	withNewDeclareResult(Class type, String name)
A	withNewDeclareResult(Class type, String name, Object value)
TernaryFluent.DeclareResultNested<A>	withNewDeclareResultLike(io.sundr.model.Declare item)
TernaryFluent.DivideAlternativeNested<A>	withNewDivideAlternative()
A	withNewDivideAlternative(Object left, Object right)
TernaryFluent.DivideAlternativeNested<A>	withNewDivideAlternativeLike(io.sundr.model.Divide item)
TernaryFluent.DivideConditionNested<A>	withNewDivideCondition()
A	withNewDivideCondition(Object left, Object right)
TernaryFluent.DivideConditionNested<A>	withNewDivideConditionLike(io.sundr.model.Divide item)
TernaryFluent.DivideResultNested<A>	withNewDivideResult()
A	withNewDivideResult(Object left, Object right)
TernaryFluent.DivideResultNested<A>	withNewDivideResultLike(io.sundr.model.Divide item)
TernaryFluent.EnclosedAlternativeNested<A>	withNewEnclosedAlternative()
TernaryFluent.EnclosedAlternativeNested<A>	withNewEnclosedAlternativeLike(io.sundr.model.Enclosed item)
TernaryFluent.EnclosedConditionNested<A>	withNewEnclosedCondition()
TernaryFluent.EnclosedConditionNested<A>	withNewEnclosedConditionLike(io.sundr.model.Enclosed item)
TernaryFluent.EnclosedResultNested<A>	withNewEnclosedResult()
TernaryFluent.EnclosedResultNested<A>	withNewEnclosedResultLike(io.sundr.model.Enclosed item)
TernaryFluent.EqualsAlternativeNested<A>	withNewEqualsAlternative()
A	withNewEqualsAlternative(Object left, Object right)
TernaryFluent.EqualsAlternativeNested<A>	withNewEqualsAlternativeLike(io.sundr.model.Equals item)
TernaryFluent.EqualsConditionNested<A>	withNewEqualsCondition()
A	withNewEqualsCondition(Object left, Object right)
TernaryFluent.EqualsConditionNested<A>	withNewEqualsConditionLike(io.sundr.model.Equals item)
TernaryFluent.EqualsResultNested<A>	withNewEqualsResult()
A	withNewEqualsResult(Object left, Object right)
TernaryFluent.EqualsResultNested<A>	withNewEqualsResultLike(io.sundr.model.Equals item)
TernaryFluent.GreaterThanAlternativeNested<A>	withNewGreaterThanAlternative()
A	withNewGreaterThanAlternative(Object left, Object right)
TernaryFluent.GreaterThanAlternativeNested<A>	withNewGreaterThanAlternativeLike(io.sundr.model.GreaterThan item)
TernaryFluent.GreaterThanConditionNested<A>	withNewGreaterThanCondition()
A	withNewGreaterThanCondition(Object left, Object right)
TernaryFluent.GreaterThanConditionNested<A>	withNewGreaterThanConditionLike(io.sundr.model.GreaterThan item)
TernaryFluent.GreaterThanOrEqualAlternativeNested<A>	withNewGreaterThanOrEqualAlternative()
A	withNewGreaterThanOrEqualAlternative(Object left, Object right)
TernaryFluent.GreaterThanOrEqualAlternativeNested<A>	withNewGreaterThanOrEqualAlternativeLike(io.sundr.model.GreaterThanOrEqual item)
TernaryFluent.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualCondition()
A	withNewGreaterThanOrEqualCondition(Object left, Object right)
TernaryFluent.GreaterThanOrEqualConditionNested<A>	withNewGreaterThanOrEqualConditionLike(io.sundr.model.GreaterThanOrEqual item)
TernaryFluent.GreaterThanOrEqualResultNested<A>	withNewGreaterThanOrEqualResult()
A	withNewGreaterThanOrEqualResult(Object left, Object right)
TernaryFluent.GreaterThanOrEqualResultNested<A>	withNewGreaterThanOrEqualResultLike(io.sundr.model.GreaterThanOrEqual item)
TernaryFluent.GreaterThanResultNested<A>	withNewGreaterThanResult()
A	withNewGreaterThanResult(Object left, Object right)
TernaryFluent.GreaterThanResultNested<A>	withNewGreaterThanResultLike(io.sundr.model.GreaterThan item)
TernaryFluent.IndexAlternativeNested<A>	withNewIndexAlternative()
TernaryFluent.IndexAlternativeNested<A>	withNewIndexAlternativeLike(io.sundr.model.Index item)
TernaryFluent.IndexConditionNested<A>	withNewIndexCondition()
TernaryFluent.IndexConditionNested<A>	withNewIndexConditionLike(io.sundr.model.Index item)
TernaryFluent.IndexResultNested<A>	withNewIndexResult()
TernaryFluent.IndexResultNested<A>	withNewIndexResultLike(io.sundr.model.Index item)
TernaryFluent.InstanceOfAlternativeNested<A>	withNewInstanceOfAlternative()
TernaryFluent.InstanceOfAlternativeNested<A>	withNewInstanceOfAlternativeLike(io.sundr.model.InstanceOf item)
TernaryFluent.InstanceOfConditionNested<A>	withNewInstanceOfCondition()
TernaryFluent.InstanceOfConditionNested<A>	withNewInstanceOfConditionLike(io.sundr.model.InstanceOf item)
TernaryFluent.InstanceOfResultNested<A>	withNewInstanceOfResult()
TernaryFluent.InstanceOfResultNested<A>	withNewInstanceOfResultLike(io.sundr.model.InstanceOf item)
TernaryFluent.InverseAlternativeNested<A>	withNewInverseAlternative()
TernaryFluent.InverseAlternativeNested<A>	withNewInverseAlternativeLike(io.sundr.model.Inverse item)
TernaryFluent.InverseConditionNested<A>	withNewInverseCondition()
TernaryFluent.InverseConditionNested<A>	withNewInverseConditionLike(io.sundr.model.Inverse item)
TernaryFluent.InverseResultNested<A>	withNewInverseResult()
TernaryFluent.InverseResultNested<A>	withNewInverseResultLike(io.sundr.model.Inverse item)
TernaryFluent.LambdaAlternativeNested<A>	withNewLambdaAlternative()
TernaryFluent.LambdaAlternativeNested<A>	withNewLambdaAlternativeLike(io.sundr.model.Lambda item)
TernaryFluent.LambdaConditionNested<A>	withNewLambdaCondition()
TernaryFluent.LambdaConditionNested<A>	withNewLambdaConditionLike(io.sundr.model.Lambda item)
TernaryFluent.LambdaResultNested<A>	withNewLambdaResult()
TernaryFluent.LambdaResultNested<A>	withNewLambdaResultLike(io.sundr.model.Lambda item)
TernaryFluent.LeftShiftAlternativeNested<A>	withNewLeftShiftAlternative()
A	withNewLeftShiftAlternative(Object left, Object right)
TernaryFluent.LeftShiftAlternativeNested<A>	withNewLeftShiftAlternativeLike(io.sundr.model.LeftShift item)
TernaryFluent.LeftShiftConditionNested<A>	withNewLeftShiftCondition()
A	withNewLeftShiftCondition(Object left, Object right)
TernaryFluent.LeftShiftConditionNested<A>	withNewLeftShiftConditionLike(io.sundr.model.LeftShift item)
TernaryFluent.LeftShiftResultNested<A>	withNewLeftShiftResult()
A	withNewLeftShiftResult(Object left, Object right)
TernaryFluent.LeftShiftResultNested<A>	withNewLeftShiftResultLike(io.sundr.model.LeftShift item)
TernaryFluent.LessThanAlternativeNested<A>	withNewLessThanAlternative()
A	withNewLessThanAlternative(Object left, Object right)
TernaryFluent.LessThanAlternativeNested<A>	withNewLessThanAlternativeLike(io.sundr.model.LessThan item)
TernaryFluent.LessThanConditionNested<A>	withNewLessThanCondition()
A	withNewLessThanCondition(Object left, Object right)
TernaryFluent.LessThanConditionNested<A>	withNewLessThanConditionLike(io.sundr.model.LessThan item)
TernaryFluent.LessThanOrEqualAlternativeNested<A>	withNewLessThanOrEqualAlternative()
A	withNewLessThanOrEqualAlternative(Object left, Object right)
TernaryFluent.LessThanOrEqualAlternativeNested<A>	withNewLessThanOrEqualAlternativeLike(io.sundr.model.LessThanOrEqual item)
TernaryFluent.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualCondition()
A	withNewLessThanOrEqualCondition(Object left, Object right)
TernaryFluent.LessThanOrEqualConditionNested<A>	withNewLessThanOrEqualConditionLike(io.sundr.model.LessThanOrEqual item)
TernaryFluent.LessThanOrEqualResultNested<A>	withNewLessThanOrEqualResult()
A	withNewLessThanOrEqualResult(Object left, Object right)
TernaryFluent.LessThanOrEqualResultNested<A>	withNewLessThanOrEqualResultLike(io.sundr.model.LessThanOrEqual item)
TernaryFluent.LessThanResultNested<A>	withNewLessThanResult()
A	withNewLessThanResult(Object left, Object right)
TernaryFluent.LessThanResultNested<A>	withNewLessThanResultLike(io.sundr.model.LessThan item)
TernaryFluent.LogicalAndAlternativeNested<A>	withNewLogicalAndAlternative()
A	withNewLogicalAndAlternative(Object left, Object right)
TernaryFluent.LogicalAndAlternativeNested<A>	withNewLogicalAndAlternativeLike(io.sundr.model.LogicalAnd item)
TernaryFluent.LogicalAndConditionNested<A>	withNewLogicalAndCondition()
A	withNewLogicalAndCondition(Object left, Object right)
TernaryFluent.LogicalAndConditionNested<A>	withNewLogicalAndConditionLike(io.sundr.model.LogicalAnd item)
TernaryFluent.LogicalAndResultNested<A>	withNewLogicalAndResult()
A	withNewLogicalAndResult(Object left, Object right)
TernaryFluent.LogicalAndResultNested<A>	withNewLogicalAndResultLike(io.sundr.model.LogicalAnd item)
TernaryFluent.LogicalOrAlternativeNested<A>	withNewLogicalOrAlternative()
A	withNewLogicalOrAlternative(Object left, Object right)
TernaryFluent.LogicalOrAlternativeNested<A>	withNewLogicalOrAlternativeLike(io.sundr.model.LogicalOr item)
TernaryFluent.LogicalOrConditionNested<A>	withNewLogicalOrCondition()
A	withNewLogicalOrCondition(Object left, Object right)
TernaryFluent.LogicalOrConditionNested<A>	withNewLogicalOrConditionLike(io.sundr.model.LogicalOr item)
TernaryFluent.LogicalOrResultNested<A>	withNewLogicalOrResult()
A	withNewLogicalOrResult(Object left, Object right)
TernaryFluent.LogicalOrResultNested<A>	withNewLogicalOrResultLike(io.sundr.model.LogicalOr item)
TernaryFluent.MethodCallAlternativeNested<A>	withNewMethodCallAlternative()
TernaryFluent.MethodCallAlternativeNested<A>	withNewMethodCallAlternativeLike(io.sundr.model.MethodCall item)
TernaryFluent.MethodCallConditionNested<A>	withNewMethodCallCondition()
TernaryFluent.MethodCallConditionNested<A>	withNewMethodCallConditionLike(io.sundr.model.MethodCall item)
TernaryFluent.MethodCallResultNested<A>	withNewMethodCallResult()
TernaryFluent.MethodCallResultNested<A>	withNewMethodCallResultLike(io.sundr.model.MethodCall item)
TernaryFluent.MinusAlternativeNested<A>	withNewMinusAlternative()
A	withNewMinusAlternative(Object left, Object right)
TernaryFluent.MinusAlternativeNested<A>	withNewMinusAlternativeLike(io.sundr.model.Minus item)
TernaryFluent.MinusConditionNested<A>	withNewMinusCondition()
A	withNewMinusCondition(Object left, Object right)
TernaryFluent.MinusConditionNested<A>	withNewMinusConditionLike(io.sundr.model.Minus item)
TernaryFluent.MinusResultNested<A>	withNewMinusResult()
A	withNewMinusResult(Object left, Object right)
TernaryFluent.MinusResultNested<A>	withNewMinusResultLike(io.sundr.model.Minus item)
TernaryFluent.ModuloAlternativeNested<A>	withNewModuloAlternative()
A	withNewModuloAlternative(Object left, Object right)
TernaryFluent.ModuloAlternativeNested<A>	withNewModuloAlternativeLike(io.sundr.model.Modulo item)
TernaryFluent.ModuloConditionNested<A>	withNewModuloCondition()
A	withNewModuloCondition(Object left, Object right)
TernaryFluent.ModuloConditionNested<A>	withNewModuloConditionLike(io.sundr.model.Modulo item)
TernaryFluent.ModuloResultNested<A>	withNewModuloResult()
A	withNewModuloResult(Object left, Object right)
TernaryFluent.ModuloResultNested<A>	withNewModuloResultLike(io.sundr.model.Modulo item)
TernaryFluent.MultiplyAlternativeNested<A>	withNewMultiplyAlternative()
A	withNewMultiplyAlternative(Object left, Object right)
TernaryFluent.MultiplyAlternativeNested<A>	withNewMultiplyAlternativeLike(io.sundr.model.Multiply item)
TernaryFluent.MultiplyConditionNested<A>	withNewMultiplyCondition()
A	withNewMultiplyCondition(Object left, Object right)
TernaryFluent.MultiplyConditionNested<A>	withNewMultiplyConditionLike(io.sundr.model.Multiply item)
TernaryFluent.MultiplyResultNested<A>	withNewMultiplyResult()
A	withNewMultiplyResult(Object left, Object right)
TernaryFluent.MultiplyResultNested<A>	withNewMultiplyResultLike(io.sundr.model.Multiply item)
TernaryFluent.NegativeAlternativeNested<A>	withNewNegativeAlternative()
TernaryFluent.NegativeAlternativeNested<A>	withNewNegativeAlternativeLike(io.sundr.model.Negative item)
TernaryFluent.NegativeConditionNested<A>	withNewNegativeCondition()
TernaryFluent.NegativeConditionNested<A>	withNewNegativeConditionLike(io.sundr.model.Negative item)
TernaryFluent.NegativeResultNested<A>	withNewNegativeResult()
TernaryFluent.NegativeResultNested<A>	withNewNegativeResultLike(io.sundr.model.Negative item)
TernaryFluent.NewArrayAlternativeNested<A>	withNewNewArrayAlternative()
A	withNewNewArrayAlternative(Class type, Integer[] sizes)
TernaryFluent.NewArrayAlternativeNested<A>	withNewNewArrayAlternativeLike(io.sundr.model.NewArray item)
TernaryFluent.NewArrayConditionNested<A>	withNewNewArrayCondition()
A	withNewNewArrayCondition(Class type, Integer[] sizes)
TernaryFluent.NewArrayConditionNested<A>	withNewNewArrayConditionLike(io.sundr.model.NewArray item)
TernaryFluent.NewArrayResultNested<A>	withNewNewArrayResult()
A	withNewNewArrayResult(Class type, Integer[] sizes)
TernaryFluent.NewArrayResultNested<A>	withNewNewArrayResultLike(io.sundr.model.NewArray item)
TernaryFluent.NotAlternativeNested<A>	withNewNotAlternative()
TernaryFluent.NotAlternativeNested<A>	withNewNotAlternativeLike(io.sundr.model.Not item)
TernaryFluent.NotConditionNested<A>	withNewNotCondition()
TernaryFluent.NotConditionNested<A>	withNewNotConditionLike(io.sundr.model.Not item)
TernaryFluent.NotEqualsAlternativeNested<A>	withNewNotEqualsAlternative()
A	withNewNotEqualsAlternative(Object left, Object right)
TernaryFluent.NotEqualsAlternativeNested<A>	withNewNotEqualsAlternativeLike(io.sundr.model.NotEquals item)
TernaryFluent.NotEqualsConditionNested<A>	withNewNotEqualsCondition()
A	withNewNotEqualsCondition(Object left, Object right)
TernaryFluent.NotEqualsConditionNested<A>	withNewNotEqualsConditionLike(io.sundr.model.NotEquals item)
TernaryFluent.NotEqualsResultNested<A>	withNewNotEqualsResult()
A	withNewNotEqualsResult(Object left, Object right)
TernaryFluent.NotEqualsResultNested<A>	withNewNotEqualsResultLike(io.sundr.model.NotEquals item)
TernaryFluent.NotResultNested<A>	withNewNotResult()
TernaryFluent.NotResultNested<A>	withNewNotResultLike(io.sundr.model.Not item)
TernaryFluent.PlusAlternativeNested<A>	withNewPlusAlternative()
A	withNewPlusAlternative(Object left, Object right)
TernaryFluent.PlusAlternativeNested<A>	withNewPlusAlternativeLike(io.sundr.model.Plus item)
TernaryFluent.PlusConditionNested<A>	withNewPlusCondition()
A	withNewPlusCondition(Object left, Object right)
TernaryFluent.PlusConditionNested<A>	withNewPlusConditionLike(io.sundr.model.Plus item)
TernaryFluent.PlusResultNested<A>	withNewPlusResult()
A	withNewPlusResult(Object left, Object right)
TernaryFluent.PlusResultNested<A>	withNewPlusResultLike(io.sundr.model.Plus item)
TernaryFluent.PositiveAlternativeNested<A>	withNewPositiveAlternative()
TernaryFluent.PositiveAlternativeNested<A>	withNewPositiveAlternativeLike(io.sundr.model.Positive item)
TernaryFluent.PositiveConditionNested<A>	withNewPositiveCondition()
TernaryFluent.PositiveConditionNested<A>	withNewPositiveConditionLike(io.sundr.model.Positive item)
TernaryFluent.PositiveResultNested<A>	withNewPositiveResult()
TernaryFluent.PositiveResultNested<A>	withNewPositiveResultLike(io.sundr.model.Positive item)
TernaryFluent.PostDecrementAlternativeNested<A>	withNewPostDecrementAlternative()
TernaryFluent.PostDecrementAlternativeNested<A>	withNewPostDecrementAlternativeLike(io.sundr.model.PostDecrement item)
TernaryFluent.PostDecrementConditionNested<A>	withNewPostDecrementCondition()
TernaryFluent.PostDecrementConditionNested<A>	withNewPostDecrementConditionLike(io.sundr.model.PostDecrement item)
TernaryFluent.PostDecrementResultNested<A>	withNewPostDecrementResult()
TernaryFluent.PostDecrementResultNested<A>	withNewPostDecrementResultLike(io.sundr.model.PostDecrement item)
TernaryFluent.PostIncrementAlternativeNested<A>	withNewPostIncrementAlternative()
TernaryFluent.PostIncrementAlternativeNested<A>	withNewPostIncrementAlternativeLike(io.sundr.model.PostIncrement item)
TernaryFluent.PostIncrementConditionNested<A>	withNewPostIncrementCondition()
TernaryFluent.PostIncrementConditionNested<A>	withNewPostIncrementConditionLike(io.sundr.model.PostIncrement item)
TernaryFluent.PostIncrementResultNested<A>	withNewPostIncrementResult()
TernaryFluent.PostIncrementResultNested<A>	withNewPostIncrementResultLike(io.sundr.model.PostIncrement item)
TernaryFluent.PreDecrementAlternativeNested<A>	withNewPreDecrementAlternative()
TernaryFluent.PreDecrementAlternativeNested<A>	withNewPreDecrementAlternativeLike(io.sundr.model.PreDecrement item)
TernaryFluent.PreDecrementConditionNested<A>	withNewPreDecrementCondition()
TernaryFluent.PreDecrementConditionNested<A>	withNewPreDecrementConditionLike(io.sundr.model.PreDecrement item)
TernaryFluent.PreDecrementResultNested<A>	withNewPreDecrementResult()
TernaryFluent.PreDecrementResultNested<A>	withNewPreDecrementResultLike(io.sundr.model.PreDecrement item)
TernaryFluent.PreIncrementAlternativeNested<A>	withNewPreIncrementAlternative()
TernaryFluent.PreIncrementAlternativeNested<A>	withNewPreIncrementAlternativeLike(io.sundr.model.PreIncrement item)
TernaryFluent.PreIncrementConditionNested<A>	withNewPreIncrementCondition()
TernaryFluent.PreIncrementConditionNested<A>	withNewPreIncrementConditionLike(io.sundr.model.PreIncrement item)
TernaryFluent.PreIncrementResultNested<A>	withNewPreIncrementResult()
TernaryFluent.PreIncrementResultNested<A>	withNewPreIncrementResultLike(io.sundr.model.PreIncrement item)
TernaryFluent.PropertyRefAlternativeNested<A>	withNewPropertyRefAlternative()
TernaryFluent.PropertyRefAlternativeNested<A>	withNewPropertyRefAlternativeLike(io.sundr.model.PropertyRef item)
TernaryFluent.PropertyRefConditionNested<A>	withNewPropertyRefCondition()
TernaryFluent.PropertyRefConditionNested<A>	withNewPropertyRefConditionLike(io.sundr.model.PropertyRef item)
TernaryFluent.PropertyRefResultNested<A>	withNewPropertyRefResult()
TernaryFluent.PropertyRefResultNested<A>	withNewPropertyRefResultLike(io.sundr.model.PropertyRef item)
TernaryFluent.RightShiftAlternativeNested<A>	withNewRightShiftAlternative()
A	withNewRightShiftAlternative(Object left, Object right)
TernaryFluent.RightShiftAlternativeNested<A>	withNewRightShiftAlternativeLike(io.sundr.model.RightShift item)
TernaryFluent.RightShiftConditionNested<A>	withNewRightShiftCondition()
A	withNewRightShiftCondition(Object left, Object right)
TernaryFluent.RightShiftConditionNested<A>	withNewRightShiftConditionLike(io.sundr.model.RightShift item)
TernaryFluent.RightShiftResultNested<A>	withNewRightShiftResult()
A	withNewRightShiftResult(Object left, Object right)
TernaryFluent.RightShiftResultNested<A>	withNewRightShiftResultLike(io.sundr.model.RightShift item)
TernaryFluent.RightUnsignedShiftAlternativeNested<A>	withNewRightUnsignedShiftAlternative()
A	withNewRightUnsignedShiftAlternative(Object left, Object right)
TernaryFluent.RightUnsignedShiftAlternativeNested<A>	withNewRightUnsignedShiftAlternativeLike(io.sundr.model.RightUnsignedShift item)
TernaryFluent.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftCondition()
A	withNewRightUnsignedShiftCondition(Object left, Object right)
TernaryFluent.RightUnsignedShiftConditionNested<A>	withNewRightUnsignedShiftConditionLike(io.sundr.model.RightUnsignedShift item)
TernaryFluent.RightUnsignedShiftResultNested<A>	withNewRightUnsignedShiftResult()
A	withNewRightUnsignedShiftResult(Object left, Object right)
TernaryFluent.RightUnsignedShiftResultNested<A>	withNewRightUnsignedShiftResultLike(io.sundr.model.RightUnsignedShift item)
TernaryFluent.TernaryAlternativeNested<A>	withNewTernaryAlternative()
TernaryFluent.TernaryAlternativeNested<A>	withNewTernaryAlternativeLike(io.sundr.model.Ternary item)
TernaryFluent.TernaryConditionNested<A>	withNewTernaryCondition()
TernaryFluent.TernaryConditionNested<A>	withNewTernaryConditionLike(io.sundr.model.Ternary item)
TernaryFluent.TernaryResultNested<A>	withNewTernaryResult()
TernaryFluent.TernaryResultNested<A>	withNewTernaryResultLike(io.sundr.model.Ternary item)
TernaryFluent.ThisAlternativeNested<A>	withNewThisAlternative()
TernaryFluent.ThisAlternativeNested<A>	withNewThisAlternativeLike(io.sundr.model.This item)
TernaryFluent.ThisConditionNested<A>	withNewThisCondition()
TernaryFluent.ThisConditionNested<A>	withNewThisConditionLike(io.sundr.model.This item)
TernaryFluent.ThisResultNested<A>	withNewThisResult()
TernaryFluent.ThisResultNested<A>	withNewThisResultLike(io.sundr.model.This item)
TernaryFluent.ValueRefAlternativeNested<A>	withNewValueRefAlternative()
A	withNewValueRefAlternative(Object value)
TernaryFluent.ValueRefAlternativeNested<A>	withNewValueRefAlternativeLike(io.sundr.model.ValueRef item)
TernaryFluent.ValueRefConditionNested<A>	withNewValueRefCondition()
A	withNewValueRefCondition(Object value)
TernaryFluent.ValueRefConditionNested<A>	withNewValueRefConditionLike(io.sundr.model.ValueRef item)
TernaryFluent.ValueRefResultNested<A>	withNewValueRefResult()
A	withNewValueRefResult(Object value)
TernaryFluent.ValueRefResultNested<A>	withNewValueRefResultLike(io.sundr.model.ValueRef item)
TernaryFluent.XorAlternativeNested<A>	withNewXorAlternative()
A	withNewXorAlternative(Object left, Object right)
TernaryFluent.XorAlternativeNested<A>	withNewXorAlternativeLike(io.sundr.model.Xor item)
TernaryFluent.XorConditionNested<A>	withNewXorCondition()
A	withNewXorCondition(Object left, Object right)
TernaryFluent.XorConditionNested<A>	withNewXorConditionLike(io.sundr.model.Xor item)
TernaryFluent.XorResultNested<A>	withNewXorResult()
A	withNewXorResult(Object left, Object right)
TernaryFluent.XorResultNested<A>	withNewXorResultLike(io.sundr.model.Xor item)
A	withResult(io.sundr.model.Expression result)

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

TernaryFluent

public TernaryFluent()

TernaryFluent

public TernaryFluent(io.sundr.model.Ternary instance)

Method Detail

copyInstance

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

buildCondition

public io.sundr.model.Expression buildCondition()

withCondition

public A withCondition(io.sundr.model.Expression condition)

hasCondition

public boolean hasCondition()

withNewMultiplyCondition

public TernaryFluent.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyConditionLike

public TernaryFluent.MultiplyConditionNested<A> withNewMultiplyConditionLike(io.sundr.model.Multiply item)

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
                                  Object right)

withNewNewArrayCondition

public TernaryFluent.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayConditionLike

public TernaryFluent.NewArrayConditionNested<A> withNewNewArrayConditionLike(io.sundr.model.NewArray item)

withNewNewArrayCondition

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

withNewInstanceOfCondition

public TernaryFluent.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

public TernaryFluent.InstanceOfConditionNested<A> withNewInstanceOfConditionLike(io.sundr.model.InstanceOf item)

withNewMethodCallCondition

public TernaryFluent.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

public TernaryFluent.MethodCallConditionNested<A> withNewMethodCallConditionLike(io.sundr.model.MethodCall item)

withNewInverseCondition

public TernaryFluent.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

public TernaryFluent.InverseConditionNested<A> withNewInverseConditionLike(io.sundr.model.Inverse item)

withNewIndexCondition

public TernaryFluent.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

public TernaryFluent.IndexConditionNested<A> withNewIndexConditionLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualCondition

public TernaryFluent.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualConditionLike

public TernaryFluent.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualConditionLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
                                            Object right)

withNewBitwiseAndCondition

public TernaryFluent.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndConditionLike

public TernaryFluent.BitwiseAndConditionNested<A> withNewBitwiseAndConditionLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
                                    Object right)

withNewMinusCondition

public TernaryFluent.MinusConditionNested<A> withNewMinusCondition()

withNewMinusConditionLike

public TernaryFluent.MinusConditionNested<A> withNewMinusConditionLike(io.sundr.model.Minus item)

withNewMinusCondition

public A withNewMinusCondition(Object left,
                               Object right)

withNewLogicalOrCondition

public TernaryFluent.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrConditionLike

public TernaryFluent.LogicalOrConditionNested<A> withNewLogicalOrConditionLike(io.sundr.model.LogicalOr item)

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
                                   Object right)

withNewNotEqualsCondition

public TernaryFluent.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsConditionLike

public TernaryFluent.NotEqualsConditionNested<A> withNewNotEqualsConditionLike(io.sundr.model.NotEquals item)

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
                                   Object right)

withNewDivideCondition

public TernaryFluent.DivideConditionNested<A> withNewDivideCondition()

withNewDivideConditionLike

public TernaryFluent.DivideConditionNested<A> withNewDivideConditionLike(io.sundr.model.Divide item)

withNewDivideCondition

public A withNewDivideCondition(Object left,
                                Object right)

withNewLessThanCondition

public TernaryFluent.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanConditionLike

public TernaryFluent.LessThanConditionNested<A> withNewLessThanConditionLike(io.sundr.model.LessThan item)

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
                                  Object right)

withNewBitwiseOrCondition

public TernaryFluent.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrConditionLike

public TernaryFluent.BitwiseOrConditionNested<A> withNewBitwiseOrConditionLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
                                   Object right)

withNewPropertyRefCondition

public TernaryFluent.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

public TernaryFluent.PropertyRefConditionNested<A> withNewPropertyRefConditionLike(io.sundr.model.PropertyRef item)

withNewRightShiftCondition

public TernaryFluent.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftConditionLike

public TernaryFluent.RightShiftConditionNested<A> withNewRightShiftConditionLike(io.sundr.model.RightShift item)

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
                                    Object right)

withNewGreaterThanCondition

public TernaryFluent.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanConditionLike

public TernaryFluent.GreaterThanConditionNested<A> withNewGreaterThanConditionLike(io.sundr.model.GreaterThan item)

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
                                     Object right)

withNewDeclareCondition

public TernaryFluent.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareConditionLike

public TernaryFluent.DeclareConditionNested<A> withNewDeclareConditionLike(io.sundr.model.Declare item)

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
                                 String name)

withNewDeclareCondition

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

withNewCastCondition

public TernaryFluent.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

public TernaryFluent.CastConditionNested<A> withNewCastConditionLike(io.sundr.model.Cast item)

withNewModuloCondition

public TernaryFluent.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloConditionLike

public TernaryFluent.ModuloConditionNested<A> withNewModuloConditionLike(io.sundr.model.Modulo item)

withNewModuloCondition

public A withNewModuloCondition(Object left,
                                Object right)

withNewValueRefCondition

public TernaryFluent.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefConditionLike

public TernaryFluent.ValueRefConditionNested<A> withNewValueRefConditionLike(io.sundr.model.ValueRef item)

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewLeftShiftCondition

public TernaryFluent.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftConditionLike

public TernaryFluent.LeftShiftConditionNested<A> withNewLeftShiftConditionLike(io.sundr.model.LeftShift item)

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
                                   Object right)

withNewTernaryCondition

public TernaryFluent.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

public TernaryFluent.TernaryConditionNested<A> withNewTernaryConditionLike(io.sundr.model.Ternary item)

withNewBinaryExpressionCondition

public TernaryFluent.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

public TernaryFluent.BinaryExpressionConditionNested<A> withNewBinaryExpressionConditionLike(io.sundr.model.BinaryExpression item)

withNewEqualsCondition

public TernaryFluent.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsConditionLike

public TernaryFluent.EqualsConditionNested<A> withNewEqualsConditionLike(io.sundr.model.Equals item)

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
                                Object right)

withNewEnclosedCondition

public TernaryFluent.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

public TernaryFluent.EnclosedConditionNested<A> withNewEnclosedConditionLike(io.sundr.model.Enclosed item)

withNewPreDecrementCondition

public TernaryFluent.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

public TernaryFluent.PreDecrementConditionNested<A> withNewPreDecrementConditionLike(io.sundr.model.PreDecrement item)

withNewPostDecrementCondition

public TernaryFluent.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

public TernaryFluent.PostDecrementConditionNested<A> withNewPostDecrementConditionLike(io.sundr.model.PostDecrement item)

withNewLambdaCondition

public TernaryFluent.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

public TernaryFluent.LambdaConditionNested<A> withNewLambdaConditionLike(io.sundr.model.Lambda item)

withNewNotCondition

public TernaryFluent.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

public TernaryFluent.NotConditionNested<A> withNewNotConditionLike(io.sundr.model.Not item)

withNewAssignCondition

public TernaryFluent.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

public TernaryFluent.AssignConditionNested<A> withNewAssignConditionLike(io.sundr.model.Assign item)

withNewNegativeCondition

public TernaryFluent.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

public TernaryFluent.NegativeConditionNested<A> withNewNegativeConditionLike(io.sundr.model.Negative item)

withNewThisCondition

public TernaryFluent.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

public TernaryFluent.ThisConditionNested<A> withNewThisConditionLike(io.sundr.model.This item)

withNewLogicalAndCondition

public TernaryFluent.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndConditionLike

public TernaryFluent.LogicalAndConditionNested<A> withNewLogicalAndConditionLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
                                    Object right)

withNewPostIncrementCondition

public TernaryFluent.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

public TernaryFluent.PostIncrementConditionNested<A> withNewPostIncrementConditionLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftCondition

public TernaryFluent.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftConditionLike

public TernaryFluent.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftConditionLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
                                            Object right)

withNewPlusCondition

public TernaryFluent.PlusConditionNested<A> withNewPlusCondition()

withNewPlusConditionLike

public TernaryFluent.PlusConditionNested<A> withNewPlusConditionLike(io.sundr.model.Plus item)

withNewPlusCondition

public A withNewPlusCondition(Object left,
                              Object right)

withNewConstructCondition

public TernaryFluent.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

public TernaryFluent.ConstructConditionNested<A> withNewConstructConditionLike(io.sundr.model.Construct item)

withNewXorCondition

public TernaryFluent.XorConditionNested<A> withNewXorCondition()

withNewXorConditionLike

public TernaryFluent.XorConditionNested<A> withNewXorConditionLike(io.sundr.model.Xor item)

withNewXorCondition

public A withNewXorCondition(Object left,
                             Object right)

withNewPreIncrementCondition

public TernaryFluent.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

public TernaryFluent.PreIncrementConditionNested<A> withNewPreIncrementConditionLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualCondition

public TernaryFluent.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualConditionLike

public TernaryFluent.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualConditionLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
                                         Object right)

withNewPositiveCondition

public TernaryFluent.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

public TernaryFluent.PositiveConditionNested<A> withNewPositiveConditionLike(io.sundr.model.Positive item)

buildResult

public io.sundr.model.Expression buildResult()

withResult

public A withResult(io.sundr.model.Expression result)

hasResult

public boolean hasResult()

withNewMultiplyResult

public TernaryFluent.MultiplyResultNested<A> withNewMultiplyResult()

withNewMultiplyResultLike

public TernaryFluent.MultiplyResultNested<A> withNewMultiplyResultLike(io.sundr.model.Multiply item)

withNewMultiplyResult

public A withNewMultiplyResult(Object left,
                               Object right)

withNewNewArrayResult

public TernaryFluent.NewArrayResultNested<A> withNewNewArrayResult()

withNewNewArrayResultLike

public TernaryFluent.NewArrayResultNested<A> withNewNewArrayResultLike(io.sundr.model.NewArray item)

withNewNewArrayResult

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

withNewInstanceOfResult

public TernaryFluent.InstanceOfResultNested<A> withNewInstanceOfResult()

withNewInstanceOfResultLike

public TernaryFluent.InstanceOfResultNested<A> withNewInstanceOfResultLike(io.sundr.model.InstanceOf item)

withNewMethodCallResult

public TernaryFluent.MethodCallResultNested<A> withNewMethodCallResult()

withNewMethodCallResultLike

public TernaryFluent.MethodCallResultNested<A> withNewMethodCallResultLike(io.sundr.model.MethodCall item)

withNewInverseResult

public TernaryFluent.InverseResultNested<A> withNewInverseResult()

withNewInverseResultLike

public TernaryFluent.InverseResultNested<A> withNewInverseResultLike(io.sundr.model.Inverse item)

withNewIndexResult

public TernaryFluent.IndexResultNested<A> withNewIndexResult()

withNewIndexResultLike

public TernaryFluent.IndexResultNested<A> withNewIndexResultLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualResult

public TernaryFluent.GreaterThanOrEqualResultNested<A> withNewGreaterThanOrEqualResult()

withNewGreaterThanOrEqualResultLike

public TernaryFluent.GreaterThanOrEqualResultNested<A> withNewGreaterThanOrEqualResultLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualResult

public A withNewGreaterThanOrEqualResult(Object left,
                                         Object right)

withNewBitwiseAndResult

public TernaryFluent.BitwiseAndResultNested<A> withNewBitwiseAndResult()

withNewBitwiseAndResultLike

public TernaryFluent.BitwiseAndResultNested<A> withNewBitwiseAndResultLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndResult

public A withNewBitwiseAndResult(Object left,
                                 Object right)

withNewMinusResult

public TernaryFluent.MinusResultNested<A> withNewMinusResult()

withNewMinusResultLike

public TernaryFluent.MinusResultNested<A> withNewMinusResultLike(io.sundr.model.Minus item)

withNewMinusResult

public A withNewMinusResult(Object left,
                            Object right)

withNewLogicalOrResult

public TernaryFluent.LogicalOrResultNested<A> withNewLogicalOrResult()

withNewLogicalOrResultLike

public TernaryFluent.LogicalOrResultNested<A> withNewLogicalOrResultLike(io.sundr.model.LogicalOr item)

withNewLogicalOrResult

public A withNewLogicalOrResult(Object left,
                                Object right)

withNewNotEqualsResult

public TernaryFluent.NotEqualsResultNested<A> withNewNotEqualsResult()

withNewNotEqualsResultLike

public TernaryFluent.NotEqualsResultNested<A> withNewNotEqualsResultLike(io.sundr.model.NotEquals item)

withNewNotEqualsResult

public A withNewNotEqualsResult(Object left,
                                Object right)

withNewDivideResult

public TernaryFluent.DivideResultNested<A> withNewDivideResult()

withNewDivideResultLike

public TernaryFluent.DivideResultNested<A> withNewDivideResultLike(io.sundr.model.Divide item)

withNewDivideResult

public A withNewDivideResult(Object left,
                             Object right)

withNewLessThanResult

public TernaryFluent.LessThanResultNested<A> withNewLessThanResult()

withNewLessThanResultLike

public TernaryFluent.LessThanResultNested<A> withNewLessThanResultLike(io.sundr.model.LessThan item)

withNewLessThanResult

public A withNewLessThanResult(Object left,
                               Object right)

withNewBitwiseOrResult

public TernaryFluent.BitwiseOrResultNested<A> withNewBitwiseOrResult()

withNewBitwiseOrResultLike

public TernaryFluent.BitwiseOrResultNested<A> withNewBitwiseOrResultLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrResult

public A withNewBitwiseOrResult(Object left,
                                Object right)

withNewPropertyRefResult

public TernaryFluent.PropertyRefResultNested<A> withNewPropertyRefResult()

withNewPropertyRefResultLike

public TernaryFluent.PropertyRefResultNested<A> withNewPropertyRefResultLike(io.sundr.model.PropertyRef item)

withNewRightShiftResult

public TernaryFluent.RightShiftResultNested<A> withNewRightShiftResult()

withNewRightShiftResultLike

public TernaryFluent.RightShiftResultNested<A> withNewRightShiftResultLike(io.sundr.model.RightShift item)

withNewRightShiftResult

public A withNewRightShiftResult(Object left,
                                 Object right)

withNewGreaterThanResult

public TernaryFluent.GreaterThanResultNested<A> withNewGreaterThanResult()

withNewGreaterThanResultLike

public TernaryFluent.GreaterThanResultNested<A> withNewGreaterThanResultLike(io.sundr.model.GreaterThan item)

withNewGreaterThanResult

public A withNewGreaterThanResult(Object left,
                                  Object right)

withNewDeclareResult

public TernaryFluent.DeclareResultNested<A> withNewDeclareResult()

withNewDeclareResultLike

public TernaryFluent.DeclareResultNested<A> withNewDeclareResultLike(io.sundr.model.Declare item)

withNewDeclareResult

public A withNewDeclareResult(Class type,
                              String name)

withNewDeclareResult

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

withNewCastResult

public TernaryFluent.CastResultNested<A> withNewCastResult()

withNewCastResultLike

public TernaryFluent.CastResultNested<A> withNewCastResultLike(io.sundr.model.Cast item)

withNewModuloResult

public TernaryFluent.ModuloResultNested<A> withNewModuloResult()

withNewModuloResultLike

public TernaryFluent.ModuloResultNested<A> withNewModuloResultLike(io.sundr.model.Modulo item)

withNewModuloResult

public A withNewModuloResult(Object left,
                             Object right)

withNewValueRefResult

public TernaryFluent.ValueRefResultNested<A> withNewValueRefResult()

withNewValueRefResultLike

public TernaryFluent.ValueRefResultNested<A> withNewValueRefResultLike(io.sundr.model.ValueRef item)

withNewValueRefResult

public A withNewValueRefResult(Object value)

withNewLeftShiftResult

public TernaryFluent.LeftShiftResultNested<A> withNewLeftShiftResult()

withNewLeftShiftResultLike

public TernaryFluent.LeftShiftResultNested<A> withNewLeftShiftResultLike(io.sundr.model.LeftShift item)

withNewLeftShiftResult

public A withNewLeftShiftResult(Object left,
                                Object right)

withNewTernaryResult

public TernaryFluent.TernaryResultNested<A> withNewTernaryResult()

withNewTernaryResultLike

public TernaryFluent.TernaryResultNested<A> withNewTernaryResultLike(io.sundr.model.Ternary item)

withNewBinaryExpressionResult

public TernaryFluent.BinaryExpressionResultNested<A> withNewBinaryExpressionResult()

withNewBinaryExpressionResultLike

public TernaryFluent.BinaryExpressionResultNested<A> withNewBinaryExpressionResultLike(io.sundr.model.BinaryExpression item)

withNewEqualsResult

public TernaryFluent.EqualsResultNested<A> withNewEqualsResult()

withNewEqualsResultLike

public TernaryFluent.EqualsResultNested<A> withNewEqualsResultLike(io.sundr.model.Equals item)

withNewEqualsResult

public A withNewEqualsResult(Object left,
                             Object right)

withNewEnclosedResult

public TernaryFluent.EnclosedResultNested<A> withNewEnclosedResult()

withNewEnclosedResultLike

public TernaryFluent.EnclosedResultNested<A> withNewEnclosedResultLike(io.sundr.model.Enclosed item)

withNewPreDecrementResult

public TernaryFluent.PreDecrementResultNested<A> withNewPreDecrementResult()

withNewPreDecrementResultLike

public TernaryFluent.PreDecrementResultNested<A> withNewPreDecrementResultLike(io.sundr.model.PreDecrement item)

withNewPostDecrementResult

public TernaryFluent.PostDecrementResultNested<A> withNewPostDecrementResult()

withNewPostDecrementResultLike

public TernaryFluent.PostDecrementResultNested<A> withNewPostDecrementResultLike(io.sundr.model.PostDecrement item)

withNewLambdaResult

public TernaryFluent.LambdaResultNested<A> withNewLambdaResult()

withNewLambdaResultLike

public TernaryFluent.LambdaResultNested<A> withNewLambdaResultLike(io.sundr.model.Lambda item)

withNewNotResult

public TernaryFluent.NotResultNested<A> withNewNotResult()

withNewNotResultLike

public TernaryFluent.NotResultNested<A> withNewNotResultLike(io.sundr.model.Not item)

withNewAssignResult

public TernaryFluent.AssignResultNested<A> withNewAssignResult()

withNewAssignResultLike

public TernaryFluent.AssignResultNested<A> withNewAssignResultLike(io.sundr.model.Assign item)

withNewNegativeResult

public TernaryFluent.NegativeResultNested<A> withNewNegativeResult()

withNewNegativeResultLike

public TernaryFluent.NegativeResultNested<A> withNewNegativeResultLike(io.sundr.model.Negative item)

withNewThisResult

public TernaryFluent.ThisResultNested<A> withNewThisResult()

withNewThisResultLike

public TernaryFluent.ThisResultNested<A> withNewThisResultLike(io.sundr.model.This item)

withNewLogicalAndResult

public TernaryFluent.LogicalAndResultNested<A> withNewLogicalAndResult()

withNewLogicalAndResultLike

public TernaryFluent.LogicalAndResultNested<A> withNewLogicalAndResultLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndResult

public A withNewLogicalAndResult(Object left,
                                 Object right)

withNewPostIncrementResult

public TernaryFluent.PostIncrementResultNested<A> withNewPostIncrementResult()

withNewPostIncrementResultLike

public TernaryFluent.PostIncrementResultNested<A> withNewPostIncrementResultLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftResult

public TernaryFluent.RightUnsignedShiftResultNested<A> withNewRightUnsignedShiftResult()

withNewRightUnsignedShiftResultLike

public TernaryFluent.RightUnsignedShiftResultNested<A> withNewRightUnsignedShiftResultLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftResult

public A withNewRightUnsignedShiftResult(Object left,
                                         Object right)

withNewPlusResult

public TernaryFluent.PlusResultNested<A> withNewPlusResult()

withNewPlusResultLike

public TernaryFluent.PlusResultNested<A> withNewPlusResultLike(io.sundr.model.Plus item)

withNewPlusResult

public A withNewPlusResult(Object left,
                           Object right)

withNewConstructResult

public TernaryFluent.ConstructResultNested<A> withNewConstructResult()

withNewConstructResultLike

public TernaryFluent.ConstructResultNested<A> withNewConstructResultLike(io.sundr.model.Construct item)

withNewXorResult

public TernaryFluent.XorResultNested<A> withNewXorResult()

withNewXorResultLike

public TernaryFluent.XorResultNested<A> withNewXorResultLike(io.sundr.model.Xor item)

withNewXorResult

public A withNewXorResult(Object left,
                          Object right)

withNewPreIncrementResult

public TernaryFluent.PreIncrementResultNested<A> withNewPreIncrementResult()

withNewPreIncrementResultLike

public TernaryFluent.PreIncrementResultNested<A> withNewPreIncrementResultLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualResult

public TernaryFluent.LessThanOrEqualResultNested<A> withNewLessThanOrEqualResult()

withNewLessThanOrEqualResultLike

public TernaryFluent.LessThanOrEqualResultNested<A> withNewLessThanOrEqualResultLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualResult

public A withNewLessThanOrEqualResult(Object left,
                                      Object right)

withNewPositiveResult

public TernaryFluent.PositiveResultNested<A> withNewPositiveResult()

withNewPositiveResultLike

public TernaryFluent.PositiveResultNested<A> withNewPositiveResultLike(io.sundr.model.Positive item)

buildAlternative

public io.sundr.model.Expression buildAlternative()

withAlternative

public A withAlternative(io.sundr.model.Expression alternative)

hasAlternative

public boolean hasAlternative()

withNewMultiplyAlternative

public TernaryFluent.MultiplyAlternativeNested<A> withNewMultiplyAlternative()

withNewMultiplyAlternativeLike

public TernaryFluent.MultiplyAlternativeNested<A> withNewMultiplyAlternativeLike(io.sundr.model.Multiply item)

withNewMultiplyAlternative

public A withNewMultiplyAlternative(Object left,
                                    Object right)

withNewNewArrayAlternative

public TernaryFluent.NewArrayAlternativeNested<A> withNewNewArrayAlternative()

withNewNewArrayAlternativeLike

public TernaryFluent.NewArrayAlternativeNested<A> withNewNewArrayAlternativeLike(io.sundr.model.NewArray item)

withNewNewArrayAlternative

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

withNewInstanceOfAlternative

public TernaryFluent.InstanceOfAlternativeNested<A> withNewInstanceOfAlternative()

withNewInstanceOfAlternativeLike

public TernaryFluent.InstanceOfAlternativeNested<A> withNewInstanceOfAlternativeLike(io.sundr.model.InstanceOf item)

withNewMethodCallAlternative

public TernaryFluent.MethodCallAlternativeNested<A> withNewMethodCallAlternative()

withNewMethodCallAlternativeLike

public TernaryFluent.MethodCallAlternativeNested<A> withNewMethodCallAlternativeLike(io.sundr.model.MethodCall item)

withNewInverseAlternative

public TernaryFluent.InverseAlternativeNested<A> withNewInverseAlternative()

withNewInverseAlternativeLike

public TernaryFluent.InverseAlternativeNested<A> withNewInverseAlternativeLike(io.sundr.model.Inverse item)

withNewIndexAlternative

public TernaryFluent.IndexAlternativeNested<A> withNewIndexAlternative()

withNewIndexAlternativeLike

public TernaryFluent.IndexAlternativeNested<A> withNewIndexAlternativeLike(io.sundr.model.Index item)

withNewGreaterThanOrEqualAlternative

public TernaryFluent.GreaterThanOrEqualAlternativeNested<A> withNewGreaterThanOrEqualAlternative()

withNewGreaterThanOrEqualAlternativeLike

public TernaryFluent.GreaterThanOrEqualAlternativeNested<A> withNewGreaterThanOrEqualAlternativeLike(io.sundr.model.GreaterThanOrEqual item)

withNewGreaterThanOrEqualAlternative

public A withNewGreaterThanOrEqualAlternative(Object left,
                                              Object right)

withNewBitwiseAndAlternative

public TernaryFluent.BitwiseAndAlternativeNested<A> withNewBitwiseAndAlternative()

withNewBitwiseAndAlternativeLike

public TernaryFluent.BitwiseAndAlternativeNested<A> withNewBitwiseAndAlternativeLike(io.sundr.model.BitwiseAnd item)

withNewBitwiseAndAlternative

public A withNewBitwiseAndAlternative(Object left,
                                      Object right)

withNewMinusAlternative

public TernaryFluent.MinusAlternativeNested<A> withNewMinusAlternative()

withNewMinusAlternativeLike

public TernaryFluent.MinusAlternativeNested<A> withNewMinusAlternativeLike(io.sundr.model.Minus item)

withNewMinusAlternative

public A withNewMinusAlternative(Object left,
                                 Object right)

withNewLogicalOrAlternative

public TernaryFluent.LogicalOrAlternativeNested<A> withNewLogicalOrAlternative()

withNewLogicalOrAlternativeLike

public TernaryFluent.LogicalOrAlternativeNested<A> withNewLogicalOrAlternativeLike(io.sundr.model.LogicalOr item)

withNewLogicalOrAlternative

public A withNewLogicalOrAlternative(Object left,
                                     Object right)

withNewNotEqualsAlternative

public TernaryFluent.NotEqualsAlternativeNested<A> withNewNotEqualsAlternative()

withNewNotEqualsAlternativeLike

public TernaryFluent.NotEqualsAlternativeNested<A> withNewNotEqualsAlternativeLike(io.sundr.model.NotEquals item)

withNewNotEqualsAlternative

public A withNewNotEqualsAlternative(Object left,
                                     Object right)

withNewDivideAlternative

public TernaryFluent.DivideAlternativeNested<A> withNewDivideAlternative()

withNewDivideAlternativeLike

public TernaryFluent.DivideAlternativeNested<A> withNewDivideAlternativeLike(io.sundr.model.Divide item)

withNewDivideAlternative

public A withNewDivideAlternative(Object left,
                                  Object right)

withNewLessThanAlternative

public TernaryFluent.LessThanAlternativeNested<A> withNewLessThanAlternative()

withNewLessThanAlternativeLike

public TernaryFluent.LessThanAlternativeNested<A> withNewLessThanAlternativeLike(io.sundr.model.LessThan item)

withNewLessThanAlternative

public A withNewLessThanAlternative(Object left,
                                    Object right)

withNewBitwiseOrAlternative

public TernaryFluent.BitwiseOrAlternativeNested<A> withNewBitwiseOrAlternative()

withNewBitwiseOrAlternativeLike

public TernaryFluent.BitwiseOrAlternativeNested<A> withNewBitwiseOrAlternativeLike(io.sundr.model.BitwiseOr item)

withNewBitwiseOrAlternative

public A withNewBitwiseOrAlternative(Object left,
                                     Object right)

withNewPropertyRefAlternative

public TernaryFluent.PropertyRefAlternativeNested<A> withNewPropertyRefAlternative()

withNewPropertyRefAlternativeLike

public TernaryFluent.PropertyRefAlternativeNested<A> withNewPropertyRefAlternativeLike(io.sundr.model.PropertyRef item)

withNewRightShiftAlternative

public TernaryFluent.RightShiftAlternativeNested<A> withNewRightShiftAlternative()

withNewRightShiftAlternativeLike

public TernaryFluent.RightShiftAlternativeNested<A> withNewRightShiftAlternativeLike(io.sundr.model.RightShift item)

withNewRightShiftAlternative

public A withNewRightShiftAlternative(Object left,
                                      Object right)

withNewGreaterThanAlternative

public TernaryFluent.GreaterThanAlternativeNested<A> withNewGreaterThanAlternative()

withNewGreaterThanAlternativeLike

public TernaryFluent.GreaterThanAlternativeNested<A> withNewGreaterThanAlternativeLike(io.sundr.model.GreaterThan item)

withNewGreaterThanAlternative

public A withNewGreaterThanAlternative(Object left,
                                       Object right)

withNewDeclareAlternative

public TernaryFluent.DeclareAlternativeNested<A> withNewDeclareAlternative()

withNewDeclareAlternativeLike

public TernaryFluent.DeclareAlternativeNested<A> withNewDeclareAlternativeLike(io.sundr.model.Declare item)

withNewDeclareAlternative

public A withNewDeclareAlternative(Class type,
                                   String name)

withNewDeclareAlternative

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

withNewCastAlternative

public TernaryFluent.CastAlternativeNested<A> withNewCastAlternative()

withNewCastAlternativeLike

public TernaryFluent.CastAlternativeNested<A> withNewCastAlternativeLike(io.sundr.model.Cast item)

withNewModuloAlternative

public TernaryFluent.ModuloAlternativeNested<A> withNewModuloAlternative()

withNewModuloAlternativeLike

public TernaryFluent.ModuloAlternativeNested<A> withNewModuloAlternativeLike(io.sundr.model.Modulo item)

withNewModuloAlternative

public A withNewModuloAlternative(Object left,
                                  Object right)

withNewValueRefAlternative

public TernaryFluent.ValueRefAlternativeNested<A> withNewValueRefAlternative()

withNewValueRefAlternativeLike

public TernaryFluent.ValueRefAlternativeNested<A> withNewValueRefAlternativeLike(io.sundr.model.ValueRef item)

withNewValueRefAlternative

public A withNewValueRefAlternative(Object value)

withNewLeftShiftAlternative

public TernaryFluent.LeftShiftAlternativeNested<A> withNewLeftShiftAlternative()

withNewLeftShiftAlternativeLike

public TernaryFluent.LeftShiftAlternativeNested<A> withNewLeftShiftAlternativeLike(io.sundr.model.LeftShift item)

withNewLeftShiftAlternative

public A withNewLeftShiftAlternative(Object left,
                                     Object right)

withNewTernaryAlternative

public TernaryFluent.TernaryAlternativeNested<A> withNewTernaryAlternative()

withNewTernaryAlternativeLike

public TernaryFluent.TernaryAlternativeNested<A> withNewTernaryAlternativeLike(io.sundr.model.Ternary item)

withNewBinaryExpressionAlternative

public TernaryFluent.BinaryExpressionAlternativeNested<A> withNewBinaryExpressionAlternative()

withNewBinaryExpressionAlternativeLike

public TernaryFluent.BinaryExpressionAlternativeNested<A> withNewBinaryExpressionAlternativeLike(io.sundr.model.BinaryExpression item)

withNewEqualsAlternative

public TernaryFluent.EqualsAlternativeNested<A> withNewEqualsAlternative()

withNewEqualsAlternativeLike

public TernaryFluent.EqualsAlternativeNested<A> withNewEqualsAlternativeLike(io.sundr.model.Equals item)

withNewEqualsAlternative

public A withNewEqualsAlternative(Object left,
                                  Object right)

withNewEnclosedAlternative

public TernaryFluent.EnclosedAlternativeNested<A> withNewEnclosedAlternative()

withNewEnclosedAlternativeLike

public TernaryFluent.EnclosedAlternativeNested<A> withNewEnclosedAlternativeLike(io.sundr.model.Enclosed item)

withNewPreDecrementAlternative

public TernaryFluent.PreDecrementAlternativeNested<A> withNewPreDecrementAlternative()

withNewPreDecrementAlternativeLike

public TernaryFluent.PreDecrementAlternativeNested<A> withNewPreDecrementAlternativeLike(io.sundr.model.PreDecrement item)

withNewPostDecrementAlternative

public TernaryFluent.PostDecrementAlternativeNested<A> withNewPostDecrementAlternative()

withNewPostDecrementAlternativeLike

public TernaryFluent.PostDecrementAlternativeNested<A> withNewPostDecrementAlternativeLike(io.sundr.model.PostDecrement item)

withNewLambdaAlternative

public TernaryFluent.LambdaAlternativeNested<A> withNewLambdaAlternative()

withNewLambdaAlternativeLike

public TernaryFluent.LambdaAlternativeNested<A> withNewLambdaAlternativeLike(io.sundr.model.Lambda item)

withNewNotAlternative

public TernaryFluent.NotAlternativeNested<A> withNewNotAlternative()

withNewNotAlternativeLike

public TernaryFluent.NotAlternativeNested<A> withNewNotAlternativeLike(io.sundr.model.Not item)

withNewAssignAlternative

public TernaryFluent.AssignAlternativeNested<A> withNewAssignAlternative()

withNewAssignAlternativeLike

public TernaryFluent.AssignAlternativeNested<A> withNewAssignAlternativeLike(io.sundr.model.Assign item)

withNewNegativeAlternative

public TernaryFluent.NegativeAlternativeNested<A> withNewNegativeAlternative()

withNewNegativeAlternativeLike

public TernaryFluent.NegativeAlternativeNested<A> withNewNegativeAlternativeLike(io.sundr.model.Negative item)

withNewThisAlternative

public TernaryFluent.ThisAlternativeNested<A> withNewThisAlternative()

withNewThisAlternativeLike

public TernaryFluent.ThisAlternativeNested<A> withNewThisAlternativeLike(io.sundr.model.This item)

withNewLogicalAndAlternative

public TernaryFluent.LogicalAndAlternativeNested<A> withNewLogicalAndAlternative()

withNewLogicalAndAlternativeLike

public TernaryFluent.LogicalAndAlternativeNested<A> withNewLogicalAndAlternativeLike(io.sundr.model.LogicalAnd item)

withNewLogicalAndAlternative

public A withNewLogicalAndAlternative(Object left,
                                      Object right)

withNewPostIncrementAlternative

public TernaryFluent.PostIncrementAlternativeNested<A> withNewPostIncrementAlternative()

withNewPostIncrementAlternativeLike

public TernaryFluent.PostIncrementAlternativeNested<A> withNewPostIncrementAlternativeLike(io.sundr.model.PostIncrement item)

withNewRightUnsignedShiftAlternative

public TernaryFluent.RightUnsignedShiftAlternativeNested<A> withNewRightUnsignedShiftAlternative()

withNewRightUnsignedShiftAlternativeLike

public TernaryFluent.RightUnsignedShiftAlternativeNested<A> withNewRightUnsignedShiftAlternativeLike(io.sundr.model.RightUnsignedShift item)

withNewRightUnsignedShiftAlternative

public A withNewRightUnsignedShiftAlternative(Object left,
                                              Object right)

withNewPlusAlternative

public TernaryFluent.PlusAlternativeNested<A> withNewPlusAlternative()

withNewPlusAlternativeLike

public TernaryFluent.PlusAlternativeNested<A> withNewPlusAlternativeLike(io.sundr.model.Plus item)

withNewPlusAlternative

public A withNewPlusAlternative(Object left,
                                Object right)

withNewConstructAlternative

public TernaryFluent.ConstructAlternativeNested<A> withNewConstructAlternative()

withNewConstructAlternativeLike

public TernaryFluent.ConstructAlternativeNested<A> withNewConstructAlternativeLike(io.sundr.model.Construct item)

withNewXorAlternative

public TernaryFluent.XorAlternativeNested<A> withNewXorAlternative()

withNewXorAlternativeLike

public TernaryFluent.XorAlternativeNested<A> withNewXorAlternativeLike(io.sundr.model.Xor item)

withNewXorAlternative

public A withNewXorAlternative(Object left,
                               Object right)

withNewPreIncrementAlternative

public TernaryFluent.PreIncrementAlternativeNested<A> withNewPreIncrementAlternative()

withNewPreIncrementAlternativeLike

public TernaryFluent.PreIncrementAlternativeNested<A> withNewPreIncrementAlternativeLike(io.sundr.model.PreIncrement item)

withNewLessThanOrEqualAlternative

public TernaryFluent.LessThanOrEqualAlternativeNested<A> withNewLessThanOrEqualAlternative()

withNewLessThanOrEqualAlternativeLike

public TernaryFluent.LessThanOrEqualAlternativeNested<A> withNewLessThanOrEqualAlternativeLike(io.sundr.model.LessThanOrEqual item)

withNewLessThanOrEqualAlternative

public A withNewLessThanOrEqualAlternative(Object left,
                                           Object right)

withNewPositiveAlternative

public TernaryFluent.PositiveAlternativeNested<A> withNewPositiveAlternative()

withNewPositiveAlternativeLike

public TernaryFluent.PositiveAlternativeNested<A> withNewPositiveAlternativeLike(io.sundr.model.Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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