AnnotationList (common 4.0.0-beta.17 API)

All Superinterfaces:

java.lang.Iterable<java.lang.annotation.Annotation>
```
public interface AnnotationList
extends java.lang.Iterable<java.lang.annotation.Annotation>
```
Represents an immutable collection of annotations. This interface provides utility methods for dealing with annotations, while respecting DistributeOnMethods and AnnotationReplacers.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`boolean`	`any(@NotNull java.util.function.Predicate<java.lang.annotation.Annotation> predicate)` Tests whether any of the annotations in this list match the given predicate
`<T extends java.lang.annotation.Annotation> boolean`	`contains(@NotNull java.lang.Class<T> type)` Tests whether this list contains the given annotation or not
`static @NotNull AnnotationList`	`create(@NotNull java.lang.reflect.AnnotatedElement element)` Creates a new `AnnotationList` for the given `AnnotatedElement`.
`static @NotNull AnnotationList`	`create(@NotNull java.util.Collection<java.lang.annotation.Annotation> annotations)` Creates a new `AnnotationList` for the given collection of annotations.
`static @NotNull AnnotationList`	`create(@NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.lang.annotation.Annotation> annotations)` Creates a new `AnnotationList` for the given map of annotations.
`static @NotNull AnnotationList`	`empty()` Returns an empty `AnnotationList`.
`<T extends java.lang.annotation.Annotation> T`	`get(@NotNull java.lang.Class<T> type)` Returns the given annotation, or `null` if it's not annotated with the given annotation (or distributed on, indirectly)
`boolean`	`isEmpty()` Tests whether this list is empty or not
`@NotNull @Unmodifiable java.util.Iterator<java.lang.annotation.Annotation>`	`iterator()` Returns an unmodifiable `Iterator` for this annotation list
`<R,T extends java.lang.annotation.Annotation> R`	`map(@NotNull java.lang.Class<T> type, java.util.function.Function<T,R> function)` Performs a map function on the annotation if it is present, otherwise returns `null` if the annotation is not present.
`<R,T extends java.lang.annotation.Annotation> R`	`mapOr(@NotNull java.lang.Class<T> type, java.util.function.Function<T,R> function, R defaultValue)` Performs a map function on the annotation if it is present, otherwise returns `defaultValue` if the annotation is not present.
`<R,T extends java.lang.annotation.Annotation> R`	`mapOrGet(@NotNull java.lang.Class<T> type, @NotNull java.util.function.Function<T,R> function, @NotNull java.util.function.Supplier<R> defaultValue)` Performs a map function on the annotation if it is present, otherwise supplies the value in `defaultValue` if the annotation is not present.
`@NotNull AnnotationList`	`replaceAnnotations(@NotNull java.lang.reflect.AnnotatedElement element, @NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Set<AnnotationReplacer<?>>> replacers)` Replaces the annotations in this type with any suitable `AnnotationReplacer`s in the supplied `replacers` map, and returns a (possibly new) `AnnotationList` with the replaced annotations.
`<T extends java.lang.annotation.Annotation> T`	`require(@NotNull java.lang.Class<T> type, @NotNull java.lang.String errorMessage)` Gets the given annotation, otherwise throws an `IllegalStateException` if it is not present.
`@NotNull java.util.Map<java.lang.Class<?>,java.lang.annotation.Annotation>`	`toMutableMap()` Returns a mutable map that contains the annotations contained in this annotation list
`default @NotNull AnnotationList`	`withAnnotations(java.lang.annotation.Annotation... annotations)` Creates a new `AnnotationList` that contains these annotations as well as the given `annotations`.
`@NotNull AnnotationList`	`withAnnotations(boolean overrideExisting, java.lang.annotation.Annotation... annotations)` Creates a new `AnnotationList` that contains these annotations as well as the given `annotations`.

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Method Detail

create
```
@NotNull
static @NotNull AnnotationList create(@NotNull
                                               @NotNull java.lang.reflect.AnnotatedElement element)
```
Creates a new AnnotationList for the given AnnotatedElement. This method will take into account DistributeOnMethods annotations

Parameters:

element - The annotated element to create from

Returns:

The newly created annotation list

create
```
@NotNull
static @NotNull AnnotationList create(@NotNull
                                               @NotNull java.util.Collection<java.lang.annotation.Annotation> annotations)
```
Creates a new AnnotationList for the given collection of annotations. This method will not take into account DistributeOnMethods annotations

Parameters:

annotations - The annotations in this list

Returns:

The newly created annotation list

create

@NotNull
static @NotNull AnnotationList create(@NotNull
                                               @NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.lang.annotation.Annotation> annotations)

Creates a new AnnotationList for the given map of annotations. This method will not take into account DistributeOnMethods annotations

Parameters:: annotations - The annotations in this list
Returns:: The newly created annotation list

empty
```
@Contract(pure=true)
 @NotNull
static @NotNull AnnotationList empty()
```
Returns an empty AnnotationList.

Returns:

The empty AnnotationList singleton.

get
```
@Contract(pure=true)
 @Nullable
<T extends java.lang.annotation.Annotation> T get(@NotNull
                                                                                  @NotNull java.lang.Class<T> type)
```
Returns the given annotation, or null if it's not annotated with the given annotation (or distributed on, indirectly)

Type Parameters:

T - The annotation type automatically cast

Parameters:

type - The annotation type

Returns:

The annotation instance, or null if not present

map

@Contract(pure=true)
 @Nullable
<R,T extends java.lang.annotation.Annotation> R map(@NotNull
                                                                                    @NotNull java.lang.Class<T> type,
                                                                                    java.util.function.Function<T,R> function)

Performs a map function on the annotation if it is present, otherwise returns null if the annotation is not present.

Type Parameters:: R - The type we are mapping to; T - The annotation type
Parameters:: type - The annotation type; function - The mapping function.
Returns:: The mapped value, or null if the annotation is not present.

mapOr

@Contract(pure=true)
<R,T extends java.lang.annotation.Annotation> R mapOr(@NotNull
                                                                           @NotNull java.lang.Class<T> type,
                                                                           java.util.function.Function<T,R> function,
                                                                           R defaultValue)

Performs a map function on the annotation if it is present, otherwise returns defaultValue if the annotation is not present.

Type Parameters:: R - The type we are mapping to; T - The annotation type
Parameters:: type - The annotation type; function - The mapping function.
Returns:: The mapped value, or defaultValue if the annotation is not present.

mapOrGet

@Contract(pure=true)
<R,T extends java.lang.annotation.Annotation> R mapOrGet(@NotNull
                                                                              @NotNull java.lang.Class<T> type,
                                                                              @NotNull
                                                                              @NotNull java.util.function.Function<T,R> function,
                                                                              @NotNull
                                                                              @NotNull java.util.function.Supplier<R> defaultValue)

Performs a map function on the annotation if it is present, otherwise supplies the value in defaultValue if the annotation is not present.

Type Parameters:: R - The type we are mapping to; T - The annotation type
Parameters:: type - The annotation type; function - The mapping function.
Returns:: The mapped value, or defaultValue if the annotation is not present.

require

@Contract(pure=true)
 @NotNull
<T extends java.lang.annotation.Annotation> T require(@NotNull
                                                                                     @NotNull java.lang.Class<T> type,
                                                                                     @NotNull
                                                                                     @NotNull java.lang.String errorMessage)

Gets the given annotation, otherwise throws an IllegalStateException if it is not present.

Type Parameters:: T - The annotation type
Parameters:: type - Annotation type to check for; errorMessage - The error message to include in the error
Returns:: The annotation

contains
```
@Contract(pure=true)
<T extends java.lang.annotation.Annotation> boolean contains(@NotNull
                                                                                  @NotNull java.lang.Class<T> type)
```
Tests whether this list contains the given annotation or not

Type Parameters:

T - The annotation type

Parameters:

type - The annotation type to check for

Returns:

true if the annotation is present, false if otherwise.

isEmpty
```
boolean isEmpty()
```
Tests whether this list is empty or not

Returns:

if this annotation list is empty

toMutableMap

@NotNull
 @Contract(value="-> new",
          pure=true)
@NotNull java.util.Map<java.lang.Class<?>,java.lang.annotation.Annotation> toMutableMap()

Returns a mutable map that contains the annotations contained in this annotation list

Returns:: The newly created map

replaceAnnotations
```
@NotNull
 @Contract(pure=true)
@NotNull AnnotationList replaceAnnotations(@NotNull
                                                                          @NotNull java.lang.reflect.AnnotatedElement element,
                                                                          @NotNull
                                                                          @NotNull java.util.Map<java.lang.Class<? extends java.lang.annotation.Annotation>,java.util.Set<AnnotationReplacer<?>>> replacers)
```
Replaces the annotations in this type with any suitable AnnotationReplacers in the supplied replacers map, and returns a (possibly new) AnnotationList with the replaced annotations.
Note that this does not modify this AnnotationList.
This also will not deeply replace annotations. If a replacer produces a replaceable annotation, this annotation will not be replaced.
In cases of empty(), this will return the same annotation list.

Parameters:

element - The annotated element. This provides additional context and allows DistributeOnMethods annotations

replacers - The annotation replacers to use

Returns:

A (possibly new) AnnotationList with the newly replaced annotations.

iterator
```
@NotNull
 @Contract(pure=true)
@NotNull @Unmodifiable java.util.Iterator<java.lang.annotation.Annotation> iterator()
```
Returns an unmodifiable Iterator for this annotation list

Specified by:

iterator in interface java.lang.Iterable<java.lang.annotation.Annotation>

Returns:

The iterator

withAnnotations

@NotNull
 @Contract(pure=true,
          value="_, _ -> new")
@NotNull AnnotationList withAnnotations(boolean overrideExisting,
                                                                                                      @NotNull
                                                                                                      java.lang.annotation.Annotation... annotations)

Creates a new AnnotationList that contains these annotations as well as the given annotations.

Parameters:: overrideExisting - Whether should existing annotations be overridden if a similar annotation is supplied; annotations - The annotations to include in the new copy
Returns:: The new annotation list.

withAnnotations

@NotNull
 @Contract(pure=true,
          value="_ -> new")
default @NotNull AnnotationList withAnnotations(@NotNull
                                                                                                           java.lang.annotation.Annotation... annotations)

Creates a new AnnotationList that contains these annotations as well as the given annotations.

Parameters:: annotations - The annotations to include in the new copy
Returns:: The new annotation list.

any
```
@Contract(pure=true)
boolean any(@NotNull
                                 @NotNull java.util.function.Predicate<java.lang.annotation.Annotation> predicate)
```
Tests whether any of the annotations in this list match the given predicate

Parameters:

predicate - Predicate to check with

Returns:

true if any annotation matches the predicate, false if otherwise.

Interface AnnotationList

Method Summary

Methods inherited from interface java.lang.Iterable

Method Detail

create

create

create

empty

get

map

mapOr

mapOrGet

require

contains

isEmpty

toMutableMap

replaceAnnotations

iterator

withAnnotations

withAnnotations

any