Package io.sundr.model

Class MethodFluent<A extends MethodFluent<A>>

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

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<A>.AnnotationsNested<A>	addNewAnnotation()
MethodFluent<A>.AnnotationsNested<A>	addNewAnnotationLike(AnnotationRef item)
MethodFluent<A>.ArgumentsNested<A>	addNewArgument()
MethodFluent<A>.ArgumentsNested<A>	addNewArgumentLike(Property item)
MethodFluent<A>.ExceptionsNested<A>	addNewException()
MethodFluent<A>.ExceptionsNested<A>	addNewExceptionLike(ClassRef item)
MethodFluent<A>.ParametersNested<A>	addNewParameter()
MethodFluent<A>.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<A>.AnnotationsNested<A>	editAnnotation(int index)
MethodFluent<A>.ArgumentsNested<A>	editArgument(int index)
MethodFluent<A>.BlockNested<A>	editBlock()
MethodFluent<A>.ExceptionsNested<A>	editException(int index)
MethodFluent<A>.AnnotationsNested<A>	editFirstAnnotation()
MethodFluent<A>.ArgumentsNested<A>	editFirstArgument()
MethodFluent<A>.ExceptionsNested<A>	editFirstException()
MethodFluent<A>.ParametersNested<A>	editFirstParameter()
MethodFluent<A>.AnnotationsNested<A>	editLastAnnotation()
MethodFluent<A>.ArgumentsNested<A>	editLastArgument()
MethodFluent<A>.ExceptionsNested<A>	editLastException()
MethodFluent<A>.ParametersNested<A>	editLastParameter()
MethodFluent<A>.AnnotationsNested<A>	editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)
MethodFluent<A>.ArgumentsNested<A>	editMatchingArgument(Predicate<PropertyBuilder> predicate)
MethodFluent<A>.ExceptionsNested<A>	editMatchingException(Predicate<ClassRefBuilder> predicate)
MethodFluent<A>.ParametersNested<A>	editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)
MethodFluent<A>.BlockNested<A>	editOrNewBlock()
MethodFluent<A>.BlockNested<A>	editOrNewBlockLike(Block item)
MethodFluent<A>.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<A>.AnnotationsNested<A>	setNewAnnotationLike(int index, AnnotationRef item)
MethodFluent<A>.ArgumentsNested<A>	setNewArgumentLike(int index, Property item)
MethodFluent<A>.ExceptionsNested<A>	setNewExceptionLike(int index, ClassRef item)
MethodFluent<A>.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<A>.BlockNested<A>	withNewBlock()
MethodFluent<A>.BlockNested<A>	withNewBlockLike(Block item)
MethodFluent<A>.ClassRefReturnTypeNested<A>	withNewClassRefReturnType()
MethodFluent<A>.ClassRefReturnTypeNested<A>	withNewClassRefReturnTypeLike(ClassRef item)
MethodFluent<A>.PrimitiveRefReturnTypeNested<A>	withNewPrimitiveRefReturnType()
MethodFluent<A>.PrimitiveRefReturnTypeNested<A>	withNewPrimitiveRefReturnTypeLike(PrimitiveRef item)
MethodFluent<A>.TypeParamRefReturnTypeNested<A>	withNewTypeParamRefReturnType()
MethodFluent<A>.TypeParamRefReturnTypeNested<A>	withNewTypeParamRefReturnTypeLike(TypeParamRef item)
MethodFluent<A>.VoidRefReturnTypeNested<A>	withNewVoidRefReturnType()
MethodFluent<A>.VoidRefReturnTypeNested<A>	withNewVoidRefReturnTypeLike(VoidRef item)
MethodFluent<A>.WildcardRefReturnTypeNested<A>	withNewWildcardRefReturnType()
MethodFluent<A>.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 Details

MethodFluent

public MethodFluent()

MethodFluent

public MethodFluent(Method instance)

Method Details

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<A>.AnnotationsNested<A> addNewAnnotation()

addNewAnnotationLike

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

setNewAnnotationLike

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

editAnnotation

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

editFirstAnnotation

public MethodFluent<A>.AnnotationsNested<A> editFirstAnnotation()

editLastAnnotation

public MethodFluent<A>.AnnotationsNested<A> editLastAnnotation()

editMatchingAnnotation

public MethodFluent<A>.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<A>.ParametersNested<A> addNewParameter()

addNewParameterLike

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

setNewParameterLike

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

editParameter

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

editFirstParameter

public MethodFluent<A>.ParametersNested<A> editFirstParameter()

editLastParameter

public MethodFluent<A>.ParametersNested<A> editLastParameter()

editMatchingParameter

public MethodFluent<A>.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<A>.ClassRefReturnTypeNested<A> withNewClassRefReturnType()

withNewClassRefReturnTypeLike

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

withNewPrimitiveRefReturnType

public MethodFluent<A>.PrimitiveRefReturnTypeNested<A> withNewPrimitiveRefReturnType()

withNewPrimitiveRefReturnTypeLike

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

withNewVoidRefReturnType

public MethodFluent<A>.VoidRefReturnTypeNested<A> withNewVoidRefReturnType()

withNewVoidRefReturnTypeLike

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

withNewTypeParamRefReturnType

public MethodFluent<A>.TypeParamRefReturnTypeNested<A> withNewTypeParamRefReturnType()

withNewTypeParamRefReturnTypeLike

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

withNewWildcardRefReturnType

public MethodFluent<A>.WildcardRefReturnTypeNested<A> withNewWildcardRefReturnType()

withNewWildcardRefReturnTypeLike

public MethodFluent<A>.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<A>.ArgumentsNested<A> addNewArgument()

addNewArgumentLike

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

setNewArgumentLike

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

editArgument

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

editFirstArgument

public MethodFluent<A>.ArgumentsNested<A> editFirstArgument()

editLastArgument

public MethodFluent<A>.ArgumentsNested<A> editLastArgument()

editMatchingArgument

public MethodFluent<A>.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<A>.ExceptionsNested<A> addNewException()

addNewExceptionLike

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

setNewExceptionLike

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

editException

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

editFirstException

public MethodFluent<A>.ExceptionsNested<A> editFirstException()

editLastException

public MethodFluent<A>.ExceptionsNested<A> editLastException()

editMatchingException

public MethodFluent<A>.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<A>.BlockNested<A> withNewBlock()

withNewBlockLike

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

editBlock

public MethodFluent<A>.BlockNested<A> editBlock()

editOrNewBlock

public MethodFluent<A>.BlockNested<A> editOrNewBlock()

editOrNewBlockLike

public MethodFluent<A>.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()