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.resources;
 
 import static org.jboss.weld.util.cache.LoadingCacheUtils.getCacheValue;
 
 import java.util.Set;
 
 
 
 
 public class DefaultReflectionCache extends AbstractBootstrapService implements ReflectionCache {
 
     private final TypeStore store;
 
     protected Annotation[] internalGetAnnotations(AnnotatedElement element) {
         return element.getAnnotations();
     }
 
     protected Annotation[] internalGetDeclaredAnnotations(AnnotatedElement element) {
         return element.getDeclaredAnnotations();
     }
 
     private static class Annotations {
         private final Annotation[] annotations;
         private final Set<AnnotationannotationSet;
 
         public Annotations(Annotation[] annotations) {
             if (annotations.length == 0) {
                 this. = .;
                 this. = Collections.emptySet();
             } else {
                 this. = annotations;
                 this. = ImmutableSet.copyOf(annotations);
             }
         }
     }
 
     private final LoadingCache<MethodAnnotation[][]> methodParameterAnnotations;
     private final LoadingCache<Class<? extends Annotation>, BooleanisScopeAnnotation;
 
     public DefaultReflectionCache(TypeStore store) {
         this. = store;
         CacheBuilder<ObjectObjectcacheBuilder = CacheBuilder.newBuilder();
         this. = cacheBuilder.build(new CacheLoader<AnnotatedElementAnnotations>() {
             @Override
             public Annotations load(AnnotatedElement input) {
                 return new Annotations(internalGetAnnotations(input));
             }
         });
         this. = cacheBuilder.build(new CacheLoader<AnnotatedElementAnnotations>() {
             @Override
             public Annotations load(AnnotatedElement input) {
                 return new Annotations(internalGetDeclaredAnnotations(input));
             }
         });
         this. = cacheBuilder.build(new CacheLoader<Constructor<?>, Annotation[][]>() {
             @Override
             public Annotation[][] load(Constructor<?> input) {
                 return input.getParameterAnnotations();
             }
         });
         this. = cacheBuilder.build(new CacheLoader<MethodAnnotation[][]>() {
            @Override
            public Annotation[][] load(Method input) {
                return input.getParameterAnnotations();
            }
        });
        this. = cacheBuilder.build(new CacheLoader<BackedAnnotatedParameter<?>, Set<Annotation>>() {
            @Override
            public Set<Annotationload(BackedAnnotatedParameter<?> parameterthrows Exception {
                final Member member = parameter.getDeclaringCallable().getJavaMember();
                if (member instanceof Method) {
                    return ImmutableSet.copyOfgetParameterAnnotations((Methodmemberparameter.getPosition()));
                } else {
                    return ImmutableSet.copyOfgetParameterAnnotations((Constructor<?>) memberparameter.getPosition()));
                }
            }
        });
        this. = cacheBuilder.build(new IsScopeAnnotationFunction());
    }
    @Override
    public Annotation[] getAnnotations(AnnotatedElement element) {
        return getCacheValue(element).;
    }
    @Override
    public Annotation[] getDeclaredAnnotations(AnnotatedElement element) {
        return getCacheValue(element).;
    }
    @Override
    public Annotation[] getParameterAnnotations(Constructor<?> constructorint parameterPosition) {
        return getCacheValue(constructor)[parameterPosition];
    }
    @Override
    public Annotation[] getParameterAnnotations(Method methodint parameterPosition) {
        return getCacheValue(method)[parameterPosition];
    }
    @Override
    public void cleanupAfterBoot() {
        .invalidateAll();
    }
    @Override
    public Set<AnnotationgetAnnotationSet(AnnotatedElement element) {
        return getCacheValue(element).;
    }
    @Override
        return getCacheValue(element).;
    }
    @Override
        return getCacheValue(parameter);
    }
    @Override
    public Set<AnnotationgetBackedAnnotatedTypeAnnotationSet(Class<?> javaClass) {
        return getCacheValue(javaClass);
    }
    private class BackedAnnotatedTypeAnnotationsFunction extends CacheLoader<Class<?>, Set<Annotation>> {
        @Override
        public Set<Annotationload(Class<?> javaClass) {
            Set<Annotationannotations = getAnnotationSet(javaClass);
            boolean scopeFound = false;
            for (Annotation annotation : annotations) {
                boolean isScope = getCacheValue(annotation.annotationType());
                if (isScope && scopeFound) {
                    // there are at least two scopes, we need to choose one using scope inheritance rules (4.1)
                    return applyScopeInheritanceRules(annotationsjavaClass);
                }
                if (isScope) {
                    scopeFound = true;
                }
            }
            return annotations;
        }
        public Set<AnnotationapplyScopeInheritanceRules(Set<AnnotationannotationsClass<?> javaClass) {
            Set<Annotationresult = new HashSet<Annotation>();
            for (Annotation annotation : annotations) {
                if (!getCacheValue(annotation.annotationType())) {
                    result.add(annotation);
                }
            }
            result.addAll(findTopLevelScopeDefinitions(javaClass));
            return ImmutableSet.copyOf(result);
        }
        public Set<AnnotationfindTopLevelScopeDefinitions(Class<?> javaClass) {
            for (Class<?> clazz = javaClassclazz != null && clazz != Object.classclazz = clazz.getSuperclass()) {
                Set<Annotationscopes = new HashSet<Annotation>();
                for (Annotation annotation : getDeclaredAnnotations(clazz)) {
                    if (getCacheValue(annotation.annotationType())) {
                        scopes.add(annotation);
                    }
                }
                if (scopes.size() > 0) {
                    return scopes;
                }
            }
            throw new IllegalStateException();
        }
    }
    private class IsScopeAnnotationFunction extends CacheLoader<Class<? extends Annotation>, Boolean> {
        @Override
        public Boolean load(Class<? extends Annotationinput) {
            if (input.isAnnotationPresent(NormalScope.class)) {
                return true;
            }
            if (input.isAnnotationPresent(Scope.class)) {
                return true;
            }
            return .isExtraScope(input);
        }
    }
New to GrepCode? Check out our FAQ X