Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jboss.weld.annotated.slim.backed;
  
  import static org.jboss.weld.util.collections.WeldCollections.immutableSet;
  import static org.jboss.weld.util.reflection.Reflections.cast;
  
 import java.util.Set;
 
 
 
 
 import  edu.umd.cs.findbugs.annotations.SuppressWarnings;
 @SuppressWarnings(value = { "SE_BAD_FIELD""SE_NO_SUITABLE_CONSTRUCTOR""SE_BAD_FIELD_STORE""SE_NO_SERIALVERSIONID" }, justification = "False positive from FindBugs - serialization is handled by SerializationProxy.")
 public class BackedAnnotatedType<X> extends BackedAnnotated implements SlimAnnotatedType<X>, Serializable {
 
     public static <X> BackedAnnotatedType<X> of(Class<X> javaClassSharedObjectCache sharedObjectCacheReflectionCache reflectionCacheString contextIdString bdaId) {
         return of(javaClassjavaClasssharedObjectCachereflectionCachecontextIdbdaId);
     }
 
     public static <X> BackedAnnotatedType<X> of(Class<X> javaClassType baseTypeSharedObjectCache sharedObjectCacheReflectionCache reflectionCacheString contextIdString bdaId) {
         return new BackedAnnotatedType<X>(javaClassbaseTypesharedObjectCachereflectionCachecontextIdbdaId);
     }
 
     private final Class<X> javaClass;
     private final LazyValueHolder<Set<AnnotatedConstructor<X>>> constructors;
     private final LazyValueHolder<Set<AnnotatedMethod<? super X>>> methods;
     private final LazyValueHolder<Set<AnnotatedField<? super X>>> fields;
     private final SharedObjectCache sharedObjectCache;
     private final ReflectionCache reflectionCache;
     private final AnnotatedTypeIdentifier identifier;
 
     private BackedAnnotatedType(Class<X> rawTypeType baseTypeSharedObjectCache sharedObjectCacheReflectionCache reflectionCacheString contextIdString bdaId) {
         super(baseTypesharedObjectCache);
         this. = rawType;
         this. = sharedObjectCache;
         this. = reflectionCache;
 
         this. = new BackedAnnotatedConstructors();
         this. = new BackedAnnotatedFields();
         this. = new BackedAnnotatedMethods();
         this. = AnnotatedTypeIdentifier.forBackedAnnotatedType(contextIdrawTypebaseTypebdaId);
     }
 
     @Override
     protected LazyValueHolder<Set<Type>> initTypeClosure(Type baseTypeSharedObjectCache cache) {
         return cache.getTypeClosureHolder(Types.getCanonicalType(baseType));
     }
 
     @Override
     protected AnnotatedElement getAnnotatedElement() {
         return ;
     }
 
     public Class<X> getJavaClass() {
         return ;
     }
 
     public Set<AnnotatedConstructor<X>> getConstructors() {
         return .get();
     }
 
     public Set<AnnotatedMethod<? super X>> getMethods() {
         return .get();
     }
 
     public Set<AnnotatedField<? super X>> getFields() {
         return .get();
     }
 
     public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
         for (Annotation annotation : getAnnotations()) {
             if (annotation.annotationType().equals(annotationType)) {
                return annotationType.cast(annotation);
            }
        }
        return null;
    }
    public boolean isAnnotationPresent(Class<? extends AnnotationannotationType) {
        return getAnnotation(annotationType) != null;
    }
    @Override
    public Set<AnnotationgetAnnotations() {
    }
    @Override
    public int hashCode() {
        return .hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof BackedAnnotatedType<?>) {
            BackedAnnotatedType<?> that = cast(obj);
            return Objects.equal(this.that.identifier);
        }
        return false;
    }
    @Override
    public String toString() {
        return Formats.formatAnnotatedType(this);
    }
    @Override
    public void clear() {
        this..clear();
        this..clear();
        this..clear();
    }
    // Serialization
    private Object writeReplace() throws ObjectStreamException {
        return new SerializationProxy<X>(getIdentifier());
    }
    private void readObject(ObjectInputStream streamthrows InvalidObjectException {
        throw ..proxyRequired();
    }
    // Lazy initialization
    // Initialize eagerly since we want to discover CNFE at bootstrap
    // After bootstrap, these holders are reset to conserve memory
    private abstract class EagerlyInitializedLazyValueHolder<T> extends LazyValueHolder<T> {
        public EagerlyInitializedLazyValueHolder() {
            this.get();
        }
    }
        @Override
        protected Set<AnnotatedConstructor<X>> computeValue() {
            Constructor<?>[] declaredConstructors = AccessController.doPrivileged(new GetDeclaredConstructorsAction());
            ArraySet<AnnotatedConstructor<X>> constructors = new ArraySet<AnnotatedConstructor<X>>(declaredConstructors.length);
            for (Constructor<?> constructor : declaredConstructors) {
                Constructor<X> c = Reflections.cast(constructor);
                constructors.add(BackedAnnotatedConstructor.of(cBackedAnnotatedType.this));
            }
            return immutableSet(constructors);
        }
    }
    private class BackedAnnotatedFields extends EagerlyInitializedLazyValueHolder<Set<AnnotatedField<? super X>>> {
        @Override
        protected Set<AnnotatedField<? super X>> computeValue() {
            ArraySet<AnnotatedField<? super X>> fields = new ArraySet<AnnotatedField<? super X>>();
            Class<? super X> clazz = ;
            while (clazz != Object.class && clazz != null) {
                for (Field field : AccessController.doPrivileged(new GetDeclaredFieldsAction(clazz))) {
                    fields.add(BackedAnnotatedField.of(fieldBackedAnnotatedType.this));
                }
                clazz = clazz.getSuperclass();
            }
            return immutableSet(fields);
        }
    }
    private class BackedAnnotatedMethods extends EagerlyInitializedLazyValueHolder<Set<AnnotatedMethod<? super X>>> {
        @Override
        protected Set<AnnotatedMethod<? super X>> computeValue() {
            ArraySet<AnnotatedMethod<? super X>> methods = new ArraySet<AnnotatedMethod<? super X>>();
            Class<? super X> clazz = ;
            while (clazz != Object.class && clazz != null) {
                for (Method method : AccessController.doPrivileged(new GetDeclaredMethodsAction(clazz))) {
                    methods.add(BackedAnnotatedMethod.of(methodBackedAnnotatedType.this));
                }
                clazz = clazz.getSuperclass();
            }
            return immutableSet(methods);
        }
    }
        return ;
    }
    @Override
        return ;
    }
New to GrepCode? Check out our FAQ X