[jboss-cvs] JBossAS SVN: r77973 - trunk/ejb3/src/main/org/jboss/ejb3/client.

[jboss-cvs-commits at lists.jboss.org]

Author: alex.loubyansky at jboss.com
Date: 2008-09-04 09:29:51 -0400 (Thu, 04 Sep 2008)
New Revision: 77973

Modified:
   trunk/ejb3/src/main/org/jboss/ejb3/client/ClientContainer.java
Log:
JBCTS-843 with comparator impl some of the callbacks were getting lost due to inconsistent impl with equals. Current impl is a copy of the helper method from the metadata project where it is also tested. After the metadata release, the method from the metadata project should be used instead.

Modified: trunk/ejb3/src/main/org/jboss/ejb3/client/ClientContainer.java
===================================================================
--- trunk/ejb3/src/main/org/jboss/ejb3/client/ClientContainer.java	2008-09-04 13:14:28 UTC (rev 77972)
+++ trunk/ejb3/src/main/org/jboss/ejb3/client/ClientContainer.java	2008-09-04 13:29:51 UTC (rev 77973)
@@ -33,11 +33,12 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
-import java.util.TreeMap;
+import java.util.Set;
 
 import javax.naming.Context;
 import javax.naming.LinkRef;
@@ -386,55 +387,50 @@
       ClassLoader cl = Thread.currentThread().getContextClassLoader();
       Class<?> parameterTypes[] = new Class[0];
 
-      Comparator<Class<?>> callbackComparator = new Comparator<Class<?>>()
-      {
-         public int compare(Class<?> o1, Class<?> o2)
-         {
-            if(o1 == o2)
-               return 0;
-            if (o1.isAssignableFrom(o2))
-               return -1;
-            if (o2.isAssignableFrom(o1))
-               return 1;
-            return 0;
-         }
-      };
+      Set<Class<?>> callbacksSet = new HashSet<Class<?>>();
+      LinkedList<Method> methods = new LinkedList<Method>();
 
-      Map<Class<?>, Method> defaultClassCallbacks = new TreeMap<Class<?>, Method>(callbackComparator);
-      Map<Class<?>, Method> nonDefaultClassCallbacks = new TreeMap<Class<?>, Method>(callbackComparator);
-
       for (LifecycleCallbackMetaData callback : callbacks)
       {
          String className = callback.getClassName();
          String methodName = callback.getMethodName();
-         Class<?> lifecycleClass;
-         Map<Class<?>, Method> callbacksMap = null;
-         if (className == null)
-         {
-            lifecycleClass = mainClass;
-            callbacksMap = defaultClassCallbacks;
-         }
-         else
-         {
-            lifecycleClass = cl.loadClass(className);
-            if(lifecycleClass.isAssignableFrom(mainClass))
-               callbacksMap = defaultClassCallbacks;
-            else
-               callbacksMap = nonDefaultClassCallbacks;
-         }
+         Class<?> lifecycleClass = className == null ? mainClass : cl.loadClass(className);
 
          // If we haven't yet added the callback for this class
-         if (!callbacksMap.containsKey(lifecycleClass))
+         if (callbacksSet.add(lifecycleClass))
          {
             Method method = lifecycleClass.getDeclaredMethod(methodName, parameterTypes);
-            callbacksMap.put(lifecycleClass, method);
-         }
+
+            boolean added = false;
+            for (int i = 0; i < methods.size(); ++i)
+            {
+               Method m = methods.get(i);
+               Class<?> methodClass = m.getDeclaringClass();
+               // insert the class before the current class in the list if the class is a superclass of the current class
+               if (lifecycleClass.isAssignableFrom(methodClass))
+               {
+                  methods.add(i, method);
+                  added = true;
+                  break;
+               }
+               // insert the class before the current class in the list
+               // if the class is not a subclass of the current class and
+               // it is a superclass of the default class or the default class itself 
+               else if(!methodClass.isAssignableFrom(lifecycleClass) &&
+                     (lifecycleClass == mainClass || lifecycleClass.isAssignableFrom(mainClass)))
+               {
+                  methods.add(i, method);
+                  added = true;
+                  break;
+               }
+            }
+            
+            if (!added)
+               methods.add(method);
+         }         
       }
       
-      if(!defaultClassCallbacks.isEmpty())
-         postConstructs.addAll(defaultClassCallbacks.values());
-      if(!nonDefaultClassCallbacks.isEmpty())
-         postConstructs.addAll(nonDefaultClassCallbacks.values());
+      postConstructs.addAll(methods);
    }
 
    /* (non-Javadoc)