private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean containsRequiredAnnotation(ClassFileInfo classInfo, ContainerLifecycleEventObserverMethod<?> observer) { if (observer.getRequiredAnnotations().isEmpty()) { return true; } for (Class<? extends Annotation> annotation : observer.getRequiredAnnotations()) { if (classInfo.containsAnnotation(annotation)) { return true; } } return false; }
/** * Fires a {@link ProcessAnnotatedType}. Instead of using the default event dispatching mechanism, this method directly notifies * extension observers resolved by FastProcessAnnotatedTypeResolver. */ @SuppressWarnings({ "rawtypes", "unchecked" }) private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, Set<ContainerLifecycleEventObserverMethod<?>> observers, BeanManagerImpl beanManager) { List<Throwable> errors = new LinkedList<Throwable>(); for (ContainerLifecycleEventObserverMethod observer : observers) { // FastProcessAnnotatedTypeResolver does not consider special scope inheritance rules (see CDI - section 4.1) if (checkScopeInheritanceRules(event.getOriginalAnnotatedType(), observer, beanManager)) { try { observer.notify(event); } catch (Throwable e) { errors.add(e); } } } if (!errors.isEmpty()) { throw new DefinitionException(errors); } }
private boolean containsRequiredAnnotation(ClassFileInfo classInfo, ContainerLifecycleEventObserverMethod<?> observer) { if (observer.getRequiredAnnotations().isEmpty()) { return true; } for (Class<? extends Annotation> annotation : observer.getRequiredAnnotations()) { if (classInfo.containsAnnotation(annotation)) { return true; } } return false; }
/** * Fires a {@link ProcessAnnotatedType}. Instead of using the default event dispatching mechanism, this method directly notifies * extension observers resolved by FastProcessAnnotatedTypeResolver. */ @SuppressWarnings({ "rawtypes", "unchecked" }) private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, Set<ContainerLifecycleEventObserverMethod<?>> observers, BeanManagerImpl beanManager) { List<Throwable> errors = new LinkedList<Throwable>(); for (ContainerLifecycleEventObserverMethod observer : observers) { // FastProcessAnnotatedTypeResolver does not consider special scope inheritance rules (see CDI - section 4.1) if (checkScopeInheritanceRules(event.getOriginalAnnotatedType(), observer, beanManager)) { try { observer.notify(event); } catch (Throwable e) { errors.add(e); } } } if (!errors.isEmpty()) { throw new DefinitionException(errors); } }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean containsRequiredAnnotation(ClassFileInfo classInfo, ContainerLifecycleEventObserverMethod<?> observer) { if (observer.getRequiredAnnotations().isEmpty()) { return true; } for (Class<? extends Annotation> annotation : observer.getRequiredAnnotations()) { if (classInfo.containsAnnotation(annotation)) { return true; } } return false; }
/** * Fires a {@link ProcessAnnotatedType}. Instead of using the default event dispatching mechanism, this method directly notifies * extension observers resolved by FastProcessAnnotatedTypeResolver. */ @SuppressWarnings({ "rawtypes", "unchecked" }) private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, Set<ContainerLifecycleEventObserverMethod<?>> observers, BeanManagerImpl beanManager) { List<Throwable> errors = new LinkedList<Throwable>(); for (ContainerLifecycleEventObserverMethod observer : observers) { // FastProcessAnnotatedTypeResolver does not consider special scope inheritance rules (see CDI - section 4.1) if (checkScopeInheritanceRules(event.getOriginalAnnotatedType(), observer, beanManager)) { try { observer.notify(event); } catch (Throwable e) { errors.add(e); } } } if (!errors.isEmpty()) { throw new DefinitionException(errors); } }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean containsRequiredAnnotation(ClassFileInfo classInfo, ContainerLifecycleEventObserverMethod<?> observer) { if (observer.getRequiredAnnotations().isEmpty()) { return true; } for (Class<? extends Annotation> annotation : observer.getRequiredAnnotations()) { if (classInfo.containsAnnotation(annotation)) { return true; } } return false; }
/** * Fires a {@link ProcessAnnotatedType}. Instead of using the default event dispatching mechanism, this method directly notifies * extension observers resolved by FastProcessAnnotatedTypeResolver. */ @SuppressWarnings({ "rawtypes", "unchecked" }) private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, Set<ContainerLifecycleEventObserverMethod<?>> observers, BeanManagerImpl beanManager) { List<Throwable> errors = new LinkedList<Throwable>(); for (ContainerLifecycleEventObserverMethod observer : observers) { // FastProcessAnnotatedTypeResolver does not consider special scope inheritance rules (see CDI - section 4.1) if (checkScopeInheritanceRules(event.getOriginalAnnotatedType(), observer, beanManager)) { try { observer.notify(event); } catch (Throwable e) { errors.add(e); } } } if (!errors.isEmpty()) { throw new DefinitionException(errors); } }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean containsRequiredAnnotation(ClassFileInfo classInfo, ContainerLifecycleEventObserverMethod<?> observer) { if (observer.getRequiredAnnotations().isEmpty()) { return true; } for (Class<? extends Annotation> annotation : observer.getRequiredAnnotations()) { if (classInfo.containsAnnotation(annotation)) { return true; } } return false; }
/** * Fires a {@link ProcessAnnotatedType}. Instead of using the default event dispatching mechanism, this method directly notifies * extension observers resolved by FastProcessAnnotatedTypeResolver. */ @SuppressWarnings({ "rawtypes", "unchecked" }) private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, Set<ContainerLifecycleEventObserverMethod<?>> observers, BeanManagerImpl beanManager) { List<Throwable> errors = new LinkedList<Throwable>(); for (ContainerLifecycleEventObserverMethod observer : observers) { // FastProcessAnnotatedTypeResolver does not consider special scope inheritance rules (see CDI - section 4.1) if (checkScopeInheritanceRules(event.getOriginalAnnotatedType(), observer, beanManager)) { try { observer.notify(event); } catch (Throwable e) { errors.add(e); } } } if (!errors.isEmpty()) { throw new DefinitionException(errors); } }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean checkScopeInheritanceRules(SlimAnnotatedType<?> type, ContainerLifecycleEventObserverMethod<?> observer, BeanManagerImpl beanManager) { Collection<Class<? extends Annotation>> scopes; if (observer instanceof ExtensionObserverMethodImpl) { ExtensionObserverMethodImpl<?, ?> extensionObserver = (ExtensionObserverMethodImpl<?, ?>) observer; scopes = extensionObserver.getRequiredScopeAnnotations(); } else { scopes = observer.getRequiredAnnotations().stream().filter((a) -> beanManager.isScope(a)).collect(Collectors.toSet()); } if (!scopes.isEmpty() && scopes.size() == observer.getRequiredAnnotations().size()) { // this check only works if only scope annotations are listed within @WithAnnotations // performing a complete check would be way too expensive - eliminating the benefit of ClassFileServices for (Class<? extends Annotation> annotation : scopes) { if (type.isAnnotationPresent(annotation)) { return true; } } return false; } return true; }
private static boolean isUnrestrictedProcessAnnotatedTypeObserver(ObserverMethod<?> observerMethod) { if (observerMethod instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> containerLifecycleObserverMethod = (ContainerLifecycleEventObserverMethod<?>) observerMethod; Class<?> rawObserverType = Reflections.getRawType(containerLifecycleObserverMethod.getObservedType()); if ((rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class)) && containerLifecycleObserverMethod.getRequiredAnnotations().isEmpty()) { Type eventType = containerLifecycleObserverMethod.getObservedType(); Type[] typeArguments; if (eventType instanceof ParameterizedType) { typeArguments = ((ParameterizedType) eventType).getActualTypeArguments(); } else { typeArguments = Arrays2.EMPTY_TYPE_ARRAY; } if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) { return true; } } } return false; }
private boolean checkScopeInheritanceRules(SlimAnnotatedType<?> type, ContainerLifecycleEventObserverMethod<?> observer, BeanManagerImpl beanManager) { Collection<Class<? extends Annotation>> scopes; if (observer instanceof ExtensionObserverMethodImpl) { ExtensionObserverMethodImpl<?, ?> extensionObserver = (ExtensionObserverMethodImpl<?, ?>) observer; scopes = extensionObserver.getRequiredScopeAnnotations(); } else { scopes = observer.getRequiredAnnotations().stream().filter((a) -> beanManager.isScope(a)).collect(Collectors.toSet()); } if (!scopes.isEmpty() && scopes.size() == observer.getRequiredAnnotations().size()) { // this check only works if only scope annotations are listed within @WithAnnotations // performing a complete check would be way too expensive - eliminating the benefit of ClassFileServices for (Class<? extends Annotation> annotation : scopes) { if (type.isAnnotationPresent(annotation)) { return true; } } return false; } return true; }
private boolean checkScopeInheritanceRules(SlimAnnotatedType<?> type, ContainerLifecycleEventObserverMethod<?> observer, BeanManagerImpl beanManager) { Collection<Class<? extends Annotation>> scopes; if (observer instanceof ExtensionObserverMethodImpl) { ExtensionObserverMethodImpl<?, ?> extensionObserver = (ExtensionObserverMethodImpl<?, ?>) observer; scopes = extensionObserver.getRequiredScopeAnnotations(); } else { scopes = observer.getRequiredAnnotations().stream().filter((a) -> beanManager.isScope(a)).collect(Collectors.toSet()); } if (!scopes.isEmpty() && scopes.size() == observer.getRequiredAnnotations().size()) { // this check only works if only scope annotations are listed within @WithAnnotations // performing a complete check would be way too expensive - eliminating the benefit of ClassFileServices for (Class<? extends Annotation> annotation : scopes) { if (type.isAnnotationPresent(annotation)) { return true; } } return false; } return true; }
private boolean checkScopeInheritanceRules(SlimAnnotatedType<?> type, ContainerLifecycleEventObserverMethod<?> observer, BeanManagerImpl beanManager) { Collection<Class<? extends Annotation>> scopes; if (observer instanceof ExtensionObserverMethodImpl) { ExtensionObserverMethodImpl<?, ?> extensionObserver = (ExtensionObserverMethodImpl<?, ?>) observer; scopes = extensionObserver.getRequiredScopeAnnotations(); } else { scopes = observer.getRequiredAnnotations().stream().filter((a) -> beanManager.isScope(a)).collect(Collectors.toSet()); } if (!scopes.isEmpty() && scopes.size() == observer.getRequiredAnnotations().size()) { // this check only works if only scope annotations are listed within @WithAnnotations // performing a complete check would be way too expensive - eliminating the benefit of ClassFileServices for (Class<? extends Annotation> annotation : scopes) { if (type.isAnnotationPresent(annotation)) { return true; } } return false; } return true; }