Package io.sundr.model

Class ConstructFluent<A extends ConstructFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.ConstructFluent<A>

Direct Known Subclasses:

AssignFluent.ConstructTargetNested, AssignFluent.ConstructValueNested, BinaryExpressionFluent.ConstructLeftNested, BinaryExpressionFluent.ConstructRightNested, BlockFluent.ConstructStatementsNested, CastFluent.ConstructExpressionNested, ConstructBuilder, ConstructFluent.ConstructArgumentsNested, DeclareFluent.ConstructValueNested, DoFluent.ConstructConditionNested, DoFluent.ConstructStatementNested, EnclosedFluent.ConstructExpresionNested, ForeachFluent.ConstructBodyNested, ForeachFluent.ConstructExpressionNested, ForFluent.ConstructBodyNested, ForFluent.ConstructCompareNested, ForFluent.ConstructInitNested, ForFluent.ConstructUpdateNested, IfDslConditionStepFluent.ConstructConditionNested, IfDslThenStepFluent.ConstructConditionNested, IfDslThenStepFluent.ConstructStatementsNested, IfFluent.ConstructConditionNested, IfFluent.ConstructElseStatementNested, IfFluent.ConstructStatementNested, IndexFluent.ConstructExpressionNested, InstanceOfFluent.ConstructExpressionNested, InverseFluent.ConstructExpresionNested, LambdaFluent.ConstructStatementNested, MethodCallFluent.ConstructArgumentsNested, NegativeFluent.ConstructExpresionNested, NewArrayFluent.ConstructExpressionsNested, NotFluent.ConstructExpresionNested, PositiveFluent.ConstructExpresionNested, PostDecrementFluent.ConstructExpressionNested, PostIncrementFluent.ConstructExpressionNested, PreDecrementFluent.ConstructExpressionNested, PreIncrementFluent.ConstructExpressionNested, PropertyFluent.ConstructInitialValueNested, ReturnFluent.ConstructExpressionNested, SwitchFluent.ConstructExpressionNested, SynchronizedFluent.ConstructBodyNested, SynchronizedFluent.ConstructLockExpressionNested, TernaryFluent.ConstructAlternativeNested, TernaryFluent.ConstructConditionNested, TernaryFluent.ConstructResultNested, ThrowFluent.ConstructExceptionNested, WhileFluent.ConstructConditionNested, WhileFluent.ConstructStatementNested, WithScopeFluent.ConstructScopeNested

public class ConstructFluent<A extends ConstructFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	ConstructFluent.AssignArgumentsNested<N>
class	ConstructFluent.BinaryExpressionArgumentsNested<N>
class	ConstructFluent.BitwiseAndArgumentsNested<N>
class	ConstructFluent.BitwiseOrArgumentsNested<N>
class	ConstructFluent.CastArgumentsNested<N>
class	ConstructFluent.ClassRefArgumentsNested<N>
class	ConstructFluent.ClassRefParametersNested<N>
class	ConstructFluent.ConstructArgumentsNested<N>
class	ConstructFluent.ContextRefArgumentsNested<N>
class	ConstructFluent.DeclareArgumentsNested<N>
class	ConstructFluent.DivideArgumentsNested<N>
class	ConstructFluent.DotClassArgumentsNested<N>
class	ConstructFluent.EmptyArgumentsNested<N>
class	ConstructFluent.EnclosedArgumentsNested<N>
class	ConstructFluent.EqualsArgumentsNested<N>
class	ConstructFluent.GreaterThanArgumentsNested<N>
class	ConstructFluent.GreaterThanOrEqualArgumentsNested<N>
class	ConstructFluent.IndexArgumentsNested<N>
class	ConstructFluent.InstanceOfArgumentsNested<N>
class	ConstructFluent.InverseArgumentsNested<N>
class	ConstructFluent.LambdaArgumentsNested<N>
class	ConstructFluent.LeftShiftArgumentsNested<N>
class	ConstructFluent.LessThanArgumentsNested<N>
class	ConstructFluent.LessThanOrEqualArgumentsNested<N>
class	ConstructFluent.LogicalAndArgumentsNested<N>
class	ConstructFluent.LogicalOrArgumentsNested<N>
class	ConstructFluent.MethodCallArgumentsNested<N>
class	ConstructFluent.MinusArgumentsNested<N>
class	ConstructFluent.ModuloArgumentsNested<N>
class	ConstructFluent.MultiplyArgumentsNested<N>
class	ConstructFluent.NegativeArgumentsNested<N>
class	ConstructFluent.NewArrayArgumentsNested<N>
class	ConstructFluent.NotArgumentsNested<N>
class	ConstructFluent.NotEqualsArgumentsNested<N>
class	ConstructFluent.PlusArgumentsNested<N>
class	ConstructFluent.PositiveArgumentsNested<N>
class	ConstructFluent.PostDecrementArgumentsNested<N>
class	ConstructFluent.PostIncrementArgumentsNested<N>
class	ConstructFluent.PreDecrementArgumentsNested<N>
class	ConstructFluent.PreIncrementArgumentsNested<N>
class	ConstructFluent.PrimitiveRefParametersNested<N>
class	ConstructFluent.PropertyArgumentsNested<N>
class	ConstructFluent.PropertyRefArgumentsNested<N>
class	ConstructFluent.RightShiftArgumentsNested<N>
class	ConstructFluent.RightUnsignedShiftArgumentsNested<N>
class	ConstructFluent.SuperArgumentsNested<N>
class	ConstructFluent.TernaryArgumentsNested<N>
class	ConstructFluent.ThisArgumentsNested<N>
class	ConstructFluent.TypeNested<N>
class	ConstructFluent.TypeParamRefParametersNested<N>
class	ConstructFluent.ValueRefArgumentsNested<N>
class	ConstructFluent.VoidRefParametersNested<N>
class	ConstructFluent.WildcardRefParametersNested<N>
class	ConstructFluent.XorArgumentsNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
ConstructFluent()
ConstructFluent(Construct instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToArguments(Collection<Expression> items)
A	addAllToParameters(Collection<TypeRef> items)
ConstructFluent<A>.AssignArgumentsNested<A>	addNewAssignArgument()
ConstructFluent<A>.AssignArgumentsNested<A>	addNewAssignArgumentLike(Assign item)
ConstructFluent<A>.BinaryExpressionArgumentsNested<A>	addNewBinaryExpressionArgument()
ConstructFluent<A>.BinaryExpressionArgumentsNested<A>	addNewBinaryExpressionArgumentLike(BinaryExpression item)
ConstructFluent<A>.BitwiseAndArgumentsNested<A>	addNewBitwiseAndArgument()
A	addNewBitwiseAndArgument(Object left, Object right)
ConstructFluent<A>.BitwiseAndArgumentsNested<A>	addNewBitwiseAndArgumentLike(BitwiseAnd item)
ConstructFluent<A>.BitwiseOrArgumentsNested<A>	addNewBitwiseOrArgument()
A	addNewBitwiseOrArgument(Object left, Object right)
ConstructFluent<A>.BitwiseOrArgumentsNested<A>	addNewBitwiseOrArgumentLike(BitwiseOr item)
ConstructFluent<A>.CastArgumentsNested<A>	addNewCastArgument()
ConstructFluent<A>.CastArgumentsNested<A>	addNewCastArgumentLike(Cast item)
ConstructFluent<A>.ClassRefArgumentsNested<A>	addNewClassRefArgument()
ConstructFluent<A>.ClassRefArgumentsNested<A>	addNewClassRefArgumentLike(ClassRef item)
ConstructFluent<A>.ClassRefParametersNested<A>	addNewClassRefParameter()
ConstructFluent<A>.ClassRefParametersNested<A>	addNewClassRefParameterLike(ClassRef item)
ConstructFluent<A>.ConstructArgumentsNested<A>	addNewConstructArgument()
ConstructFluent<A>.ConstructArgumentsNested<A>	addNewConstructArgumentLike(Construct item)
ConstructFluent<A>.ContextRefArgumentsNested<A>	addNewContextRefArgument()
A	addNewContextRefArgument(String name)
ConstructFluent<A>.ContextRefArgumentsNested<A>	addNewContextRefArgumentLike(ContextRef item)
ConstructFluent<A>.DeclareArgumentsNested<A>	addNewDeclareArgument()
A	addNewDeclareArgument(Class type, String name)
A	addNewDeclareArgument(Class type, String name, Object value)
ConstructFluent<A>.DeclareArgumentsNested<A>	addNewDeclareArgumentLike(Declare item)
ConstructFluent<A>.DivideArgumentsNested<A>	addNewDivideArgument()
A	addNewDivideArgument(Object left, Object right)
ConstructFluent<A>.DivideArgumentsNested<A>	addNewDivideArgumentLike(Divide item)
ConstructFluent<A>.DotClassArgumentsNested<A>	addNewDotClassArgument()
ConstructFluent<A>.DotClassArgumentsNested<A>	addNewDotClassArgumentLike(DotClass item)
ConstructFluent<A>.EmptyArgumentsNested<A>	addNewEmptyArgument()
ConstructFluent<A>.EmptyArgumentsNested<A>	addNewEmptyArgumentLike(Empty item)
ConstructFluent<A>.EnclosedArgumentsNested<A>	addNewEnclosedArgument()
ConstructFluent<A>.EnclosedArgumentsNested<A>	addNewEnclosedArgumentLike(Enclosed item)
ConstructFluent<A>.EqualsArgumentsNested<A>	addNewEqualsArgument()
A	addNewEqualsArgument(Object left, Object right)
ConstructFluent<A>.EqualsArgumentsNested<A>	addNewEqualsArgumentLike(Equals item)
ConstructFluent<A>.GreaterThanArgumentsNested<A>	addNewGreaterThanArgument()
A	addNewGreaterThanArgument(Object left, Object right)
ConstructFluent<A>.GreaterThanArgumentsNested<A>	addNewGreaterThanArgumentLike(GreaterThan item)
ConstructFluent<A>.GreaterThanOrEqualArgumentsNested<A>	addNewGreaterThanOrEqualArgument()
A	addNewGreaterThanOrEqualArgument(Object left, Object right)
ConstructFluent<A>.GreaterThanOrEqualArgumentsNested<A>	addNewGreaterThanOrEqualArgumentLike(GreaterThanOrEqual item)
ConstructFluent<A>.IndexArgumentsNested<A>	addNewIndexArgument()
ConstructFluent<A>.IndexArgumentsNested<A>	addNewIndexArgumentLike(Index item)
ConstructFluent<A>.InstanceOfArgumentsNested<A>	addNewInstanceOfArgument()
ConstructFluent<A>.InstanceOfArgumentsNested<A>	addNewInstanceOfArgumentLike(InstanceOf item)
ConstructFluent<A>.InverseArgumentsNested<A>	addNewInverseArgument()
ConstructFluent<A>.InverseArgumentsNested<A>	addNewInverseArgumentLike(Inverse item)
ConstructFluent<A>.LambdaArgumentsNested<A>	addNewLambdaArgument()
ConstructFluent<A>.LambdaArgumentsNested<A>	addNewLambdaArgumentLike(Lambda item)
ConstructFluent<A>.LeftShiftArgumentsNested<A>	addNewLeftShiftArgument()
A	addNewLeftShiftArgument(Object left, Object right)
ConstructFluent<A>.LeftShiftArgumentsNested<A>	addNewLeftShiftArgumentLike(LeftShift item)
ConstructFluent<A>.LessThanArgumentsNested<A>	addNewLessThanArgument()
A	addNewLessThanArgument(Object left, Object right)
ConstructFluent<A>.LessThanArgumentsNested<A>	addNewLessThanArgumentLike(LessThan item)
ConstructFluent<A>.LessThanOrEqualArgumentsNested<A>	addNewLessThanOrEqualArgument()
A	addNewLessThanOrEqualArgument(Object left, Object right)
ConstructFluent<A>.LessThanOrEqualArgumentsNested<A>	addNewLessThanOrEqualArgumentLike(LessThanOrEqual item)
ConstructFluent<A>.LogicalAndArgumentsNested<A>	addNewLogicalAndArgument()
A	addNewLogicalAndArgument(Object left, Object right)
ConstructFluent<A>.LogicalAndArgumentsNested<A>	addNewLogicalAndArgumentLike(LogicalAnd item)
ConstructFluent<A>.LogicalOrArgumentsNested<A>	addNewLogicalOrArgument()
A	addNewLogicalOrArgument(Object left, Object right)
ConstructFluent<A>.LogicalOrArgumentsNested<A>	addNewLogicalOrArgumentLike(LogicalOr item)
ConstructFluent<A>.MethodCallArgumentsNested<A>	addNewMethodCallArgument()
ConstructFluent<A>.MethodCallArgumentsNested<A>	addNewMethodCallArgumentLike(MethodCall item)
ConstructFluent<A>.MinusArgumentsNested<A>	addNewMinusArgument()
A	addNewMinusArgument(Object left, Object right)
ConstructFluent<A>.MinusArgumentsNested<A>	addNewMinusArgumentLike(Minus item)
ConstructFluent<A>.ModuloArgumentsNested<A>	addNewModuloArgument()
A	addNewModuloArgument(Object left, Object right)
ConstructFluent<A>.ModuloArgumentsNested<A>	addNewModuloArgumentLike(Modulo item)
ConstructFluent<A>.MultiplyArgumentsNested<A>	addNewMultiplyArgument()
A	addNewMultiplyArgument(Object left, Object right)
ConstructFluent<A>.MultiplyArgumentsNested<A>	addNewMultiplyArgumentLike(Multiply item)
ConstructFluent<A>.NegativeArgumentsNested<A>	addNewNegativeArgument()
ConstructFluent<A>.NegativeArgumentsNested<A>	addNewNegativeArgumentLike(Negative item)
ConstructFluent<A>.NewArrayArgumentsNested<A>	addNewNewArrayArgument()
A	addNewNewArrayArgument(Class type, Integer[] sizes)
ConstructFluent<A>.NewArrayArgumentsNested<A>	addNewNewArrayArgumentLike(NewArray item)
ConstructFluent<A>.NotArgumentsNested<A>	addNewNotArgument()
ConstructFluent<A>.NotArgumentsNested<A>	addNewNotArgumentLike(Not item)
ConstructFluent<A>.NotEqualsArgumentsNested<A>	addNewNotEqualsArgument()
A	addNewNotEqualsArgument(Object left, Object right)
ConstructFluent<A>.NotEqualsArgumentsNested<A>	addNewNotEqualsArgumentLike(NotEquals item)
ConstructFluent<A>.PlusArgumentsNested<A>	addNewPlusArgument()
A	addNewPlusArgument(Object left, Object right)
ConstructFluent<A>.PlusArgumentsNested<A>	addNewPlusArgumentLike(Plus item)
ConstructFluent<A>.PositiveArgumentsNested<A>	addNewPositiveArgument()
ConstructFluent<A>.PositiveArgumentsNested<A>	addNewPositiveArgumentLike(Positive item)
ConstructFluent<A>.PostDecrementArgumentsNested<A>	addNewPostDecrementArgument()
ConstructFluent<A>.PostDecrementArgumentsNested<A>	addNewPostDecrementArgumentLike(PostDecrement item)
ConstructFluent<A>.PostIncrementArgumentsNested<A>	addNewPostIncrementArgument()
ConstructFluent<A>.PostIncrementArgumentsNested<A>	addNewPostIncrementArgumentLike(PostIncrement item)
ConstructFluent<A>.PreDecrementArgumentsNested<A>	addNewPreDecrementArgument()
ConstructFluent<A>.PreDecrementArgumentsNested<A>	addNewPreDecrementArgumentLike(PreDecrement item)
ConstructFluent<A>.PreIncrementArgumentsNested<A>	addNewPreIncrementArgument()
ConstructFluent<A>.PreIncrementArgumentsNested<A>	addNewPreIncrementArgumentLike(PreIncrement item)
ConstructFluent<A>.PrimitiveRefParametersNested<A>	addNewPrimitiveRefParameter()
ConstructFluent<A>.PrimitiveRefParametersNested<A>	addNewPrimitiveRefParameterLike(PrimitiveRef item)
ConstructFluent<A>.PropertyArgumentsNested<A>	addNewPropertyArgument()
ConstructFluent<A>.PropertyArgumentsNested<A>	addNewPropertyArgumentLike(Property item)
ConstructFluent<A>.PropertyRefArgumentsNested<A>	addNewPropertyRefArgument()
ConstructFluent<A>.PropertyRefArgumentsNested<A>	addNewPropertyRefArgumentLike(PropertyRef item)
ConstructFluent<A>.RightShiftArgumentsNested<A>	addNewRightShiftArgument()
A	addNewRightShiftArgument(Object left, Object right)
ConstructFluent<A>.RightShiftArgumentsNested<A>	addNewRightShiftArgumentLike(RightShift item)
ConstructFluent<A>.RightUnsignedShiftArgumentsNested<A>	addNewRightUnsignedShiftArgument()
A	addNewRightUnsignedShiftArgument(Object left, Object right)
ConstructFluent<A>.RightUnsignedShiftArgumentsNested<A>	addNewRightUnsignedShiftArgumentLike(RightUnsignedShift item)
ConstructFluent<A>.SuperArgumentsNested<A>	addNewSuperArgument()
ConstructFluent<A>.SuperArgumentsNested<A>	addNewSuperArgumentLike(Super item)
ConstructFluent<A>.TernaryArgumentsNested<A>	addNewTernaryArgument()
ConstructFluent<A>.TernaryArgumentsNested<A>	addNewTernaryArgumentLike(Ternary item)
ConstructFluent<A>.ThisArgumentsNested<A>	addNewThisArgument()
ConstructFluent<A>.ThisArgumentsNested<A>	addNewThisArgumentLike(This item)
ConstructFluent<A>.TypeParamRefParametersNested<A>	addNewTypeParamRefParameter()
ConstructFluent<A>.TypeParamRefParametersNested<A>	addNewTypeParamRefParameterLike(TypeParamRef item)
ConstructFluent<A>.ValueRefArgumentsNested<A>	addNewValueRefArgument()
A	addNewValueRefArgument(Object value)
ConstructFluent<A>.ValueRefArgumentsNested<A>	addNewValueRefArgumentLike(ValueRef item)
ConstructFluent<A>.VoidRefParametersNested<A>	addNewVoidRefParameter()
ConstructFluent<A>.VoidRefParametersNested<A>	addNewVoidRefParameterLike(VoidRef item)
ConstructFluent<A>.WildcardRefParametersNested<A>	addNewWildcardRefParameter()
ConstructFluent<A>.WildcardRefParametersNested<A>	addNewWildcardRefParameterLike(WildcardRef item)
ConstructFluent<A>.XorArgumentsNested<A>	addNewXorArgument()
A	addNewXorArgument(Object left, Object right)
ConstructFluent<A>.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()
ClassRef	buildType()
protected void	copyInstance(Construct instance)
ConstructFluent<A>.TypeNested<A>	editOrNewType()
ConstructFluent<A>.TypeNested<A>	editOrNewTypeLike(ClassRef item)
ConstructFluent<A>.TypeNested<A>	editType()
boolean	equals(Object o)
boolean	hasArguments()
int	hashCode()
boolean	hasMatchingArgument(Predicate<VisitableBuilder<? extends Expression,?>> predicate)
boolean	hasMatchingParameter(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
boolean	hasParameters()
boolean	hasType()
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)
ConstructFluent<A>.AssignArgumentsNested<A>	setNewAssignArgumentLike(int index, Assign item)
ConstructFluent<A>.BinaryExpressionArgumentsNested<A>	setNewBinaryExpressionArgumentLike(int index, BinaryExpression item)
ConstructFluent<A>.BitwiseAndArgumentsNested<A>	setNewBitwiseAndArgumentLike(int index, BitwiseAnd item)
ConstructFluent<A>.BitwiseOrArgumentsNested<A>	setNewBitwiseOrArgumentLike(int index, BitwiseOr item)
ConstructFluent<A>.CastArgumentsNested<A>	setNewCastArgumentLike(int index, Cast item)
ConstructFluent<A>.ClassRefArgumentsNested<A>	setNewClassRefArgumentLike(int index, ClassRef item)
ConstructFluent<A>.ClassRefParametersNested<A>	setNewClassRefParameterLike(int index, ClassRef item)
ConstructFluent<A>.ConstructArgumentsNested<A>	setNewConstructArgumentLike(int index, Construct item)
ConstructFluent<A>.ContextRefArgumentsNested<A>	setNewContextRefArgumentLike(int index, ContextRef item)
ConstructFluent<A>.DeclareArgumentsNested<A>	setNewDeclareArgumentLike(int index, Declare item)
ConstructFluent<A>.DivideArgumentsNested<A>	setNewDivideArgumentLike(int index, Divide item)
ConstructFluent<A>.DotClassArgumentsNested<A>	setNewDotClassArgumentLike(int index, DotClass item)
ConstructFluent<A>.EmptyArgumentsNested<A>	setNewEmptyArgumentLike(int index, Empty item)
ConstructFluent<A>.EnclosedArgumentsNested<A>	setNewEnclosedArgumentLike(int index, Enclosed item)
ConstructFluent<A>.EqualsArgumentsNested<A>	setNewEqualsArgumentLike(int index, Equals item)
ConstructFluent<A>.GreaterThanArgumentsNested<A>	setNewGreaterThanArgumentLike(int index, GreaterThan item)
ConstructFluent<A>.GreaterThanOrEqualArgumentsNested<A>	setNewGreaterThanOrEqualArgumentLike(int index, GreaterThanOrEqual item)
ConstructFluent<A>.IndexArgumentsNested<A>	setNewIndexArgumentLike(int index, Index item)
ConstructFluent<A>.InstanceOfArgumentsNested<A>	setNewInstanceOfArgumentLike(int index, InstanceOf item)
ConstructFluent<A>.InverseArgumentsNested<A>	setNewInverseArgumentLike(int index, Inverse item)
ConstructFluent<A>.LambdaArgumentsNested<A>	setNewLambdaArgumentLike(int index, Lambda item)
ConstructFluent<A>.LeftShiftArgumentsNested<A>	setNewLeftShiftArgumentLike(int index, LeftShift item)
ConstructFluent<A>.LessThanArgumentsNested<A>	setNewLessThanArgumentLike(int index, LessThan item)
ConstructFluent<A>.LessThanOrEqualArgumentsNested<A>	setNewLessThanOrEqualArgumentLike(int index, LessThanOrEqual item)
ConstructFluent<A>.LogicalAndArgumentsNested<A>	setNewLogicalAndArgumentLike(int index, LogicalAnd item)
ConstructFluent<A>.LogicalOrArgumentsNested<A>	setNewLogicalOrArgumentLike(int index, LogicalOr item)
ConstructFluent<A>.MethodCallArgumentsNested<A>	setNewMethodCallArgumentLike(int index, MethodCall item)
ConstructFluent<A>.MinusArgumentsNested<A>	setNewMinusArgumentLike(int index, Minus item)
ConstructFluent<A>.ModuloArgumentsNested<A>	setNewModuloArgumentLike(int index, Modulo item)
ConstructFluent<A>.MultiplyArgumentsNested<A>	setNewMultiplyArgumentLike(int index, Multiply item)
ConstructFluent<A>.NegativeArgumentsNested<A>	setNewNegativeArgumentLike(int index, Negative item)
ConstructFluent<A>.NewArrayArgumentsNested<A>	setNewNewArrayArgumentLike(int index, NewArray item)
ConstructFluent<A>.NotArgumentsNested<A>	setNewNotArgumentLike(int index, Not item)
ConstructFluent<A>.NotEqualsArgumentsNested<A>	setNewNotEqualsArgumentLike(int index, NotEquals item)
ConstructFluent<A>.PlusArgumentsNested<A>	setNewPlusArgumentLike(int index, Plus item)
ConstructFluent<A>.PositiveArgumentsNested<A>	setNewPositiveArgumentLike(int index, Positive item)
ConstructFluent<A>.PostDecrementArgumentsNested<A>	setNewPostDecrementArgumentLike(int index, PostDecrement item)
ConstructFluent<A>.PostIncrementArgumentsNested<A>	setNewPostIncrementArgumentLike(int index, PostIncrement item)
ConstructFluent<A>.PreDecrementArgumentsNested<A>	setNewPreDecrementArgumentLike(int index, PreDecrement item)
ConstructFluent<A>.PreIncrementArgumentsNested<A>	setNewPreIncrementArgumentLike(int index, PreIncrement item)
ConstructFluent<A>.PrimitiveRefParametersNested<A>	setNewPrimitiveRefParameterLike(int index, PrimitiveRef item)
ConstructFluent<A>.PropertyArgumentsNested<A>	setNewPropertyArgumentLike(int index, Property item)
ConstructFluent<A>.PropertyRefArgumentsNested<A>	setNewPropertyRefArgumentLike(int index, PropertyRef item)
ConstructFluent<A>.RightShiftArgumentsNested<A>	setNewRightShiftArgumentLike(int index, RightShift item)
ConstructFluent<A>.RightUnsignedShiftArgumentsNested<A>	setNewRightUnsignedShiftArgumentLike(int index, RightUnsignedShift item)
ConstructFluent<A>.SuperArgumentsNested<A>	setNewSuperArgumentLike(int index, Super item)
ConstructFluent<A>.TernaryArgumentsNested<A>	setNewTernaryArgumentLike(int index, Ternary item)
ConstructFluent<A>.ThisArgumentsNested<A>	setNewThisArgumentLike(int index, This item)
ConstructFluent<A>.TypeParamRefParametersNested<A>	setNewTypeParamRefParameterLike(int index, TypeParamRef item)
ConstructFluent<A>.ValueRefArgumentsNested<A>	setNewValueRefArgumentLike(int index, ValueRef item)
ConstructFluent<A>.VoidRefParametersNested<A>	setNewVoidRefParameterLike(int index, VoidRef item)
ConstructFluent<A>.WildcardRefParametersNested<A>	setNewWildcardRefParameterLike(int index, WildcardRef item)
ConstructFluent<A>.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)
ConstructFluent<A>.TypeNested<A>	withNewType()
ConstructFluent<A>.TypeNested<A>	withNewTypeLike(ClassRef item)
A	withParameters(TypeRef... parameters)
A	withParameters(List<TypeRef> parameters)
A	withType(ClassRef type)

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

ConstructFluent

public ConstructFluent()

ConstructFluent

public ConstructFluent(Construct instance)

Method Details

addAllToArguments

public A addAllToArguments(Collection<Expression> items)

addAllToParameters

public A addAllToParameters(Collection<TypeRef> items)

addNewAssignArgument

public ConstructFluent<A>.AssignArgumentsNested<A> addNewAssignArgument()

addNewAssignArgumentLike

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

addNewBinaryExpressionArgument

public ConstructFluent<A>.BinaryExpressionArgumentsNested<A> addNewBinaryExpressionArgument()

addNewBinaryExpressionArgumentLike

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

addNewBitwiseAndArgument

public ConstructFluent<A>.BitwiseAndArgumentsNested<A> addNewBitwiseAndArgument()

addNewBitwiseAndArgument

public A addNewBitwiseAndArgument(Object left,
 Object right)

addNewBitwiseAndArgumentLike

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

addNewBitwiseOrArgument

public ConstructFluent<A>.BitwiseOrArgumentsNested<A> addNewBitwiseOrArgument()

addNewBitwiseOrArgument

public A addNewBitwiseOrArgument(Object left,
 Object right)

addNewBitwiseOrArgumentLike

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

addNewCastArgument

public ConstructFluent<A>.CastArgumentsNested<A> addNewCastArgument()

addNewCastArgumentLike

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

addNewClassRefArgument

public ConstructFluent<A>.ClassRefArgumentsNested<A> addNewClassRefArgument()

addNewClassRefArgumentLike

public ConstructFluent<A>.ClassRefArgumentsNested<A> addNewClassRefArgumentLike(ClassRef item)

addNewClassRefParameter

public ConstructFluent<A>.ClassRefParametersNested<A> addNewClassRefParameter()

addNewClassRefParameterLike

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

addNewConstructArgument

public ConstructFluent<A>.ConstructArgumentsNested<A> addNewConstructArgument()

addNewConstructArgumentLike

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

addNewContextRefArgument

public ConstructFluent<A>.ContextRefArgumentsNested<A> addNewContextRefArgument()

addNewContextRefArgument

public A addNewContextRefArgument(String name)

addNewContextRefArgumentLike

public ConstructFluent<A>.ContextRefArgumentsNested<A> addNewContextRefArgumentLike(ContextRef item)

addNewDeclareArgument

public ConstructFluent<A>.DeclareArgumentsNested<A> addNewDeclareArgument()

addNewDeclareArgument

public A addNewDeclareArgument(Class type,
 String name)

addNewDeclareArgument

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

addNewDeclareArgumentLike

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

addNewDivideArgument

public ConstructFluent<A>.DivideArgumentsNested<A> addNewDivideArgument()

addNewDivideArgument

public A addNewDivideArgument(Object left,
 Object right)

addNewDivideArgumentLike

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

addNewDotClassArgument

public ConstructFluent<A>.DotClassArgumentsNested<A> addNewDotClassArgument()

addNewDotClassArgumentLike

public ConstructFluent<A>.DotClassArgumentsNested<A> addNewDotClassArgumentLike(DotClass item)

addNewEmptyArgument

public ConstructFluent<A>.EmptyArgumentsNested<A> addNewEmptyArgument()

addNewEmptyArgumentLike

public ConstructFluent<A>.EmptyArgumentsNested<A> addNewEmptyArgumentLike(Empty item)

addNewEnclosedArgument

public ConstructFluent<A>.EnclosedArgumentsNested<A> addNewEnclosedArgument()

addNewEnclosedArgumentLike

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

addNewEqualsArgument

public ConstructFluent<A>.EqualsArgumentsNested<A> addNewEqualsArgument()

addNewEqualsArgument

public A addNewEqualsArgument(Object left,
 Object right)

addNewEqualsArgumentLike

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

addNewGreaterThanArgument

public ConstructFluent<A>.GreaterThanArgumentsNested<A> addNewGreaterThanArgument()

addNewGreaterThanArgument

public A addNewGreaterThanArgument(Object left,
 Object right)

addNewGreaterThanArgumentLike

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

addNewGreaterThanOrEqualArgument

public ConstructFluent<A>.GreaterThanOrEqualArgumentsNested<A> addNewGreaterThanOrEqualArgument()

addNewGreaterThanOrEqualArgument

public A addNewGreaterThanOrEqualArgument(Object left,
 Object right)

addNewGreaterThanOrEqualArgumentLike

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

addNewIndexArgument

public ConstructFluent<A>.IndexArgumentsNested<A> addNewIndexArgument()

addNewIndexArgumentLike

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

addNewInstanceOfArgument

public ConstructFluent<A>.InstanceOfArgumentsNested<A> addNewInstanceOfArgument()

addNewInstanceOfArgumentLike

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

addNewInverseArgument

public ConstructFluent<A>.InverseArgumentsNested<A> addNewInverseArgument()

addNewInverseArgumentLike

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

addNewLambdaArgument

public ConstructFluent<A>.LambdaArgumentsNested<A> addNewLambdaArgument()

addNewLambdaArgumentLike

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

addNewLeftShiftArgument

public ConstructFluent<A>.LeftShiftArgumentsNested<A> addNewLeftShiftArgument()

addNewLeftShiftArgument

public A addNewLeftShiftArgument(Object left,
 Object right)

addNewLeftShiftArgumentLike

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

addNewLessThanArgument

public ConstructFluent<A>.LessThanArgumentsNested<A> addNewLessThanArgument()

addNewLessThanArgument

public A addNewLessThanArgument(Object left,
 Object right)

addNewLessThanArgumentLike

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

addNewLessThanOrEqualArgument

public ConstructFluent<A>.LessThanOrEqualArgumentsNested<A> addNewLessThanOrEqualArgument()

addNewLessThanOrEqualArgument

public A addNewLessThanOrEqualArgument(Object left,
 Object right)

addNewLessThanOrEqualArgumentLike

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

addNewLogicalAndArgument

public ConstructFluent<A>.LogicalAndArgumentsNested<A> addNewLogicalAndArgument()

addNewLogicalAndArgument

public A addNewLogicalAndArgument(Object left,
 Object right)

addNewLogicalAndArgumentLike

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

addNewLogicalOrArgument

public ConstructFluent<A>.LogicalOrArgumentsNested<A> addNewLogicalOrArgument()

addNewLogicalOrArgument

public A addNewLogicalOrArgument(Object left,
 Object right)

addNewLogicalOrArgumentLike

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

addNewMethodCallArgument

public ConstructFluent<A>.MethodCallArgumentsNested<A> addNewMethodCallArgument()

addNewMethodCallArgumentLike

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

addNewMinusArgument

public ConstructFluent<A>.MinusArgumentsNested<A> addNewMinusArgument()

addNewMinusArgument

public A addNewMinusArgument(Object left,
 Object right)

addNewMinusArgumentLike

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

addNewModuloArgument

public ConstructFluent<A>.ModuloArgumentsNested<A> addNewModuloArgument()

addNewModuloArgument

public A addNewModuloArgument(Object left,
 Object right)

addNewModuloArgumentLike

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

addNewMultiplyArgument

public ConstructFluent<A>.MultiplyArgumentsNested<A> addNewMultiplyArgument()

addNewMultiplyArgument

public A addNewMultiplyArgument(Object left,
 Object right)

addNewMultiplyArgumentLike

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

addNewNegativeArgument

public ConstructFluent<A>.NegativeArgumentsNested<A> addNewNegativeArgument()

addNewNegativeArgumentLike

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

addNewNewArrayArgument

public ConstructFluent<A>.NewArrayArgumentsNested<A> addNewNewArrayArgument()

addNewNewArrayArgument

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

addNewNewArrayArgumentLike

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

addNewNotArgument

public ConstructFluent<A>.NotArgumentsNested<A> addNewNotArgument()

addNewNotArgumentLike

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

addNewNotEqualsArgument

public ConstructFluent<A>.NotEqualsArgumentsNested<A> addNewNotEqualsArgument()

addNewNotEqualsArgument

public A addNewNotEqualsArgument(Object left,
 Object right)

addNewNotEqualsArgumentLike

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

addNewPlusArgument

public ConstructFluent<A>.PlusArgumentsNested<A> addNewPlusArgument()

addNewPlusArgument

public A addNewPlusArgument(Object left,
 Object right)

addNewPlusArgumentLike

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

addNewPositiveArgument

public ConstructFluent<A>.PositiveArgumentsNested<A> addNewPositiveArgument()

addNewPositiveArgumentLike

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

addNewPostDecrementArgument

public ConstructFluent<A>.PostDecrementArgumentsNested<A> addNewPostDecrementArgument()

addNewPostDecrementArgumentLike

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

addNewPostIncrementArgument

public ConstructFluent<A>.PostIncrementArgumentsNested<A> addNewPostIncrementArgument()

addNewPostIncrementArgumentLike

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

addNewPreDecrementArgument

public ConstructFluent<A>.PreDecrementArgumentsNested<A> addNewPreDecrementArgument()

addNewPreDecrementArgumentLike

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

addNewPreIncrementArgument

public ConstructFluent<A>.PreIncrementArgumentsNested<A> addNewPreIncrementArgument()

addNewPreIncrementArgumentLike

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

addNewPrimitiveRefParameter

public ConstructFluent<A>.PrimitiveRefParametersNested<A> addNewPrimitiveRefParameter()

addNewPrimitiveRefParameterLike

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

addNewPropertyArgument

public ConstructFluent<A>.PropertyArgumentsNested<A> addNewPropertyArgument()

addNewPropertyArgumentLike

public ConstructFluent<A>.PropertyArgumentsNested<A> addNewPropertyArgumentLike(Property item)

addNewPropertyRefArgument

public ConstructFluent<A>.PropertyRefArgumentsNested<A> addNewPropertyRefArgument()

addNewPropertyRefArgumentLike

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

addNewRightShiftArgument

public ConstructFluent<A>.RightShiftArgumentsNested<A> addNewRightShiftArgument()

addNewRightShiftArgument

public A addNewRightShiftArgument(Object left,
 Object right)

addNewRightShiftArgumentLike

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

addNewRightUnsignedShiftArgument

public ConstructFluent<A>.RightUnsignedShiftArgumentsNested<A> addNewRightUnsignedShiftArgument()

addNewRightUnsignedShiftArgument

public A addNewRightUnsignedShiftArgument(Object left,
 Object right)

addNewRightUnsignedShiftArgumentLike

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

addNewSuperArgument

public ConstructFluent<A>.SuperArgumentsNested<A> addNewSuperArgument()

addNewSuperArgumentLike

public ConstructFluent<A>.SuperArgumentsNested<A> addNewSuperArgumentLike(Super item)

addNewTernaryArgument

public ConstructFluent<A>.TernaryArgumentsNested<A> addNewTernaryArgument()

addNewTernaryArgumentLike

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

addNewThisArgument

public ConstructFluent<A>.ThisArgumentsNested<A> addNewThisArgument()

addNewThisArgumentLike

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

addNewTypeParamRefParameter

public ConstructFluent<A>.TypeParamRefParametersNested<A> addNewTypeParamRefParameter()

addNewTypeParamRefParameterLike

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

addNewValueRefArgument

public ConstructFluent<A>.ValueRefArgumentsNested<A> addNewValueRefArgument()

addNewValueRefArgument

public A addNewValueRefArgument(Object value)

addNewValueRefArgumentLike

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

addNewVoidRefParameter

public ConstructFluent<A>.VoidRefParametersNested<A> addNewVoidRefParameter()

addNewVoidRefParameterLike

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

addNewWildcardRefParameter

public ConstructFluent<A>.WildcardRefParametersNested<A> addNewWildcardRefParameter()

addNewWildcardRefParameterLike

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

addNewXorArgument

public ConstructFluent<A>.XorArgumentsNested<A> addNewXorArgument()

addNewXorArgument

public A addNewXorArgument(Object left,
 Object right)

addNewXorArgumentLike

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

addToArguments

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

addToArguments

public A addToArguments(Expression... items)

addToArguments

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

addToArguments

public A addToArguments(int index,
 Expression item)

addToParameters

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

addToParameters

public A addToParameters(TypeRef... items)

addToParameters

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

addToParameters

public A addToParameters(int index,
 TypeRef item)

buildArgument

public Expression buildArgument(int index)

buildArguments

public List<Expression> buildArguments()

buildFirstArgument

public Expression buildFirstArgument()

buildFirstParameter

public TypeRef buildFirstParameter()

buildLastArgument

public Expression buildLastArgument()

buildLastParameter

public TypeRef buildLastParameter()

buildMatchingArgument

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

buildMatchingParameter

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

buildParameter

public TypeRef buildParameter(int index)

buildParameters

public List<TypeRef> buildParameters()

buildType

public ClassRef buildType()

builder

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

copyInstance

protected void copyInstance(Construct instance)

editOrNewType

public ConstructFluent<A>.TypeNested<A> editOrNewType()

editOrNewTypeLike

public ConstructFluent<A>.TypeNested<A> editOrNewTypeLike(ClassRef item)

editType

public ConstructFluent<A>.TypeNested<A> editType()

equals

public boolean equals(Object o)

Overrides:

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

hasArguments

public boolean hasArguments()

hasMatchingArgument

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

hasMatchingParameter

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

hasParameters

public boolean hasParameters()

hasType

public boolean hasType()

hashCode

public int hashCode()

Overrides:

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

removeAllFromArguments

public A removeAllFromArguments(Collection<Expression> items)

removeAllFromParameters

public A removeAllFromParameters(Collection<TypeRef> items)

removeFromArguments

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

removeFromArguments

public A removeFromArguments(Expression... items)

removeFromParameters

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

removeFromParameters

public A removeFromParameters(TypeRef... items)

removeMatchingFromArguments

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

removeMatchingFromParameters

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

setNewAssignArgumentLike

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

setNewBinaryExpressionArgumentLike

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

setNewBitwiseAndArgumentLike

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

setNewBitwiseOrArgumentLike

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

setNewCastArgumentLike

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

setNewClassRefArgumentLike

public ConstructFluent<A>.ClassRefArgumentsNested<A> setNewClassRefArgumentLike(int index,
 ClassRef item)

setNewClassRefParameterLike

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

setNewConstructArgumentLike

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

setNewContextRefArgumentLike

public ConstructFluent<A>.ContextRefArgumentsNested<A> setNewContextRefArgumentLike(int index,
 ContextRef item)

setNewDeclareArgumentLike

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

setNewDivideArgumentLike

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

setNewDotClassArgumentLike

public ConstructFluent<A>.DotClassArgumentsNested<A> setNewDotClassArgumentLike(int index,
 DotClass item)

setNewEmptyArgumentLike

public ConstructFluent<A>.EmptyArgumentsNested<A> setNewEmptyArgumentLike(int index,
 Empty item)

setNewEnclosedArgumentLike

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

setNewEqualsArgumentLike

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

setNewGreaterThanArgumentLike

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

setNewGreaterThanOrEqualArgumentLike

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

setNewIndexArgumentLike

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

setNewInstanceOfArgumentLike

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

setNewInverseArgumentLike

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

setNewLambdaArgumentLike

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

setNewLeftShiftArgumentLike

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

setNewLessThanArgumentLike

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

setNewLessThanOrEqualArgumentLike

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

setNewLogicalAndArgumentLike

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

setNewLogicalOrArgumentLike

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

setNewMethodCallArgumentLike

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

setNewMinusArgumentLike

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

setNewModuloArgumentLike

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

setNewMultiplyArgumentLike

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

setNewNegativeArgumentLike

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

setNewNewArrayArgumentLike

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

setNewNotArgumentLike

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

setNewNotEqualsArgumentLike

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

setNewPlusArgumentLike

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

setNewPositiveArgumentLike

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

setNewPostDecrementArgumentLike

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

setNewPostIncrementArgumentLike

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

setNewPreDecrementArgumentLike

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

setNewPreIncrementArgumentLike

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

setNewPrimitiveRefParameterLike

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

setNewPropertyArgumentLike

public ConstructFluent<A>.PropertyArgumentsNested<A> setNewPropertyArgumentLike(int index,
 Property item)

setNewPropertyRefArgumentLike

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

setNewRightShiftArgumentLike

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

setNewRightUnsignedShiftArgumentLike

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

setNewSuperArgumentLike

public ConstructFluent<A>.SuperArgumentsNested<A> setNewSuperArgumentLike(int index,
 Super item)

setNewTernaryArgumentLike

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

setNewThisArgumentLike

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

setNewTypeParamRefParameterLike

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

setNewValueRefArgumentLike

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

setNewVoidRefParameterLike

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

setNewWildcardRefParameterLike

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

setNewXorArgumentLike

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

setToArguments

public A setToArguments(int index,
 Expression item)

setToParameters

public A setToParameters(int index,
 TypeRef item)

toString

public String toString()

Overrides:

toString in class Object

withArguments

public A withArguments(List<Expression> arguments)

withArguments

public A withArguments(Expression... arguments)

withNewType

public ConstructFluent<A>.TypeNested<A> withNewType()

withNewTypeLike

public ConstructFluent<A>.TypeNested<A> withNewTypeLike(ClassRef item)

withParameters

public A withParameters(List<TypeRef> parameters)

withParameters

public A withParameters(TypeRef... parameters)

withType

public A withType(ClassRef type)