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 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 BackedAnnotatedConstructor<X> extends BackedAnnotatedCallable<X, Constructor<X>> implements AnnotatedConstructor<X>, Serializable {
 
     public static <X> AnnotatedConstructor<X> of(Constructor<X> constructorBackedAnnotatedType<X> declaringTypeSharedObjectCache sharedObjectCache) {
         return new BackedAnnotatedConstructor<X>(constructordeclaringTypesharedObjectCache);
     }
 
     private final Constructor<X> constructor;
 
     public BackedAnnotatedConstructor(Constructor<X> constructorBackedAnnotatedType<X> declaringTypeSharedObjectCache sharedObjectCache) {
         super(constructorconstructor.getDeclaringClass(), declaringTypesharedObjectCache);
         this. = constructor;
     }
 
     @Override
     protected List<AnnotatedParameter<X>> initParameters(Constructor<X> memberSharedObjectCache sharedObjectCache) {
         final Class<?>[] parameterTypes = member.getParameterTypes();
         final Type[] genericParameterTypes = member.getGenericParameterTypes();
         Annotation[][] parameterAnnotations = member.getParameterAnnotations();
 
         if (parameterTypes.length == genericParameterTypes.length && genericParameterTypes.length == parameterAnnotations.length) {
             List<AnnotatedParameter<X>> parameters = new ArrayList<AnnotatedParameter<X>>(parameterTypes.length);
             int nesting = Reflections.getNesting(getDeclaringType().getJavaClass());
             for (int i = 0; i < parameterTypes.lengthi++) {
                 int gi = i - nesting;
                 Class<?> clazz = parameterTypes[i];
 
                 Type parameterType;
                 int position;
                 if (member.getGenericParameterTypes().length > gi && gi >= 0) {
                     parameterType = member.getGenericParameterTypes()[gi];
                     position = gi;
                 } else {
                     parameterType = clazz;
                     position = i;
                 }
                 parameters.add(new BackedAnnotatedParameter<X>(parameterTypeparameterAnnotations[position], positionthissharedObjectCache));
             }
             return immutableList(parameters);
         } else {
             /*
              * We are seeing either http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6520205 or
              * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5087240 or both.
              *
              * It is difficult to detect and adapt to these bugs properly. Therefore, we pretend to see a no-args constructor.
              * Although misleading, it is quite safe to do that since non-static inner classes are not CDI-managed beans anyway
              * and CDI constructor injection into Enums is not supported.
              */
             return Collections.emptyList();
         }
     }
 
     @Override
     protected AnnotatedElement getAnnotatedElement() {
         return ;
     }
 
     public Constructor<X> getJavaMember() {
         return ;
     }
 
     public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
         return .getAnnotation(annotationType);
     }
 
     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;
        }
        BackedAnnotatedConstructor<?> other = (BackedAnnotatedConstructor<?>) obj;
        if ( == null) {
            if (other.constructor != null) {
                return false;
            }
        } else if (!.equals(other.constructor)) {
            return false;
        }
        return true;
    }
    @Override
    public String toString() {
        return Formats.formatAnnotatedConstructor(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, AnnotatedConstructor<X>> {
        private static final long serialVersionUID = -2726172060851333254L;
        public SerializationProxy(BackedAnnotatedConstructor<X> constructor) {
            super(constructor.getDeclaringType(), new ConstructorHolder<X>(constructor.getJavaMember()));
        }
        private Object readResolve() throws ObjectStreamException {
            return resolve();
        }
        @Override
        protected Iterable<AnnotatedConstructor<X>> getCandidates() {
            return .getConstructors();
        }
    }
New to GrepCode? Check out our FAQ X