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, DeclareFluent.TernaryValueNested, DoFluent.TernaryConditionNested, EnclosedFluent.TernaryExpresionNested, ForeachFluent.TernaryExpressionNested, ForFluent.TernaryCompareNested, ForFluent.TernaryInitNested, ForFluent.TernaryUpdateNested, IfDslConditionStepFluent.TernaryConditionNested, IfDslThenStepFluent.TernaryConditionNested, IfFluent.TernaryConditionNested, IndexFluent.TernaryExpressionNested, InstanceOfFluent.TernaryExpressionNested, InverseFluent.TernaryExpresionNested, MethodCallFluent.TernaryArgumentsNested, NegativeFluent.TernaryExpresionNested, NewArrayFluent.TernaryExpressionsNested, NotFluent.TernaryExpresionNested, PositiveFluent.TernaryExpresionNested, PostDecrementFluent.TernaryExpressionNested, PostIncrementFluent.TernaryExpressionNested, PreDecrementFluent.TernaryExpressionNested, PreIncrementFluent.TernaryExpressionNested, PropertyFluent.TernaryInitialValueNested, ReturnFluent.TernaryExpressionNested, SwitchFluent.TernaryExpressionNested, SynchronizedFluent.TernaryLockExpressionNested, TernaryBuilder, TernaryFluent.TernaryAlternativeNested, TernaryFluent.TernaryConditionNested, TernaryFluent.TernaryResultNested, ThrowFluent.TernaryExceptionNested, WhileFluent.TernaryConditionNested, WithScopeFluent.TernaryScopeNested

public class TernaryFluent<A extends TernaryFluent<A>>
extends 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.ClassRefAlternativeNested<N>
class	TernaryFluent.ClassRefConditionNested<N>
class	TernaryFluent.ClassRefResultNested<N>
class	TernaryFluent.ConstructAlternativeNested<N>
class	TernaryFluent.ConstructConditionNested<N>
class	TernaryFluent.ConstructResultNested<N>
class	TernaryFluent.ContextRefAlternativeNested<N>
class	TernaryFluent.ContextRefConditionNested<N>
class	TernaryFluent.ContextRefResultNested<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.DotClassAlternativeNested<N>
class	TernaryFluent.DotClassConditionNested<N>
class	TernaryFluent.DotClassResultNested<N>
class	TernaryFluent.EmptyAlternativeNested<N>
class	TernaryFluent.EmptyConditionNested<N>
class	TernaryFluent.EmptyResultNested<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.PropertyAlternativeNested<N>
class	TernaryFluent.PropertyConditionNested<N>
class	TernaryFluent.PropertyRefAlternativeNested<N>
class	TernaryFluent.PropertyRefConditionNested<N>
class	TernaryFluent.PropertyRefResultNested<N>
class	TernaryFluent.PropertyResultNested<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.SuperAlternativeNested<N>
class	TernaryFluent.SuperConditionNested<N>
class	TernaryFluent.SuperResultNested<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(Ternary instance)

Method Summary

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

TernaryFluent

public TernaryFluent()

TernaryFluent

public TernaryFluent(Ternary instance)

Method Details

buildAlternative

public Expression buildAlternative()

buildCondition

public Expression buildCondition()

buildResult

public Expression buildResult()

builder

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

copyInstance

protected void copyInstance(Ternary instance)

equals

public boolean equals(Object o)

Overrides:

equals in class BaseFluent<A extends TernaryFluent<A>>

hasAlternative

public boolean hasAlternative()

hasCondition

public boolean hasCondition()

hasResult

public boolean hasResult()

hashCode

public int hashCode()

Overrides:

hashCode in class BaseFluent<A extends TernaryFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

withAlternative

public A withAlternative(Expression alternative)

withCondition

public A withCondition(Expression condition)

withNewAssignAlternative

public TernaryFluent<A>.AssignAlternativeNested<A> withNewAssignAlternative()

withNewAssignAlternativeLike

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

withNewAssignCondition

public TernaryFluent<A>.AssignConditionNested<A> withNewAssignCondition()

withNewAssignConditionLike

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

withNewAssignResult

public TernaryFluent<A>.AssignResultNested<A> withNewAssignResult()

withNewAssignResultLike

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

withNewBinaryExpressionAlternative

public TernaryFluent<A>.BinaryExpressionAlternativeNested<A> withNewBinaryExpressionAlternative()

withNewBinaryExpressionAlternativeLike

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

withNewBinaryExpressionCondition

public TernaryFluent<A>.BinaryExpressionConditionNested<A> withNewBinaryExpressionCondition()

withNewBinaryExpressionConditionLike

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

withNewBinaryExpressionResult

public TernaryFluent<A>.BinaryExpressionResultNested<A> withNewBinaryExpressionResult()

withNewBinaryExpressionResultLike

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

withNewBitwiseAndAlternative

public TernaryFluent<A>.BitwiseAndAlternativeNested<A> withNewBitwiseAndAlternative()

withNewBitwiseAndAlternative

public A withNewBitwiseAndAlternative(Object left,
 Object right)

withNewBitwiseAndAlternativeLike

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

withNewBitwiseAndCondition

public TernaryFluent<A>.BitwiseAndConditionNested<A> withNewBitwiseAndCondition()

withNewBitwiseAndCondition

public A withNewBitwiseAndCondition(Object left,
 Object right)

withNewBitwiseAndConditionLike

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

withNewBitwiseAndResult

public TernaryFluent<A>.BitwiseAndResultNested<A> withNewBitwiseAndResult()

withNewBitwiseAndResult

public A withNewBitwiseAndResult(Object left,
 Object right)

withNewBitwiseAndResultLike

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

withNewBitwiseOrAlternative

public TernaryFluent<A>.BitwiseOrAlternativeNested<A> withNewBitwiseOrAlternative()

withNewBitwiseOrAlternative

public A withNewBitwiseOrAlternative(Object left,
 Object right)

withNewBitwiseOrAlternativeLike

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

withNewBitwiseOrCondition

public TernaryFluent<A>.BitwiseOrConditionNested<A> withNewBitwiseOrCondition()

withNewBitwiseOrCondition

public A withNewBitwiseOrCondition(Object left,
 Object right)

withNewBitwiseOrConditionLike

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

withNewBitwiseOrResult

public TernaryFluent<A>.BitwiseOrResultNested<A> withNewBitwiseOrResult()

withNewBitwiseOrResult

public A withNewBitwiseOrResult(Object left,
 Object right)

withNewBitwiseOrResultLike

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

withNewCastAlternative

public TernaryFluent<A>.CastAlternativeNested<A> withNewCastAlternative()

withNewCastAlternativeLike

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

withNewCastCondition

public TernaryFluent<A>.CastConditionNested<A> withNewCastCondition()

withNewCastConditionLike

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

withNewCastResult

public TernaryFluent<A>.CastResultNested<A> withNewCastResult()

withNewCastResultLike

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

withNewClassRefAlternative

public TernaryFluent<A>.ClassRefAlternativeNested<A> withNewClassRefAlternative()

withNewClassRefAlternativeLike

public TernaryFluent<A>.ClassRefAlternativeNested<A> withNewClassRefAlternativeLike(ClassRef item)

withNewClassRefCondition

public TernaryFluent<A>.ClassRefConditionNested<A> withNewClassRefCondition()

withNewClassRefConditionLike

public TernaryFluent<A>.ClassRefConditionNested<A> withNewClassRefConditionLike(ClassRef item)

withNewClassRefResult

public TernaryFluent<A>.ClassRefResultNested<A> withNewClassRefResult()

withNewClassRefResultLike

public TernaryFluent<A>.ClassRefResultNested<A> withNewClassRefResultLike(ClassRef item)

withNewConstructAlternative

public TernaryFluent<A>.ConstructAlternativeNested<A> withNewConstructAlternative()

withNewConstructAlternativeLike

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

withNewConstructCondition

public TernaryFluent<A>.ConstructConditionNested<A> withNewConstructCondition()

withNewConstructConditionLike

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

withNewConstructResult

public TernaryFluent<A>.ConstructResultNested<A> withNewConstructResult()

withNewConstructResultLike

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

withNewContextRefAlternative

public TernaryFluent<A>.ContextRefAlternativeNested<A> withNewContextRefAlternative()

withNewContextRefAlternative

public A withNewContextRefAlternative(String name)

withNewContextRefAlternativeLike

public TernaryFluent<A>.ContextRefAlternativeNested<A> withNewContextRefAlternativeLike(ContextRef item)

withNewContextRefCondition

public TernaryFluent<A>.ContextRefConditionNested<A> withNewContextRefCondition()

withNewContextRefCondition

public A withNewContextRefCondition(String name)

withNewContextRefConditionLike

public TernaryFluent<A>.ContextRefConditionNested<A> withNewContextRefConditionLike(ContextRef item)

withNewContextRefResult

public TernaryFluent<A>.ContextRefResultNested<A> withNewContextRefResult()

withNewContextRefResult

public A withNewContextRefResult(String name)

withNewContextRefResultLike

public TernaryFluent<A>.ContextRefResultNested<A> withNewContextRefResultLike(ContextRef item)

withNewDeclareAlternative

public TernaryFluent<A>.DeclareAlternativeNested<A> withNewDeclareAlternative()

withNewDeclareAlternative

public A withNewDeclareAlternative(Class type,
 String name)

withNewDeclareAlternative

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

withNewDeclareAlternativeLike

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

withNewDeclareCondition

public TernaryFluent<A>.DeclareConditionNested<A> withNewDeclareCondition()

withNewDeclareCondition

public A withNewDeclareCondition(Class type,
 String name)

withNewDeclareCondition

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

withNewDeclareConditionLike

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

withNewDeclareResult

public TernaryFluent<A>.DeclareResultNested<A> withNewDeclareResult()

withNewDeclareResult

public A withNewDeclareResult(Class type,
 String name)

withNewDeclareResult

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

withNewDeclareResultLike

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

withNewDivideAlternative

public TernaryFluent<A>.DivideAlternativeNested<A> withNewDivideAlternative()

withNewDivideAlternative

public A withNewDivideAlternative(Object left,
 Object right)

withNewDivideAlternativeLike

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

withNewDivideCondition

public TernaryFluent<A>.DivideConditionNested<A> withNewDivideCondition()

withNewDivideCondition

public A withNewDivideCondition(Object left,
 Object right)

withNewDivideConditionLike

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

withNewDivideResult

public TernaryFluent<A>.DivideResultNested<A> withNewDivideResult()

withNewDivideResult

public A withNewDivideResult(Object left,
 Object right)

withNewDivideResultLike

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

withNewDotClassAlternative

public TernaryFluent<A>.DotClassAlternativeNested<A> withNewDotClassAlternative()

withNewDotClassAlternativeLike

public TernaryFluent<A>.DotClassAlternativeNested<A> withNewDotClassAlternativeLike(DotClass item)

withNewDotClassCondition

public TernaryFluent<A>.DotClassConditionNested<A> withNewDotClassCondition()

withNewDotClassConditionLike

public TernaryFluent<A>.DotClassConditionNested<A> withNewDotClassConditionLike(DotClass item)

withNewDotClassResult

public TernaryFluent<A>.DotClassResultNested<A> withNewDotClassResult()

withNewDotClassResultLike

public TernaryFluent<A>.DotClassResultNested<A> withNewDotClassResultLike(DotClass item)

withNewEmptyAlternative

public TernaryFluent<A>.EmptyAlternativeNested<A> withNewEmptyAlternative()

withNewEmptyAlternativeLike

public TernaryFluent<A>.EmptyAlternativeNested<A> withNewEmptyAlternativeLike(Empty item)

withNewEmptyCondition

public TernaryFluent<A>.EmptyConditionNested<A> withNewEmptyCondition()

withNewEmptyConditionLike

public TernaryFluent<A>.EmptyConditionNested<A> withNewEmptyConditionLike(Empty item)

withNewEmptyResult

public TernaryFluent<A>.EmptyResultNested<A> withNewEmptyResult()

withNewEmptyResultLike

public TernaryFluent<A>.EmptyResultNested<A> withNewEmptyResultLike(Empty item)

withNewEnclosedAlternative

public TernaryFluent<A>.EnclosedAlternativeNested<A> withNewEnclosedAlternative()

withNewEnclosedAlternativeLike

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

withNewEnclosedCondition

public TernaryFluent<A>.EnclosedConditionNested<A> withNewEnclosedCondition()

withNewEnclosedConditionLike

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

withNewEnclosedResult

public TernaryFluent<A>.EnclosedResultNested<A> withNewEnclosedResult()

withNewEnclosedResultLike

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

withNewEqualsAlternative

public TernaryFluent<A>.EqualsAlternativeNested<A> withNewEqualsAlternative()

withNewEqualsAlternative

public A withNewEqualsAlternative(Object left,
 Object right)

withNewEqualsAlternativeLike

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

withNewEqualsCondition

public TernaryFluent<A>.EqualsConditionNested<A> withNewEqualsCondition()

withNewEqualsCondition

public A withNewEqualsCondition(Object left,
 Object right)

withNewEqualsConditionLike

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

withNewEqualsResult

public TernaryFluent<A>.EqualsResultNested<A> withNewEqualsResult()

withNewEqualsResult

public A withNewEqualsResult(Object left,
 Object right)

withNewEqualsResultLike

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

withNewGreaterThanAlternative

public TernaryFluent<A>.GreaterThanAlternativeNested<A> withNewGreaterThanAlternative()

withNewGreaterThanAlternative

public A withNewGreaterThanAlternative(Object left,
 Object right)

withNewGreaterThanAlternativeLike

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

withNewGreaterThanCondition

public TernaryFluent<A>.GreaterThanConditionNested<A> withNewGreaterThanCondition()

withNewGreaterThanCondition

public A withNewGreaterThanCondition(Object left,
 Object right)

withNewGreaterThanConditionLike

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

withNewGreaterThanOrEqualAlternative

public TernaryFluent<A>.GreaterThanOrEqualAlternativeNested<A> withNewGreaterThanOrEqualAlternative()

withNewGreaterThanOrEqualAlternative

public A withNewGreaterThanOrEqualAlternative(Object left,
 Object right)

withNewGreaterThanOrEqualAlternativeLike

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

withNewGreaterThanOrEqualCondition

public TernaryFluent<A>.GreaterThanOrEqualConditionNested<A> withNewGreaterThanOrEqualCondition()

withNewGreaterThanOrEqualCondition

public A withNewGreaterThanOrEqualCondition(Object left,
 Object right)

withNewGreaterThanOrEqualConditionLike

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

withNewGreaterThanOrEqualResult

public TernaryFluent<A>.GreaterThanOrEqualResultNested<A> withNewGreaterThanOrEqualResult()

withNewGreaterThanOrEqualResult

public A withNewGreaterThanOrEqualResult(Object left,
 Object right)

withNewGreaterThanOrEqualResultLike

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

withNewGreaterThanResult

public TernaryFluent<A>.GreaterThanResultNested<A> withNewGreaterThanResult()

withNewGreaterThanResult

public A withNewGreaterThanResult(Object left,
 Object right)

withNewGreaterThanResultLike

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

withNewIndexAlternative

public TernaryFluent<A>.IndexAlternativeNested<A> withNewIndexAlternative()

withNewIndexAlternativeLike

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

withNewIndexCondition

public TernaryFluent<A>.IndexConditionNested<A> withNewIndexCondition()

withNewIndexConditionLike

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

withNewIndexResult

public TernaryFluent<A>.IndexResultNested<A> withNewIndexResult()

withNewIndexResultLike

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

withNewInstanceOfAlternative

public TernaryFluent<A>.InstanceOfAlternativeNested<A> withNewInstanceOfAlternative()

withNewInstanceOfAlternativeLike

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

withNewInstanceOfCondition

public TernaryFluent<A>.InstanceOfConditionNested<A> withNewInstanceOfCondition()

withNewInstanceOfConditionLike

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

withNewInstanceOfResult

public TernaryFluent<A>.InstanceOfResultNested<A> withNewInstanceOfResult()

withNewInstanceOfResultLike

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

withNewInverseAlternative

public TernaryFluent<A>.InverseAlternativeNested<A> withNewInverseAlternative()

withNewInverseAlternativeLike

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

withNewInverseCondition

public TernaryFluent<A>.InverseConditionNested<A> withNewInverseCondition()

withNewInverseConditionLike

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

withNewInverseResult

public TernaryFluent<A>.InverseResultNested<A> withNewInverseResult()

withNewInverseResultLike

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

withNewLambdaAlternative

public TernaryFluent<A>.LambdaAlternativeNested<A> withNewLambdaAlternative()

withNewLambdaAlternativeLike

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

withNewLambdaCondition

public TernaryFluent<A>.LambdaConditionNested<A> withNewLambdaCondition()

withNewLambdaConditionLike

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

withNewLambdaResult

public TernaryFluent<A>.LambdaResultNested<A> withNewLambdaResult()

withNewLambdaResultLike

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

withNewLeftShiftAlternative

public TernaryFluent<A>.LeftShiftAlternativeNested<A> withNewLeftShiftAlternative()

withNewLeftShiftAlternative

public A withNewLeftShiftAlternative(Object left,
 Object right)

withNewLeftShiftAlternativeLike

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

withNewLeftShiftCondition

public TernaryFluent<A>.LeftShiftConditionNested<A> withNewLeftShiftCondition()

withNewLeftShiftCondition

public A withNewLeftShiftCondition(Object left,
 Object right)

withNewLeftShiftConditionLike

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

withNewLeftShiftResult

public TernaryFluent<A>.LeftShiftResultNested<A> withNewLeftShiftResult()

withNewLeftShiftResult

public A withNewLeftShiftResult(Object left,
 Object right)

withNewLeftShiftResultLike

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

withNewLessThanAlternative

public TernaryFluent<A>.LessThanAlternativeNested<A> withNewLessThanAlternative()

withNewLessThanAlternative

public A withNewLessThanAlternative(Object left,
 Object right)

withNewLessThanAlternativeLike

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

withNewLessThanCondition

public TernaryFluent<A>.LessThanConditionNested<A> withNewLessThanCondition()

withNewLessThanCondition

public A withNewLessThanCondition(Object left,
 Object right)

withNewLessThanConditionLike

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

withNewLessThanOrEqualAlternative

public TernaryFluent<A>.LessThanOrEqualAlternativeNested<A> withNewLessThanOrEqualAlternative()

withNewLessThanOrEqualAlternative

public A withNewLessThanOrEqualAlternative(Object left,
 Object right)

withNewLessThanOrEqualAlternativeLike

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

withNewLessThanOrEqualCondition

public TernaryFluent<A>.LessThanOrEqualConditionNested<A> withNewLessThanOrEqualCondition()

withNewLessThanOrEqualCondition

public A withNewLessThanOrEqualCondition(Object left,
 Object right)

withNewLessThanOrEqualConditionLike

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

withNewLessThanOrEqualResult

public TernaryFluent<A>.LessThanOrEqualResultNested<A> withNewLessThanOrEqualResult()

withNewLessThanOrEqualResult

public A withNewLessThanOrEqualResult(Object left,
 Object right)

withNewLessThanOrEqualResultLike

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

withNewLessThanResult

public TernaryFluent<A>.LessThanResultNested<A> withNewLessThanResult()

withNewLessThanResult

public A withNewLessThanResult(Object left,
 Object right)

withNewLessThanResultLike

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

withNewLogicalAndAlternative

public TernaryFluent<A>.LogicalAndAlternativeNested<A> withNewLogicalAndAlternative()

withNewLogicalAndAlternative

public A withNewLogicalAndAlternative(Object left,
 Object right)

withNewLogicalAndAlternativeLike

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

withNewLogicalAndCondition

public TernaryFluent<A>.LogicalAndConditionNested<A> withNewLogicalAndCondition()

withNewLogicalAndCondition

public A withNewLogicalAndCondition(Object left,
 Object right)

withNewLogicalAndConditionLike

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

withNewLogicalAndResult

public TernaryFluent<A>.LogicalAndResultNested<A> withNewLogicalAndResult()

withNewLogicalAndResult

public A withNewLogicalAndResult(Object left,
 Object right)

withNewLogicalAndResultLike

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

withNewLogicalOrAlternative

public TernaryFluent<A>.LogicalOrAlternativeNested<A> withNewLogicalOrAlternative()

withNewLogicalOrAlternative

public A withNewLogicalOrAlternative(Object left,
 Object right)

withNewLogicalOrAlternativeLike

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

withNewLogicalOrCondition

public TernaryFluent<A>.LogicalOrConditionNested<A> withNewLogicalOrCondition()

withNewLogicalOrCondition

public A withNewLogicalOrCondition(Object left,
 Object right)

withNewLogicalOrConditionLike

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

withNewLogicalOrResult

public TernaryFluent<A>.LogicalOrResultNested<A> withNewLogicalOrResult()

withNewLogicalOrResult

public A withNewLogicalOrResult(Object left,
 Object right)

withNewLogicalOrResultLike

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

withNewMethodCallAlternative

public TernaryFluent<A>.MethodCallAlternativeNested<A> withNewMethodCallAlternative()

withNewMethodCallAlternativeLike

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

withNewMethodCallCondition

public TernaryFluent<A>.MethodCallConditionNested<A> withNewMethodCallCondition()

withNewMethodCallConditionLike

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

withNewMethodCallResult

public TernaryFluent<A>.MethodCallResultNested<A> withNewMethodCallResult()

withNewMethodCallResultLike

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

withNewMinusAlternative

public TernaryFluent<A>.MinusAlternativeNested<A> withNewMinusAlternative()

withNewMinusAlternative

public A withNewMinusAlternative(Object left,
 Object right)

withNewMinusAlternativeLike

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

withNewMinusCondition

public TernaryFluent<A>.MinusConditionNested<A> withNewMinusCondition()

withNewMinusCondition

public A withNewMinusCondition(Object left,
 Object right)

withNewMinusConditionLike

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

withNewMinusResult

public TernaryFluent<A>.MinusResultNested<A> withNewMinusResult()

withNewMinusResult

public A withNewMinusResult(Object left,
 Object right)

withNewMinusResultLike

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

withNewModuloAlternative

public TernaryFluent<A>.ModuloAlternativeNested<A> withNewModuloAlternative()

withNewModuloAlternative

public A withNewModuloAlternative(Object left,
 Object right)

withNewModuloAlternativeLike

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

withNewModuloCondition

public TernaryFluent<A>.ModuloConditionNested<A> withNewModuloCondition()

withNewModuloCondition

public A withNewModuloCondition(Object left,
 Object right)

withNewModuloConditionLike

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

withNewModuloResult

public TernaryFluent<A>.ModuloResultNested<A> withNewModuloResult()

withNewModuloResult

public A withNewModuloResult(Object left,
 Object right)

withNewModuloResultLike

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

withNewMultiplyAlternative

public TernaryFluent<A>.MultiplyAlternativeNested<A> withNewMultiplyAlternative()

withNewMultiplyAlternative

public A withNewMultiplyAlternative(Object left,
 Object right)

withNewMultiplyAlternativeLike

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

withNewMultiplyCondition

public TernaryFluent<A>.MultiplyConditionNested<A> withNewMultiplyCondition()

withNewMultiplyCondition

public A withNewMultiplyCondition(Object left,
 Object right)

withNewMultiplyConditionLike

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

withNewMultiplyResult

public TernaryFluent<A>.MultiplyResultNested<A> withNewMultiplyResult()

withNewMultiplyResult

public A withNewMultiplyResult(Object left,
 Object right)

withNewMultiplyResultLike

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

withNewNegativeAlternative

public TernaryFluent<A>.NegativeAlternativeNested<A> withNewNegativeAlternative()

withNewNegativeAlternativeLike

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

withNewNegativeCondition

public TernaryFluent<A>.NegativeConditionNested<A> withNewNegativeCondition()

withNewNegativeConditionLike

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

withNewNegativeResult

public TernaryFluent<A>.NegativeResultNested<A> withNewNegativeResult()

withNewNegativeResultLike

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

withNewNewArrayAlternative

public TernaryFluent<A>.NewArrayAlternativeNested<A> withNewNewArrayAlternative()

withNewNewArrayAlternative

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

withNewNewArrayAlternativeLike

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

withNewNewArrayCondition

public TernaryFluent<A>.NewArrayConditionNested<A> withNewNewArrayCondition()

withNewNewArrayCondition

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

withNewNewArrayConditionLike

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

withNewNewArrayResult

public TernaryFluent<A>.NewArrayResultNested<A> withNewNewArrayResult()

withNewNewArrayResult

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

withNewNewArrayResultLike

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

withNewNotAlternative

public TernaryFluent<A>.NotAlternativeNested<A> withNewNotAlternative()

withNewNotAlternativeLike

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

withNewNotCondition

public TernaryFluent<A>.NotConditionNested<A> withNewNotCondition()

withNewNotConditionLike

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

withNewNotEqualsAlternative

public TernaryFluent<A>.NotEqualsAlternativeNested<A> withNewNotEqualsAlternative()

withNewNotEqualsAlternative

public A withNewNotEqualsAlternative(Object left,
 Object right)

withNewNotEqualsAlternativeLike

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

withNewNotEqualsCondition

public TernaryFluent<A>.NotEqualsConditionNested<A> withNewNotEqualsCondition()

withNewNotEqualsCondition

public A withNewNotEqualsCondition(Object left,
 Object right)

withNewNotEqualsConditionLike

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

withNewNotEqualsResult

public TernaryFluent<A>.NotEqualsResultNested<A> withNewNotEqualsResult()

withNewNotEqualsResult

public A withNewNotEqualsResult(Object left,
 Object right)

withNewNotEqualsResultLike

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

withNewNotResult

public TernaryFluent<A>.NotResultNested<A> withNewNotResult()

withNewNotResultLike

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

withNewPlusAlternative

public TernaryFluent<A>.PlusAlternativeNested<A> withNewPlusAlternative()

withNewPlusAlternative

public A withNewPlusAlternative(Object left,
 Object right)

withNewPlusAlternativeLike

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

withNewPlusCondition

public TernaryFluent<A>.PlusConditionNested<A> withNewPlusCondition()

withNewPlusCondition

public A withNewPlusCondition(Object left,
 Object right)

withNewPlusConditionLike

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

withNewPlusResult

public TernaryFluent<A>.PlusResultNested<A> withNewPlusResult()

withNewPlusResult

public A withNewPlusResult(Object left,
 Object right)

withNewPlusResultLike

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

withNewPositiveAlternative

public TernaryFluent<A>.PositiveAlternativeNested<A> withNewPositiveAlternative()

withNewPositiveAlternativeLike

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

withNewPositiveCondition

public TernaryFluent<A>.PositiveConditionNested<A> withNewPositiveCondition()

withNewPositiveConditionLike

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

withNewPositiveResult

public TernaryFluent<A>.PositiveResultNested<A> withNewPositiveResult()

withNewPositiveResultLike

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

withNewPostDecrementAlternative

public TernaryFluent<A>.PostDecrementAlternativeNested<A> withNewPostDecrementAlternative()

withNewPostDecrementAlternativeLike

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

withNewPostDecrementCondition

public TernaryFluent<A>.PostDecrementConditionNested<A> withNewPostDecrementCondition()

withNewPostDecrementConditionLike

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

withNewPostDecrementResult

public TernaryFluent<A>.PostDecrementResultNested<A> withNewPostDecrementResult()

withNewPostDecrementResultLike

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

withNewPostIncrementAlternative

public TernaryFluent<A>.PostIncrementAlternativeNested<A> withNewPostIncrementAlternative()

withNewPostIncrementAlternativeLike

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

withNewPostIncrementCondition

public TernaryFluent<A>.PostIncrementConditionNested<A> withNewPostIncrementCondition()

withNewPostIncrementConditionLike

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

withNewPostIncrementResult

public TernaryFluent<A>.PostIncrementResultNested<A> withNewPostIncrementResult()

withNewPostIncrementResultLike

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

withNewPreDecrementAlternative

public TernaryFluent<A>.PreDecrementAlternativeNested<A> withNewPreDecrementAlternative()

withNewPreDecrementAlternativeLike

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

withNewPreDecrementCondition

public TernaryFluent<A>.PreDecrementConditionNested<A> withNewPreDecrementCondition()

withNewPreDecrementConditionLike

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

withNewPreDecrementResult

public TernaryFluent<A>.PreDecrementResultNested<A> withNewPreDecrementResult()

withNewPreDecrementResultLike

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

withNewPreIncrementAlternative

public TernaryFluent<A>.PreIncrementAlternativeNested<A> withNewPreIncrementAlternative()

withNewPreIncrementAlternativeLike

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

withNewPreIncrementCondition

public TernaryFluent<A>.PreIncrementConditionNested<A> withNewPreIncrementCondition()

withNewPreIncrementConditionLike

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

withNewPreIncrementResult

public TernaryFluent<A>.PreIncrementResultNested<A> withNewPreIncrementResult()

withNewPreIncrementResultLike

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

withNewPropertyAlternative

public TernaryFluent<A>.PropertyAlternativeNested<A> withNewPropertyAlternative()

withNewPropertyAlternativeLike

public TernaryFluent<A>.PropertyAlternativeNested<A> withNewPropertyAlternativeLike(Property item)

withNewPropertyCondition

public TernaryFluent<A>.PropertyConditionNested<A> withNewPropertyCondition()

withNewPropertyConditionLike

public TernaryFluent<A>.PropertyConditionNested<A> withNewPropertyConditionLike(Property item)

withNewPropertyRefAlternative

public TernaryFluent<A>.PropertyRefAlternativeNested<A> withNewPropertyRefAlternative()

withNewPropertyRefAlternativeLike

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

withNewPropertyRefCondition

public TernaryFluent<A>.PropertyRefConditionNested<A> withNewPropertyRefCondition()

withNewPropertyRefConditionLike

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

withNewPropertyRefResult

public TernaryFluent<A>.PropertyRefResultNested<A> withNewPropertyRefResult()

withNewPropertyRefResultLike

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

withNewPropertyResult

public TernaryFluent<A>.PropertyResultNested<A> withNewPropertyResult()

withNewPropertyResultLike

public TernaryFluent<A>.PropertyResultNested<A> withNewPropertyResultLike(Property item)

withNewRightShiftAlternative

public TernaryFluent<A>.RightShiftAlternativeNested<A> withNewRightShiftAlternative()

withNewRightShiftAlternative

public A withNewRightShiftAlternative(Object left,
 Object right)

withNewRightShiftAlternativeLike

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

withNewRightShiftCondition

public TernaryFluent<A>.RightShiftConditionNested<A> withNewRightShiftCondition()

withNewRightShiftCondition

public A withNewRightShiftCondition(Object left,
 Object right)

withNewRightShiftConditionLike

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

withNewRightShiftResult

public TernaryFluent<A>.RightShiftResultNested<A> withNewRightShiftResult()

withNewRightShiftResult

public A withNewRightShiftResult(Object left,
 Object right)

withNewRightShiftResultLike

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

withNewRightUnsignedShiftAlternative

public TernaryFluent<A>.RightUnsignedShiftAlternativeNested<A> withNewRightUnsignedShiftAlternative()

withNewRightUnsignedShiftAlternative

public A withNewRightUnsignedShiftAlternative(Object left,
 Object right)

withNewRightUnsignedShiftAlternativeLike

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

withNewRightUnsignedShiftCondition

public TernaryFluent<A>.RightUnsignedShiftConditionNested<A> withNewRightUnsignedShiftCondition()

withNewRightUnsignedShiftCondition

public A withNewRightUnsignedShiftCondition(Object left,
 Object right)

withNewRightUnsignedShiftConditionLike

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

withNewRightUnsignedShiftResult

public TernaryFluent<A>.RightUnsignedShiftResultNested<A> withNewRightUnsignedShiftResult()

withNewRightUnsignedShiftResult

public A withNewRightUnsignedShiftResult(Object left,
 Object right)

withNewRightUnsignedShiftResultLike

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

withNewSuperAlternative

public TernaryFluent<A>.SuperAlternativeNested<A> withNewSuperAlternative()

withNewSuperAlternativeLike

public TernaryFluent<A>.SuperAlternativeNested<A> withNewSuperAlternativeLike(Super item)

withNewSuperCondition

public TernaryFluent<A>.SuperConditionNested<A> withNewSuperCondition()

withNewSuperConditionLike

public TernaryFluent<A>.SuperConditionNested<A> withNewSuperConditionLike(Super item)

withNewSuperResult

public TernaryFluent<A>.SuperResultNested<A> withNewSuperResult()

withNewSuperResultLike

public TernaryFluent<A>.SuperResultNested<A> withNewSuperResultLike(Super item)

withNewTernaryAlternative

public TernaryFluent<A>.TernaryAlternativeNested<A> withNewTernaryAlternative()

withNewTernaryAlternativeLike

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

withNewTernaryCondition

public TernaryFluent<A>.TernaryConditionNested<A> withNewTernaryCondition()

withNewTernaryConditionLike

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

withNewTernaryResult

public TernaryFluent<A>.TernaryResultNested<A> withNewTernaryResult()

withNewTernaryResultLike

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

withNewThisAlternative

public TernaryFluent<A>.ThisAlternativeNested<A> withNewThisAlternative()

withNewThisAlternativeLike

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

withNewThisCondition

public TernaryFluent<A>.ThisConditionNested<A> withNewThisCondition()

withNewThisConditionLike

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

withNewThisResult

public TernaryFluent<A>.ThisResultNested<A> withNewThisResult()

withNewThisResultLike

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

withNewValueRefAlternative

public TernaryFluent<A>.ValueRefAlternativeNested<A> withNewValueRefAlternative()

withNewValueRefAlternative

public A withNewValueRefAlternative(Object value)

withNewValueRefAlternativeLike

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

withNewValueRefCondition

public TernaryFluent<A>.ValueRefConditionNested<A> withNewValueRefCondition()

withNewValueRefCondition

public A withNewValueRefCondition(Object value)

withNewValueRefConditionLike

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

withNewValueRefResult

public TernaryFluent<A>.ValueRefResultNested<A> withNewValueRefResult()

withNewValueRefResult

public A withNewValueRefResult(Object value)

withNewValueRefResultLike

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

withNewXorAlternative

public TernaryFluent<A>.XorAlternativeNested<A> withNewXorAlternative()

withNewXorAlternative

public A withNewXorAlternative(Object left,
 Object right)

withNewXorAlternativeLike

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

withNewXorCondition

public TernaryFluent<A>.XorConditionNested<A> withNewXorCondition()

withNewXorCondition

public A withNewXorCondition(Object left,
 Object right)

withNewXorConditionLike

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

withNewXorResult

public TernaryFluent<A>.XorResultNested<A> withNewXorResult()

withNewXorResult

public A withNewXorResult(Object left,
 Object right)

withNewXorResultLike

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

withResult

public A withResult(Expression result)