Package io.sundr.model

Class TypeDefFluent<A extends TypeDefFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.AttributeSupportFluent<A>

io.sundr.model.ModifierSupportFluent<A>

io.sundr.model.TypeDefFluent<A>

Direct Known Subclasses:

SourceFluent.TypesNested, TypeDefBuilder, TypeDefFluent.InnerTypesNested

public class TypeDefFluent<A extends TypeDefFluent<A>>
extends ModifierSupportFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	TypeDefFluent.AnnotationsNested<N>
class	TypeDefFluent.ConstructorsNested<N>
class	TypeDefFluent.ExtendsListNested<N>
class	TypeDefFluent.ImplementsListNested<N>
class	TypeDefFluent.InnerTypesNested<N>
class	TypeDefFluent.MethodsNested<N>
class	TypeDefFluent.ParametersNested<N>
class	TypeDefFluent.PropertiesNested<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
TypeDefFluent()
TypeDefFluent(TypeDef instance)

Method Summary

Modifier and Type	Method	Description
A	addAllToAnnotations(Collection<AnnotationRef> items)
A	addAllToComments(Collection<String> items)
A	addAllToConstructors(Collection<Method> items)
A	addAllToExtendsList(Collection<ClassRef> items)
A	addAllToImplementsList(Collection<ClassRef> items)
A	addAllToInnerTypes(Collection<TypeDef> items)
A	addAllToMethods(Collection<Method> items)
A	addAllToParameters(Collection<TypeParamDef> items)
A	addAllToProperties(Collection<Property> items)
TypeDefFluent<A>.AnnotationsNested<A>	addNewAnnotation()
TypeDefFluent<A>.AnnotationsNested<A>	addNewAnnotationLike(AnnotationRef item)
TypeDefFluent<A>.ConstructorsNested<A>	addNewConstructor()
TypeDefFluent<A>.ConstructorsNested<A>	addNewConstructorLike(Method item)
TypeDefFluent<A>.ExtendsListNested<A>	addNewExtendsList()
TypeDefFluent<A>.ExtendsListNested<A>	addNewExtendsListLike(ClassRef item)
TypeDefFluent<A>.ImplementsListNested<A>	addNewImplementsList()
TypeDefFluent<A>.ImplementsListNested<A>	addNewImplementsListLike(ClassRef item)
TypeDefFluent<A>.InnerTypesNested<A>	addNewInnerType()
A	addNewInnerType(String fullyQualifiedName)
TypeDefFluent<A>.InnerTypesNested<A>	addNewInnerTypeLike(TypeDef item)
TypeDefFluent<A>.MethodsNested<A>	addNewMethod()
TypeDefFluent<A>.MethodsNested<A>	addNewMethodLike(Method item)
TypeDefFluent<A>.ParametersNested<A>	addNewParameter()
TypeDefFluent<A>.ParametersNested<A>	addNewParameterLike(TypeParamDef item)
TypeDefFluent<A>.PropertiesNested<A>	addNewProperty()
TypeDefFluent<A>.PropertiesNested<A>	addNewPropertyLike(Property item)
A	addToAnnotations(int index, AnnotationRef item)
A	addToAnnotations(AnnotationRef... items)
A	addToComments(int index, String item)
A	addToComments(String... items)
A	addToConstructors(int index, Method item)
A	addToConstructors(Method... items)
A	addToExtendsList(int index, ClassRef item)
A	addToExtendsList(ClassRef... items)
A	addToImplementsList(int index, ClassRef item)
A	addToImplementsList(ClassRef... items)
A	addToInnerTypes(int index, TypeDef item)
A	addToInnerTypes(TypeDef... items)
A	addToMethods(int index, Method item)
A	addToMethods(Method... items)
A	addToParameters(int index, TypeParamDef item)
A	addToParameters(TypeParamDef... items)
A	addToProperties(int index, Property item)
A	addToProperties(Property... items)
AnnotationRef	buildAnnotation(int index)
List<AnnotationRef>	buildAnnotations()
Method	buildConstructor(int index)
List<Method>	buildConstructors()
List<ClassRef>	buildExtendsList()
ClassRef	buildExtendsList(int index)
AnnotationRef	buildFirstAnnotation()
Method	buildFirstConstructor()
ClassRef	buildFirstExtendsList()
ClassRef	buildFirstImplementsList()
TypeDef	buildFirstInnerType()
Method	buildFirstMethod()
TypeParamDef	buildFirstParameter()
Property	buildFirstProperty()
List<ClassRef>	buildImplementsList()
ClassRef	buildImplementsList(int index)
TypeDef	buildInnerType(int index)
List<TypeDef>	buildInnerTypes()
AnnotationRef	buildLastAnnotation()
Method	buildLastConstructor()
ClassRef	buildLastExtendsList()
ClassRef	buildLastImplementsList()
TypeDef	buildLastInnerType()
Method	buildLastMethod()
TypeParamDef	buildLastParameter()
Property	buildLastProperty()
AnnotationRef	buildMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)
Method	buildMatchingConstructor(Predicate<MethodBuilder> predicate)
ClassRef	buildMatchingExtendsList(Predicate<ClassRefBuilder> predicate)
ClassRef	buildMatchingImplementsList(Predicate<ClassRefBuilder> predicate)
TypeDef	buildMatchingInnerType(Predicate<TypeDefBuilder> predicate)
Method	buildMatchingMethod(Predicate<MethodBuilder> predicate)
TypeParamDef	buildMatchingParameter(Predicate<TypeParamDefBuilder> predicate)
Property	buildMatchingProperty(Predicate<PropertyBuilder> predicate)
Method	buildMethod(int index)
List<Method>	buildMethods()
TypeParamDef	buildParameter(int index)
List<TypeParamDef>	buildParameters()
List<Property>	buildProperties()
Property	buildProperty(int index)
protected void	copyInstance(TypeDef instance)
TypeDefFluent<A>.AnnotationsNested<A>	editAnnotation(int index)
TypeDefFluent<A>.ConstructorsNested<A>	editConstructor(int index)
TypeDefFluent<A>.ExtendsListNested<A>	editExtendsList(int index)
TypeDefFluent<A>.AnnotationsNested<A>	editFirstAnnotation()
TypeDefFluent<A>.ConstructorsNested<A>	editFirstConstructor()
TypeDefFluent<A>.ExtendsListNested<A>	editFirstExtendsList()
TypeDefFluent<A>.ImplementsListNested<A>	editFirstImplementsList()
TypeDefFluent<A>.InnerTypesNested<A>	editFirstInnerType()
TypeDefFluent<A>.MethodsNested<A>	editFirstMethod()
TypeDefFluent<A>.ParametersNested<A>	editFirstParameter()
TypeDefFluent<A>.PropertiesNested<A>	editFirstProperty()
TypeDefFluent<A>.ImplementsListNested<A>	editImplementsList(int index)
TypeDefFluent<A>.InnerTypesNested<A>	editInnerType(int index)
TypeDefFluent<A>.AnnotationsNested<A>	editLastAnnotation()
TypeDefFluent<A>.ConstructorsNested<A>	editLastConstructor()
TypeDefFluent<A>.ExtendsListNested<A>	editLastExtendsList()
TypeDefFluent<A>.ImplementsListNested<A>	editLastImplementsList()
TypeDefFluent<A>.InnerTypesNested<A>	editLastInnerType()
TypeDefFluent<A>.MethodsNested<A>	editLastMethod()
TypeDefFluent<A>.ParametersNested<A>	editLastParameter()
TypeDefFluent<A>.PropertiesNested<A>	editLastProperty()
TypeDefFluent<A>.AnnotationsNested<A>	editMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)
TypeDefFluent<A>.ConstructorsNested<A>	editMatchingConstructor(Predicate<MethodBuilder> predicate)
TypeDefFluent<A>.ExtendsListNested<A>	editMatchingExtendsList(Predicate<ClassRefBuilder> predicate)
TypeDefFluent<A>.ImplementsListNested<A>	editMatchingImplementsList(Predicate<ClassRefBuilder> predicate)
TypeDefFluent<A>.InnerTypesNested<A>	editMatchingInnerType(Predicate<TypeDefBuilder> predicate)
TypeDefFluent<A>.MethodsNested<A>	editMatchingMethod(Predicate<MethodBuilder> predicate)
TypeDefFluent<A>.ParametersNested<A>	editMatchingParameter(Predicate<TypeParamDefBuilder> predicate)
TypeDefFluent<A>.PropertiesNested<A>	editMatchingProperty(Predicate<PropertyBuilder> predicate)
TypeDefFluent<A>.MethodsNested<A>	editMethod(int index)
TypeDefFluent<A>.ParametersNested<A>	editParameter(int index)
TypeDefFluent<A>.PropertiesNested<A>	editProperty(int index)
boolean	equals(Object o)
String	getComment(int index)
List<String>	getComments()
String	getFirstComment()
Kind	getKind()
String	getLastComment()
String	getMatchingComment(Predicate<String> predicate)
String	getName()
String	getOuterTypeName()
String	getPackageName()
boolean	hasAnnotations()
boolean	hasComments()
boolean	hasConstructors()
boolean	hasExtendsList()
int	hashCode()
boolean	hasImplementsList()
boolean	hasInnerTypes()
boolean	hasKind()
boolean	hasMatchingAnnotation(Predicate<AnnotationRefBuilder> predicate)
boolean	hasMatchingComment(Predicate<String> predicate)
boolean	hasMatchingConstructor(Predicate<MethodBuilder> predicate)
boolean	hasMatchingExtendsList(Predicate<ClassRefBuilder> predicate)
boolean	hasMatchingImplementsList(Predicate<ClassRefBuilder> predicate)
boolean	hasMatchingInnerType(Predicate<TypeDefBuilder> predicate)
boolean	hasMatchingMethod(Predicate<MethodBuilder> predicate)
boolean	hasMatchingParameter(Predicate<TypeParamDefBuilder> predicate)
boolean	hasMatchingProperty(Predicate<PropertyBuilder> predicate)
boolean	hasMethods()
boolean	hasName()
boolean	hasOuterTypeName()
boolean	hasPackageName()
boolean	hasParameters()
boolean	hasProperties()
A	removeAllFromAnnotations(Collection<AnnotationRef> items)
A	removeAllFromComments(Collection<String> items)
A	removeAllFromConstructors(Collection<Method> items)
A	removeAllFromExtendsList(Collection<ClassRef> items)
A	removeAllFromImplementsList(Collection<ClassRef> items)
A	removeAllFromInnerTypes(Collection<TypeDef> items)
A	removeAllFromMethods(Collection<Method> items)
A	removeAllFromParameters(Collection<TypeParamDef> items)
A	removeAllFromProperties(Collection<Property> items)
A	removeFromAnnotations(AnnotationRef... items)
A	removeFromComments(String... items)
A	removeFromConstructors(Method... items)
A	removeFromExtendsList(ClassRef... items)
A	removeFromImplementsList(ClassRef... items)
A	removeFromInnerTypes(TypeDef... items)
A	removeFromMethods(Method... items)
A	removeFromParameters(TypeParamDef... items)
A	removeFromProperties(Property... items)
A	removeMatchingFromAnnotations(Predicate<AnnotationRefBuilder> predicate)
A	removeMatchingFromConstructors(Predicate<MethodBuilder> predicate)
A	removeMatchingFromExtendsList(Predicate<ClassRefBuilder> predicate)
A	removeMatchingFromImplementsList(Predicate<ClassRefBuilder> predicate)
A	removeMatchingFromInnerTypes(Predicate<TypeDefBuilder> predicate)
A	removeMatchingFromMethods(Predicate<MethodBuilder> predicate)
A	removeMatchingFromParameters(Predicate<TypeParamDefBuilder> predicate)
A	removeMatchingFromProperties(Predicate<PropertyBuilder> predicate)
TypeDefFluent<A>.AnnotationsNested<A>	setNewAnnotationLike(int index, AnnotationRef item)
TypeDefFluent<A>.ConstructorsNested<A>	setNewConstructorLike(int index, Method item)
TypeDefFluent<A>.ExtendsListNested<A>	setNewExtendsListLike(int index, ClassRef item)
TypeDefFluent<A>.ImplementsListNested<A>	setNewImplementsListLike(int index, ClassRef item)
TypeDefFluent<A>.InnerTypesNested<A>	setNewInnerTypeLike(int index, TypeDef item)
TypeDefFluent<A>.MethodsNested<A>	setNewMethodLike(int index, Method item)
TypeDefFluent<A>.ParametersNested<A>	setNewParameterLike(int index, TypeParamDef item)
TypeDefFluent<A>.PropertiesNested<A>	setNewPropertyLike(int index, Property item)
A	setToAnnotations(int index, AnnotationRef item)
A	setToComments(int index, String item)
A	setToConstructors(int index, Method item)
A	setToExtendsList(int index, ClassRef item)
A	setToImplementsList(int index, ClassRef item)
A	setToInnerTypes(int index, TypeDef item)
A	setToMethods(int index, Method item)
A	setToParameters(int index, TypeParamDef item)
A	setToProperties(int index, Property item)
String	toString()
A	withAnnotations(AnnotationRef... annotations)
A	withAnnotations(List<AnnotationRef> annotations)
A	withComments(String... comments)
A	withComments(List<String> comments)
A	withConstructors(Method... constructors)
A	withConstructors(List<Method> constructors)
A	withExtendsList(ClassRef... extendsList)
A	withExtendsList(List<ClassRef> extendsList)
A	withImplementsList(ClassRef... implementsList)
A	withImplementsList(List<ClassRef> implementsList)
A	withInnerTypes(TypeDef... innerTypes)
A	withInnerTypes(List<TypeDef> innerTypes)
A	withKind(Kind kind)
A	withMethods(Method... methods)
A	withMethods(List<Method> methods)
A	withName(String name)
A	withOuterTypeName(String outerTypeName)
A	withPackageName(String packageName)
A	withParameters(TypeParamDef... parameters)
A	withParameters(List<TypeParamDef> parameters)
A	withProperties(Property... properties)
A	withProperties(List<Property> properties)

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

TypeDefFluent

public TypeDefFluent()

TypeDefFluent

public TypeDefFluent(TypeDef instance)

Method Details

copyInstance

protected void copyInstance(TypeDef instance)

getKind

public Kind getKind()

withKind

public A withKind(Kind kind)

hasKind

public boolean hasKind()

getPackageName

public String getPackageName()

withPackageName

public A withPackageName(String packageName)

hasPackageName

public boolean hasPackageName()

getName

public String getName()

withName

public A withName(String name)

hasName

public boolean hasName()

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

addNewAnnotationLike

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

setNewAnnotationLike

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

editAnnotation

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

editFirstAnnotation

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

editLastAnnotation

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

editMatchingAnnotation

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

addToExtendsList

public A addToExtendsList(int index,
 ClassRef item)

setToExtendsList

public A setToExtendsList(int index,
 ClassRef item)

addToExtendsList

public A addToExtendsList(ClassRef... items)

addAllToExtendsList

public A addAllToExtendsList(Collection<ClassRef> items)

removeFromExtendsList

public A removeFromExtendsList(ClassRef... items)

removeAllFromExtendsList

public A removeAllFromExtendsList(Collection<ClassRef> items)

removeMatchingFromExtendsList

public A removeMatchingFromExtendsList(Predicate<ClassRefBuilder> predicate)

buildExtendsList

public List<ClassRef> buildExtendsList()

buildExtendsList

public ClassRef buildExtendsList(int index)

buildFirstExtendsList

public ClassRef buildFirstExtendsList()

buildLastExtendsList

public ClassRef buildLastExtendsList()

buildMatchingExtendsList

public ClassRef buildMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

hasMatchingExtendsList

public boolean hasMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

withExtendsList

public A withExtendsList(List<ClassRef> extendsList)

withExtendsList

public A withExtendsList(ClassRef... extendsList)

hasExtendsList

public boolean hasExtendsList()

addNewExtendsList

public TypeDefFluent<A>.ExtendsListNested<A> addNewExtendsList()

addNewExtendsListLike

public TypeDefFluent<A>.ExtendsListNested<A> addNewExtendsListLike(ClassRef item)

setNewExtendsListLike

public TypeDefFluent<A>.ExtendsListNested<A> setNewExtendsListLike(int index,
 ClassRef item)

editExtendsList

public TypeDefFluent<A>.ExtendsListNested<A> editExtendsList(int index)

editFirstExtendsList

public TypeDefFluent<A>.ExtendsListNested<A> editFirstExtendsList()

editLastExtendsList

public TypeDefFluent<A>.ExtendsListNested<A> editLastExtendsList()

editMatchingExtendsList

public TypeDefFluent<A>.ExtendsListNested<A> editMatchingExtendsList(Predicate<ClassRefBuilder> predicate)

addToImplementsList

public A addToImplementsList(int index,
 ClassRef item)

setToImplementsList

public A setToImplementsList(int index,
 ClassRef item)

addToImplementsList

public A addToImplementsList(ClassRef... items)

addAllToImplementsList

public A addAllToImplementsList(Collection<ClassRef> items)

removeFromImplementsList

public A removeFromImplementsList(ClassRef... items)

removeAllFromImplementsList

public A removeAllFromImplementsList(Collection<ClassRef> items)

removeMatchingFromImplementsList

public A removeMatchingFromImplementsList(Predicate<ClassRefBuilder> predicate)

buildImplementsList

public List<ClassRef> buildImplementsList()

buildImplementsList

public ClassRef buildImplementsList(int index)

buildFirstImplementsList

public ClassRef buildFirstImplementsList()

buildLastImplementsList

public ClassRef buildLastImplementsList()

buildMatchingImplementsList

public ClassRef buildMatchingImplementsList(Predicate<ClassRefBuilder> predicate)

hasMatchingImplementsList

public boolean hasMatchingImplementsList(Predicate<ClassRefBuilder> predicate)

withImplementsList

public A withImplementsList(List<ClassRef> implementsList)

withImplementsList

public A withImplementsList(ClassRef... implementsList)

hasImplementsList

public boolean hasImplementsList()

addNewImplementsList

public TypeDefFluent<A>.ImplementsListNested<A> addNewImplementsList()

addNewImplementsListLike

public TypeDefFluent<A>.ImplementsListNested<A> addNewImplementsListLike(ClassRef item)

setNewImplementsListLike

public TypeDefFluent<A>.ImplementsListNested<A> setNewImplementsListLike(int index,
 ClassRef item)

editImplementsList

public TypeDefFluent<A>.ImplementsListNested<A> editImplementsList(int index)

editFirstImplementsList

public TypeDefFluent<A>.ImplementsListNested<A> editFirstImplementsList()

editLastImplementsList

public TypeDefFluent<A>.ImplementsListNested<A> editLastImplementsList()

editMatchingImplementsList

public TypeDefFluent<A>.ImplementsListNested<A> editMatchingImplementsList(Predicate<ClassRefBuilder> 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 TypeDefFluent<A>.ParametersNested<A> addNewParameter()

addNewParameterLike

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

setNewParameterLike

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

editParameter

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

editFirstParameter

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

editLastParameter

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

editMatchingParameter

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

addToProperties

public A addToProperties(int index,
 Property item)

setToProperties

public A setToProperties(int index,
 Property item)

addToProperties

public A addToProperties(Property... items)

addAllToProperties

public A addAllToProperties(Collection<Property> items)

removeFromProperties

public A removeFromProperties(Property... items)

removeAllFromProperties

public A removeAllFromProperties(Collection<Property> items)

removeMatchingFromProperties

public A removeMatchingFromProperties(Predicate<PropertyBuilder> predicate)

buildProperties

public List<Property> buildProperties()

buildProperty

public Property buildProperty(int index)

buildFirstProperty

public Property buildFirstProperty()

buildLastProperty

public Property buildLastProperty()

buildMatchingProperty

public Property buildMatchingProperty(Predicate<PropertyBuilder> predicate)

hasMatchingProperty

public boolean hasMatchingProperty(Predicate<PropertyBuilder> predicate)

withProperties

public A withProperties(List<Property> properties)

withProperties

public A withProperties(Property... properties)

hasProperties

public boolean hasProperties()

addNewProperty

public TypeDefFluent<A>.PropertiesNested<A> addNewProperty()

addNewPropertyLike

public TypeDefFluent<A>.PropertiesNested<A> addNewPropertyLike(Property item)

setNewPropertyLike

public TypeDefFluent<A>.PropertiesNested<A> setNewPropertyLike(int index,
 Property item)

editProperty

public TypeDefFluent<A>.PropertiesNested<A> editProperty(int index)

editFirstProperty

public TypeDefFluent<A>.PropertiesNested<A> editFirstProperty()

editLastProperty

public TypeDefFluent<A>.PropertiesNested<A> editLastProperty()

editMatchingProperty

public TypeDefFluent<A>.PropertiesNested<A> editMatchingProperty(Predicate<PropertyBuilder> predicate)

addToConstructors

public A addToConstructors(int index,
 Method item)

setToConstructors

public A setToConstructors(int index,
 Method item)

addToConstructors

public A addToConstructors(Method... items)

addAllToConstructors

public A addAllToConstructors(Collection<Method> items)

removeFromConstructors

public A removeFromConstructors(Method... items)

removeAllFromConstructors

public A removeAllFromConstructors(Collection<Method> items)

removeMatchingFromConstructors

public A removeMatchingFromConstructors(Predicate<MethodBuilder> predicate)

buildConstructors

public List<Method> buildConstructors()

buildConstructor

public Method buildConstructor(int index)

buildFirstConstructor

public Method buildFirstConstructor()

buildLastConstructor

public Method buildLastConstructor()

buildMatchingConstructor

public Method buildMatchingConstructor(Predicate<MethodBuilder> predicate)

hasMatchingConstructor

public boolean hasMatchingConstructor(Predicate<MethodBuilder> predicate)

withConstructors

public A withConstructors(List<Method> constructors)

withConstructors

public A withConstructors(Method... constructors)

hasConstructors

public boolean hasConstructors()

addNewConstructor

public TypeDefFluent<A>.ConstructorsNested<A> addNewConstructor()

addNewConstructorLike

public TypeDefFluent<A>.ConstructorsNested<A> addNewConstructorLike(Method item)

setNewConstructorLike

public TypeDefFluent<A>.ConstructorsNested<A> setNewConstructorLike(int index,
 Method item)

editConstructor

public TypeDefFluent<A>.ConstructorsNested<A> editConstructor(int index)

editFirstConstructor

public TypeDefFluent<A>.ConstructorsNested<A> editFirstConstructor()

editLastConstructor

public TypeDefFluent<A>.ConstructorsNested<A> editLastConstructor()

editMatchingConstructor

public TypeDefFluent<A>.ConstructorsNested<A> editMatchingConstructor(Predicate<MethodBuilder> predicate)

addToMethods

public A addToMethods(int index,
 Method item)

setToMethods

public A setToMethods(int index,
 Method item)

addToMethods

public A addToMethods(Method... items)

addAllToMethods

public A addAllToMethods(Collection<Method> items)

removeFromMethods

public A removeFromMethods(Method... items)

removeAllFromMethods

public A removeAllFromMethods(Collection<Method> items)

removeMatchingFromMethods

public A removeMatchingFromMethods(Predicate<MethodBuilder> predicate)

buildMethods

public List<Method> buildMethods()

buildMethod

public Method buildMethod(int index)

buildFirstMethod

public Method buildFirstMethod()

buildLastMethod

public Method buildLastMethod()

buildMatchingMethod

public Method buildMatchingMethod(Predicate<MethodBuilder> predicate)

hasMatchingMethod

public boolean hasMatchingMethod(Predicate<MethodBuilder> predicate)

withMethods

public A withMethods(List<Method> methods)

withMethods

public A withMethods(Method... methods)

hasMethods

public boolean hasMethods()

addNewMethod

public TypeDefFluent<A>.MethodsNested<A> addNewMethod()

addNewMethodLike

public TypeDefFluent<A>.MethodsNested<A> addNewMethodLike(Method item)

setNewMethodLike

public TypeDefFluent<A>.MethodsNested<A> setNewMethodLike(int index,
 Method item)

editMethod

public TypeDefFluent<A>.MethodsNested<A> editMethod(int index)

editFirstMethod

public TypeDefFluent<A>.MethodsNested<A> editFirstMethod()

editLastMethod

public TypeDefFluent<A>.MethodsNested<A> editLastMethod()

editMatchingMethod

public TypeDefFluent<A>.MethodsNested<A> editMatchingMethod(Predicate<MethodBuilder> predicate)

getOuterTypeName

public String getOuterTypeName()

withOuterTypeName

public A withOuterTypeName(String outerTypeName)

hasOuterTypeName

public boolean hasOuterTypeName()

addToInnerTypes

public A addToInnerTypes(int index,
 TypeDef item)

setToInnerTypes

public A setToInnerTypes(int index,
 TypeDef item)

addToInnerTypes

public A addToInnerTypes(TypeDef... items)

addAllToInnerTypes

public A addAllToInnerTypes(Collection<TypeDef> items)

removeFromInnerTypes

public A removeFromInnerTypes(TypeDef... items)

removeAllFromInnerTypes

public A removeAllFromInnerTypes(Collection<TypeDef> items)

removeMatchingFromInnerTypes

public A removeMatchingFromInnerTypes(Predicate<TypeDefBuilder> predicate)

buildInnerTypes

public List<TypeDef> buildInnerTypes()

buildInnerType

public TypeDef buildInnerType(int index)

buildFirstInnerType

public TypeDef buildFirstInnerType()

buildLastInnerType

public TypeDef buildLastInnerType()

buildMatchingInnerType

public TypeDef buildMatchingInnerType(Predicate<TypeDefBuilder> predicate)

hasMatchingInnerType

public boolean hasMatchingInnerType(Predicate<TypeDefBuilder> predicate)

withInnerTypes

public A withInnerTypes(List<TypeDef> innerTypes)

withInnerTypes

public A withInnerTypes(TypeDef... innerTypes)

hasInnerTypes

public boolean hasInnerTypes()

addNewInnerType

public A addNewInnerType(String fullyQualifiedName)

addNewInnerType

public TypeDefFluent<A>.InnerTypesNested<A> addNewInnerType()

addNewInnerTypeLike

public TypeDefFluent<A>.InnerTypesNested<A> addNewInnerTypeLike(TypeDef item)

setNewInnerTypeLike

public TypeDefFluent<A>.InnerTypesNested<A> setNewInnerTypeLike(int index,
 TypeDef item)

editInnerType

public TypeDefFluent<A>.InnerTypesNested<A> editInnerType(int index)

editFirstInnerType

public TypeDefFluent<A>.InnerTypesNested<A> editFirstInnerType()

editLastInnerType

public TypeDefFluent<A>.InnerTypesNested<A> editLastInnerType()

editMatchingInnerType

public TypeDefFluent<A>.InnerTypesNested<A> editMatchingInnerType(Predicate<TypeDefBuilder> predicate)

equals

public boolean equals(Object o)

Overrides:

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

hashCode

public int hashCode()

Overrides:

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

toString

public String toString()

Overrides:

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