Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2010, 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.event;
 
 import java.util.Set;
 
 
 
An implementation of javax.enterprise.inject.spi.ObserverMethod used for events delivered to extensions. The observer method does not require contexts to be active.

Author(s):
Jozef Hartinger
 
 public class ExtensionObserverMethodImpl<T, X> extends ObserverMethodImpl<T, X> {
 
     private final Set<Class<? extends Annotation>> requiredTypeAnnotations;
     private volatile Set<Class<? extends Annotation>> requiredScopeTypeAnnotations;
 
     protected ExtensionObserverMethodImpl(EnhancedAnnotatedMethod<T, ? super X> observerRIBean<X> declaringBeanBeanManagerImpl manager) {
         super(observerdeclaringBeanmanager);
         this. = Container.instance(manager);
         this. = initRequiredTypeAnnotations(observer);
     }
 
     protected Set<Class<? extends Annotation>> initRequiredTypeAnnotations(EnhancedAnnotatedMethod<T, ? super X> observer) {
         EnhancedAnnotatedParameter<?, ? super X> eventParameter = observer.getEnhancedParameters(Observes.class).get(0);
         WithAnnotations annotation = eventParameter.getAnnotation(WithAnnotations.class);
         if (annotation != null) {
             return ImmutableSet.<Class<? extends Annotation>>copyOf(annotation.value());
         }
         return Collections.emptySet();
     }
 
     @Override
     protected void checkRequiredTypeAnnotations(EnhancedAnnotatedParameter<?, ?> eventParameter) {
         Class<?> rawObserverType = Reflections.getRawType(getObservedType());
         boolean isProcessAnnotatedType = rawObserverType.equals(ProcessAnnotatedType.class) || rawObserverType.equals(ProcessSyntheticAnnotatedType.class);
         if (!isProcessAnnotatedType && !.isEmpty()) {
             throw ..invalidWithAnnotations(this);
         }
         if (isProcessAnnotatedType && .isEmpty()) {
             Type[] typeArguments = eventParameter.getActualTypeArguments();
             if (typeArguments.length == 0 || Reflections.isUnboundedWildcard(typeArguments[0]) || Reflections.isUnboundedTypeVariable(typeArguments[0])) {
                 ..unrestrictedProcessAnnotatedTypes(this);
             }
         }
     }
 
     @Override
     protected MethodInjectionPoint<T, ? super X> initMethodInjectionPoint(EnhancedAnnotatedMethod<T, ? super X> observerRIBean<X> declaringBeanBeanManagerImpl manager) {
         // use silent creation of injection points for ProcessInjectionPoint events not to be fired for extension observer methods
         return InjectionPointFactory.silentInstance().createMethodInjectionPoint(observerdeclaringBeandeclaringBean.getBeanClass(), truemanager);
     }
 
     @Override
     protected void preNotify(T eventObject receiver) {
         if (event instanceof NotificationListener) {
             NotificationListener.class.cast(event).preNotify((Extensionreceiver);
         }
    }
    @Override
    protected void postNotify(T eventObject receiver) {
        if (event instanceof NotificationListener) {
            NotificationListener.class.cast(event).postNotify((Extensionreceiver);
        }
    }
    /*
     * Contexts may not be active during notification of container lifecycle events. Therefore, we invoke the methods directly on
     * an extension instance.
     */
    @Override
    protected Object getReceiver(CreationalContext<X> ctx) {
        return getDeclaringBean().create(null);
    }
    @Override
    protected void sendEvent(T eventObject receiverCreationalContext<?> creationalContext) {
        synchronized () {
            super.sendEvent(eventreceivercreationalContext);
        }
    }
    public Collection<Class<? extends Annotation>> getRequiredAnnotations() {
        return ;
    }
    public Collection<Class<? extends Annotation>> getRequiredScopeAnnotations() {
        if ( == null) {
            // this init may be performed more than once - which is OK
            ImmutableSet.Builder<Class<? extends Annotation>> builder = ImmutableSet.builder();
            for (Class<? extends Annotationannotation : ) {
                if (.isScope(annotation)) {
                    builder.add(annotation);
                }
            }
            this. = builder.build();
        }
        return ;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        ExtensionObserverMethodImpl<?, ?> that = (ExtensionObserverMethodImpl<?, ?>) obj;
        return super.equals(that);
    }
    @Override
    public int hashCode() {
        return super.hashCode();
    }
New to GrepCode? Check out our FAQ X