private static ClassTransformer getClassTransformer() { TypeStore store = new TypeStore(); SharedObjectCache cache = new SharedObjectCache(); ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store); ClassTransformer classTransformer = new ClassTransformer(store, cache, reflectionCache, "STATIC_INSTANCE"); return classTransformer; }
@Override public void addStereotype(Class<? extends Annotation> stereotype, Annotation... stereotypeDef) { checkWithinObserverNotification(); TypeStore typeStore = getTypeStore(); typeStore.add(stereotype, StereotypeLiteral.INSTANCE); for (Annotation a : stereotypeDef) { typeStore.add(stereotype, a); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(stereotype); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(stereotype); BootstrapLogger.LOG.addStereoTypeCalled(getReceiver(), stereotype); }
@Override public void addScope(Class<? extends Annotation> scopeType, boolean normal, boolean passivating) { checkWithinObserverNotification(); if (normal) { getTypeStore().add(scopeType, new NormalScopeLiteral(passivating)); } else if (passivating) { throw BootstrapLogger.LOG.passivatingNonNormalScopeIllegal(scopeType); } else { getTypeStore().add(scopeType, ScopeLiteral.INSTANCE); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(ReflectionCache.class).cleanup(); BootstrapLogger.LOG.addScopeCalled(getReceiver(), scopeType); }
private void setupInitialServices() { if (initialServices.contains(TypeStore.class)) { return; } // instantiate initial services which we need for this phase TypeStore store = new TypeStore(); SharedObjectCache cache = new SharedObjectCache(); ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store); ClassTransformer classTransformer = new ClassTransformer(store, cache, reflectionCache, contextId); initialServices.add(TypeStore.class, store); initialServices.add(SharedObjectCache.class, cache); initialServices.add(ReflectionCache.class, reflectionCache); initialServices.add(ClassTransformer.class, classTransformer); }
protected void processMetaAnnotations(SetMultimap<Class<? extends Annotation>, Annotation> metaAnnotationMap, Annotation annotation, ClassTransformer classTransformer, boolean declared) { // WELD-1310 Include synthetic annotations SlimAnnotatedType<?> syntheticAnnotationAnnotatedType = classTransformer.getSyntheticAnnotationAnnotatedType(annotation.annotationType()); if (syntheticAnnotationAnnotatedType != null) { addMetaAnnotations(metaAnnotationMap, annotation, syntheticAnnotationAnnotatedType.getAnnotations(), declared); } else { addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getReflectionCache().getAnnotations(annotation.annotationType()), declared); ReflectionCache.AnnotationClass<?> annotationClass = classTransformer.getReflectionCache().getAnnotationClass(annotation.annotationType()); if (annotationClass.isRepeatableAnnotationContainer()) { processMetaAnnotations(metaAnnotationMap, annotationClass.getRepeatableAnnotations(annotation), classTransformer, declared); } } addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getTypeStore().get(annotation.annotationType()), declared); }
public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) { Class<A> annotationType = annotatedType.getJavaClass(); Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>(); annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations())); annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType))); // Annotations and declared annotations are the same for annotation type return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer); }
@Override public Boolean apply(Class<? extends Annotation> input) { if (input.isAnnotationPresent(NormalScope.class)) { return true; } if (input.isAnnotationPresent(Scope.class)) { return true; } return store.isExtraScope(input); } }
@Override public void addStereotype(Class<? extends Annotation> stereotype, Annotation... stereotypeDef) { checkWithinObserverNotification(); TypeStore typeStore = getTypeStore(); typeStore.add(stereotype, StereotypeLiteral.INSTANCE); for (Annotation a : stereotypeDef) { typeStore.add(stereotype, a); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(stereotype); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(stereotype); BootstrapLogger.LOG.addStereoTypeCalled(getReceiver(), stereotype); }
@Override public void addScope(Class<? extends Annotation> scopeType, boolean normal, boolean passivating) { checkWithinObserverNotification(); if (normal) { getTypeStore().add(scopeType, new NormalScopeLiteral(passivating)); } else if (passivating) { throw BootstrapLogger.LOG.passivatingNonNormalScopeIllegal(scopeType); } else { getTypeStore().add(scopeType, ScopeLiteral.INSTANCE); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(ReflectionCache.class).cleanup(); BootstrapLogger.LOG.addScopeCalled(getReceiver(), scopeType); }
private void setupInitialServices() { if (initialServices.contains(TypeStore.class)) { return; } // instantiate initial services which we need for this phase TypeStore store = new TypeStore(); SharedObjectCache cache = new SharedObjectCache(); ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store); ClassTransformer classTransformer = new ClassTransformer(store, cache, reflectionCache, contextId); initialServices.add(TypeStore.class, store); initialServices.add(SharedObjectCache.class, cache); initialServices.add(ReflectionCache.class, reflectionCache); initialServices.add(ClassTransformer.class, classTransformer); }
protected void processMetaAnnotations(SetMultimap<Class<? extends Annotation>, Annotation> metaAnnotationMap, Annotation annotation, ClassTransformer classTransformer, boolean declared) { // WELD-1310 Include synthetic annotations SlimAnnotatedType<?> syntheticAnnotationAnnotatedType = classTransformer.getSyntheticAnnotationAnnotatedType(annotation.annotationType()); if (syntheticAnnotationAnnotatedType != null) { addMetaAnnotations(metaAnnotationMap, annotation, syntheticAnnotationAnnotatedType.getAnnotations(), declared); } else { addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getReflectionCache().getAnnotations(annotation.annotationType()), declared); ReflectionCache.AnnotationClass<?> annotationClass = classTransformer.getReflectionCache().getAnnotationClass(annotation.annotationType()); if (annotationClass.isRepeatableAnnotationContainer()) { processMetaAnnotations(metaAnnotationMap, annotationClass.getRepeatableAnnotations(annotation), classTransformer, declared); } } addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getTypeStore().get(annotation.annotationType()), declared); }
public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) { Class<A> annotationType = annotatedType.getJavaClass(); Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>(); annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations())); annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType))); // Annotations and declared annotations are the same for annotation type return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer); }
@Override public AnnotationClass<?> apply(Class<? extends Annotation> input) { boolean scope = input.isAnnotationPresent(NormalScope.class) || input.isAnnotationPresent(Scope.class) || store.isExtraScope(input); Method repeatableAnnotationAccessor = Annotations.getRepeatableAnnotationAccessor(input); Set<Annotation> metaAnnotations = ImmutableSet.of(internalGetAnnotations(input)); return new AnnotationClassImpl<>(scope, repeatableAnnotationAccessor, metaAnnotations); } }
@Override public void addStereotype(Class<? extends Annotation> stereotype, Annotation... stereotypeDef) { checkWithinObserverNotification(); TypeStore typeStore = getTypeStore(); typeStore.add(stereotype, StereotypeLiteral.INSTANCE); for (Annotation a : stereotypeDef) { typeStore.add(stereotype, a); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(stereotype); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(stereotype); BootstrapLogger.LOG.addStereoTypeCalled(getReceiver(), stereotype); }
@Override public void addScope(Class<? extends Annotation> scopeType, boolean normal, boolean passivating) { checkWithinObserverNotification(); if (normal) { getTypeStore().add(scopeType, new NormalScopeLiteral(passivating)); } else if (passivating) { throw BootstrapLogger.LOG.passivatingNonNormalScopeIllegal(scopeType); } else { getTypeStore().add(scopeType, ScopeLiteral.INSTANCE); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(scopeType); getBeanManager().getServices().get(ReflectionCache.class).cleanup(); BootstrapLogger.LOG.addScopeCalled(getReceiver(), scopeType); }
private void setupInitialServices() { if (initialServices.contains(TypeStore.class)) { return; } // instantiate initial services which we need for this phase TypeStore store = new TypeStore(); SharedObjectCache cache = new SharedObjectCache(); ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store); ClassTransformer classTransformer = new ClassTransformer(store, cache, reflectionCache, contextId); initialServices.add(TypeStore.class, store); initialServices.add(SharedObjectCache.class, cache); initialServices.add(ReflectionCache.class, reflectionCache); initialServices.add(ClassTransformer.class, classTransformer); }
protected void processMetaAnnotations(SetMultimap<Class<? extends Annotation>, Annotation> metaAnnotationMap, Annotation annotation, ClassTransformer classTransformer, boolean declared) { // WELD-1310 Include synthetic annotations SlimAnnotatedType<?> syntheticAnnotationAnnotatedType = classTransformer.getSyntheticAnnotationAnnotatedType(annotation.annotationType()); if (syntheticAnnotationAnnotatedType != null) { addMetaAnnotations(metaAnnotationMap, annotation, syntheticAnnotationAnnotatedType.getAnnotations(), declared); } else { addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getReflectionCache().getAnnotations(annotation.annotationType()), declared); ReflectionCache.AnnotationClass<?> annotationClass = classTransformer.getReflectionCache().getAnnotationClass(annotation.annotationType()); if (annotationClass.isRepeatableAnnotationContainer()) { processMetaAnnotations(metaAnnotationMap, annotationClass.getRepeatableAnnotations(annotation), classTransformer, declared); } } addMetaAnnotations(metaAnnotationMap, annotation, classTransformer.getTypeStore().get(annotation.annotationType()), declared); }
public static <A extends Annotation> EnhancedAnnotation<A> create(SlimAnnotatedType<A> annotatedType, ClassTransformer classTransformer) { Class<A> annotationType = annotatedType.getJavaClass(); Map<Class<? extends Annotation>, Annotation> annotationMap = new HashMap<Class<? extends Annotation>, Annotation>(); annotationMap.putAll(buildAnnotationMap(annotatedType.getAnnotations())); annotationMap.putAll(buildAnnotationMap(classTransformer.getTypeStore().get(annotationType))); // Annotations and declared annotations are the same for annotation type return new EnhancedAnnotationImpl<A>(annotatedType, annotationMap, annotationMap, classTransformer); }
@Override public AnnotationClass<?> apply(Class<? extends Annotation> input) { boolean scope = input.isAnnotationPresent(NormalScope.class) || input.isAnnotationPresent(Scope.class) || store.isExtraScope(input); Method repeatableAnnotationAccessor = Annotations.getRepeatableAnnotationAccessor(input); Set<Annotation> metaAnnotations = ImmutableSet.of(internalGetAnnotations(input)); return new AnnotationClassImpl<>(scope, repeatableAnnotationAccessor, metaAnnotations); } }
@Override public void addInterceptorBinding(Class<? extends Annotation> bindingType, Annotation... bindingTypeDef) { checkWithinObserverNotification(); TypeStore typeStore = getTypeStore(); typeStore.add(bindingType, InterceptorBindingTypeLiteral.INSTANCE); for (Annotation a : bindingTypeDef) { typeStore.add(bindingType, a); } getBeanManager().getServices().get(ClassTransformer.class).clearAnnotationData(bindingType); getBeanManager().getServices().get(MetaAnnotationStore.class).clearAnnotationData(bindingType); BootstrapLogger.LOG.addInterceptorBindingCalled(getReceiver(), bindingType); }