Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jboss.weld.annotated.slim.backed;
  
  import static org.jboss.weld.util.collections.WeldCollections.immutableList;
  import static org.jboss.weld.util.reflection.Reflections.cast;
  
 import java.util.List;
 
 
 
 import  edu.umd.cs.findbugs.annotations.SuppressWarnings;
 
 @SuppressWarnings(value = { "SE_BAD_FIELD""SE_NO_SUITABLE_CONSTRUCTOR""SE_NO_SERIALVERSIONID" }, justification = "False positive from FindBugs - serialization is handled by SerializationProxy.")
 public class BackedAnnotatedMethod<X> extends BackedAnnotatedCallable<X, Methodimplements AnnotatedMethod<X>, Serializable {
 
     public static <X, Y extends X> AnnotatedMethod<X> of(Method methodBackedAnnotatedType<Y> declaringTypeSharedObjectCache sharedObjectCache) {
         BackedAnnotatedType<X> downcastDeclaringType = cast(declaringType);
         return new BackedAnnotatedMethod<X>(methoddowncastDeclaringTypesharedObjectCache);
     }
 
     private final Method method;
 
     public BackedAnnotatedMethod(Method methodBackedAnnotatedType<X> declaringTypeSharedObjectCache sharedObjectCache) {
         super(methodmethod.getGenericReturnType(), declaringTypesharedObjectCache);
         this. = method;
     }
 
     @Override
     protected List<AnnotatedParameter<X>> initParameters(Method methodSharedObjectCache sharedObjectCache) {
         final Type[] genericParameterTypes = method.getGenericParameterTypes();
 
         List<AnnotatedParameter<X>> parameters = new ArrayList<AnnotatedParameter<X>>(genericParameterTypes.length);
 
         Annotation[][] parameterAnnotations = method.getParameterAnnotations();
         for (int i = 0; i < genericParameterTypes.lengthi++) {
             Type parameterType = genericParameterTypes[i];
             parameters.add(BackedAnnotatedParameter.of(parameterTypeparameterAnnotations[i], ithissharedObjectCache));
         }
         return immutableList(parameters);
     }
 
     public Method getJavaMember() {
         return ;
     }
 
     public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
         return .getAnnotation(annotationType);
     }
 
     @Override
     protected AnnotatedElement getAnnotatedElement() {
         return ;
     }
 
     public boolean isAnnotationPresent(Class<? extends AnnotationannotationType) {
         return .isAnnotationPresent(annotationType);
     }
 
     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + (( == null) ? 0 : .hashCode());
         return result;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null) {
             return false;
         }
         if (getClass() != obj.getClass()) {
             return false;
         }
         BackedAnnotatedMethod<?> other = (BackedAnnotatedMethod<?>) obj;
         if ( == null) {
             if (other.method != null) {
                 return false;
             }
         } else if (!.equals(other.method)) {
             return false;
         }
        return true;
    }
    @Override
    public String toString() {
        return Formats.formatAnnotatedMethod(this);
    }
    // Serialization
    private Object writeReplace() throws ObjectStreamException {
        return new SerializationProxy<X>(this);
    }
    private void readObject(ObjectInputStream streamthrows InvalidObjectException {
        throw ..proxyRequired();
    }
    private static class SerializationProxy<X> extends BackedAnnotatedMemberSerializationProxy<X, AnnotatedMethod<X>> {
        private static final long serialVersionUID = 8008578690970722095L;
        public SerializationProxy(BackedAnnotatedMethod<X> method) {
            super(method.getDeclaringType(), MethodHolder.of(method));
        }
        private Object readResolve() throws ObjectStreamException {
            return resolve();
        }
        @Override
        protected Iterable<AnnotatedMethod<X>> getCandidates() {
            return cast(.getMethods());
        }
    }
New to GrepCode? Check out our FAQ X