Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2008, 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.injection;
 
 
 import java.util.List;
 import java.util.Set;
 
 import static org.jboss.weld.injection.Exceptions.rethrowException;
 import static org.jboss.weld.logging.messages.BeanMessage.PROXY_REQUIRED;
 
 public class MethodInjectionPoint<T, X> extends ForwardingWeldMethod<T, X> implements WeldInjectionPoint<T, Method> {
 
     private abstract static class ForwardingParameterInjectionPointList<T, X> extends AbstractList<ParameterInjectionPoint<T, X>> {
 
         protected abstract List<? extends WeldParameter<T, X>> delegate();
 
         protected abstract Bean<X> declaringBean();
 
         @Override
         public ParameterInjectionPoint<T, X> get(int index) {
             return ParameterInjectionPoint.of(declaringBean(), delegate().get(index));
         }
 
         @Override
         public int size() {
             return delegate().size();
         }
 
     }
 
     private final Bean<?> declaringBean;
     private final WeldMethod<T, X> method;
 
     public static <T, X> MethodInjectionPoint<T, X> of(Bean<?> declaringBeanWeldMethod<T, X> method) {
         return new MethodInjectionPoint<T, X>(declaringBeanmethod);
     }
 
     protected MethodInjectionPoint(Bean<?> declaringBeanWeldMethod<T, X> method) {
         this. = declaringBean;
         this. = method;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (obj instanceof MethodInjectionPoint<?, ?>) {
             MethodInjectionPoint<?, ?> ip = (MethodInjectionPoint<?, ?>) obj;
             if (AnnotatedTypes.compareAnnotatedCallable(ip.method)) {
                 return true;
             }
         }
         return false;
     }
 
     @Override
     public int hashCode() {
         return .hashCode();
     }
 
     @Override
     protected WeldMethod<T, X> delegate() {
         return ;
     }
 
    public Bean<?> getBean() {
        return ;
    }
    @Override
    public Set<AnnotationgetQualifiers() {
        return delegate().getQualifiers();
    }
    public T invoke(Object declaringInstanceBeanManagerImpl managerCreationalContext<?> creationalContextClass<? extends RuntimeExceptionexceptionTypeToThrow) {
        try {
            return delegate().invoke(declaringInstancegetParameterValues(getWeldParameters(), nullnullmanagercreationalContext));
        } catch (IllegalArgumentException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (IllegalAccessException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (InvocationTargetException e) {
            rethrowException(eexceptionTypeToThrow);
        }
        return null;
    }
    public T invokeWithSpecialValue(Object declaringInstanceClass<? extends AnnotationannotatedParameterObject parameterBeanManagerImpl managerCreationalContext<?> creationalContextClass<? extends RuntimeExceptionexceptionTypeToThrow) {
        try {
            return invoke(declaringInstancegetParameterValues(getWeldParameters(), annotatedParameterparametermanagercreationalContext));
        } catch (IllegalArgumentException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (IllegalAccessException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (InvocationTargetException e) {
            rethrowException(eexceptionTypeToThrow);
        }
        return null;
    }
    public T invokeOnInstance(Object declaringInstanceBeanManagerImpl managerCreationalContext<?> creationalContextClass<? extends RuntimeExceptionexceptionTypeToThrow) {
        try {
            return delegate().invokeOnInstance(declaringInstancegetParameterValues(getWeldParameters(), nullnullmanagercreationalContext));
        } catch (IllegalArgumentException e) {
            rethrowException(e);
        } catch (IllegalAccessException e) {
            rethrowException(e);
        } catch (InvocationTargetException e) {
            rethrowException(e);
        } catch (SecurityException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (NoSuchMethodException e) {
            rethrowException(eexceptionTypeToThrow);
        }
        return null;
    }
    public T invokeOnInstanceWithSpecialValue(Object declaringInstanceClass<? extends AnnotationannotatedParameterObject parameterBeanManagerImpl managerCreationalContext<?> creationalContextClass<? extends RuntimeExceptionexceptionTypeToThrow) {
        try {
            return invokeOnInstance(declaringInstancegetParameterValues(getWeldParameters(), annotatedParameterparametermanagercreationalContext));
        } catch (IllegalArgumentException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (SecurityException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (IllegalAccessException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (InvocationTargetException e) {
            rethrowException(eexceptionTypeToThrow);
        } catch (NoSuchMethodException e) {
            rethrowException(eexceptionTypeToThrow);
        }
        return null;
    }
    @Override
    public List<ParameterInjectionPoint<?, X>> getWeldParameters() {
        final List<? extends WeldParameter<?, X>> delegate = super.getWeldParameters();
        return new ForwardingParameterInjectionPointList() {
            @Override
            protected Bean<?> declaringBean() {
                return ;
            }
            @Override
            protected List<? extends WeldParameter<?, X>> delegate() {
                return delegate;
            }
        };
    }
    public void inject(Object declaringInstanceObject value) {
        try {
            delegate().invoke(declaringInstancevalue);
        } catch (IllegalArgumentException e) {
            rethrowException(e);
        } catch (IllegalAccessException e) {
            rethrowException(e);
        } catch (InvocationTargetException e) {
            rethrowException(e);
        }
    }

    
Helper method for getting the current parameter values from a list of annotated parameters.

Parameters:
parameters The list of annotated parameter to look up
manager The Bean manager
Returns:
The object array of looked up values
    protected Object[] getParameterValues(List<ParameterInjectionPoint<?, X>> parameters,
                                          Class<? extends AnnotationspecialParamObject specialVal,
                                          BeanManagerImpl managerCreationalContext<?> creationalContext) {
        Object[] parameterValues = new Object[parameters.size()];
        Iterator<ParameterInjectionPoint<?, X>> iterator = parameters.iterator();
        for (int i = 0; i < parameterValues.lengthi++) {
            ParameterInjectionPoint<?, ?> param = iterator.next();
            if (specialParam != null && param.isAnnotationPresent(specialParam)) {
                parameterValues[i] = specialVal;
            } else {
                parameterValues[i] = param.getValueToInject(managercreationalContext);
            }
        }
        return parameterValues;
    }
    public Annotated getAnnotated() {
        return delegate();
    }
    public boolean isDelegate() {
        return false;
    }
    public boolean isTransient() {
        // TODO Auto-generated method stub
        return false;
    }
    public Type getType() {
        return getBaseType();
    }
    public Member getMember() {
        return getJavaMember();
    }
    // Serialization
    private Object writeReplace() throws ObjectStreamException {
        return new SerializationProxy<T>(this);
    }
    private void readObject(ObjectInputStream streamthrows InvalidObjectException {
        throw new InvalidObjectException();
    }
    private static class SerializationProxy<T> extends WeldInjectionPointSerializationProxy<T, Method> {
        private static final long serialVersionUID = 9181171328831559650L;
        private final MethodSignature signature;
        public SerializationProxy(MethodInjectionPoint<T, ?> injectionPoint) {
            super(injectionPoint);
            this. = injectionPoint.getSignature();
        }
        private Object readResolve() {
            WeldMethod<T, ?> method = getWeldMethod();
            Bean<T> bean = getDeclaringBean();
            if (method == null || (bean == null && getDeclaringBeanId() != null)) {
            }
            return MethodInjectionPoint.of(getDeclaringBean(), getWeldMethod());
        }
        protected WeldMethod<T, ?> getWeldMethod() {
            return getDeclaringWeldClass().getDeclaredWeldMethod();
        }
    }
New to GrepCode? Check out our FAQ X