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.resources;
 
 import static org.jboss.weld.util.cache.LoadingCacheUtils.getCastCacheValue;
 import static org.jboss.weld.util.reflection.Reflections.cast;
 
 
 
 

Author(s):
Pete Muir
Stuart Douglas
JBoss Weld Community
Ales Justin
 
 public class ClassTransformer implements BootstrapService {
 
     public static ClassTransformer instance(BeanManagerImpl manager) {
         return manager.getServices().get(ClassTransformer.class);
     }
 
     private class TransformClassToWeldAnnotation extends CacheLoader<Class<? extends Annotation>, EnhancedAnnotation<?>> {
         @Override
         public EnhancedAnnotation<?> load(Class<? extends Annotationfrom) {
 
             SlimAnnotatedType<? extends AnnotationslimAnnotatedType = .get(from);
 
             if (slimAnnotatedType == null) {
                 /*
                  * TODO: we do not recognize the BDA that defined the annotation This could in theory cause problem is two
                  * annotations with the same name but different definition are defined within the same application (different
                  * BDAs)
                  */
                 slimAnnotatedType = getBackedAnnotatedType(from.);
             }
             return EnhancedAnnotationImpl.create(slimAnnotatedTypeClassTransformer.this);
         }
     }
 
         @Override
         public BackedAnnotatedType<?> load(TypeHolder<?> typeHolder) {
             BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), ,
                     typeHolder.getBdaId());
             return updateLookupTable(type);
         }
     }
 
     private class TransformSlimAnnotatedTypeToEnhancedAnnotatedType extends
             CacheLoader<SlimAnnotatedType<?>, EnhancedAnnotatedType<?>> {
         @Override
         public EnhancedAnnotatedType<?> load(SlimAnnotatedType<?> annotatedType) {
             return EnhancedAnnotatedTypeImpl.of(annotatedTypeClassTransformer.this);
         }
     }
 
     private static final class TypeHolder<T> {
 
         private final String bdaId;
        private final Class<T> rawType;
        private final Type baseType;
        private TypeHolder(Class<T> rawTypeType baseTypeString bdaId) {
            this. = rawType;
            this. = baseType;
            this. = bdaId;
        }
        public Type getBaseType() {
            return ;
        }
        public Class<T> getRawType() {
            return ;
        }
        public String getBdaId() {
            return ;
        }
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof TypeHolder<?>) {
                TypeHolder<?> that = (TypeHolder<?>) obj;
                return Objects.equal(this.getBaseType(), that.getBaseType()) && Objects.equal(this.getBdaId(), that.getBdaId());
            }
            return false;
        }
        @Override
        public int hashCode() {
            return Objects.hashCode(this.getBaseType(), this.getBdaId());
        }
        @Override
        public String toString() {
            return getBaseType() + " from " + getBdaId();
        }
    }
    // The synthetic annotations map (annotation type -> annotated type)
    private final LoadingCache<Class<? extends Annotation>, EnhancedAnnotation<?>> annotations;
    private final TypeStore typeStore;
    private final SharedObjectCache cache;
    private final ReflectionCache reflectionCache;
    private final String contextId;
    public ClassTransformer(TypeStore typeStoreSharedObjectCache cacheReflectionCache reflectionCacheString contextId) {
        this. = contextId;
        CacheBuilder<ObjectObjectdefaultBuilder = CacheBuilder.newBuilder();
        // if an AnnotatedType reference is not retained by a Bean we are not going to need it at runtime and can therefore drop
        // it immediately
        this. = defaultBuilder.build(new TransformClassToWeldAnnotation());
        this. = typeStore;
        this. = cache;
        this. = reflectionCache;
    }
    // Slim AnnotatedTypes
    public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawTypefinal Type baseTypefinal String bdaId) {
        try {
            return getCastCacheValue(new TypeHolder<T>(rawTypebaseTypebdaId));
        } catch (RuntimeException e) {
            if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) {
                ..exceptionWhileLoadingClass(rawType.getName(), e);
                throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e);
            }
            throw e;
        } catch (ExecutionError e) {
            // LoadingCache throws ExecutionError if an error was thrown while loading the value
            final Throwable cause = e.getCause();
            if(cause instanceof NoClassDefFoundError || cause instanceof LinkageError) {
                throw new ResourceLoadingException("Error while loading class " + rawType.getName(), cause);
            }
            ..errorWhileLoadingClass(rawType.getName(), cause);
            throw e;
        }
    }
    public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawTypefinal String bdaId) {
        return getBackedAnnotatedType(rawTyperawTypebdaId);
    }
        return cast(.get(id));
    }
    public <T> UnbackedAnnotatedType<T> getUnbackedAnnotatedType(AnnotatedType<T> sourceString bdaIdString suffix) {
        UnbackedAnnotatedType<T> type = UnbackedAnnotatedType.additionalAnnotatedType(sourcebdaIdsuffix);
        return updateLookupTable(type);
    }
    public <T> UnbackedAnnotatedType<T> getUnbackedAnnotatedType(SlimAnnotatedType<T> originalTypeAnnotatedType<T> source) {
        UnbackedAnnotatedType<T> type = UnbackedAnnotatedType.modifiedAnnotatedType(originalTypesource);
        return updateLookupTable(type);
    }
            Class<? extends AnnotationannotationType) {
        return .get(annotationType);
    }
    private <T, S extends SlimAnnotatedType<T>> S updateLookupTable(S annotatedType) {
        SlimAnnotatedType<?> previousValue = .putIfAbsent(annotatedType.getIdentifier(), annotatedType);
        if (previousValue == null) {
            return annotatedType;
        } else {
            return cast(previousValue);
        }
    }
    // Enhanced AnnotatedTypes
    public <T> EnhancedAnnotatedType<T> getEnhancedAnnotatedType(Class<T> rawTypeString bdaId) {
        return getEnhancedAnnotatedType(getBackedAnnotatedType(rawTypebdaId));
    }
    public <T> EnhancedAnnotatedType<T> getEnhancedAnnotatedType(Class<T> rawTypeType baseTypeString bdaId) {
        return getEnhancedAnnotatedType(getBackedAnnotatedType(rawTypebaseTypebdaId));
    }
    public <T> EnhancedAnnotatedType<T> getEnhancedAnnotatedType(AnnotatedType<T> annotatedTypeString bdaId) {
        if (annotatedType instanceof EnhancedAnnotatedType<?>) {
            return cast(annotatedType);
        }
        if (annotatedType instanceof SlimAnnotatedType<?>) {
            return cast(getEnhancedAnnotatedType((SlimAnnotatedType<?>) annotatedType));
        }
        return getEnhancedAnnotatedType(getUnbackedAnnotatedType(annotatedTypebdaId,
                AnnotatedTypes.createTypeId(annotatedType)));
    }
    public <T> EnhancedAnnotatedType<T> getEnhancedAnnotatedType(SlimAnnotatedType<T> annotatedType) {
        return getCastCacheValue(annotatedType);
    }
    public <T extends AnnotationEnhancedAnnotation<T> getEnhancedAnnotation(final Class<T> clazz) {
        return getCastCacheValue(clazz);
    }
    public void clearAnnotationData(Class<? extends AnnotationannotationClass) {
        .invalidate(annotationClass);
    }
    public TypeStore getTypeStore() {
        return ;
    }
        return ;
    }
        return ;
    }

    

Parameters:
annotation
    public void addSyntheticAnnotation(AnnotatedType<? extends AnnotationannotationString bdaId) {
                getUnbackedAnnotatedType(annotationbdaId.));
        clearAnnotationData(annotation.getJavaClass());
    }
    @Override
    public void cleanupAfterBoot() {
        this..invalidateAll();
        for (BackedAnnotatedType<?> annotatedType : .asMap().values()) {
            annotatedType.clear();
        }
        this..invalidateAll();
    }
    @Override
    public void cleanup() {
        cleanupAfterBoot();
        .clear();
    }
New to GrepCode? Check out our FAQ X