java.lang.Object
- io.sundr.builder.BaseFluent<A>
- - io.sundr.model.AttributeSupportFluent<A>
  - - io.sundr.model.ModifierSupportFluent<A>
    - - io.sundr.model.MethodFluent<A>

Direct Known Subclasses:

MethodBuilder, TypeDefFluent.ConstructorsNested, TypeDefFluent.MethodsNested
```
public class MethodFluent<A extends MethodFluent<A>>
extends ModifierSupportFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`MethodFluent.AnnotationsNested<N>`
`class`	`MethodFluent.ArgumentsNested<N>`
`class`	`MethodFluent.BlockNested<N>`
`class`	`MethodFluent.ClassRefReturnTypeNested<N>`
`class`	`MethodFluent.ExceptionsNested<N>`
`class`	`MethodFluent.ParametersNested<N>`
`class`	`MethodFluent.PrimitiveRefReturnTypeNested<N>`
`class`	`MethodFluent.TypeParamRefReturnTypeNested<N>`
`class`	`MethodFluent.VoidRefReturnTypeNested<N>`
`class`	`MethodFluent.WildcardRefReturnTypeNested<N>`

Nested classes/interfaces inherited from class io.sundr.model.ModifierSupportFluent
ModifierSupportFluent.ModifiersNested<N>

Field Summary
- Fields inherited from class io.sundr.builder.BaseFluent
  _visitables

Constructor Summary

Constructors
Constructor Description

MethodFluent()

MethodFluent(Method instance)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToAnnotations(Collection<AnnotationRef> items)`
`A`	`addAllToArguments(Collection<Property> items)`
`A`	`addAllToComments(Collection<String> items)`
`A`	`addAllToExceptions(Collection<ClassRef> items)`
`A`	`addAllToParameters(Collection<TypeParamDef> items)`
`MethodFluent.AnnotationsNested<A>`	`addNewAnnotation()`
`MethodFluent.AnnotationsNested<A>`	`addNewAnnotationLike(AnnotationRef item)`
`MethodFluent.ArgumentsNested<A>`	`addNewArgument()`
`MethodFluent.ArgumentsNested<A>`	`addNewArgumentLike(Property item)`
`MethodFluent.ExceptionsNested<A>`	`addNewException()`
`MethodFluent.ExceptionsNested<A>`	`addNewExceptionLike(ClassRef item)`
`MethodFluent.ParametersNested<A>`	`addNewParameter()`
`MethodFluent.ParametersNested<A>`	`addNewParameterLike(TypeParamDef item)`
`A`	`addToAnnotations(int index, AnnotationRef item)`
`A`	`addToAnnotations(AnnotationRef... items)`
`A`	`addToArguments(int index, Property item)`
`A`	`addToArguments(Property... items)`
`A`	`addToComments(int index, String item)`
`A`	`addToComments(String... items)`
`A`	`addToExceptions(int index, ClassRef item)`
`A`	`addToExceptions(ClassRef... items)`
`A`	`addToParameters(int index, TypeParamDef item)`
`A`	`addToParameters(TypeParamDef... items)`
`AnnotationRef`	`buildAnnotation(int index)`
`List<AnnotationRef>`	`buildAnnotations()`
`Property`	`buildArgument(int index)`
`List<Property>`	`buildArguments()`
`Block`	`buildBlock()`
`protected static <T> VisitableBuilder<T,?>`	`builder(Object item)`
`ClassRef`	`buildException(int index)`
`List<ClassRef>`	`buildExceptions()`
`AnnotationRef`	`buildFirstAnnotation()`
`Property`	`buildFirstArgument()`
`ClassRef`	`buildFirstException()`
`TypeParamDef`	`buildFirstParameter()`
`AnnotationRef`	`buildLastAnnotation()`
`Property`	`buildLastArgument()`
`ClassRef`	`buildLastException()`
`TypeParamDef`	`buildLastParameter()`
`AnnotationRef`	`buildMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`Property`	`buildMatchingArgument(Predicate<PropertyBuilder> predicate)`
`ClassRef`	`buildMatchingException(Predicate<ClassRefBuilder> predicate)`
`TypeParamDef`	`buildMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`TypeParamDef`	`buildParameter(int index)`
`List<TypeParamDef>`	`buildParameters()`
`TypeRef`	`buildReturnType()`
`protected void`	`copyInstance(Method instance)`
`MethodFluent.AnnotationsNested<A>`	`editAnnotation(int index)`
`MethodFluent.ArgumentsNested<A>`	`editArgument(int index)`
`MethodFluent.BlockNested<A>`	`editBlock()`
`MethodFluent.ExceptionsNested<A>`	`editException(int index)`
`MethodFluent.AnnotationsNested<A>`	`editFirstAnnotation()`
`MethodFluent.ArgumentsNested<A>`	`editFirstArgument()`
`MethodFluent.ExceptionsNested<A>`	`editFirstException()`
`MethodFluent.ParametersNested<A>`	`editFirstParameter()`
`MethodFluent.AnnotationsNested<A>`	`editLastAnnotation()`
`MethodFluent.ArgumentsNested<A>`	`editLastArgument()`
`MethodFluent.ExceptionsNested<A>`	`editLastException()`
`MethodFluent.ParametersNested<A>`	`editLastParameter()`
`MethodFluent.AnnotationsNested<A>`	`editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`MethodFluent.ArgumentsNested<A>`	`editMatchingArgument(Predicate<PropertyBuilder> predicate)`
`MethodFluent.ExceptionsNested<A>`	`editMatchingException(Predicate<ClassRefBuilder> predicate)`
`MethodFluent.ParametersNested<A>`	`editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`MethodFluent.BlockNested<A>`	`editOrNewBlock()`
`MethodFluent.BlockNested<A>`	`editOrNewBlockLike(Block item)`
`MethodFluent.ParametersNested<A>`	`editParameter(int index)`
`boolean`	`equals(Object o)`
`String`	`getComment(int index)`
`List<String>`	`getComments()`
`String`	`getFirstComment()`
`String`	`getLastComment()`
`String`	`getMatchingComment(Predicate<String> predicate)`
`String`	`getName()`
`boolean`	`hasAnnotations()`
`boolean`	`hasArguments()`
`boolean`	`hasBlock()`
`boolean`	`hasComments()`
`boolean`	`hasDefaultMethod()`
`boolean`	`hasExceptions()`
`int`	`hashCode()`
`boolean`	`hasMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)`
`boolean`	`hasMatchingArgument(Predicate<PropertyBuilder> predicate)`
`boolean`	`hasMatchingComment(Predicate<String> predicate)`
`boolean`	`hasMatchingException(Predicate<ClassRefBuilder> predicate)`
`boolean`	`hasMatchingParameter(Predicate<TypeParamDefBuilder> predicate)`
`boolean`	`hasName()`
`boolean`	`hasParameters()`
`boolean`	`hasReturnType()`
`boolean`	`hasVarArgPreferred()`
`boolean`	`isDefaultMethod()`
`boolean`	`isVarArgPreferred()`
`A`	`removeAllFromAnnotations(Collection<AnnotationRef> items)`
`A`	`removeAllFromArguments(Collection<Property> items)`
`A`	`removeAllFromComments(Collection<String> items)`
`A`	`removeAllFromExceptions(Collection<ClassRef> items)`
`A`	`removeAllFromParameters(Collection<TypeParamDef> items)`
`A`	`removeFromAnnotations(AnnotationRef... items)`
`A`	`removeFromArguments(Property... items)`
`A`	`removeFromComments(String... items)`
`A`	`removeFromExceptions(ClassRef... items)`
`A`	`removeFromParameters(TypeParamDef... items)`
`A`	`removeMatchingFromAnnotations(Predicate<AnnotationRefBuilder> predicate)`
`A`	`removeMatchingFromArguments(Predicate<PropertyBuilder> predicate)`
`A`	`removeMatchingFromExceptions(Predicate<ClassRefBuilder> predicate)`
`A`	`removeMatchingFromParameters(Predicate<TypeParamDefBuilder> predicate)`
`MethodFluent.AnnotationsNested<A>`	`setNewAnnotationLike(int index, AnnotationRef item)`
`MethodFluent.ArgumentsNested<A>`	`setNewArgumentLike(int index, Property item)`
`MethodFluent.ExceptionsNested<A>`	`setNewExceptionLike(int index, ClassRef item)`
`MethodFluent.ParametersNested<A>`	`setNewParameterLike(int index, TypeParamDef item)`
`A`	`setToAnnotations(int index, AnnotationRef item)`
`A`	`setToArguments(int index, Property item)`
`A`	`setToComments(int index, String item)`
`A`	`setToExceptions(int index, ClassRef item)`
`A`	`setToParameters(int index, TypeParamDef item)`
`String`	`toString()`
`A`	`withAnnotations(AnnotationRef... annotations)`
`A`	`withAnnotations(List<AnnotationRef> annotations)`
`A`	`withArguments(Property... arguments)`
`A`	`withArguments(List<Property> arguments)`
`A`	`withBlock(Block block)`
`A`	`withComments(String... comments)`
`A`	`withComments(List<String> comments)`
`A`	`withDefaultMethod()`
`A`	`withDefaultMethod(boolean defaultMethod)`
`A`	`withExceptions(ClassRef... exceptions)`
`A`	`withExceptions(List<ClassRef> exceptions)`
`A`	`withName(String name)`
`MethodFluent.BlockNested<A>`	`withNewBlock()`
`MethodFluent.BlockNested<A>`	`withNewBlockLike(Block item)`
`MethodFluent.ClassRefReturnTypeNested<A>`	`withNewClassRefReturnType()`
`MethodFluent.ClassRefReturnTypeNested<A>`	`withNewClassRefReturnTypeLike(ClassRef item)`
`MethodFluent.PrimitiveRefReturnTypeNested<A>`	`withNewPrimitiveRefReturnType()`
`MethodFluent.PrimitiveRefReturnTypeNested<A>`	`withNewPrimitiveRefReturnTypeLike(PrimitiveRef item)`
`MethodFluent.TypeParamRefReturnTypeNested<A>`	`withNewTypeParamRefReturnType()`
`MethodFluent.TypeParamRefReturnTypeNested<A>`	`withNewTypeParamRefReturnTypeLike(TypeParamRef item)`
`MethodFluent.VoidRefReturnTypeNested<A>`	`withNewVoidRefReturnType()`
`MethodFluent.VoidRefReturnTypeNested<A>`	`withNewVoidRefReturnTypeLike(VoidRef item)`
`MethodFluent.WildcardRefReturnTypeNested<A>`	`withNewWildcardRefReturnType()`
`MethodFluent.WildcardRefReturnTypeNested<A>`	`withNewWildcardRefReturnTypeLike(WildcardRef item)`
`A`	`withParameters(TypeParamDef... parameters)`
`A`	`withParameters(List<TypeParamDef> parameters)`
`A`	`withReturnType(TypeRef returnType)`
`A`	`withVarArgPreferred()`
`A`	`withVarArgPreferred(boolean varArgPreferred)`

Methods inherited from class io.sundr.model.ModifierSupportFluent
buildModifiers, copyInstance, editModifiers, editOrNewModifiers, editOrNewModifiersLike, hasModifiers, withModifiers, withNewModifiers, withNewModifiersLike

Methods inherited from class io.sundr.model.AttributeSupportFluent
addToAttributes, addToAttributes, copyInstance, getAttributes, hasAttributes, removeFromAttributes, removeFromAttributes, withAttributes

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

MethodFluent
```
public MethodFluent()
```

MethodFluent

public MethodFluent(Method instance)

Method Detail

copyInstance

protected void copyInstance(Method instance)

addToComments

public A addToComments(int index,
                       String item)

setToComments

public A setToComments(int index,
                       String item)

addToComments

public A addToComments(String... items)

addAllToComments

public A addAllToComments(Collection<String> items)

removeFromComments

public A removeFromComments(String... items)

removeAllFromComments

public A removeAllFromComments(Collection<String> items)

getComments
```
public List<String> getComments()
```

getComment

public String getComment(int index)

getFirstComment
```
public String getFirstComment()
```

getLastComment
```
public String getLastComment()
```

getMatchingComment

public String getMatchingComment(Predicate<String> predicate)

hasMatchingComment

public boolean hasMatchingComment(Predicate<String> predicate)

withComments

public A withComments(List<String> comments)

withComments

public A withComments(String... comments)

hasComments
```
public boolean hasComments()
```

addToAnnotations

public A addToAnnotations(int index,
                          AnnotationRef item)

setToAnnotations

public A setToAnnotations(int index,
                          AnnotationRef item)

addToAnnotations

public A addToAnnotations(AnnotationRef... items)

addAllToAnnotations

public A addAllToAnnotations(Collection<AnnotationRef> items)

removeFromAnnotations

public A removeFromAnnotations(AnnotationRef... items)

removeAllFromAnnotations

public A removeAllFromAnnotations(Collection<AnnotationRef> items)

removeMatchingFromAnnotations

public A removeMatchingFromAnnotations(Predicate<AnnotationRefBuilder> predicate)

buildAnnotations

public List<AnnotationRef> buildAnnotations()

buildAnnotation

public AnnotationRef buildAnnotation(int index)

buildFirstAnnotation

public AnnotationRef buildFirstAnnotation()

buildLastAnnotation

public AnnotationRef buildLastAnnotation()

buildMatchingAnnotation

public AnnotationRef buildMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

hasMatchingAnnotation

public boolean hasMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

withAnnotations

public A withAnnotations(List<AnnotationRef> annotations)

withAnnotations

public A withAnnotations(AnnotationRef... annotations)

hasAnnotations
```
public boolean hasAnnotations()
```

addNewAnnotation

public MethodFluent.AnnotationsNested<A> addNewAnnotation()

addNewAnnotationLike

public MethodFluent.AnnotationsNested<A> addNewAnnotationLike(AnnotationRef item)

setNewAnnotationLike

public MethodFluent.AnnotationsNested<A> setNewAnnotationLike(int index,
                                                              AnnotationRef item)

editAnnotation

public MethodFluent.AnnotationsNested<A> editAnnotation(int index)

editFirstAnnotation

public MethodFluent.AnnotationsNested<A> editFirstAnnotation()

editLastAnnotation

public MethodFluent.AnnotationsNested<A> editLastAnnotation()

editMatchingAnnotation

public MethodFluent.AnnotationsNested<A> editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)

addToParameters

public A addToParameters(int index,
                         TypeParamDef item)

setToParameters

public A setToParameters(int index,
                         TypeParamDef item)

addToParameters

public A addToParameters(TypeParamDef... items)

addAllToParameters

public A addAllToParameters(Collection<TypeParamDef> items)

removeFromParameters

public A removeFromParameters(TypeParamDef... items)

removeAllFromParameters

public A removeAllFromParameters(Collection<TypeParamDef> items)

removeMatchingFromParameters

public A removeMatchingFromParameters(Predicate<TypeParamDefBuilder> predicate)

buildParameters

public List<TypeParamDef> buildParameters()

buildParameter

public TypeParamDef buildParameter(int index)

buildFirstParameter

public TypeParamDef buildFirstParameter()

buildLastParameter

public TypeParamDef buildLastParameter()

buildMatchingParameter

public TypeParamDef buildMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

hasMatchingParameter

public boolean hasMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

withParameters

public A withParameters(List<TypeParamDef> parameters)

withParameters

public A withParameters(TypeParamDef... parameters)

hasParameters
```
public boolean hasParameters()
```

addNewParameter

public MethodFluent.ParametersNested<A> addNewParameter()

addNewParameterLike

public MethodFluent.ParametersNested<A> addNewParameterLike(TypeParamDef item)

setNewParameterLike

public MethodFluent.ParametersNested<A> setNewParameterLike(int index,
                                                            TypeParamDef item)

editParameter

public MethodFluent.ParametersNested<A> editParameter(int index)

editFirstParameter

public MethodFluent.ParametersNested<A> editFirstParameter()

editLastParameter

public MethodFluent.ParametersNested<A> editLastParameter()

editMatchingParameter

public MethodFluent.ParametersNested<A> editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)

getName
```
public String getName()
```

withName
```
public A withName(String name)
```

hasName
```
public boolean hasName()
```

buildReturnType
```
public TypeRef buildReturnType()
```

withReturnType

public A withReturnType(TypeRef returnType)

hasReturnType
```
public boolean hasReturnType()
```

withNewClassRefReturnType

public MethodFluent.ClassRefReturnTypeNested<A> withNewClassRefReturnType()

withNewClassRefReturnTypeLike

public MethodFluent.ClassRefReturnTypeNested<A> withNewClassRefReturnTypeLike(ClassRef item)

withNewPrimitiveRefReturnType

public MethodFluent.PrimitiveRefReturnTypeNested<A> withNewPrimitiveRefReturnType()

withNewPrimitiveRefReturnTypeLike

public MethodFluent.PrimitiveRefReturnTypeNested<A> withNewPrimitiveRefReturnTypeLike(PrimitiveRef item)

withNewVoidRefReturnType

public MethodFluent.VoidRefReturnTypeNested<A> withNewVoidRefReturnType()

withNewVoidRefReturnTypeLike

public MethodFluent.VoidRefReturnTypeNested<A> withNewVoidRefReturnTypeLike(VoidRef item)

withNewTypeParamRefReturnType

public MethodFluent.TypeParamRefReturnTypeNested<A> withNewTypeParamRefReturnType()

withNewTypeParamRefReturnTypeLike

public MethodFluent.TypeParamRefReturnTypeNested<A> withNewTypeParamRefReturnTypeLike(TypeParamRef item)

withNewWildcardRefReturnType

public MethodFluent.WildcardRefReturnTypeNested<A> withNewWildcardRefReturnType()

withNewWildcardRefReturnTypeLike

public MethodFluent.WildcardRefReturnTypeNested<A> withNewWildcardRefReturnTypeLike(WildcardRef item)

addToArguments

public A addToArguments(int index,
                        Property item)

setToArguments

public A setToArguments(int index,
                        Property item)

addToArguments

public A addToArguments(Property... items)

addAllToArguments

public A addAllToArguments(Collection<Property> items)

removeFromArguments

public A removeFromArguments(Property... items)

removeAllFromArguments

public A removeAllFromArguments(Collection<Property> items)

removeMatchingFromArguments

public A removeMatchingFromArguments(Predicate<PropertyBuilder> predicate)

buildArguments

public List<Property> buildArguments()

buildArgument

public Property buildArgument(int index)

buildFirstArgument
```
public Property buildFirstArgument()
```

buildLastArgument
```
public Property buildLastArgument()
```

buildMatchingArgument

public Property buildMatchingArgument(Predicate<PropertyBuilder> predicate)

hasMatchingArgument

public boolean hasMatchingArgument(Predicate<PropertyBuilder> predicate)

withArguments

public A withArguments(List<Property> arguments)

withArguments

public A withArguments(Property... arguments)

hasArguments
```
public boolean hasArguments()
```

addNewArgument

public MethodFluent.ArgumentsNested<A> addNewArgument()

addNewArgumentLike

public MethodFluent.ArgumentsNested<A> addNewArgumentLike(Property item)

setNewArgumentLike

public MethodFluent.ArgumentsNested<A> setNewArgumentLike(int index,
                                                          Property item)

editArgument

public MethodFluent.ArgumentsNested<A> editArgument(int index)

editFirstArgument

public MethodFluent.ArgumentsNested<A> editFirstArgument()

editLastArgument

public MethodFluent.ArgumentsNested<A> editLastArgument()

editMatchingArgument

public MethodFluent.ArgumentsNested<A> editMatchingArgument(Predicate<PropertyBuilder> predicate)

isVarArgPreferred
```
public boolean isVarArgPreferred()
```

withVarArgPreferred

public A withVarArgPreferred(boolean varArgPreferred)

hasVarArgPreferred
```
public boolean hasVarArgPreferred()
```

addToExceptions

public A addToExceptions(int index,
                         ClassRef item)

setToExceptions

public A setToExceptions(int index,
                         ClassRef item)

addToExceptions

public A addToExceptions(ClassRef... items)

addAllToExceptions

public A addAllToExceptions(Collection<ClassRef> items)

removeFromExceptions

public A removeFromExceptions(ClassRef... items)

removeAllFromExceptions

public A removeAllFromExceptions(Collection<ClassRef> items)

removeMatchingFromExceptions

public A removeMatchingFromExceptions(Predicate<ClassRefBuilder> predicate)

buildExceptions

public List<ClassRef> buildExceptions()

buildException

public ClassRef buildException(int index)

buildFirstException
```
public ClassRef buildFirstException()
```

buildLastException
```
public ClassRef buildLastException()
```

buildMatchingException

public ClassRef buildMatchingException(Predicate<ClassRefBuilder> predicate)

hasMatchingException

public boolean hasMatchingException(Predicate<ClassRefBuilder> predicate)

withExceptions

public A withExceptions(List<ClassRef> exceptions)

withExceptions

public A withExceptions(ClassRef... exceptions)

hasExceptions
```
public boolean hasExceptions()
```

addNewException

public MethodFluent.ExceptionsNested<A> addNewException()

addNewExceptionLike

public MethodFluent.ExceptionsNested<A> addNewExceptionLike(ClassRef item)

setNewExceptionLike

public MethodFluent.ExceptionsNested<A> setNewExceptionLike(int index,
                                                            ClassRef item)

editException

public MethodFluent.ExceptionsNested<A> editException(int index)

editFirstException

public MethodFluent.ExceptionsNested<A> editFirstException()

editLastException

public MethodFluent.ExceptionsNested<A> editLastException()

editMatchingException

public MethodFluent.ExceptionsNested<A> editMatchingException(Predicate<ClassRefBuilder> predicate)

isDefaultMethod
```
public boolean isDefaultMethod()
```

withDefaultMethod

public A withDefaultMethod(boolean defaultMethod)

hasDefaultMethod
```
public boolean hasDefaultMethod()
```

buildBlock
```
public Block buildBlock()
```

withBlock
```
public A withBlock(Block block)
```

hasBlock
```
public boolean hasBlock()
```

withNewBlock

public MethodFluent.BlockNested<A> withNewBlock()

withNewBlockLike

public MethodFluent.BlockNested<A> withNewBlockLike(Block item)

editBlock

public MethodFluent.BlockNested<A> editBlock()

editOrNewBlock

public MethodFluent.BlockNested<A> editOrNewBlock()

editOrNewBlockLike

public MethodFluent.BlockNested<A> editOrNewBlockLike(Block item)

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class ModifierSupportFluent<A extends MethodFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class ModifierSupportFluent<A extends MethodFluent<A>>

toString
```
public String toString()
```
Overrides:

toString in class ModifierSupportFluent<A extends MethodFluent<A>>

builder

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

withVarArgPreferred
```
public A withVarArgPreferred()
```

withDefaultMethod
```
public A withDefaultMethod()
```

Class MethodFluent<A extends MethodFluent<A>>

Nested Class Summary

Nested classes/interfaces inherited from class io.sundr.model.ModifierSupportFluent

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.sundr.model.ModifierSupportFluent

Methods inherited from class io.sundr.model.AttributeSupportFluent

Methods inherited from class io.sundr.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

MethodFluent

MethodFluent

Method Detail

copyInstance

addToComments

setToComments

addToComments

addAllToComments

removeFromComments

removeAllFromComments

getComments

getComment

getFirstComment

getLastComment

getMatchingComment

hasMatchingComment

withComments

withComments

hasComments

addToAnnotations

setToAnnotations

addToAnnotations

addAllToAnnotations

removeFromAnnotations

removeAllFromAnnotations

removeMatchingFromAnnotations

buildAnnotations

buildAnnotation

buildFirstAnnotation

buildLastAnnotation

buildMatchingAnnotation

hasMatchingAnnotation

withAnnotations

withAnnotations

hasAnnotations

addNewAnnotation

addNewAnnotationLike

setNewAnnotationLike

editAnnotation

editFirstAnnotation

editLastAnnotation

editMatchingAnnotation

addToParameters

setToParameters

addToParameters

addAllToParameters

removeFromParameters

removeAllFromParameters

removeMatchingFromParameters

buildParameters

buildParameter

buildFirstParameter

buildLastParameter

buildMatchingParameter

hasMatchingParameter

withParameters

withParameters

hasParameters

addNewParameter

addNewParameterLike

setNewParameterLike

editParameter

editFirstParameter

editLastParameter

editMatchingParameter

getName

withName

hasName