java.net.bytebuddy.description.annotation.AnnotationList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of securemock Show documentation
Show all versions of securemock Show documentation
Libraries for Elasticsearch
The newest version!
/*
* Copyright 2014 - 2018 Rafael Winterhalter
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.bytebuddy.description.annotation;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.description.type.TypeList;
import net.bytebuddy.matcher.ElementMatcher;
import net.bytebuddy.matcher.FilterableList;
import java.lang.annotation.Annotation;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
/**
* Defines a list of annotation instances.
*/
public interface AnnotationList extends FilterableList {
/**
* Checks if this list contains an annotation of the given type.
*
* @param annotationType The type to find in the list.
* @return {@code true} if the list contains the annotation type.
*/
boolean isAnnotationPresent(Class annotationType);
/**
* Checks if this list contains an annotation of the given type.
*
* @param annotationType The type to find in the list.
* @return {@code true} if the list contains the annotation type.
*/
boolean isAnnotationPresent(TypeDescription annotationType);
/**
* Finds the first annotation of the given type and returns it.
*
* @param annotationType The type to be found in the list.
* @param The annotation type.
* @return The annotation description or {@code null} if no such annotation was found.
*/
AnnotationDescription.Loadable ofType(Class annotationType);
/**
* Finds the first annotation of the given type and returns it.
*
* @param annotationType The type to be found in the list.
* @return The annotation description or {@code null} if no such annotation was found.
*/
AnnotationDescription ofType(TypeDescription annotationType);
/**
* Returns only annotations that are marked as {@link java.lang.annotation.Inherited} as long as they are not
* contained by the set of ignored annotation types.
*
* @param ignoredTypes A list of annotation types to be ignored from the lookup.
* @return A list of all inherited annotations besides of the given ignored types.
*/
AnnotationList inherited(Set ignoredTypes);
/**
* Only retains annotations with the given retention policy.
*
* @param matcher A matcher for the required retention policy.
* @return A of annotations only with elements
*/
AnnotationList visibility(ElementMatcher matcher);
/**
* Returns a list of the annotation types of this list.
*
* @return A list of the annotation types of this list.
*/
TypeList asTypeList();
/**
* An abstract base implementation of an annotation list.
*/
abstract class AbstractBase extends FilterableList.AbstractBase implements AnnotationList {
/**
* {@inheritDoc}
*/
public boolean isAnnotationPresent(Class annotationType) {
for (AnnotationDescription annotation : this) {
if (annotation.getAnnotationType().represents(annotationType)) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public boolean isAnnotationPresent(TypeDescription annotationType) {
for (AnnotationDescription annotation : this) {
if (annotation.getAnnotationType().equals(annotationType)) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public AnnotationDescription.Loadable ofType(Class annotationType) {
for (AnnotationDescription annotation : this) {
if (annotation.getAnnotationType().represents(annotationType)) {
return annotation.prepare(annotationType);
}
}
return (AnnotationDescription.Loadable) AnnotationDescription.UNDEFINED;
}
/**
* {@inheritDoc}
*/
public AnnotationDescription ofType(TypeDescription annotationType) {
for (AnnotationDescription annotation : this) {
if (annotation.getAnnotationType().equals(annotationType)) {
return annotation;
}
}
return AnnotationDescription.UNDEFINED;
}
/**
* {@inheritDoc}
*/
public AnnotationList inherited(Set ignoredTypes) {
List inherited = new ArrayList(size());
for (AnnotationDescription annotation : this) {
if (!ignoredTypes.contains(annotation.getAnnotationType()) && annotation.isInherited()) {
inherited.add(annotation);
}
}
return wrap(inherited);
}
/**
* {@inheritDoc}
*/
public AnnotationList visibility(ElementMatcher matcher) {
List annotationDescriptions = new ArrayList(size());
for (AnnotationDescription annotation : this) {
if (matcher.matches(annotation.getRetention())) {
annotationDescriptions.add(annotation);
}
}
return wrap(annotationDescriptions);
}
/**
* {@inheritDoc}
*/
public TypeList asTypeList() {
List annotationTypes = new ArrayList(size());
for (AnnotationDescription annotation : this) {
annotationTypes.add(annotation.getAnnotationType());
}
return new TypeList.Explicit(annotationTypes);
}
@Override
protected AnnotationList wrap(List values) {
return new Explicit(values);
}
}
/**
* Describes an array of loaded {@link java.lang.annotation.Annotation}s as an annotation list.
*/
class ForLoadedAnnotations extends AbstractBase {
/**
* The represented annotations.
*/
private final List annotations;
/**
* Creates a new list of loaded annotations.
*
* @param annotation The represented annotations.
*/
public ForLoadedAnnotations(Annotation... annotation) {
this(Arrays.asList(annotation));
}
/**
* Creates a new list of loaded annotations.
*
* @param annotations The represented annotations.
*/
public ForLoadedAnnotations(List annotations) {
this.annotations = annotations;
}
/**
* Creates a list of annotation lists representing the given loaded annotations.
*
* @param annotations The annotations to represent where each dimension is converted into a list.
* @return A list of annotation lists representing the given annotations.
*/
public static List asList(Annotation[][] annotations) {
List result = new ArrayList(annotations.length);
for (Annotation[] annotation : annotations) {
result.add(new ForLoadedAnnotations(annotation));
}
return result;
}
/**
* {@inheritDoc}
*/
public AnnotationDescription get(int index) {
return AnnotationDescription.ForLoadedAnnotation.of(annotations.get(index));
}
/**
* {@inheritDoc}
*/
public int size() {
return annotations.size();
}
}
/**
* Represents a list of explicitly provided annotation descriptions.
*/
class Explicit extends AbstractBase {
/**
* The list of represented annotation descriptions.
*/
private final List annotationDescriptions;
/**
* Creates a new list of annotation descriptions.
*
* @param annotationDescription The list of represented annotation descriptions.
*/
public Explicit(AnnotationDescription... annotationDescription) {
this(Arrays.asList(annotationDescription));
}
/**
* Creates a new list of annotation descriptions.
*
* @param annotationDescriptions The list of represented annotation descriptions.
*/
public Explicit(List annotationDescriptions) {
this.annotationDescriptions = annotationDescriptions;
}
/**
* Creates a list of annotation lists for a given multidimensional list of annotation descriptions.
*
* @param annotations The list of annotations to represent as a list of annotation lists.
* @return The list of annotation lists.
*/
public static List asList(List> annotations) {
List result = new ArrayList(annotations.size());
for (List annotation : annotations) {
result.add(new Explicit(annotation));
}
return result;
}
/**
* {@inheritDoc}
*/
public AnnotationDescription get(int index) {
return annotationDescriptions.get(index);
}
/**
* {@inheritDoc}
*/
public int size() {
return annotationDescriptions.size();
}
}
/**
* Represents an empty annotation list.
*/
class Empty extends FilterableList.Empty implements AnnotationList {
/**
* Creates a list of empty annotation lists of the given dimension.
*
* @param length The length of the list.
* @return A list of empty annotation lists of the given length.
*/
public static List asList(int length) {
List result = new ArrayList(length);
for (int i = 0; i < length; i++) {
result.add(new AnnotationList.Empty());
}
return result;
}
/**
* {@inheritDoc}
*/
public boolean isAnnotationPresent(Class annotationType) {
return false;
}
/**
* {@inheritDoc}
*/
public boolean isAnnotationPresent(TypeDescription annotationType) {
return false;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
public AnnotationDescription.Loadable ofType(Class annotationType) {
return (AnnotationDescription.Loadable) AnnotationDescription.UNDEFINED;
}
/**
* {@inheritDoc}
*/
public AnnotationDescription ofType(TypeDescription annotationType) {
return AnnotationDescription.UNDEFINED;
}
/**
* {@inheritDoc}
*/
public AnnotationList inherited(Set ignoredTypes) {
return this;
}
/**
* {@inheritDoc}
*/
public AnnotationList visibility(ElementMatcher matcher) {
return this;
}
/**
* {@inheritDoc}
*/
public TypeList asTypeList() {
return new TypeList.Empty();
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy