[weld-commits] Weld SVN: r5649 - core/trunk/impl/src/main/java/org/jboss/weld/util.

[weld-commits at lists.jboss.org]

Author: swd847
Date: 2010-01-27 21:26:52 -0500 (Wed, 27 Jan 2010)
New Revision: 5649

Modified:
   core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java
Log:
WELD-335  forgot file


Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java
===================================================================
--- core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java	2010-01-28 01:36:40 UTC (rev 5648)
+++ core/trunk/impl/src/main/java/org/jboss/weld/util/AnnotatedTypes.java	2010-01-28 02:26:52 UTC (rev 5649)
@@ -26,9 +26,12 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
+import javax.enterprise.inject.spi.Annotated;
 import javax.enterprise.inject.spi.AnnotatedCallable;
 import javax.enterprise.inject.spi.AnnotatedConstructor;
 import javax.enterprise.inject.spi.AnnotatedField;
@@ -282,7 +285,10 @@
          builder.append('(');
          Method[] declaredMethods = a.annotationType().getDeclaredMethods();
          List<Method> methods = new ArrayList<Method>(declaredMethods.length);
-         // TODO Shouldn't the declared methods be added here?
+         for (Method m : declaredMethods)
+         {
+            methods.add(m);
+         }
          Collections.sort(methods, MethodComparator.INSTANCE);
 
          for (int i = 0; i < methods.size(); ++i)
@@ -387,6 +393,136 @@
       return builder.toString();
    }
 
+   /**
+    * compares two annotated elemetes to see if they have the same annotations
+    * 
+    * @param a1
+    * @param a2
+    * @return
+    */
+   private static boolean compareAnnotated(Annotated a1, Annotated a2)
+   {
+      return a1.getAnnotations().equals(a2.getAnnotations());
+   }
+
+   /**
+    * compares two annotated elements to see if they have the same annotations
+    * 
+    */
+   private static boolean compareAnnotatedParameters(List<? extends AnnotatedParameter<?>> p1, List<? extends AnnotatedParameter<?>> p2)
+   {
+      if (p1.size() != p2.size())
+      {
+         return false;
+      }
+      for (int i = 0; i < p1.size(); ++i)
+      {
+         if (!compareAnnotated(p1.get(i), p2.get(i)))
+         {
+            return false;
+         }
+      }
+      return true;
+   }
+
+   public static boolean compareAnnotatedField(AnnotatedField<?> f1, AnnotatedField<?> f2)
+   {
+      if (f1.getJavaMember() != f2.getJavaMember())
+      {
+         return false;
+      }
+      return compareAnnotated(f1, f2);
+   }
+
+   public static boolean compareAnnotatedCallable(AnnotatedCallable<?> m1, AnnotatedCallable<?> m2)
+   {
+      if(m1.getJavaMember() != m2.getJavaMember())
+      {
+         return false;
+      }
+      if(!compareAnnotated(m1, m2))
+      {
+         return false;
+      }
+      return compareAnnotatedParameters(m1.getParameters(), m2.getParameters());
+   }
+
+   /**
+    * Compares two annotated types and returns true if they are the same
+    */
+   public static boolean compareAnnotatedTypes(AnnotatedType<?> t1, AnnotatedType<?> t2)
+   {
+      if (t1.getJavaClass() != t2.getJavaClass())
+      {
+         return false;
+      }
+      if (!compareAnnotated(t1, t2))
+      {
+         return false;
+      }
+      Map<Field, AnnotatedField<?>> fields = new HashMap<Field, AnnotatedField<?>>();
+      for (AnnotatedField<?> f : t2.getFields())
+      {
+         fields.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedField<?> f : t1.getFields())
+      {
+         if (fields.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedField(f, fields.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+
+      Map<Method, AnnotatedMethod<?>> methods = new HashMap<Method, AnnotatedMethod<?>>();
+      for (AnnotatedMethod<?> f : t2.getMethods())
+      {
+         methods.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedMethod<?> f : t1.getMethods())
+      {
+         if (methods.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedCallable(f, methods.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+
+      Map<Constructor<?>, AnnotatedConstructor<?>> constructors = new HashMap<Constructor<?>, AnnotatedConstructor<?>>();
+      for (AnnotatedConstructor<?> f : t2.getConstructors())
+      {
+         constructors.put(f.getJavaMember(), f);
+      }
+      for (AnnotatedConstructor<?> f : t1.getConstructors())
+      {
+         if (constructors.containsKey(f.getJavaMember()))
+         {
+            if (!compareAnnotatedCallable(f, constructors.get(f.getJavaMember())))
+            {
+               return false;
+            }
+         }
+         else
+         {
+            return false;
+         }
+      }
+      return true;
+
+   }
+
    public static <X> String createParameterId(AnnotatedParameter<X> annotatedParameter)
    {
       return createParameterId(annotatedParameter.getBaseType(), annotatedParameter.getAnnotations());