Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2012, 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.util;
 
 import java.util.List;
 import java.util.Set;
 
Forwarding implementation of javax.enterprise.inject.spi.BeanManager.

Author(s):
Martin Kouba
 
 public abstract class ForwardingBeanManager implements BeanManagerSerializable {
 
     private static final long serialVersionUID = -3116833950882475733L;
 
     public abstract BeanManager delegate();
 
     @Override
     public Object getReference(Bean<?> beanType beanTypeCreationalContext<?> ctx) {
         return delegate().getReference(beanbeanTypectx);
     }
 
     @Override
         return delegate().getInjectableReference(ijctx);
     }
 
     @Override
     public <T> CreationalContext<T> createCreationalContext(Contextual<T> contextual) {
         return delegate().createCreationalContext(contextual);
     }
 
     @Override
     public Set<Bean<?>> getBeans(Type beanTypeAnnotation... qualifiers) {
         return delegate().getBeans(beanTypequalifiers);
     }
 
     @Override
     public Set<Bean<?>> getBeans(String name) {
         return delegate().getBeans(name);
     }
 
     @Override
     public Bean<?> getPassivationCapableBean(String id) {
         return delegate().getPassivationCapableBean(id);
     }
 
     @Override
     public <X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans) {
         return delegate().resolve(beans);
     }
 
     @Override
     public void validate(InjectionPoint injectionPoint) {
         delegate().validate(injectionPoint);
     }
 
     @Override
    public void fireEvent(Object eventAnnotation... qualifiers) {
        delegate().fireEvent(eventqualifiers);
    }
    @Override
    public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(T eventAnnotation... qualifiers) {
        return delegate().resolveObserverMethods(eventqualifiers);
    }
    @Override
    public List<Decorator<?>> resolveDecorators(Set<TypetypesAnnotation... qualifiers) {
        return delegate().resolveDecorators(typesqualifiers);
    }
    @Override
    public List<Interceptor<?>> resolveInterceptors(InterceptionType typeAnnotation... interceptorBindings) {
        return delegate().resolveInterceptors(typeinterceptorBindings);
    }
    @Override
    public boolean isScope(Class<? extends AnnotationannotationType) {
        return delegate().isScope(annotationType);
    }
    @Override
    public boolean isNormalScope(Class<? extends AnnotationannotationType) {
        return delegate().isNormalScope(annotationType);
    }
    @Override
    public boolean isPassivatingScope(Class<? extends AnnotationannotationType) {
        return delegate().isPassivatingScope(annotationType);
    }
    @Override
    public boolean isQualifier(Class<? extends AnnotationannotationType) {
        return delegate().isQualifier(annotationType);
    }
    @Override
    public boolean isInterceptorBinding(Class<? extends AnnotationannotationType) {
        return delegate().isInterceptorBinding(annotationType);
    }
    @Override
    public boolean isStereotype(Class<? extends AnnotationannotationType) {
        return delegate().isStereotype(annotationType);
    }
    @Override
    public Set<AnnotationgetInterceptorBindingDefinition(Class<? extends AnnotationbindingType) {
        return delegate().getInterceptorBindingDefinition(bindingType);
    }
    @Override
    public Set<AnnotationgetStereotypeDefinition(Class<? extends Annotationstereotype) {
        return delegate().getStereotypeDefinition(stereotype);
    }
    @Override
    public boolean areQualifiersEquivalent(Annotation qualifier1Annotation qualifier2) {
        return delegate().areQualifiersEquivalent(qualifier1qualifier2);
    }
    @Override
    public boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1Annotation interceptorBinding2) {
        return delegate().areInterceptorBindingsEquivalent(interceptorBinding1interceptorBinding2);
    }
    @Override
    public int getQualifierHashCode(Annotation qualifier) {
        return delegate().getQualifierHashCode(qualifier);
    }
    @Override
    public int getInterceptorBindingHashCode(Annotation interceptorBinding) {
        return delegate().getInterceptorBindingHashCode(interceptorBinding);
    }
    @Override
    public Context getContext(Class<? extends AnnotationscopeType) {
        return delegate().getContext(scopeType);
    }
    @Override
    public ELResolver getELResolver() {
        return delegate().getELResolver();
    }
    @Override
    public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory) {
        return delegate().wrapExpressionFactory(expressionFactory);
    }
    @Override
    public <T> AnnotatedType<T> createAnnotatedType(Class<T> type) {
        return delegate().createAnnotatedType(type);
    }
    @Override
    public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type) {
        return delegate().createInjectionTarget(type);
    }
    @Override
    public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type) {
        return delegate().createBeanAttributes(type);
    }
    @Override
    public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type) {
        return delegate().createBeanAttributes(type);
    }
    @Override
    public <T> Bean<T> createBean(BeanAttributes<T> attributesClass<T> beanClassInjectionTargetFactory<T> injectionTargetFactory) {
        return delegate().createBean(attributesbeanClassinjectionTargetFactory);
    }
    @Override
    public <T, X> Bean<T> createBean(BeanAttributes<T> attributesClass<X> beanClassProducerFactory<X> producerFactory) {
        return delegate().createBean(attributesbeanClassproducerFactory);
    }
    @Override
        return delegate().createInjectionPoint(field);
    }
    @Override
    public InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter) {
        return delegate().createInjectionPoint(parameter);
    }
    @Override
    public <T extends Extension> T getExtension(Class<T> extensionClass) {
        return delegate().getExtension(extensionClass);
    }
    @Override
    public int hashCode() {
        return delegate().hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof ForwardingBeanManager) {
            ForwardingBeanManager that = (ForwardingBeanManagerobj;
            return delegate().equals(that.delegate());
        }
        return delegate().equals(obj);
    }
    @Override
    public String toString() {
        return delegate().toString();
    }
    @Override
    public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType) {
        return delegate().getInjectionTargetFactory(annotatedType);
    }
    @Override
    public <X> ProducerFactory<X> getProducerFactory(AnnotatedField<? super X> fieldBean<X> declaringBean) {
        return delegate().getProducerFactory(fielddeclaringBean);
    }
    @Override
    public <X> ProducerFactory<X> getProducerFactory(AnnotatedMethod<? super X> methodBean<X> declaringBean) {
        return delegate().getProducerFactory(methoddeclaringBean);
    }
New to GrepCode? Check out our FAQ X