Package io.sundr.model

Class MethodCallFluent<A extends MethodCallFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.MethodCallFluent<A>

Direct Known Subclasses:

AssignFluent.MethodCallTargetNested, AssignFluent.MethodCallValueNested, BinaryExpressionFluent.MethodCallLeftNested, BinaryExpressionFluent.MethodCallRightNested, BlockFluent.MethodCallStatementsNested, CastFluent.MethodCallExpressionNested, ConstructFluent.MethodCallArgumentsNested, DoFluent.MethodCallConditionNested, DoFluent.MethodCallStatementNested, EnclosedFluent.MethodCallExpresionNested, ForeachFluent.MethodCallBodyNested, ForeachFluent.MethodCallExpressionNested, ForFluent.MethodCallBodyNested, ForFluent.MethodCallCompareNested, ForFluent.MethodCallInitNested, ForFluent.MethodCallUpdateNested, IfFluent.MethodCallConditionNested, IfFluent.MethodCallStatementNested, IndexFluent.MethodCallExpressionNested, IndexFluent.MethodCallScopeNested, InstanceOfFluent.MethodCallExpressionNested, InverseFluent.MethodCallExpresionNested, LambdaFluent.MethodCallStatementNested, MethodCallBuilder, MethodCallFluent.MethodCallArgumentsNested, MethodCallFluent.MethodCallScopeNested, NegativeFluent.MethodCallExpresionNested, NewArrayFluent.MethodCallExpressionsNested, NotFluent.MethodCallExpresionNested, PositiveFluent.MethodCallExpresionNested, PostDecrementFluent.MethodCallExpressionNested, PostIncrementFluent.MethodCallExpressionNested, PreDecrementFluent.MethodCallExpressionNested, PreIncrementFluent.MethodCallExpressionNested, PropertyRefFluent.MethodCallScopeNested, ReturnFluent.MethodCallExpressionNested, SwitchFluent.MethodCallExpressionNested, TernaryFluent.MethodCallAlternativeNested, TernaryFluent.MethodCallConditionNested, TernaryFluent.MethodCallResultNested, WhileFluent.MethodCallConditionNested, WhileFluent.MethodCallStatementNested

public class MethodCallFluent<A extends MethodCallFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	MethodCallFluent.AssignArgumentsNested<N>
class	MethodCallFluent.AssignScopeNested<N>
class	MethodCallFluent.BinaryExpressionArgumentsNested<N>
class	MethodCallFluent.BinaryExpressionScopeNested<N>
class	MethodCallFluent.BitwiseAndArgumentsNested<N>
class	MethodCallFluent.BitwiseAndScopeNested<N>
class	MethodCallFluent.BitwiseOrArgumentsNested<N>
class	MethodCallFluent.BitwiseOrScopeNested<N>
class	MethodCallFluent.CastArgumentsNested<N>
class	MethodCallFluent.CastScopeNested<N>
class	MethodCallFluent.ClassRefParametersNested<N>
class	MethodCallFluent.ConstructArgumentsNested<N>
class	MethodCallFluent.ConstructScopeNested<N>
class	MethodCallFluent.DeclareArgumentsNested<N>
class	MethodCallFluent.DeclareScopeNested<N>
class	MethodCallFluent.DivideArgumentsNested<N>
class	MethodCallFluent.DivideScopeNested<N>
class	MethodCallFluent.EnclosedArgumentsNested<N>
class	MethodCallFluent.EnclosedScopeNested<N>
class	MethodCallFluent.EqualsArgumentsNested<N>
class	MethodCallFluent.EqualsScopeNested<N>
class	MethodCallFluent.GreaterThanArgumentsNested<N>
class	MethodCallFluent.GreaterThanOrEqualArgumentsNested<N>
class	MethodCallFluent.GreaterThanOrEqualScopeNested<N>
class	MethodCallFluent.GreaterThanScopeNested<N>
class	MethodCallFluent.IndexArgumentsNested<N>
class	MethodCallFluent.IndexScopeNested<N>
class	MethodCallFluent.InstanceOfArgumentsNested<N>
class	MethodCallFluent.InstanceOfScopeNested<N>
class	MethodCallFluent.InverseArgumentsNested<N>
class	MethodCallFluent.InverseScopeNested<N>
class	MethodCallFluent.LambdaArgumentsNested<N>
class	MethodCallFluent.LambdaScopeNested<N>
class	MethodCallFluent.LeftShiftArgumentsNested<N>
class	MethodCallFluent.LeftShiftScopeNested<N>
class	MethodCallFluent.LessThanArgumentsNested<N>
class	MethodCallFluent.LessThanOrEqualArgumentsNested<N>
class	MethodCallFluent.LessThanOrEqualScopeNested<N>
class	MethodCallFluent.LessThanScopeNested<N>
class	MethodCallFluent.LogicalAndArgumentsNested<N>
class	MethodCallFluent.LogicalAndScopeNested<N>
class	MethodCallFluent.LogicalOrArgumentsNested<N>
class	MethodCallFluent.LogicalOrScopeNested<N>
class	MethodCallFluent.MethodCallArgumentsNested<N>
class	MethodCallFluent.MethodCallScopeNested<N>
class	MethodCallFluent.MinusArgumentsNested<N>
class	MethodCallFluent.MinusScopeNested<N>
class	MethodCallFluent.ModuloArgumentsNested<N>
class	MethodCallFluent.ModuloScopeNested<N>
class	MethodCallFluent.MultiplyArgumentsNested<N>
class	MethodCallFluent.MultiplyScopeNested<N>
class	MethodCallFluent.NegativeArgumentsNested<N>
class	MethodCallFluent.NegativeScopeNested<N>
class	MethodCallFluent.NewArrayArgumentsNested<N>
class	MethodCallFluent.NewArrayScopeNested<N>
class	MethodCallFluent.NotArgumentsNested<N>
class	MethodCallFluent.NotEqualsArgumentsNested<N>
class	MethodCallFluent.NotEqualsScopeNested<N>
class	MethodCallFluent.NotScopeNested<N>
class	MethodCallFluent.PlusArgumentsNested<N>
class	MethodCallFluent.PlusScopeNested<N>
class	MethodCallFluent.PositiveArgumentsNested<N>
class	MethodCallFluent.PositiveScopeNested<N>
class	MethodCallFluent.PostDecrementArgumentsNested<N>
class	MethodCallFluent.PostDecrementScopeNested<N>
class	MethodCallFluent.PostIncrementArgumentsNested<N>
class	MethodCallFluent.PostIncrementScopeNested<N>
class	MethodCallFluent.PreDecrementArgumentsNested<N>
class	MethodCallFluent.PreDecrementScopeNested<N>
class	MethodCallFluent.PreIncrementArgumentsNested<N>
class	MethodCallFluent.PreIncrementScopeNested<N>
class	MethodCallFluent.PrimitiveRefParametersNested<N>
class	MethodCallFluent.PropertyRefArgumentsNested<N>
class	MethodCallFluent.PropertyRefScopeNested<N>
class	MethodCallFluent.RightShiftArgumentsNested<N>
class	MethodCallFluent.RightShiftScopeNested<N>
class	MethodCallFluent.RightUnsignedShiftArgumentsNested<N>
class	MethodCallFluent.RightUnsignedShiftScopeNested<N>
class	MethodCallFluent.TernaryArgumentsNested<N>
class	MethodCallFluent.TernaryScopeNested<N>
class	MethodCallFluent.ThisArgumentsNested<N>
class	MethodCallFluent.ThisScopeNested<N>
class	MethodCallFluent.TypeParamRefParametersNested<N>
class	MethodCallFluent.ValueRefArgumentsNested<N>
class	MethodCallFluent.ValueRefScopeNested<N>
class	MethodCallFluent.VoidRefParametersNested<N>
class	MethodCallFluent.WildcardRefParametersNested<N>
class	MethodCallFluent.XorArgumentsNested<N>
class	MethodCallFluent.XorScopeNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
MethodCallFluent()
MethodCallFluent(MethodCall instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToArguments(Collection<Expression> items)
A	addAllToParameters(Collection<TypeRef> items)
MethodCallFluent.AssignArgumentsNested<A>	addNewAssignArgument()
MethodCallFluent.AssignArgumentsNested<A>	addNewAssignArgumentLike(Assign item)
MethodCallFluent.BinaryExpressionArgumentsNested<A>	addNewBinaryExpressionArgument()
MethodCallFluent.BinaryExpressionArgumentsNested<A>	addNewBinaryExpressionArgumentLike(BinaryExpression item)
MethodCallFluent.BitwiseAndArgumentsNested<A>	addNewBitwiseAndArgument()
A	addNewBitwiseAndArgument(Object left, Object right)
MethodCallFluent.BitwiseAndArgumentsNested<A>	addNewBitwiseAndArgumentLike(BitwiseAnd item)
MethodCallFluent.BitwiseOrArgumentsNested<A>	addNewBitwiseOrArgument()
A	addNewBitwiseOrArgument(Object left, Object right)
MethodCallFluent.BitwiseOrArgumentsNested<A>	addNewBitwiseOrArgumentLike(BitwiseOr item)
MethodCallFluent.CastArgumentsNested<A>	addNewCastArgument()
MethodCallFluent.CastArgumentsNested<A>	addNewCastArgumentLike(Cast item)
MethodCallFluent.ClassRefParametersNested<A>	addNewClassRefParameter()
MethodCallFluent.ClassRefParametersNested<A>	addNewClassRefParameterLike(ClassRef item)
MethodCallFluent.ConstructArgumentsNested<A>	addNewConstructArgument()
MethodCallFluent.ConstructArgumentsNested<A>	addNewConstructArgumentLike(Construct item)
MethodCallFluent.DeclareArgumentsNested<A>	addNewDeclareArgument()
A	addNewDeclareArgument(Class type, String name)
A	addNewDeclareArgument(Class type, String name, Object value)
MethodCallFluent.DeclareArgumentsNested<A>	addNewDeclareArgumentLike(Declare item)
MethodCallFluent.DivideArgumentsNested<A>	addNewDivideArgument()
A	addNewDivideArgument(Object left, Object right)
MethodCallFluent.DivideArgumentsNested<A>	addNewDivideArgumentLike(Divide item)
MethodCallFluent.EnclosedArgumentsNested<A>	addNewEnclosedArgument()
MethodCallFluent.EnclosedArgumentsNested<A>	addNewEnclosedArgumentLike(Enclosed item)
MethodCallFluent.EqualsArgumentsNested<A>	addNewEqualsArgument()
A	addNewEqualsArgument(Object left, Object right)
MethodCallFluent.EqualsArgumentsNested<A>	addNewEqualsArgumentLike(Equals item)
MethodCallFluent.GreaterThanArgumentsNested<A>	addNewGreaterThanArgument()
A	addNewGreaterThanArgument(Object left, Object right)
MethodCallFluent.GreaterThanArgumentsNested<A>	addNewGreaterThanArgumentLike(GreaterThan item)
MethodCallFluent.GreaterThanOrEqualArgumentsNested<A>	addNewGreaterThanOrEqualArgument()
A	addNewGreaterThanOrEqualArgument(Object left, Object right)
MethodCallFluent.GreaterThanOrEqualArgumentsNested<A>	addNewGreaterThanOrEqualArgumentLike(GreaterThanOrEqual item)
MethodCallFluent.IndexArgumentsNested<A>	addNewIndexArgument()
MethodCallFluent.IndexArgumentsNested<A>	addNewIndexArgumentLike(Index item)
MethodCallFluent.InstanceOfArgumentsNested<A>	addNewInstanceOfArgument()
MethodCallFluent.InstanceOfArgumentsNested<A>	addNewInstanceOfArgumentLike(InstanceOf item)
MethodCallFluent.InverseArgumentsNested<A>	addNewInverseArgument()
MethodCallFluent.InverseArgumentsNested<A>	addNewInverseArgumentLike(Inverse item)
MethodCallFluent.LambdaArgumentsNested<A>	addNewLambdaArgument()
MethodCallFluent.LambdaArgumentsNested<A>	addNewLambdaArgumentLike(Lambda item)
MethodCallFluent.LeftShiftArgumentsNested<A>	addNewLeftShiftArgument()
A	addNewLeftShiftArgument(Object left, Object right)
MethodCallFluent.LeftShiftArgumentsNested<A>	addNewLeftShiftArgumentLike(LeftShift item)
MethodCallFluent.LessThanArgumentsNested<A>	addNewLessThanArgument()
A	addNewLessThanArgument(Object left, Object right)
MethodCallFluent.LessThanArgumentsNested<A>	addNewLessThanArgumentLike(LessThan item)
MethodCallFluent.LessThanOrEqualArgumentsNested<A>	addNewLessThanOrEqualArgument()
A	addNewLessThanOrEqualArgument(Object left, Object right)
MethodCallFluent.LessThanOrEqualArgumentsNested<A>	addNewLessThanOrEqualArgumentLike(LessThanOrEqual item)
MethodCallFluent.LogicalAndArgumentsNested<A>	addNewLogicalAndArgument()
A	addNewLogicalAndArgument(Object left, Object right)
MethodCallFluent.LogicalAndArgumentsNested<A>	addNewLogicalAndArgumentLike(LogicalAnd item)
MethodCallFluent.LogicalOrArgumentsNested<A>	addNewLogicalOrArgument()
A	addNewLogicalOrArgument(Object left, Object right)
MethodCallFluent.LogicalOrArgumentsNested<A>	addNewLogicalOrArgumentLike(LogicalOr item)
MethodCallFluent.MethodCallArgumentsNested<A>	addNewMethodCallArgument()
MethodCallFluent.MethodCallArgumentsNested<A>	addNewMethodCallArgumentLike(MethodCall item)
MethodCallFluent.MinusArgumentsNested<A>	addNewMinusArgument()
A	addNewMinusArgument(Object left, Object right)
MethodCallFluent.MinusArgumentsNested<A>	addNewMinusArgumentLike(Minus item)
MethodCallFluent.ModuloArgumentsNested<A>	addNewModuloArgument()
A	addNewModuloArgument(Object left, Object right)
MethodCallFluent.ModuloArgumentsNested<A>	addNewModuloArgumentLike(Modulo item)
MethodCallFluent.MultiplyArgumentsNested<A>	addNewMultiplyArgument()
A	addNewMultiplyArgument(Object left, Object right)
MethodCallFluent.MultiplyArgumentsNested<A>	addNewMultiplyArgumentLike(Multiply item)
MethodCallFluent.NegativeArgumentsNested<A>	addNewNegativeArgument()
MethodCallFluent.NegativeArgumentsNested<A>	addNewNegativeArgumentLike(Negative item)
MethodCallFluent.NewArrayArgumentsNested<A>	addNewNewArrayArgument()
A	addNewNewArrayArgument(Class type, Integer[] sizes)
MethodCallFluent.NewArrayArgumentsNested<A>	addNewNewArrayArgumentLike(NewArray item)
MethodCallFluent.NotArgumentsNested<A>	addNewNotArgument()
MethodCallFluent.NotArgumentsNested<A>	addNewNotArgumentLike(Not item)
MethodCallFluent.NotEqualsArgumentsNested<A>	addNewNotEqualsArgument()
A	addNewNotEqualsArgument(Object left, Object right)
MethodCallFluent.NotEqualsArgumentsNested<A>	addNewNotEqualsArgumentLike(NotEquals item)
MethodCallFluent.PlusArgumentsNested<A>	addNewPlusArgument()
A	addNewPlusArgument(Object left, Object right)
MethodCallFluent.PlusArgumentsNested<A>	addNewPlusArgumentLike(Plus item)
MethodCallFluent.PositiveArgumentsNested<A>	addNewPositiveArgument()
MethodCallFluent.PositiveArgumentsNested<A>	addNewPositiveArgumentLike(Positive item)
MethodCallFluent.PostDecrementArgumentsNested<A>	addNewPostDecrementArgument()
MethodCallFluent.PostDecrementArgumentsNested<A>	addNewPostDecrementArgumentLike(PostDecrement item)
MethodCallFluent.PostIncrementArgumentsNested<A>	addNewPostIncrementArgument()
MethodCallFluent.PostIncrementArgumentsNested<A>	addNewPostIncrementArgumentLike(PostIncrement item)
MethodCallFluent.PreDecrementArgumentsNested<A>	addNewPreDecrementArgument()
MethodCallFluent.PreDecrementArgumentsNested<A>	addNewPreDecrementArgumentLike(PreDecrement item)
MethodCallFluent.PreIncrementArgumentsNested<A>	addNewPreIncrementArgument()
MethodCallFluent.PreIncrementArgumentsNested<A>	addNewPreIncrementArgumentLike(PreIncrement item)
MethodCallFluent.PrimitiveRefParametersNested<A>	addNewPrimitiveRefParameter()
MethodCallFluent.PrimitiveRefParametersNested<A>	addNewPrimitiveRefParameterLike(PrimitiveRef item)
MethodCallFluent.PropertyRefArgumentsNested<A>	addNewPropertyRefArgument()
MethodCallFluent.PropertyRefArgumentsNested<A>	addNewPropertyRefArgumentLike(PropertyRef item)
MethodCallFluent.RightShiftArgumentsNested<A>	addNewRightShiftArgument()
A	addNewRightShiftArgument(Object left, Object right)
MethodCallFluent.RightShiftArgumentsNested<A>	addNewRightShiftArgumentLike(RightShift item)
MethodCallFluent.RightUnsignedShiftArgumentsNested<A>	addNewRightUnsignedShiftArgument()
A	addNewRightUnsignedShiftArgument(Object left, Object right)
MethodCallFluent.RightUnsignedShiftArgumentsNested<A>	addNewRightUnsignedShiftArgumentLike(RightUnsignedShift item)
MethodCallFluent.TernaryArgumentsNested<A>	addNewTernaryArgument()
MethodCallFluent.TernaryArgumentsNested<A>	addNewTernaryArgumentLike(Ternary item)
MethodCallFluent.ThisArgumentsNested<A>	addNewThisArgument()
MethodCallFluent.ThisArgumentsNested<A>	addNewThisArgumentLike(This item)
MethodCallFluent.TypeParamRefParametersNested<A>	addNewTypeParamRefParameter()
MethodCallFluent.TypeParamRefParametersNested<A>	addNewTypeParamRefParameterLike(TypeParamRef item)
MethodCallFluent.ValueRefArgumentsNested<A>	addNewValueRefArgument()
A	addNewValueRefArgument(Object value)
MethodCallFluent.ValueRefArgumentsNested<A>	addNewValueRefArgumentLike(ValueRef item)
MethodCallFluent.VoidRefParametersNested<A>	addNewVoidRefParameter()
MethodCallFluent.VoidRefParametersNested<A>	addNewVoidRefParameterLike(VoidRef item)
MethodCallFluent.WildcardRefParametersNested<A>	addNewWildcardRefParameter()
MethodCallFluent.WildcardRefParametersNested<A>	addNewWildcardRefParameterLike(WildcardRef item)
MethodCallFluent.XorArgumentsNested<A>	addNewXorArgument()
A	addNewXorArgument(Object left, Object right)
MethodCallFluent.XorArgumentsNested<A>	addNewXorArgumentLike(Xor item)
A	addToArguments(int index, VisitableBuilder<? extends Expression,?> builder)
A	addToArguments(int index, Expression item)
A	addToArguments(VisitableBuilder<? extends Expression,?> builder)
A	addToArguments(Expression... items)
A	addToParameters(int index, VisitableBuilder<? extends TypeRef,?> builder)
A	addToParameters(int index, TypeRef item)
A	addToParameters(VisitableBuilder<? extends TypeRef,?> builder)
A	addToParameters(TypeRef... items)
Expression	buildArgument(int index)
List<Expression>	buildArguments()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildFirstArgument()
TypeRef	buildFirstParameter()
Expression	buildLastArgument()
TypeRef	buildLastParameter()
Expression	buildMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
TypeRef	buildMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
TypeRef	buildParameter(int index)
List<TypeRef>	buildParameters()
Expression	buildScope()
protected void	copyInstance(MethodCall instance)
boolean	equals(Object o)
String	getName()
boolean	hasArguments()
int	hashCode()
boolean	hasMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
boolean	hasMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
boolean	hasName()
boolean	hasParameters()
boolean	hasScope()
A	removeAllFromArguments(Collection<Expression> items)
A	removeAllFromParameters(Collection<TypeRef> items)
A	removeFromArguments(VisitableBuilder<? extends Expression,?> builder)
A	removeFromArguments(Expression... items)
A	removeFromParameters(VisitableBuilder<? extends TypeRef,?> builder)
A	removeFromParameters(TypeRef... items)
A	removeMatchingFromArguments(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
A	removeMatchingFromParameters(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
MethodCallFluent.AssignArgumentsNested<A>	setNewAssignArgumentLike(int index, Assign item)
MethodCallFluent.BinaryExpressionArgumentsNested<A>	setNewBinaryExpressionArgumentLike(int index, BinaryExpression item)
MethodCallFluent.BitwiseAndArgumentsNested<A>	setNewBitwiseAndArgumentLike(int index, BitwiseAnd item)
MethodCallFluent.BitwiseOrArgumentsNested<A>	setNewBitwiseOrArgumentLike(int index, BitwiseOr item)
MethodCallFluent.CastArgumentsNested<A>	setNewCastArgumentLike(int index, Cast item)
MethodCallFluent.ClassRefParametersNested<A>	setNewClassRefParameterLike(int index, ClassRef item)
MethodCallFluent.ConstructArgumentsNested<A>	setNewConstructArgumentLike(int index, Construct item)
MethodCallFluent.DeclareArgumentsNested<A>	setNewDeclareArgumentLike(int index, Declare item)
MethodCallFluent.DivideArgumentsNested<A>	setNewDivideArgumentLike(int index, Divide item)
MethodCallFluent.EnclosedArgumentsNested<A>	setNewEnclosedArgumentLike(int index, Enclosed item)
MethodCallFluent.EqualsArgumentsNested<A>	setNewEqualsArgumentLike(int index, Equals item)
MethodCallFluent.GreaterThanArgumentsNested<A>	setNewGreaterThanArgumentLike(int index, GreaterThan item)
MethodCallFluent.GreaterThanOrEqualArgumentsNested<A>	setNewGreaterThanOrEqualArgumentLike(int index, GreaterThanOrEqual item)
MethodCallFluent.IndexArgumentsNested<A>	setNewIndexArgumentLike(int index, Index item)
MethodCallFluent.InstanceOfArgumentsNested<A>	setNewInstanceOfArgumentLike(int index, InstanceOf item)
MethodCallFluent.InverseArgumentsNested<A>	setNewInverseArgumentLike(int index, Inverse item)
MethodCallFluent.LambdaArgumentsNested<A>	setNewLambdaArgumentLike(int index, Lambda item)
MethodCallFluent.LeftShiftArgumentsNested<A>	setNewLeftShiftArgumentLike(int index, LeftShift item)
MethodCallFluent.LessThanArgumentsNested<A>	setNewLessThanArgumentLike(int index, LessThan item)
MethodCallFluent.LessThanOrEqualArgumentsNested<A>	setNewLessThanOrEqualArgumentLike(int index, LessThanOrEqual item)
MethodCallFluent.LogicalAndArgumentsNested<A>	setNewLogicalAndArgumentLike(int index, LogicalAnd item)
MethodCallFluent.LogicalOrArgumentsNested<A>	setNewLogicalOrArgumentLike(int index, LogicalOr item)
MethodCallFluent.MethodCallArgumentsNested<A>	setNewMethodCallArgumentLike(int index, MethodCall item)
MethodCallFluent.MinusArgumentsNested<A>	setNewMinusArgumentLike(int index, Minus item)
MethodCallFluent.ModuloArgumentsNested<A>	setNewModuloArgumentLike(int index, Modulo item)
MethodCallFluent.MultiplyArgumentsNested<A>	setNewMultiplyArgumentLike(int index, Multiply item)
MethodCallFluent.NegativeArgumentsNested<A>	setNewNegativeArgumentLike(int index, Negative item)
MethodCallFluent.NewArrayArgumentsNested<A>	setNewNewArrayArgumentLike(int index, NewArray item)
MethodCallFluent.NotArgumentsNested<A>	setNewNotArgumentLike(int index, Not item)
MethodCallFluent.NotEqualsArgumentsNested<A>	setNewNotEqualsArgumentLike(int index, NotEquals item)
MethodCallFluent.PlusArgumentsNested<A>	setNewPlusArgumentLike(int index, Plus item)
MethodCallFluent.PositiveArgumentsNested<A>	setNewPositiveArgumentLike(int index, Positive item)
MethodCallFluent.PostDecrementArgumentsNested<A>	setNewPostDecrementArgumentLike(int index, PostDecrement item)
MethodCallFluent.PostIncrementArgumentsNested<A>	setNewPostIncrementArgumentLike(int index, PostIncrement item)
MethodCallFluent.PreDecrementArgumentsNested<A>	setNewPreDecrementArgumentLike(int index, PreDecrement item)
MethodCallFluent.PreIncrementArgumentsNested<A>	setNewPreIncrementArgumentLike(int index, PreIncrement item)
MethodCallFluent.PrimitiveRefParametersNested<A>	setNewPrimitiveRefParameterLike(int index, PrimitiveRef item)
MethodCallFluent.PropertyRefArgumentsNested<A>	setNewPropertyRefArgumentLike(int index, PropertyRef item)
MethodCallFluent.RightShiftArgumentsNested<A>	setNewRightShiftArgumentLike(int index, RightShift item)
MethodCallFluent.RightUnsignedShiftArgumentsNested<A>	setNewRightUnsignedShiftArgumentLike(int index, RightUnsignedShift item)
MethodCallFluent.TernaryArgumentsNested<A>	setNewTernaryArgumentLike(int index, Ternary item)
MethodCallFluent.ThisArgumentsNested<A>	setNewThisArgumentLike(int index, This item)
MethodCallFluent.TypeParamRefParametersNested<A>	setNewTypeParamRefParameterLike(int index, TypeParamRef item)
MethodCallFluent.ValueRefArgumentsNested<A>	setNewValueRefArgumentLike(int index, ValueRef item)
MethodCallFluent.VoidRefParametersNested<A>	setNewVoidRefParameterLike(int index, VoidRef item)
MethodCallFluent.WildcardRefParametersNested<A>	setNewWildcardRefParameterLike(int index, WildcardRef item)
MethodCallFluent.XorArgumentsNested<A>	setNewXorArgumentLike(int index, Xor item)
A	setToArguments(int index, Expression item)
A	setToParameters(int index, TypeRef item)
String	toString()
A	withArguments(Expression... arguments)
A	withArguments(List<Expression> arguments)
A	withName(String name)
MethodCallFluent.AssignScopeNested<A>	withNewAssignScope()
MethodCallFluent.AssignScopeNested<A>	withNewAssignScopeLike(Assign item)
MethodCallFluent.BinaryExpressionScopeNested<A>	withNewBinaryExpressionScope()
MethodCallFluent.BinaryExpressionScopeNested<A>	withNewBinaryExpressionScopeLike(BinaryExpression item)
MethodCallFluent.BitwiseAndScopeNested<A>	withNewBitwiseAndScope()
A	withNewBitwiseAndScope(Object left, Object right)
MethodCallFluent.BitwiseAndScopeNested<A>	withNewBitwiseAndScopeLike(BitwiseAnd item)
MethodCallFluent.BitwiseOrScopeNested<A>	withNewBitwiseOrScope()
A	withNewBitwiseOrScope(Object left, Object right)
MethodCallFluent.BitwiseOrScopeNested<A>	withNewBitwiseOrScopeLike(BitwiseOr item)
MethodCallFluent.CastScopeNested<A>	withNewCastScope()
MethodCallFluent.CastScopeNested<A>	withNewCastScopeLike(Cast item)
MethodCallFluent.ConstructScopeNested<A>	withNewConstructScope()
MethodCallFluent.ConstructScopeNested<A>	withNewConstructScopeLike(Construct item)
MethodCallFluent.DeclareScopeNested<A>	withNewDeclareScope()
A	withNewDeclareScope(Class type, String name)
A	withNewDeclareScope(Class type, String name, Object value)
MethodCallFluent.DeclareScopeNested<A>	withNewDeclareScopeLike(Declare item)
MethodCallFluent.DivideScopeNested<A>	withNewDivideScope()
A	withNewDivideScope(Object left, Object right)
MethodCallFluent.DivideScopeNested<A>	withNewDivideScopeLike(Divide item)
MethodCallFluent.EnclosedScopeNested<A>	withNewEnclosedScope()
MethodCallFluent.EnclosedScopeNested<A>	withNewEnclosedScopeLike(Enclosed item)
MethodCallFluent.EqualsScopeNested<A>	withNewEqualsScope()
A	withNewEqualsScope(Object left, Object right)
MethodCallFluent.EqualsScopeNested<A>	withNewEqualsScopeLike(Equals item)
MethodCallFluent.GreaterThanOrEqualScopeNested<A>	withNewGreaterThanOrEqualScope()
A	withNewGreaterThanOrEqualScope(Object left, Object right)
MethodCallFluent.GreaterThanOrEqualScopeNested<A>	withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item)
MethodCallFluent.GreaterThanScopeNested<A>	withNewGreaterThanScope()
A	withNewGreaterThanScope(Object left, Object right)
MethodCallFluent.GreaterThanScopeNested<A>	withNewGreaterThanScopeLike(GreaterThan item)
MethodCallFluent.IndexScopeNested<A>	withNewIndexScope()
MethodCallFluent.IndexScopeNested<A>	withNewIndexScopeLike(Index item)
MethodCallFluent.InstanceOfScopeNested<A>	withNewInstanceOfScope()
MethodCallFluent.InstanceOfScopeNested<A>	withNewInstanceOfScopeLike(InstanceOf item)
MethodCallFluent.InverseScopeNested<A>	withNewInverseScope()
MethodCallFluent.InverseScopeNested<A>	withNewInverseScopeLike(Inverse item)
MethodCallFluent.LambdaScopeNested<A>	withNewLambdaScope()
MethodCallFluent.LambdaScopeNested<A>	withNewLambdaScopeLike(Lambda item)
MethodCallFluent.LeftShiftScopeNested<A>	withNewLeftShiftScope()
A	withNewLeftShiftScope(Object left, Object right)
MethodCallFluent.LeftShiftScopeNested<A>	withNewLeftShiftScopeLike(LeftShift item)
MethodCallFluent.LessThanOrEqualScopeNested<A>	withNewLessThanOrEqualScope()
A	withNewLessThanOrEqualScope(Object left, Object right)
MethodCallFluent.LessThanOrEqualScopeNested<A>	withNewLessThanOrEqualScopeLike(LessThanOrEqual item)
MethodCallFluent.LessThanScopeNested<A>	withNewLessThanScope()
A	withNewLessThanScope(Object left, Object right)
MethodCallFluent.LessThanScopeNested<A>	withNewLessThanScopeLike(LessThan item)
MethodCallFluent.LogicalAndScopeNested<A>	withNewLogicalAndScope()
A	withNewLogicalAndScope(Object left, Object right)
MethodCallFluent.LogicalAndScopeNested<A>	withNewLogicalAndScopeLike(LogicalAnd item)
MethodCallFluent.LogicalOrScopeNested<A>	withNewLogicalOrScope()
A	withNewLogicalOrScope(Object left, Object right)
MethodCallFluent.LogicalOrScopeNested<A>	withNewLogicalOrScopeLike(LogicalOr item)
MethodCallFluent.MethodCallScopeNested<A>	withNewMethodCallScope()
MethodCallFluent.MethodCallScopeNested<A>	withNewMethodCallScopeLike(MethodCall item)
MethodCallFluent.MinusScopeNested<A>	withNewMinusScope()
A	withNewMinusScope(Object left, Object right)
MethodCallFluent.MinusScopeNested<A>	withNewMinusScopeLike(Minus item)
MethodCallFluent.ModuloScopeNested<A>	withNewModuloScope()
A	withNewModuloScope(Object left, Object right)
MethodCallFluent.ModuloScopeNested<A>	withNewModuloScopeLike(Modulo item)
MethodCallFluent.MultiplyScopeNested<A>	withNewMultiplyScope()
A	withNewMultiplyScope(Object left, Object right)
MethodCallFluent.MultiplyScopeNested<A>	withNewMultiplyScopeLike(Multiply item)
MethodCallFluent.NegativeScopeNested<A>	withNewNegativeScope()
MethodCallFluent.NegativeScopeNested<A>	withNewNegativeScopeLike(Negative item)
MethodCallFluent.NewArrayScopeNested<A>	withNewNewArrayScope()
A	withNewNewArrayScope(Class type, Integer[] sizes)
MethodCallFluent.NewArrayScopeNested<A>	withNewNewArrayScopeLike(NewArray item)
MethodCallFluent.NotEqualsScopeNested<A>	withNewNotEqualsScope()
A	withNewNotEqualsScope(Object left, Object right)
MethodCallFluent.NotEqualsScopeNested<A>	withNewNotEqualsScopeLike(NotEquals item)
MethodCallFluent.NotScopeNested<A>	withNewNotScope()
MethodCallFluent.NotScopeNested<A>	withNewNotScopeLike(Not item)
MethodCallFluent.PlusScopeNested<A>	withNewPlusScope()
A	withNewPlusScope(Object left, Object right)
MethodCallFluent.PlusScopeNested<A>	withNewPlusScopeLike(Plus item)
MethodCallFluent.PositiveScopeNested<A>	withNewPositiveScope()
MethodCallFluent.PositiveScopeNested<A>	withNewPositiveScopeLike(Positive item)
MethodCallFluent.PostDecrementScopeNested<A>	withNewPostDecrementScope()
MethodCallFluent.PostDecrementScopeNested<A>	withNewPostDecrementScopeLike(PostDecrement item)
MethodCallFluent.PostIncrementScopeNested<A>	withNewPostIncrementScope()
MethodCallFluent.PostIncrementScopeNested<A>	withNewPostIncrementScopeLike(PostIncrement item)
MethodCallFluent.PreDecrementScopeNested<A>	withNewPreDecrementScope()
MethodCallFluent.PreDecrementScopeNested<A>	withNewPreDecrementScopeLike(PreDecrement item)
MethodCallFluent.PreIncrementScopeNested<A>	withNewPreIncrementScope()
MethodCallFluent.PreIncrementScopeNested<A>	withNewPreIncrementScopeLike(PreIncrement item)
MethodCallFluent.PropertyRefScopeNested<A>	withNewPropertyRefScope()
MethodCallFluent.PropertyRefScopeNested<A>	withNewPropertyRefScopeLike(PropertyRef item)
MethodCallFluent.RightShiftScopeNested<A>	withNewRightShiftScope()
A	withNewRightShiftScope(Object left, Object right)
MethodCallFluent.RightShiftScopeNested<A>	withNewRightShiftScopeLike(RightShift item)
MethodCallFluent.RightUnsignedShiftScopeNested<A>	withNewRightUnsignedShiftScope()
A	withNewRightUnsignedShiftScope(Object left, Object right)
MethodCallFluent.RightUnsignedShiftScopeNested<A>	withNewRightUnsignedShiftScopeLike(RightUnsignedShift item)
MethodCallFluent.TernaryScopeNested<A>	withNewTernaryScope()
MethodCallFluent.TernaryScopeNested<A>	withNewTernaryScopeLike(Ternary item)
MethodCallFluent.ThisScopeNested<A>	withNewThisScope()
MethodCallFluent.ThisScopeNested<A>	withNewThisScopeLike(This item)
MethodCallFluent.ValueRefScopeNested<A>	withNewValueRefScope()
A	withNewValueRefScope(Object value)
MethodCallFluent.ValueRefScopeNested<A>	withNewValueRefScopeLike(ValueRef item)
MethodCallFluent.XorScopeNested<A>	withNewXorScope()
A	withNewXorScope(Object left, Object right)
MethodCallFluent.XorScopeNested<A>	withNewXorScopeLike(Xor item)
A	withParameters(TypeRef... parameters)
A	withParameters(List<TypeRef> parameters)
A	withScope(Expression scope)

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

MethodCallFluent

public MethodCallFluent()

MethodCallFluent

public MethodCallFluent(MethodCall instance)

Method Detail

copyInstance

protected void copyInstance(MethodCall instance)

getName

public String getName()

withName

public A withName(String name)

hasName

public boolean hasName()

buildScope

public Expression buildScope()

withScope

public A withScope(Expression scope)

hasScope

public boolean hasScope()

withNewMultiplyScope

public MethodCallFluent.MultiplyScopeNested<A> withNewMultiplyScope()

withNewMultiplyScopeLike

public MethodCallFluent.MultiplyScopeNested<A> withNewMultiplyScopeLike(Multiply item)

withNewMultiplyScope

public A withNewMultiplyScope(Object left,
                              Object right)

withNewNewArrayScope

public MethodCallFluent.NewArrayScopeNested<A> withNewNewArrayScope()

withNewNewArrayScopeLike

public MethodCallFluent.NewArrayScopeNested<A> withNewNewArrayScopeLike(NewArray item)

withNewNewArrayScope

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

withNewInstanceOfScope

public MethodCallFluent.InstanceOfScopeNested<A> withNewInstanceOfScope()

withNewInstanceOfScopeLike

public MethodCallFluent.InstanceOfScopeNested<A> withNewInstanceOfScopeLike(InstanceOf item)

withNewMethodCallScope

public MethodCallFluent.MethodCallScopeNested<A> withNewMethodCallScope()

withNewMethodCallScopeLike

public MethodCallFluent.MethodCallScopeNested<A> withNewMethodCallScopeLike(MethodCall item)

withNewInverseScope

public MethodCallFluent.InverseScopeNested<A> withNewInverseScope()

withNewInverseScopeLike

public MethodCallFluent.InverseScopeNested<A> withNewInverseScopeLike(Inverse item)

withNewIndexScope

public MethodCallFluent.IndexScopeNested<A> withNewIndexScope()

withNewIndexScopeLike

public MethodCallFluent.IndexScopeNested<A> withNewIndexScopeLike(Index item)

withNewGreaterThanOrEqualScope

public MethodCallFluent.GreaterThanOrEqualScopeNested<A> withNewGreaterThanOrEqualScope()

withNewGreaterThanOrEqualScopeLike

public MethodCallFluent.GreaterThanOrEqualScopeNested<A> withNewGreaterThanOrEqualScopeLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualScope

public A withNewGreaterThanOrEqualScope(Object left,
                                        Object right)

withNewBitwiseAndScope

public MethodCallFluent.BitwiseAndScopeNested<A> withNewBitwiseAndScope()

withNewBitwiseAndScopeLike

public MethodCallFluent.BitwiseAndScopeNested<A> withNewBitwiseAndScopeLike(BitwiseAnd item)

withNewBitwiseAndScope

public A withNewBitwiseAndScope(Object left,
                                Object right)

withNewMinusScope

public MethodCallFluent.MinusScopeNested<A> withNewMinusScope()

withNewMinusScopeLike

public MethodCallFluent.MinusScopeNested<A> withNewMinusScopeLike(Minus item)

withNewMinusScope

public A withNewMinusScope(Object left,
                           Object right)

withNewLogicalOrScope

public MethodCallFluent.LogicalOrScopeNested<A> withNewLogicalOrScope()

withNewLogicalOrScopeLike

public MethodCallFluent.LogicalOrScopeNested<A> withNewLogicalOrScopeLike(LogicalOr item)

withNewLogicalOrScope

public A withNewLogicalOrScope(Object left,
                               Object right)

withNewNotEqualsScope

public MethodCallFluent.NotEqualsScopeNested<A> withNewNotEqualsScope()

withNewNotEqualsScopeLike

public MethodCallFluent.NotEqualsScopeNested<A> withNewNotEqualsScopeLike(NotEquals item)

withNewNotEqualsScope

public A withNewNotEqualsScope(Object left,
                               Object right)

withNewDivideScope

public MethodCallFluent.DivideScopeNested<A> withNewDivideScope()

withNewDivideScopeLike

public MethodCallFluent.DivideScopeNested<A> withNewDivideScopeLike(Divide item)

withNewDivideScope

public A withNewDivideScope(Object left,
                            Object right)

withNewLessThanScope

public MethodCallFluent.LessThanScopeNested<A> withNewLessThanScope()

withNewLessThanScopeLike

public MethodCallFluent.LessThanScopeNested<A> withNewLessThanScopeLike(LessThan item)

withNewLessThanScope

public A withNewLessThanScope(Object left,
                              Object right)

withNewBitwiseOrScope

public MethodCallFluent.BitwiseOrScopeNested<A> withNewBitwiseOrScope()

withNewBitwiseOrScopeLike

public MethodCallFluent.BitwiseOrScopeNested<A> withNewBitwiseOrScopeLike(BitwiseOr item)

withNewBitwiseOrScope

public A withNewBitwiseOrScope(Object left,
                               Object right)

withNewPropertyRefScope

public MethodCallFluent.PropertyRefScopeNested<A> withNewPropertyRefScope()

withNewPropertyRefScopeLike

public MethodCallFluent.PropertyRefScopeNested<A> withNewPropertyRefScopeLike(PropertyRef item)

withNewRightShiftScope

public MethodCallFluent.RightShiftScopeNested<A> withNewRightShiftScope()

withNewRightShiftScopeLike

public MethodCallFluent.RightShiftScopeNested<A> withNewRightShiftScopeLike(RightShift item)

withNewRightShiftScope

public A withNewRightShiftScope(Object left,
                                Object right)

withNewGreaterThanScope

public MethodCallFluent.GreaterThanScopeNested<A> withNewGreaterThanScope()

withNewGreaterThanScopeLike

public MethodCallFluent.GreaterThanScopeNested<A> withNewGreaterThanScopeLike(GreaterThan item)

withNewGreaterThanScope

public A withNewGreaterThanScope(Object left,
                                 Object right)

withNewDeclareScope

public MethodCallFluent.DeclareScopeNested<A> withNewDeclareScope()

withNewDeclareScopeLike

public MethodCallFluent.DeclareScopeNested<A> withNewDeclareScopeLike(Declare item)

withNewDeclareScope

public A withNewDeclareScope(Class type,
                             String name)

withNewDeclareScope

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

withNewCastScope

public MethodCallFluent.CastScopeNested<A> withNewCastScope()

withNewCastScopeLike

public MethodCallFluent.CastScopeNested<A> withNewCastScopeLike(Cast item)

withNewModuloScope

public MethodCallFluent.ModuloScopeNested<A> withNewModuloScope()

withNewModuloScopeLike

public MethodCallFluent.ModuloScopeNested<A> withNewModuloScopeLike(Modulo item)

withNewModuloScope

public A withNewModuloScope(Object left,
                            Object right)

withNewValueRefScope

public MethodCallFluent.ValueRefScopeNested<A> withNewValueRefScope()

withNewValueRefScopeLike

public MethodCallFluent.ValueRefScopeNested<A> withNewValueRefScopeLike(ValueRef item)

withNewValueRefScope

public A withNewValueRefScope(Object value)

withNewLeftShiftScope

public MethodCallFluent.LeftShiftScopeNested<A> withNewLeftShiftScope()

withNewLeftShiftScopeLike

public MethodCallFluent.LeftShiftScopeNested<A> withNewLeftShiftScopeLike(LeftShift item)

withNewLeftShiftScope

public A withNewLeftShiftScope(Object left,
                               Object right)

withNewTernaryScope

public MethodCallFluent.TernaryScopeNested<A> withNewTernaryScope()

withNewTernaryScopeLike

public MethodCallFluent.TernaryScopeNested<A> withNewTernaryScopeLike(Ternary item)

withNewBinaryExpressionScope

public MethodCallFluent.BinaryExpressionScopeNested<A> withNewBinaryExpressionScope()

withNewBinaryExpressionScopeLike

public MethodCallFluent.BinaryExpressionScopeNested<A> withNewBinaryExpressionScopeLike(BinaryExpression item)

withNewEqualsScope

public MethodCallFluent.EqualsScopeNested<A> withNewEqualsScope()

withNewEqualsScopeLike

public MethodCallFluent.EqualsScopeNested<A> withNewEqualsScopeLike(Equals item)

withNewEqualsScope

public A withNewEqualsScope(Object left,
                            Object right)

withNewEnclosedScope

public MethodCallFluent.EnclosedScopeNested<A> withNewEnclosedScope()

withNewEnclosedScopeLike

public MethodCallFluent.EnclosedScopeNested<A> withNewEnclosedScopeLike(Enclosed item)

withNewPreDecrementScope

public MethodCallFluent.PreDecrementScopeNested<A> withNewPreDecrementScope()

withNewPreDecrementScopeLike

public MethodCallFluent.PreDecrementScopeNested<A> withNewPreDecrementScopeLike(PreDecrement item)

withNewPostDecrementScope

public MethodCallFluent.PostDecrementScopeNested<A> withNewPostDecrementScope()

withNewPostDecrementScopeLike

public MethodCallFluent.PostDecrementScopeNested<A> withNewPostDecrementScopeLike(PostDecrement item)

withNewLambdaScope

public MethodCallFluent.LambdaScopeNested<A> withNewLambdaScope()

withNewLambdaScopeLike

public MethodCallFluent.LambdaScopeNested<A> withNewLambdaScopeLike(Lambda item)

withNewNotScope

public MethodCallFluent.NotScopeNested<A> withNewNotScope()

withNewNotScopeLike

public MethodCallFluent.NotScopeNested<A> withNewNotScopeLike(Not item)

withNewAssignScope

public MethodCallFluent.AssignScopeNested<A> withNewAssignScope()

withNewAssignScopeLike

public MethodCallFluent.AssignScopeNested<A> withNewAssignScopeLike(Assign item)

withNewNegativeScope

public MethodCallFluent.NegativeScopeNested<A> withNewNegativeScope()

withNewNegativeScopeLike

public MethodCallFluent.NegativeScopeNested<A> withNewNegativeScopeLike(Negative item)

withNewThisScope

public MethodCallFluent.ThisScopeNested<A> withNewThisScope()

withNewThisScopeLike

public MethodCallFluent.ThisScopeNested<A> withNewThisScopeLike(This item)

withNewLogicalAndScope

public MethodCallFluent.LogicalAndScopeNested<A> withNewLogicalAndScope()

withNewLogicalAndScopeLike

public MethodCallFluent.LogicalAndScopeNested<A> withNewLogicalAndScopeLike(LogicalAnd item)

withNewLogicalAndScope

public A withNewLogicalAndScope(Object left,
                                Object right)

withNewPostIncrementScope

public MethodCallFluent.PostIncrementScopeNested<A> withNewPostIncrementScope()

withNewPostIncrementScopeLike

public MethodCallFluent.PostIncrementScopeNested<A> withNewPostIncrementScopeLike(PostIncrement item)

withNewRightUnsignedShiftScope

public MethodCallFluent.RightUnsignedShiftScopeNested<A> withNewRightUnsignedShiftScope()

withNewRightUnsignedShiftScopeLike

public MethodCallFluent.RightUnsignedShiftScopeNested<A> withNewRightUnsignedShiftScopeLike(RightUnsignedShift item)

withNewRightUnsignedShiftScope

public A withNewRightUnsignedShiftScope(Object left,
                                        Object right)

withNewPlusScope

public MethodCallFluent.PlusScopeNested<A> withNewPlusScope()

withNewPlusScopeLike

public MethodCallFluent.PlusScopeNested<A> withNewPlusScopeLike(Plus item)

withNewPlusScope

public A withNewPlusScope(Object left,
                          Object right)

withNewConstructScope

public MethodCallFluent.ConstructScopeNested<A> withNewConstructScope()

withNewConstructScopeLike

public MethodCallFluent.ConstructScopeNested<A> withNewConstructScopeLike(Construct item)

withNewXorScope

public MethodCallFluent.XorScopeNested<A> withNewXorScope()

withNewXorScopeLike

public MethodCallFluent.XorScopeNested<A> withNewXorScopeLike(Xor item)

withNewXorScope

public A withNewXorScope(Object left,
                         Object right)

withNewPreIncrementScope

public MethodCallFluent.PreIncrementScopeNested<A> withNewPreIncrementScope()

withNewPreIncrementScopeLike

public MethodCallFluent.PreIncrementScopeNested<A> withNewPreIncrementScopeLike(PreIncrement item)

withNewLessThanOrEqualScope

public MethodCallFluent.LessThanOrEqualScopeNested<A> withNewLessThanOrEqualScope()

withNewLessThanOrEqualScopeLike

public MethodCallFluent.LessThanOrEqualScopeNested<A> withNewLessThanOrEqualScopeLike(LessThanOrEqual item)

withNewLessThanOrEqualScope

public A withNewLessThanOrEqualScope(Object left,
                                     Object right)

withNewPositiveScope

public MethodCallFluent.PositiveScopeNested<A> withNewPositiveScope()

withNewPositiveScopeLike

public MethodCallFluent.PositiveScopeNested<A> withNewPositiveScopeLike(Positive item)

addToParameters

public A addToParameters(VisitableBuilder<? extends TypeRef,?> builder)

addToParameters

public A addToParameters(int index,
                         VisitableBuilder<? extends TypeRef,?> builder)

addToParameters

public A addToParameters(int index,
                         TypeRef item)

setToParameters

public A setToParameters(int index,
                         TypeRef item)

addToParameters

public A addToParameters(TypeRef... items)

addAllToParameters

public A addAllToParameters(Collection<TypeRef> items)

removeFromParameters

public A removeFromParameters(VisitableBuilder<? extends TypeRef,?> builder)

removeFromParameters

public A removeFromParameters(TypeRef... items)

removeAllFromParameters

public A removeAllFromParameters(Collection<TypeRef> items)

removeMatchingFromParameters

public A removeMatchingFromParameters(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

buildParameters

public List<TypeRef> buildParameters()

buildParameter

public TypeRef buildParameter(int index)

buildFirstParameter

public TypeRef buildFirstParameter()

buildLastParameter

public TypeRef buildLastParameter()

buildMatchingParameter

public TypeRef buildMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

hasMatchingParameter

public boolean hasMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

withParameters

public A withParameters(List<TypeRef> parameters)

withParameters

public A withParameters(TypeRef... parameters)

hasParameters

public boolean hasParameters()

addNewClassRefParameter

public MethodCallFluent.ClassRefParametersNested<A> addNewClassRefParameter()

addNewClassRefParameterLike

public MethodCallFluent.ClassRefParametersNested<A> addNewClassRefParameterLike(ClassRef item)

setNewClassRefParameterLike

public MethodCallFluent.ClassRefParametersNested<A> setNewClassRefParameterLike(int index,
                                                                                ClassRef item)

addNewPrimitiveRefParameter

public MethodCallFluent.PrimitiveRefParametersNested<A> addNewPrimitiveRefParameter()

addNewPrimitiveRefParameterLike

public MethodCallFluent.PrimitiveRefParametersNested<A> addNewPrimitiveRefParameterLike(PrimitiveRef item)

setNewPrimitiveRefParameterLike

public MethodCallFluent.PrimitiveRefParametersNested<A> setNewPrimitiveRefParameterLike(int index,
                                                                                        PrimitiveRef item)

addNewVoidRefParameter

public MethodCallFluent.VoidRefParametersNested<A> addNewVoidRefParameter()

addNewVoidRefParameterLike

public MethodCallFluent.VoidRefParametersNested<A> addNewVoidRefParameterLike(VoidRef item)

setNewVoidRefParameterLike

public MethodCallFluent.VoidRefParametersNested<A> setNewVoidRefParameterLike(int index,
                                                                              VoidRef item)

addNewTypeParamRefParameter

public MethodCallFluent.TypeParamRefParametersNested<A> addNewTypeParamRefParameter()

addNewTypeParamRefParameterLike

public MethodCallFluent.TypeParamRefParametersNested<A> addNewTypeParamRefParameterLike(TypeParamRef item)

setNewTypeParamRefParameterLike

public MethodCallFluent.TypeParamRefParametersNested<A> setNewTypeParamRefParameterLike(int index,
                                                                                        TypeParamRef item)

addNewWildcardRefParameter

public MethodCallFluent.WildcardRefParametersNested<A> addNewWildcardRefParameter()

addNewWildcardRefParameterLike

public MethodCallFluent.WildcardRefParametersNested<A> addNewWildcardRefParameterLike(WildcardRef item)

setNewWildcardRefParameterLike

public MethodCallFluent.WildcardRefParametersNested<A> setNewWildcardRefParameterLike(int index,
                                                                                      WildcardRef item)

addToArguments

public A addToArguments(VisitableBuilder<? extends Expression,?> builder)

addToArguments

public A addToArguments(int index,
                        VisitableBuilder<? extends Expression,?> builder)

addToArguments

public A addToArguments(int index,
                        Expression item)

setToArguments

public A setToArguments(int index,
                        Expression item)

addToArguments

public A addToArguments(Expression... items)

addAllToArguments

public A addAllToArguments(Collection<Expression> items)

removeFromArguments

public A removeFromArguments(VisitableBuilder<? extends Expression,?> builder)

removeFromArguments

public A removeFromArguments(Expression... items)

removeAllFromArguments

public A removeAllFromArguments(Collection<Expression> items)

removeMatchingFromArguments

public A removeMatchingFromArguments(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

buildArguments

public List<Expression> buildArguments()

buildArgument

public Expression buildArgument(int index)

buildFirstArgument

public Expression buildFirstArgument()

buildLastArgument

public Expression buildLastArgument()

buildMatchingArgument

public Expression buildMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

hasMatchingArgument

public boolean hasMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)

withArguments

public A withArguments(List<Expression> arguments)

withArguments

public A withArguments(Expression... arguments)

hasArguments

public boolean hasArguments()

addNewMultiplyArgument

public MethodCallFluent.MultiplyArgumentsNested<A> addNewMultiplyArgument()

addNewMultiplyArgumentLike

public MethodCallFluent.MultiplyArgumentsNested<A> addNewMultiplyArgumentLike(Multiply item)

addNewMultiplyArgument

public A addNewMultiplyArgument(Object left,
                                Object right)

setNewMultiplyArgumentLike

public MethodCallFluent.MultiplyArgumentsNested<A> setNewMultiplyArgumentLike(int index,
                                                                              Multiply item)

addNewNewArrayArgument

public MethodCallFluent.NewArrayArgumentsNested<A> addNewNewArrayArgument()

addNewNewArrayArgumentLike

public MethodCallFluent.NewArrayArgumentsNested<A> addNewNewArrayArgumentLike(NewArray item)

addNewNewArrayArgument

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

setNewNewArrayArgumentLike

public MethodCallFluent.NewArrayArgumentsNested<A> setNewNewArrayArgumentLike(int index,
                                                                              NewArray item)

addNewInstanceOfArgument

public MethodCallFluent.InstanceOfArgumentsNested<A> addNewInstanceOfArgument()

addNewInstanceOfArgumentLike

public MethodCallFluent.InstanceOfArgumentsNested<A> addNewInstanceOfArgumentLike(InstanceOf item)

setNewInstanceOfArgumentLike

public MethodCallFluent.InstanceOfArgumentsNested<A> setNewInstanceOfArgumentLike(int index,
                                                                                  InstanceOf item)

addNewMethodCallArgument

public MethodCallFluent.MethodCallArgumentsNested<A> addNewMethodCallArgument()

addNewMethodCallArgumentLike

public MethodCallFluent.MethodCallArgumentsNested<A> addNewMethodCallArgumentLike(MethodCall item)

setNewMethodCallArgumentLike

public MethodCallFluent.MethodCallArgumentsNested<A> setNewMethodCallArgumentLike(int index,
                                                                                  MethodCall item)

addNewInverseArgument

public MethodCallFluent.InverseArgumentsNested<A> addNewInverseArgument()

addNewInverseArgumentLike

public MethodCallFluent.InverseArgumentsNested<A> addNewInverseArgumentLike(Inverse item)

setNewInverseArgumentLike

public MethodCallFluent.InverseArgumentsNested<A> setNewInverseArgumentLike(int index,
                                                                            Inverse item)

addNewIndexArgument

public MethodCallFluent.IndexArgumentsNested<A> addNewIndexArgument()

addNewIndexArgumentLike

public MethodCallFluent.IndexArgumentsNested<A> addNewIndexArgumentLike(Index item)

setNewIndexArgumentLike

public MethodCallFluent.IndexArgumentsNested<A> setNewIndexArgumentLike(int index,
                                                                        Index item)

addNewGreaterThanOrEqualArgument

public MethodCallFluent.GreaterThanOrEqualArgumentsNested<A> addNewGreaterThanOrEqualArgument()

addNewGreaterThanOrEqualArgumentLike

public MethodCallFluent.GreaterThanOrEqualArgumentsNested<A> addNewGreaterThanOrEqualArgumentLike(GreaterThanOrEqual item)

addNewGreaterThanOrEqualArgument

public A addNewGreaterThanOrEqualArgument(Object left,
                                          Object right)

setNewGreaterThanOrEqualArgumentLike

public MethodCallFluent.GreaterThanOrEqualArgumentsNested<A> setNewGreaterThanOrEqualArgumentLike(int index,
                                                                                                  GreaterThanOrEqual item)

addNewBitwiseAndArgument

public MethodCallFluent.BitwiseAndArgumentsNested<A> addNewBitwiseAndArgument()

addNewBitwiseAndArgumentLike

public MethodCallFluent.BitwiseAndArgumentsNested<A> addNewBitwiseAndArgumentLike(BitwiseAnd item)

addNewBitwiseAndArgument

public A addNewBitwiseAndArgument(Object left,
                                  Object right)

setNewBitwiseAndArgumentLike

public MethodCallFluent.BitwiseAndArgumentsNested<A> setNewBitwiseAndArgumentLike(int index,
                                                                                  BitwiseAnd item)

addNewMinusArgument

public MethodCallFluent.MinusArgumentsNested<A> addNewMinusArgument()

addNewMinusArgumentLike

public MethodCallFluent.MinusArgumentsNested<A> addNewMinusArgumentLike(Minus item)

addNewMinusArgument

public A addNewMinusArgument(Object left,
                             Object right)

setNewMinusArgumentLike

public MethodCallFluent.MinusArgumentsNested<A> setNewMinusArgumentLike(int index,
                                                                        Minus item)

addNewLogicalOrArgument

public MethodCallFluent.LogicalOrArgumentsNested<A> addNewLogicalOrArgument()

addNewLogicalOrArgumentLike

public MethodCallFluent.LogicalOrArgumentsNested<A> addNewLogicalOrArgumentLike(LogicalOr item)

addNewLogicalOrArgument

public A addNewLogicalOrArgument(Object left,
                                 Object right)

setNewLogicalOrArgumentLike

public MethodCallFluent.LogicalOrArgumentsNested<A> setNewLogicalOrArgumentLike(int index,
                                                                                LogicalOr item)

addNewNotEqualsArgument

public MethodCallFluent.NotEqualsArgumentsNested<A> addNewNotEqualsArgument()

addNewNotEqualsArgumentLike

public MethodCallFluent.NotEqualsArgumentsNested<A> addNewNotEqualsArgumentLike(NotEquals item)

addNewNotEqualsArgument

public A addNewNotEqualsArgument(Object left,
                                 Object right)

setNewNotEqualsArgumentLike

public MethodCallFluent.NotEqualsArgumentsNested<A> setNewNotEqualsArgumentLike(int index,
                                                                                NotEquals item)

addNewDivideArgument

public MethodCallFluent.DivideArgumentsNested<A> addNewDivideArgument()

addNewDivideArgumentLike

public MethodCallFluent.DivideArgumentsNested<A> addNewDivideArgumentLike(Divide item)

addNewDivideArgument

public A addNewDivideArgument(Object left,
                              Object right)

setNewDivideArgumentLike

public MethodCallFluent.DivideArgumentsNested<A> setNewDivideArgumentLike(int index,
                                                                          Divide item)

addNewLessThanArgument

public MethodCallFluent.LessThanArgumentsNested<A> addNewLessThanArgument()

addNewLessThanArgumentLike

public MethodCallFluent.LessThanArgumentsNested<A> addNewLessThanArgumentLike(LessThan item)

addNewLessThanArgument

public A addNewLessThanArgument(Object left,
                                Object right)

setNewLessThanArgumentLike

public MethodCallFluent.LessThanArgumentsNested<A> setNewLessThanArgumentLike(int index,
                                                                              LessThan item)

addNewBitwiseOrArgument

public MethodCallFluent.BitwiseOrArgumentsNested<A> addNewBitwiseOrArgument()

addNewBitwiseOrArgumentLike

public MethodCallFluent.BitwiseOrArgumentsNested<A> addNewBitwiseOrArgumentLike(BitwiseOr item)

addNewBitwiseOrArgument

public A addNewBitwiseOrArgument(Object left,
                                 Object right)

setNewBitwiseOrArgumentLike

public MethodCallFluent.BitwiseOrArgumentsNested<A> setNewBitwiseOrArgumentLike(int index,
                                                                                BitwiseOr item)

addNewPropertyRefArgument

public MethodCallFluent.PropertyRefArgumentsNested<A> addNewPropertyRefArgument()

addNewPropertyRefArgumentLike

public MethodCallFluent.PropertyRefArgumentsNested<A> addNewPropertyRefArgumentLike(PropertyRef item)

setNewPropertyRefArgumentLike

public MethodCallFluent.PropertyRefArgumentsNested<A> setNewPropertyRefArgumentLike(int index,
                                                                                    PropertyRef item)

addNewRightShiftArgument

public MethodCallFluent.RightShiftArgumentsNested<A> addNewRightShiftArgument()

addNewRightShiftArgumentLike

public MethodCallFluent.RightShiftArgumentsNested<A> addNewRightShiftArgumentLike(RightShift item)

addNewRightShiftArgument

public A addNewRightShiftArgument(Object left,
                                  Object right)

setNewRightShiftArgumentLike

public MethodCallFluent.RightShiftArgumentsNested<A> setNewRightShiftArgumentLike(int index,
                                                                                  RightShift item)

addNewGreaterThanArgument

public MethodCallFluent.GreaterThanArgumentsNested<A> addNewGreaterThanArgument()

addNewGreaterThanArgumentLike

public MethodCallFluent.GreaterThanArgumentsNested<A> addNewGreaterThanArgumentLike(GreaterThan item)

addNewGreaterThanArgument

public A addNewGreaterThanArgument(Object left,
                                   Object right)

setNewGreaterThanArgumentLike

public MethodCallFluent.GreaterThanArgumentsNested<A> setNewGreaterThanArgumentLike(int index,
                                                                                    GreaterThan item)

addNewDeclareArgument

public MethodCallFluent.DeclareArgumentsNested<A> addNewDeclareArgument()

addNewDeclareArgumentLike

public MethodCallFluent.DeclareArgumentsNested<A> addNewDeclareArgumentLike(Declare item)

addNewDeclareArgument

public A addNewDeclareArgument(Class type,
                               String name)

addNewDeclareArgument

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

setNewDeclareArgumentLike

public MethodCallFluent.DeclareArgumentsNested<A> setNewDeclareArgumentLike(int index,
                                                                            Declare item)

addNewCastArgument

public MethodCallFluent.CastArgumentsNested<A> addNewCastArgument()

addNewCastArgumentLike

public MethodCallFluent.CastArgumentsNested<A> addNewCastArgumentLike(Cast item)

setNewCastArgumentLike

public MethodCallFluent.CastArgumentsNested<A> setNewCastArgumentLike(int index,
                                                                      Cast item)

addNewModuloArgument

public MethodCallFluent.ModuloArgumentsNested<A> addNewModuloArgument()

addNewModuloArgumentLike

public MethodCallFluent.ModuloArgumentsNested<A> addNewModuloArgumentLike(Modulo item)

addNewModuloArgument

public A addNewModuloArgument(Object left,
                              Object right)

setNewModuloArgumentLike

public MethodCallFluent.ModuloArgumentsNested<A> setNewModuloArgumentLike(int index,
                                                                          Modulo item)

addNewValueRefArgument

public MethodCallFluent.ValueRefArgumentsNested<A> addNewValueRefArgument()

addNewValueRefArgumentLike

public MethodCallFluent.ValueRefArgumentsNested<A> addNewValueRefArgumentLike(ValueRef item)

addNewValueRefArgument

public A addNewValueRefArgument(Object value)

setNewValueRefArgumentLike

public MethodCallFluent.ValueRefArgumentsNested<A> setNewValueRefArgumentLike(int index,
                                                                              ValueRef item)

addNewLeftShiftArgument

public MethodCallFluent.LeftShiftArgumentsNested<A> addNewLeftShiftArgument()

addNewLeftShiftArgumentLike

public MethodCallFluent.LeftShiftArgumentsNested<A> addNewLeftShiftArgumentLike(LeftShift item)

addNewLeftShiftArgument

public A addNewLeftShiftArgument(Object left,
                                 Object right)

setNewLeftShiftArgumentLike

public MethodCallFluent.LeftShiftArgumentsNested<A> setNewLeftShiftArgumentLike(int index,
                                                                                LeftShift item)

addNewTernaryArgument

public MethodCallFluent.TernaryArgumentsNested<A> addNewTernaryArgument()

addNewTernaryArgumentLike

public MethodCallFluent.TernaryArgumentsNested<A> addNewTernaryArgumentLike(Ternary item)

setNewTernaryArgumentLike

public MethodCallFluent.TernaryArgumentsNested<A> setNewTernaryArgumentLike(int index,
                                                                            Ternary item)

addNewBinaryExpressionArgument

public MethodCallFluent.BinaryExpressionArgumentsNested<A> addNewBinaryExpressionArgument()

addNewBinaryExpressionArgumentLike

public MethodCallFluent.BinaryExpressionArgumentsNested<A> addNewBinaryExpressionArgumentLike(BinaryExpression item)

setNewBinaryExpressionArgumentLike

public MethodCallFluent.BinaryExpressionArgumentsNested<A> setNewBinaryExpressionArgumentLike(int index,
                                                                                              BinaryExpression item)

addNewEqualsArgument

public MethodCallFluent.EqualsArgumentsNested<A> addNewEqualsArgument()

addNewEqualsArgumentLike

public MethodCallFluent.EqualsArgumentsNested<A> addNewEqualsArgumentLike(Equals item)

addNewEqualsArgument

public A addNewEqualsArgument(Object left,
                              Object right)

setNewEqualsArgumentLike

public MethodCallFluent.EqualsArgumentsNested<A> setNewEqualsArgumentLike(int index,
                                                                          Equals item)

addNewEnclosedArgument

public MethodCallFluent.EnclosedArgumentsNested<A> addNewEnclosedArgument()

addNewEnclosedArgumentLike

public MethodCallFluent.EnclosedArgumentsNested<A> addNewEnclosedArgumentLike(Enclosed item)

setNewEnclosedArgumentLike

public MethodCallFluent.EnclosedArgumentsNested<A> setNewEnclosedArgumentLike(int index,
                                                                              Enclosed item)

addNewPreDecrementArgument

public MethodCallFluent.PreDecrementArgumentsNested<A> addNewPreDecrementArgument()

addNewPreDecrementArgumentLike

public MethodCallFluent.PreDecrementArgumentsNested<A> addNewPreDecrementArgumentLike(PreDecrement item)

setNewPreDecrementArgumentLike

public MethodCallFluent.PreDecrementArgumentsNested<A> setNewPreDecrementArgumentLike(int index,
                                                                                      PreDecrement item)

addNewPostDecrementArgument

public MethodCallFluent.PostDecrementArgumentsNested<A> addNewPostDecrementArgument()

addNewPostDecrementArgumentLike

public MethodCallFluent.PostDecrementArgumentsNested<A> addNewPostDecrementArgumentLike(PostDecrement item)

setNewPostDecrementArgumentLike

public MethodCallFluent.PostDecrementArgumentsNested<A> setNewPostDecrementArgumentLike(int index,
                                                                                        PostDecrement item)

addNewLambdaArgument

public MethodCallFluent.LambdaArgumentsNested<A> addNewLambdaArgument()

addNewLambdaArgumentLike

public MethodCallFluent.LambdaArgumentsNested<A> addNewLambdaArgumentLike(Lambda item)

setNewLambdaArgumentLike

public MethodCallFluent.LambdaArgumentsNested<A> setNewLambdaArgumentLike(int index,
                                                                          Lambda item)

addNewNotArgument

public MethodCallFluent.NotArgumentsNested<A> addNewNotArgument()

addNewNotArgumentLike

public MethodCallFluent.NotArgumentsNested<A> addNewNotArgumentLike(Not item)

setNewNotArgumentLike

public MethodCallFluent.NotArgumentsNested<A> setNewNotArgumentLike(int index,
                                                                    Not item)

addNewAssignArgument

public MethodCallFluent.AssignArgumentsNested<A> addNewAssignArgument()

addNewAssignArgumentLike

public MethodCallFluent.AssignArgumentsNested<A> addNewAssignArgumentLike(Assign item)

setNewAssignArgumentLike

public MethodCallFluent.AssignArgumentsNested<A> setNewAssignArgumentLike(int index,
                                                                          Assign item)

addNewNegativeArgument

public MethodCallFluent.NegativeArgumentsNested<A> addNewNegativeArgument()

addNewNegativeArgumentLike

public MethodCallFluent.NegativeArgumentsNested<A> addNewNegativeArgumentLike(Negative item)

setNewNegativeArgumentLike

public MethodCallFluent.NegativeArgumentsNested<A> setNewNegativeArgumentLike(int index,
                                                                              Negative item)

addNewThisArgument

public MethodCallFluent.ThisArgumentsNested<A> addNewThisArgument()

addNewThisArgumentLike

public MethodCallFluent.ThisArgumentsNested<A> addNewThisArgumentLike(This item)

setNewThisArgumentLike

public MethodCallFluent.ThisArgumentsNested<A> setNewThisArgumentLike(int index,
                                                                      This item)

addNewLogicalAndArgument

public MethodCallFluent.LogicalAndArgumentsNested<A> addNewLogicalAndArgument()

addNewLogicalAndArgumentLike

public MethodCallFluent.LogicalAndArgumentsNested<A> addNewLogicalAndArgumentLike(LogicalAnd item)

addNewLogicalAndArgument

public A addNewLogicalAndArgument(Object left,
                                  Object right)

setNewLogicalAndArgumentLike

public MethodCallFluent.LogicalAndArgumentsNested<A> setNewLogicalAndArgumentLike(int index,
                                                                                  LogicalAnd item)

addNewPostIncrementArgument

public MethodCallFluent.PostIncrementArgumentsNested<A> addNewPostIncrementArgument()

addNewPostIncrementArgumentLike

public MethodCallFluent.PostIncrementArgumentsNested<A> addNewPostIncrementArgumentLike(PostIncrement item)

setNewPostIncrementArgumentLike

public MethodCallFluent.PostIncrementArgumentsNested<A> setNewPostIncrementArgumentLike(int index,
                                                                                        PostIncrement item)

addNewRightUnsignedShiftArgument

public MethodCallFluent.RightUnsignedShiftArgumentsNested<A> addNewRightUnsignedShiftArgument()

addNewRightUnsignedShiftArgumentLike

public MethodCallFluent.RightUnsignedShiftArgumentsNested<A> addNewRightUnsignedShiftArgumentLike(RightUnsignedShift item)

addNewRightUnsignedShiftArgument

public A addNewRightUnsignedShiftArgument(Object left,
                                          Object right)

setNewRightUnsignedShiftArgumentLike

public MethodCallFluent.RightUnsignedShiftArgumentsNested<A> setNewRightUnsignedShiftArgumentLike(int index,
                                                                                                  RightUnsignedShift item)

addNewPlusArgument

public MethodCallFluent.PlusArgumentsNested<A> addNewPlusArgument()

addNewPlusArgumentLike

public MethodCallFluent.PlusArgumentsNested<A> addNewPlusArgumentLike(Plus item)

addNewPlusArgument

public A addNewPlusArgument(Object left,
                            Object right)

setNewPlusArgumentLike

public MethodCallFluent.PlusArgumentsNested<A> setNewPlusArgumentLike(int index,
                                                                      Plus item)

addNewConstructArgument

public MethodCallFluent.ConstructArgumentsNested<A> addNewConstructArgument()

addNewConstructArgumentLike

public MethodCallFluent.ConstructArgumentsNested<A> addNewConstructArgumentLike(Construct item)

setNewConstructArgumentLike

public MethodCallFluent.ConstructArgumentsNested<A> setNewConstructArgumentLike(int index,
                                                                                Construct item)

addNewXorArgument

public MethodCallFluent.XorArgumentsNested<A> addNewXorArgument()

addNewXorArgumentLike

public MethodCallFluent.XorArgumentsNested<A> addNewXorArgumentLike(Xor item)

addNewXorArgument

public A addNewXorArgument(Object left,
                           Object right)

setNewXorArgumentLike

public MethodCallFluent.XorArgumentsNested<A> setNewXorArgumentLike(int index,
                                                                    Xor item)

addNewPreIncrementArgument

public MethodCallFluent.PreIncrementArgumentsNested<A> addNewPreIncrementArgument()

addNewPreIncrementArgumentLike

public MethodCallFluent.PreIncrementArgumentsNested<A> addNewPreIncrementArgumentLike(PreIncrement item)

setNewPreIncrementArgumentLike

public MethodCallFluent.PreIncrementArgumentsNested<A> setNewPreIncrementArgumentLike(int index,
                                                                                      PreIncrement item)

addNewLessThanOrEqualArgument

public MethodCallFluent.LessThanOrEqualArgumentsNested<A> addNewLessThanOrEqualArgument()

addNewLessThanOrEqualArgumentLike

public MethodCallFluent.LessThanOrEqualArgumentsNested<A> addNewLessThanOrEqualArgumentLike(LessThanOrEqual item)

addNewLessThanOrEqualArgument

public A addNewLessThanOrEqualArgument(Object left,
                                       Object right)

setNewLessThanOrEqualArgumentLike

public MethodCallFluent.LessThanOrEqualArgumentsNested<A> setNewLessThanOrEqualArgumentLike(int index,
                                                                                            LessThanOrEqual item)

addNewPositiveArgument

public MethodCallFluent.PositiveArgumentsNested<A> addNewPositiveArgument()

addNewPositiveArgumentLike

public MethodCallFluent.PositiveArgumentsNested<A> addNewPositiveArgumentLike(Positive item)

setNewPositiveArgumentLike

public MethodCallFluent.PositiveArgumentsNested<A> setNewPositiveArgumentLike(int index,
                                                                              Positive item)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

toString in class Object

builder

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