Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2012, 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.bootstrap.events;
 
 import java.util.Set;
 
 
 
 
 public class ProcessAnnotatedTypeEventResolvable implements Resolvable {
 
         if (event instanceof ProcessSyntheticAnnotatedType) {
             return forProcessSyntheticAnnotatedType(event.getOriginalAnnotatedType(), discovery);
         } else {
             return forProcessAnnotatedType(event.getOriginalAnnotatedType(), discovery);
         }
     }
 
         ParameterizedType type = new ParameterizedTypeImpl(ProcessAnnotatedType.classnew Type[] { annotatedType.getJavaClass() }, null);
         return new ProcessAnnotatedTypeEventResolvable(Sets.<TypenewHashSet(Object.classtype), annotatedTypediscovery);
     }
 
         ParameterizedType type1 = new ParameterizedTypeImpl(ProcessAnnotatedType.classnew Type[] { annotatedType.getJavaClass() }, null);
         ParameterizedType type2 = new ParameterizedTypeImpl(ProcessSyntheticAnnotatedType.classnew Type[] { annotatedType.getJavaClass() }, null);
         return new ProcessAnnotatedTypeEventResolvable(Sets.<TypenewHashSet(Object.classtype1type2), annotatedTypediscovery);
     }
 
     private static final Set<QualifierInstanceQUALIFIERS = Collections.singleton(.);
     private final Set<Typetypes;
     private final SlimAnnotatedType<?> annotatedType;
     private final RequiredAnnotationDiscovery discovery;
 
     protected ProcessAnnotatedTypeEventResolvable(Set<TypetypesSlimAnnotatedType<?> annotatedTypeRequiredAnnotationDiscovery discovery) {
         this. = types;
         this. = annotatedType;
         this. = discovery;
     }
 
     @Override
     public Set<TypegetTypes() {
         return ;
     }
 
     @Override
     public Set<QualifierInstancegetQualifiers() {
         return ;
     }

    
Returns true if and only if the underlying javax.enterprise.inject.spi.AnnotatedType contains any of the given annotation types.
 
     public boolean containsRequiredAnnotations(Collection<Class<? extends Annotation>> requiredAnnotations) {
         if ( instanceof BackedAnnotatedType<?>) {
             return containsAnnotation((BackedAnnotatedType<?>) requiredAnnotations);
         } else if ( instanceof UnbackedAnnotatedType<?>) {
            return containsAnnotation((UnbackedAnnotatedType<?>) requiredAnnotations);
        } else {
            throw new IllegalArgumentException("Unknown SlimAnnotatedType implementation: " + .getClass().toString());
        }
    }
    protected boolean containsAnnotation(UnbackedAnnotatedType<?> annotatedTypeCollection<Class<? extends Annotation>> requiredAnnotations) {
        for (final Class<? extends AnnotationrequiredAnnotation : requiredAnnotations) {
            if (apply(annotatedTyperequiredAnnotation)) {
                return true;
            }
        }
        return false;
    }
    private static boolean isEqualOrAnnotated(Class<? extends AnnotationrequiredAnnotationAnnotation annotation) {
        return annotation.annotationType().equals(requiredAnnotation) || annotation.annotationType().isAnnotationPresent(requiredAnnotation);
    }

    

Returns:
true if predicate returns true for any annotation defined anywhere on the annotatedType
    protected boolean apply(UnbackedAnnotatedType<?> annotatedTypeClass<? extends AnnotationrequiredAnnotation) {
     // type annotations
        for (Annotation annotation : annotatedType.getAnnotations()) {
            if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                return true;
            }
            if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                return true;
            }
        }
        for (AnnotatedField<?> field : annotatedType.getFields()) {
            for (Annotation annotation : field.getAnnotations()) {
                if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                    return true;
                }
            }
        }
        for (AnnotatedConstructor<?> constructor : annotatedType.getConstructors()) {
            for (Annotation annotation : constructor.getAnnotations()) {
                if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                    return true;
                }
            }
            for (AnnotatedParameter<?> parameter : constructor.getParameters()) {
                for (Annotation annotation : parameter.getAnnotations()) {
                    if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                        return true;
                    }
                }
            }
        }
        for (AnnotatedMethod<?> method : annotatedType.getMethods()) {
            for (Annotation annotation : method.getAnnotations()) {
                if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                    return true;
                }
            }
            for (AnnotatedParameter<?> parameter : method.getParameters()) {
                for (Annotation annotation : parameter.getAnnotations()) {
                    if (isEqualOrAnnotated(requiredAnnotationannotation)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    protected boolean containsAnnotation(BackedAnnotatedType<?> annotatedTypeCollection<Class<? extends Annotation>> requiredAnnotations) {
        for (Class<? extends AnnotationrequiredAnnotation : requiredAnnotations) {
            if (.containsAnnotation(annotatedTyperequiredAnnotation)) {
                return true;
            }
        }
        return false;
    }
    @Override
    public boolean isAnnotationPresent(Class<? extends AnnotationannotationType) {
        return false;
    }
    @Override
    public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
        return null;
    }
    @Override
    public Class<?> getJavaClass() {
        return null;
    }
    @Override
    public Bean<?> getDeclaringBean() {
        return null;
    }
    @Override
    public boolean isDelegate() {
        return false;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (( == null) ? 0 : .hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof ProcessAnnotatedTypeEventResolvable)) {
            return false;
        }
        if ( == null) {
            if (other.types != null) {
                return false;
            }
        } else if (!.equals(other.types)) {
            return false;
        }
        return true;
    }
New to GrepCode? Check out our FAQ X