io.sundr.model

Interface ClassRefFluent<A extends ClassRefFluent<A>>

All Superinterfaces:

AttributeSupportFluent<A>, Fluent<A>, TypeRefFluent<A>

All Known Subinterfaces:

AnnotationRefFluent.ClassRefNested<N>, ClassRefFluent.ClassRefArgumentsNested<N>, MethodFluent.ClassRefReturnTypeNested<N>, MethodFluent.ExceptionsNested<N>, PropertyFluent.ClassRefTypeNested<N>, TypeDefFluent.ExtendsListNested<N>, TypeDefFluent.ImplementsListNested<N>, TypeParamDefFluent.BoundsNested<N>, WildcardRefFluent.ClassRefBoundsNested<N>

All Known Implementing Classes:

ClassRefBuilder, ClassRefFluentImpl

public interface ClassRefFluent<A extends ClassRefFluent<A>>
extends TypeRefFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	ClassRefFluent.ClassRefArgumentsNested<N>
static interface	ClassRefFluent.PrimitiveRefArgumentsNested<N>
static interface	ClassRefFluent.TypeParamRefArgumentsNested<N>
static interface	ClassRefFluent.VoidRefArgumentsNested<N>
static interface	ClassRefFluent.WildcardRefArgumentsNested<N>

Method Summary

Modifier and Type	Method and Description
A	addAllToArguments(Collection<TypeRef> items)
A	addAllToClassRefArguments(Collection<ClassRef> items)
A	addAllToPrimitiveRefArguments(Collection<PrimitiveRef> items)
A	addAllToTypeParamRefArguments(Collection<TypeParamRef> items)
A	addAllToVoidRefArguments(Collection<VoidRef> items)
A	addAllToWildcardRefArguments(Collection<WildcardRef> items)
ClassRefFluent.ClassRefArgumentsNested<A>	addNewClassRefArgument()
ClassRefFluent.ClassRefArgumentsNested<A>	addNewClassRefArgumentLike(ClassRef item)
ClassRefFluent.PrimitiveRefArgumentsNested<A>	addNewPrimitiveRefArgument()
ClassRefFluent.PrimitiveRefArgumentsNested<A>	addNewPrimitiveRefArgumentLike(PrimitiveRef item)
ClassRefFluent.TypeParamRefArgumentsNested<A>	addNewTypeParamRefArgument()
ClassRefFluent.TypeParamRefArgumentsNested<A>	addNewTypeParamRefArgumentLike(TypeParamRef item)
ClassRefFluent.VoidRefArgumentsNested<A>	addNewVoidRefArgument()
ClassRefFluent.VoidRefArgumentsNested<A>	addNewVoidRefArgumentLike(VoidRef item)
ClassRefFluent.WildcardRefArgumentsNested<A>	addNewWildcardRefArgument()
ClassRefFluent.WildcardRefArgumentsNested<A>	addNewWildcardRefArgumentLike(WildcardRef item)
A	addToArguments(Integer index, TypeRef item)
A	addToArguments(Integer index, VisitableBuilder<? extends TypeRef,?> builder)
A	addToArguments(TypeRef... items)
A	addToArguments(VisitableBuilder<? extends TypeRef,?> builder)
A	addToClassRefArguments(ClassRef... items)
A	addToClassRefArguments(Integer index, ClassRef item)
A	addToPrimitiveRefArguments(Integer index, PrimitiveRef item)
A	addToPrimitiveRefArguments(PrimitiveRef... items)
A	addToTypeParamRefArguments(Integer index, TypeParamRef item)
A	addToTypeParamRefArguments(TypeParamRef... items)
A	addToVoidRefArguments(Integer index, VoidRef item)
A	addToVoidRefArguments(VoidRef... items)
A	addToWildcardRefArguments(Integer index, WildcardRef item)
A	addToWildcardRefArguments(WildcardRef... items)
TypeRef	buildArgument(Integer index)
List<TypeRef>	buildArguments()
TypeRef	buildFirstArgument()
TypeRef	buildLastArgument()
TypeRef	buildMatchingArgument(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
List<TypeRef>	getArguments() Deprecated.
int	getDimensions()
String	getFullyQualifiedName()
Boolean	hasArguments()
Boolean	hasDimensions()
Boolean	hasFullyQualifiedName()
Boolean	hasMatchingArgument(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
A	removeAllFromArguments(Collection<TypeRef> items)
A	removeAllFromClassRefArguments(Collection<ClassRef> items)
A	removeAllFromPrimitiveRefArguments(Collection<PrimitiveRef> items)
A	removeAllFromTypeParamRefArguments(Collection<TypeParamRef> items)
A	removeAllFromVoidRefArguments(Collection<VoidRef> items)
A	removeAllFromWildcardRefArguments(Collection<WildcardRef> items)
A	removeFromArguments(TypeRef... items)
A	removeFromArguments(VisitableBuilder<? extends TypeRef,?> builder)
A	removeFromClassRefArguments(ClassRef... items)
A	removeFromPrimitiveRefArguments(PrimitiveRef... items)
A	removeFromTypeParamRefArguments(TypeParamRef... items)
A	removeFromVoidRefArguments(VoidRef... items)
A	removeFromWildcardRefArguments(WildcardRef... items)
A	removeMatchingFromClassRefArguments(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
A	removeMatchingFromPrimitiveRefArguments(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
A	removeMatchingFromTypeParamRefArguments(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
A	removeMatchingFromVoidRefArguments(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
A	removeMatchingFromWildcardRefArguments(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)
ClassRefFluent.ClassRefArgumentsNested<A>	setNewClassRefArgumentLike(Integer index, ClassRef item)
ClassRefFluent.PrimitiveRefArgumentsNested<A>	setNewPrimitiveRefArgumentLike(Integer index, PrimitiveRef item)
ClassRefFluent.TypeParamRefArgumentsNested<A>	setNewTypeParamRefArgumentLike(Integer index, TypeParamRef item)
ClassRefFluent.VoidRefArgumentsNested<A>	setNewVoidRefArgumentLike(Integer index, VoidRef item)
ClassRefFluent.WildcardRefArgumentsNested<A>	setNewWildcardRefArgumentLike(Integer index, WildcardRef item)
A	setToArguments(Integer index, TypeRef item)
A	setToClassRefArguments(Integer index, ClassRef item)
A	setToPrimitiveRefArguments(Integer index, PrimitiveRef item)
A	setToTypeParamRefArguments(Integer index, TypeParamRef item)
A	setToVoidRefArguments(Integer index, VoidRef item)
A	setToWildcardRefArguments(Integer index, WildcardRef item)
A	withArguments(List<TypeRef> arguments)
A	withArguments(TypeRef... arguments)
A	withDimensions(int dimensions)
A	withFullyQualifiedName(String fullyQualifiedName)

Methods inherited from interface io.sundr.model.AttributeSupportFluent

addToAttributes, addToAttributes, getAttributes, hasAttributes, removeFromAttributes, removeFromAttributes, withAttributes

Method Detail

getFullyQualifiedName

String getFullyQualifiedName()

withFullyQualifiedName

A withFullyQualifiedName(String fullyQualifiedName)

hasFullyQualifiedName

Boolean hasFullyQualifiedName()

getDimensions

int getDimensions()

withDimensions

A withDimensions(int dimensions)

hasDimensions

Boolean hasDimensions()

addToArguments

A addToArguments(VisitableBuilder<? extends TypeRef,?> builder)

addToArguments

A addToArguments(Integer index,
                 VisitableBuilder<? extends TypeRef,?> builder)

addToArguments

A addToArguments(Integer index,
                 TypeRef item)

setToArguments

A setToArguments(Integer index,
                 TypeRef item)

addToArguments

A addToArguments(TypeRef... items)

addAllToArguments

A addAllToArguments(Collection<TypeRef> items)

removeFromArguments

A removeFromArguments(VisitableBuilder<? extends TypeRef,?> builder)

removeFromArguments

A removeFromArguments(TypeRef... items)

removeAllFromArguments

A removeAllFromArguments(Collection<TypeRef> items)

getArguments

@Deprecated
List<TypeRef> getArguments()

Deprecated.

This method has been deprecated, please use method buildArguments instead.

Returns:

The buildable object.

buildArguments

List<TypeRef> buildArguments()

buildArgument

TypeRef buildArgument(Integer index)

buildFirstArgument

TypeRef buildFirstArgument()

buildLastArgument

TypeRef buildLastArgument()

buildMatchingArgument

TypeRef buildMatchingArgument(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

hasMatchingArgument

Boolean hasMatchingArgument(Predicate<VisitableBuilder<? extends TypeRef,?>> predicate)

withArguments

A withArguments(List<TypeRef> arguments)

withArguments

A withArguments(TypeRef... arguments)

hasArguments

Boolean hasArguments()

addToTypeParamRefArguments

A addToTypeParamRefArguments(Integer index,
                             TypeParamRef item)

setToTypeParamRefArguments

A setToTypeParamRefArguments(Integer index,
                             TypeParamRef item)

addToTypeParamRefArguments

A addToTypeParamRefArguments(TypeParamRef... items)

addAllToTypeParamRefArguments

A addAllToTypeParamRefArguments(Collection<TypeParamRef> items)

removeFromTypeParamRefArguments

A removeFromTypeParamRefArguments(TypeParamRef... items)

removeAllFromTypeParamRefArguments

A removeAllFromTypeParamRefArguments(Collection<TypeParamRef> items)

removeMatchingFromTypeParamRefArguments

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

setNewTypeParamRefArgumentLike

ClassRefFluent.TypeParamRefArgumentsNested<A> setNewTypeParamRefArgumentLike(Integer index,
                                                                             TypeParamRef item)

addNewTypeParamRefArgument

ClassRefFluent.TypeParamRefArgumentsNested<A> addNewTypeParamRefArgument()

addNewTypeParamRefArgumentLike

ClassRefFluent.TypeParamRefArgumentsNested<A> addNewTypeParamRefArgumentLike(TypeParamRef item)

addToWildcardRefArguments

A addToWildcardRefArguments(Integer index,
                            WildcardRef item)

setToWildcardRefArguments

A setToWildcardRefArguments(Integer index,
                            WildcardRef item)

addToWildcardRefArguments

A addToWildcardRefArguments(WildcardRef... items)

addAllToWildcardRefArguments

A addAllToWildcardRefArguments(Collection<WildcardRef> items)

removeFromWildcardRefArguments

A removeFromWildcardRefArguments(WildcardRef... items)

removeAllFromWildcardRefArguments

A removeAllFromWildcardRefArguments(Collection<WildcardRef> items)

removeMatchingFromWildcardRefArguments

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

setNewWildcardRefArgumentLike

ClassRefFluent.WildcardRefArgumentsNested<A> setNewWildcardRefArgumentLike(Integer index,
                                                                           WildcardRef item)

addNewWildcardRefArgument

ClassRefFluent.WildcardRefArgumentsNested<A> addNewWildcardRefArgument()

addNewWildcardRefArgumentLike

ClassRefFluent.WildcardRefArgumentsNested<A> addNewWildcardRefArgumentLike(WildcardRef item)

addToClassRefArguments

A addToClassRefArguments(Integer index,
                         ClassRef item)

setToClassRefArguments

A setToClassRefArguments(Integer index,
                         ClassRef item)

addToClassRefArguments

A addToClassRefArguments(ClassRef... items)

addAllToClassRefArguments

A addAllToClassRefArguments(Collection<ClassRef> items)

removeFromClassRefArguments

A removeFromClassRefArguments(ClassRef... items)

removeAllFromClassRefArguments

A removeAllFromClassRefArguments(Collection<ClassRef> items)

removeMatchingFromClassRefArguments

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

setNewClassRefArgumentLike

ClassRefFluent.ClassRefArgumentsNested<A> setNewClassRefArgumentLike(Integer index,
                                                                     ClassRef item)

addNewClassRefArgument

ClassRefFluent.ClassRefArgumentsNested<A> addNewClassRefArgument()

addNewClassRefArgumentLike

ClassRefFluent.ClassRefArgumentsNested<A> addNewClassRefArgumentLike(ClassRef item)

addToPrimitiveRefArguments

A addToPrimitiveRefArguments(Integer index,
                             PrimitiveRef item)

setToPrimitiveRefArguments

A setToPrimitiveRefArguments(Integer index,
                             PrimitiveRef item)

addToPrimitiveRefArguments

A addToPrimitiveRefArguments(PrimitiveRef... items)

addAllToPrimitiveRefArguments

A addAllToPrimitiveRefArguments(Collection<PrimitiveRef> items)

removeFromPrimitiveRefArguments

A removeFromPrimitiveRefArguments(PrimitiveRef... items)

removeAllFromPrimitiveRefArguments

A removeAllFromPrimitiveRefArguments(Collection<PrimitiveRef> items)

removeMatchingFromPrimitiveRefArguments

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

setNewPrimitiveRefArgumentLike

ClassRefFluent.PrimitiveRefArgumentsNested<A> setNewPrimitiveRefArgumentLike(Integer index,
                                                                             PrimitiveRef item)

addNewPrimitiveRefArgument

ClassRefFluent.PrimitiveRefArgumentsNested<A> addNewPrimitiveRefArgument()

addNewPrimitiveRefArgumentLike

ClassRefFluent.PrimitiveRefArgumentsNested<A> addNewPrimitiveRefArgumentLike(PrimitiveRef item)

addToVoidRefArguments

A addToVoidRefArguments(Integer index,
                        VoidRef item)

setToVoidRefArguments

A setToVoidRefArguments(Integer index,
                        VoidRef item)

addToVoidRefArguments

A addToVoidRefArguments(VoidRef... items)

addAllToVoidRefArguments

A addAllToVoidRefArguments(Collection<VoidRef> items)

removeFromVoidRefArguments

A removeFromVoidRefArguments(VoidRef... items)

removeAllFromVoidRefArguments

A removeAllFromVoidRefArguments(Collection<VoidRef> items)

removeMatchingFromVoidRefArguments

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

setNewVoidRefArgumentLike

ClassRefFluent.VoidRefArgumentsNested<A> setNewVoidRefArgumentLike(Integer index,
                                                                   VoidRef item)

addNewVoidRefArgument

ClassRefFluent.VoidRefArgumentsNested<A> addNewVoidRefArgument()

addNewVoidRefArgumentLike

ClassRefFluent.VoidRefArgumentsNested<A> addNewVoidRefArgumentLike(VoidRef item)