Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2008, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * 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 org.jboss.weld.annotated.enhanced.jlr;
 
 import static org.jboss.weld.util.collections.WeldCollections.immutableMap;
 import static org.jboss.weld.util.reflection.Reflections.EMPTY_ANNOTATIONS;
 
 import java.util.Map;
 import java.util.Set;
 
 
Represents functionality common for all annotated items, mainly different mappings of the annotations and meta-annotations

AbstractAnnotatedItem is an immutable class and therefore threadsafe

Parameters:
<T>
<S>
Author(s):
Pete Muir
Nicklas Karlsson
See also:
org.jboss.weld.annotated.enhanced.EnhancedAnnotated
 
 public abstract class AbstractEnhancedAnnotated<T, S> implements EnhancedAnnotated<T, S> {
 
     // The set of default binding types
     private static final Set<AnnotationDEFAULT_QUALIFIERS = Collections.<Annotation>singleton(.);

    
Builds the annotation map (annotation type -> annotation)

Parameters:
annotations The array of annotations to map
Returns:
The annotation map
 
     protected static Map<Class<? extends Annotation>, AnnotationbuildAnnotationMap(Annotation[] annotations) {
         Map<Class<? extends Annotation>, AnnotationannotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
         for (Annotation annotation : annotations) {
             annotationMap.put(annotation.annotationType(), annotation);
         }
         return annotationMap;
     }

    
Builds the annotation map (annotation type -> annotation)

Parameters:
annotations The array of annotations to map
Returns:
The annotation map
 
     protected static Map<Class<? extends Annotation>, AnnotationbuildAnnotationMap(Iterable<Annotationannotations) {
         Map<Class<? extends Annotation>, AnnotationannotationMap = new HashMap<Class<? extends Annotation>, Annotation>();
         for (Annotation annotation : annotations) {
             annotationMap.put(annotation.annotationType(), annotation);
         }
         return annotationMap;
     }
 
 
     protected static void addMetaAnnotations(ArraySetMultimap<Class<? extends Annotation>, AnnotationmetaAnnotationMapAnnotation annotationAnnotation[] metaAnnotationsboolean declared) {
         for (Annotation metaAnnotation : metaAnnotations) {
             addMetaAnnotation(metaAnnotationMapannotationmetaAnnotation.annotationType(), declared);
         }
     }
 
     protected static void addMetaAnnotations(ArraySetMultimap<Class<? extends Annotation>, AnnotationmetaAnnotationMapAnnotation annotationIterable<AnnotationmetaAnnotationsboolean declared) {
         for (Annotation metaAnnotation : metaAnnotations) {
             addMetaAnnotation(metaAnnotationMapannotationmetaAnnotation.annotationType(), declared);
        }
    }
    private static void addMetaAnnotation(ArraySetMultimap<Class<? extends Annotation>, AnnotationmetaAnnotationMapAnnotation annotationClass<? extends AnnotationmetaAnnotationTypeboolean declared) {
        // Only map meta-annotations we are interested in
        if (declared ? .contains(metaAnnotationType) : .contains(metaAnnotationType)) {
            metaAnnotationMap.putSingleElement(metaAnnotationTypeannotation);
        }
    }
    // The annotation map (annotation type -> annotation) of the item
    private final Map<Class<? extends Annotation>, AnnotationannotationMap;
    // The meta-annotation map (annotation type -> set of annotations containing
    // meta-annotation) of the item
    private final ArraySetMultimap<Class<? extends Annotation>, AnnotationmetaAnnotationMap;
    private final Class<T> rawType;
    private final Type[] actualTypeArguments;
    private final Annotated delegate;

    
Constructor

Also builds the meta-annotation map. Throws a NullPointerException if trying to register a null map

Parameters:
annotationMap A map of annotation to register
    public AbstractEnhancedAnnotated(Annotated annotatedMap<Class<? extends Annotation>, AnnotationannotationMapMap<Class<? extends Annotation>, AnnotationdeclaredAnnotationMapClassTransformer classTransformer) {
        this. = annotated;
        if (annotated instanceof AnnotatedType<?>) {
            this. = Reflections.<AnnotatedType<T>>cast(annotated).getJavaClass();
        } else {
            this. = Reflections.getRawType(annotated.getBaseType());
        }
        if (annotationMap == null) {
            throw ..annotationMapNull();
        }
        this. = immutableMap(annotationMap);
        ArraySetMultimap<Class<? extends Annotation>, AnnotationmetaAnnotationMap = new ArraySetMultimap<Class<? extends Annotation>, Annotation>();
        for (Annotation annotation : annotationMap.values()) {
            // WELD-1310 Include synthetic annotations
            SlimAnnotatedType<?> syntheticAnnotationAnnotatedType = classTransformer
                    .getSyntheticAnnotationAnnotatedType(annotation.annotationType());
            if (syntheticAnnotationAnnotatedType == null) {
                addMetaAnnotations(metaAnnotationMapannotation,
                        classTransformer.getReflectionCache().getAnnotations(annotation.annotationType()), false);
            } else {
                addMetaAnnotations(metaAnnotationMapannotationsyntheticAnnotationAnnotatedType.getAnnotations(), false);
            }
            addMetaAnnotations(metaAnnotationMapannotationclassTransformer.getTypeStore().get(annotation.annotationType()), false);
        }
        this. = metaAnnotationMap;
        if (declaredAnnotationMap == null) {
            throw ..declaredAnnotationMapNull();
        }
        if (.getBaseType() instanceof ParameterizedType) {
        } else {
            this. = .;
        }
    }
    public Class<T> getJavaClass() {
        return ;
    }
    public Type[] getActualTypeArguments() {
        return Arrays2.copyOf(.);
    }
    public Set<TypegetInterfaceClosure() {
        Set<Typeinterfaces = new HashSet<Type>();
        for (Type t : getTypeClosure()) {
            if (Reflections.getRawType(t).isInterface()) {
                interfaces.add(t);
            }
        }
        return Collections.unmodifiableSet(interfaces);
    }
    public abstract S getDelegate();
    public boolean isParameterizedType() {
        return .getTypeParameters().length > 0;
    }
    public boolean isPrimitive() {
        return getJavaClass().isPrimitive();
    }
    public Type getBaseType() {
        return .getBaseType();
    }
    public Set<TypegetTypeClosure() {
        return .getTypeClosure();
    }
    public Set<AnnotationgetAnnotations() {
        return Collections.unmodifiableSet(new ArraySet<Annotation>(.values()));
    }
    public Set<AnnotationgetMetaAnnotations(Class<? extends AnnotationmetaAnnotationType) {
        return Collections.unmodifiableSet(new ArraySet<Annotation>(.get(metaAnnotationType)));
    }
    @Deprecated
    public Set<AnnotationgetQualifiers() {
        if (getMetaAnnotations(Qualifier.class).size() > 0) {
            return Collections.unmodifiableSet(getMetaAnnotations(Qualifier.class));
        } else {
            return ;
        }
    }
    @Deprecated
    public Annotation[] getBindingsAsArray() {
        return getQualifiers().toArray();
    }
    public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
        return annotationType.cast(.get(annotationType));
    }
    public boolean isAnnotationPresent(Class<? extends AnnotationannotationType) {
        return .containsKey(annotationType);
    }
    Map<Class<? extends Annotation>, AnnotationgetAnnotationMap() {
        return ;
    }
New to GrepCode? Check out our FAQ X