cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dk...@apache.org
Subject svn commit: r552502 - in /incubator/cxf/trunk: common/common/src/main/java/org/apache/cxf/jaxb/ common/common/src/test/java/org/apache/cxf/jaxb/ rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/
Date Mon, 02 Jul 2007 14:27:49 GMT
Author: dkulp
Date: Mon Jul  2 07:27:48 2007
New Revision: 552502

URL: http://svn.apache.org/viewvc?view=rev&rev=552502
Log:
WrapperType handling optimizations phase one - collect the Method/Field objects
up front and use those each time instead of re-quearying for each property.

Modified:
    incubator/cxf/trunk/common/common/src/main/java/org/apache/cxf/jaxb/WrapperHelper.java
    incubator/cxf/trunk/common/common/src/test/java/org/apache/cxf/jaxb/WrapperHelperTest.java
    incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassInInterceptor.java
    incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassOutInterceptor.java

Modified: incubator/cxf/trunk/common/common/src/main/java/org/apache/cxf/jaxb/WrapperHelper.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/common/common/src/main/java/org/apache/cxf/jaxb/WrapperHelper.java?view=diff&rev=552502&r1=552501&r2=552502
==============================================================================
--- incubator/cxf/trunk/common/common/src/main/java/org/apache/cxf/jaxb/WrapperHelper.java
(original)
+++ incubator/cxf/trunk/common/common/src/main/java/org/apache/cxf/jaxb/WrapperHelper.java
Mon Jul  2 07:27:48 2007
@@ -22,261 +22,222 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.annotation.XmlElement;
 
-public final class WrapperHelper {
+import org.apache.cxf.helpers.CastUtils;
 
-    private WrapperHelper() {
-        // complete
+public class WrapperHelper {
+    private static final Class NO_PARAMS[] = new Class[0]; 
+    
+    final Class<?> wrapperType;
+    final Method setMethods[];
+    final Method getMethods[];
+    final Method jaxbObjectMethods[];
+    final Field fields[];
+    final Object objectFactory;
+                 
+    WrapperHelper(Class<?> wt,
+                  Method sets[],
+                  Method gets[],
+                  Method jaxbs[],
+                  Field f[],
+                  Object of) {
+        setMethods = sets;
+        getMethods = gets;
+        fields = f;
+        jaxbObjectMethods = jaxbs;
+        wrapperType = wt;
+        objectFactory = of;
     }
-
-    public static void setWrappedPart(String partName, Object wrapperType, Object part)
-        throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
-
-        if (part instanceof List) {
-            setWrappedListProperty(partName, wrapperType, part);
-        } else {
-            String fieldName = partName;
-            if (JAXBUtils.isJavaKeyword(partName)) {
-                fieldName = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.VARIABLE);
-            }
-
-
-            if (part == null) {
-                XmlElement el = null;
-                Field elField = null;
-                for (Field field : wrapperType.getClass().getDeclaredFields()) {
-                    if (field.getName().equals(fieldName)) {
-                        elField = field;
-                        el = elField.getAnnotation(XmlElement.class);
-                        break;
-                    }
-                }
-                if (el != null 
-                    && !el.nillable() 
-                    && elField.getType().isPrimitive()) {
-                    throw new IllegalArgumentException("null value for field not permitted.");
-                }
-                return;
-            }
-
-            String modifier = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.SETTER);
-            String modifier2 = modifier;
-            if ("return".equals(partName)) {
-                //some versions of jaxb map "return" to "set_return" instead of "setReturn"
-                modifier2 = "set_return";
-            }
-
-            boolean setInvoked = false;
-            for (Method method : wrapperType.getClass().getMethods()) {
-                if (method.getParameterTypes() != null && method.getParameterTypes().length
== 1
-                    && (modifier.equals(method.getName())
-                        || modifier2.equals(method.getName()))) {
-                    if ("javax.xml.bind.JAXBElement".equals(method.getParameterTypes()[0].getName()))
{
-                        if (!setJAXBElementValueIntoWrapType(method, wrapperType, part))
{
-                            throw new RuntimeException("Failed to set the part value (" +
part 
-                                + ") to wrapper type (" + wrapperType.getClass() + ")");
-                        }
-                    } else {
-                        method.invoke(wrapperType, part);
-                    }
-                    setInvoked = true;
-                    break;
-                }
-            }
-            if (!setInvoked) {
-                Field elField = getField(wrapperType, partName, fieldName);
-                // JAXB Type get XmlElement Annotation
-                if (elField != null) {
-                    elField.setAccessible(true);
-                    elField.set(wrapperType, part);
-                    setInvoked = true;
-                }
-            }
-            if (!setInvoked) {
-                throw new IllegalArgumentException("Could not find a modifier method on Wrapper
Type for "
-                                                   + partName);
+    
+    public Object createWrapperObject(List<?> lst) 
+        throws InstantiationException, IllegalAccessException, 
+        IllegalArgumentException, InvocationTargetException {
+        
+        Object ret = wrapperType.newInstance();
+        
+        for (int x = 0; x < setMethods.length; x++) {
+            Object o = lst.get(x);
+            if (jaxbObjectMethods[x] != null) {
+                o = jaxbObjectMethods[x].invoke(objectFactory, o);
+            }
+            if (o instanceof List) {
+                List<Object> col = CastUtils.cast((List)getMethods[x].invoke(ret));
+                List<Object> olst = CastUtils.cast((List)o);
+                col.addAll(olst);
+            } else if (setMethods[x] != null) {
+                setMethods[x].invoke(ret, o);
+            } else {
+                fields[x].set(ret, lst.get(x));
             }
         }
+        
+        return ret;
     }
-
-    private static Field getField(Object wrapperType, String partName, String fieldName)
{
-        // match fieldName and partName first
-        for (Field field : wrapperType.getClass().getDeclaredFields()) {
-            if (field.getName().equals(fieldName)) {
-                XmlElement el = field.getAnnotation(XmlElement.class);
-                if (el != null && el.name().equals(partName)) {
-                    return field;
-                }
-            }
-        }
-        // if above fails, check partName only
-        for (Field field : wrapperType.getClass().getDeclaredFields()) {
-            XmlElement el = field.getAnnotation(XmlElement.class);
-            if (el != null && el.name().equals(partName)) {
-                return field;
+    
+    public List<Object> getWrapperParts(Object o) 
+        throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
{
+        
+        List<Object> ret = new ArrayList<Object>(getMethods.length);
+        for (int x = 0; x < getMethods.length; x++) {
+            if (getMethods[x] != null) {
+                ret.add(getValue(getMethods[x], o));
+            } else if (fields[x] != null) {
+                ret.add(fields[x].get(o));
+            } else {
+                //placeholder
+                ret.add(null);
             }
         }
-        return null;
+        
+        return ret;
     }
-
-    private static boolean setJAXBElementValueIntoWrapType(Method method, Object wrapType,
Object value) {
-        String typeClassName = wrapType.getClass().getCanonicalName();
-        String objectFactoryClassName = typeClassName.substring(0, typeClassName.lastIndexOf('.'))
+    
+    public static WrapperHelper createWrapperHelper(Class<?> wrapperType,
+                                                    List<String> partNames,
+                                                    List<String> elTypeNames,
+                                                    List<Class<?>> partClasses)
{
+        List<Method> getMethods = new ArrayList<Method>(partNames.size());
+        List<Method> setMethods = new ArrayList<Method>(partNames.size());
+        List<Method> jaxbMethods = new ArrayList<Method>(partNames.size());
+        List<Field> fields = new ArrayList<Field>(partNames.size());
+        
+        Method allMethods[] = wrapperType.getMethods();
+        
+        String objectFactoryClassName = wrapperType.getPackage().getName()
                                         + ".ObjectFactory";
+
+        Object objectFactory = null;
         try {
-            Object objectFactory = wrapType.getClass().getClassLoader().loadClass(objectFactoryClassName)
-                .newInstance();
-            String methodName = "create" + wrapType.getClass().getSimpleName()
-                                + method.getName().substring(3);
-            Method objectFactoryMethod = objectFactory.getClass().getMethod(methodName, value.getClass());
-            if (objectFactoryMethod != null) {
-                JAXBElement je = (JAXBElement)objectFactoryMethod.invoke(objectFactory, value);
-                method.invoke(wrapType, je);
-            } else {
-                return false;
-            }
-            return true;
+            objectFactory = wrapperType.getClassLoader().loadClass(objectFactoryClassName).newInstance();
         } catch (Exception e) {
-            return false;
-        }
-
-    }
-
-    private static void setWrappedListProperty(String partName, Object wrapperType, Object
part)
-        throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
-
-        String accessorName = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
-        for (Method method : wrapperType.getClass().getMethods()) {
-            if (accessorName.equals(method.getName()) 
-                && List.class.isAssignableFrom(method.getReturnType())) {
-                Object ret = method.invoke(wrapperType);
-                Method addAll = ret.getClass().getMethod("addAll", Collection.class);
-                addAll.invoke(ret, part);
-                break;
-            }
+            //ignore, probably won't need it
         }
-    }
-
-    public static Object getWrappedPart(String partName, Object wrapperType, Class<?>
partClazz)
-        throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
-
-        String accessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
-
-        if (partClazz.equals(boolean.class) || partClazz.equals(Boolean.class)) {
-            // JAXB Exception to get the Boolean property
-            accessor = accessor.replaceFirst("get", "is");
+        Method allOFMethods[];
+        if (objectFactory != null) {
+            allOFMethods = objectFactory.getClass().getMethods(); 
+        } else {
+            allOFMethods = new Method[0];
         }
-
-        for (Method method : wrapperType.getClass().getMethods()) {
-            if (method.getParameterTypes().length == 0 && accessor.equals(method.getName()))
{
-
-                return getValue(method, wrapperType);
+        
+        for (int x = 0; x < partNames.size(); x++) {
+            String partName = partNames.get(x);
+            if (partName == null) {
+                getMethods.add(null);
+                setMethods.add(null);
+                fields.add(null);
+                jaxbMethods.add(null);
+                continue;
             }
-        }
-        return null;
-    }
-
-    public static Object getWrappedPart(String partName, Object wrapperType, String elementType)
-        throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
-
-        String accessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
-        Method method = null;
-        NoSuchMethodException nsex = null;
-        try {
-            method = wrapperType.getClass().getMethod(accessor, new Class[0]); 
-        } catch (NoSuchMethodException ex) {
-            //ignore for now
-            nsex = (NoSuchMethodException)ex.fillInStackTrace();
-        }
-
-        Field elField = null;
-        if (method == null
-            && elementType != null
-            && "boolean".equals(elementType.toLowerCase())) {
             
-            elField = getElField(partName, wrapperType);
-                
-            if (elField == null
-                || (!Collection.class.isAssignableFrom(elField.getType())
-                && !elField.getType().isArray())) {
-    
+            String elementType = elTypeNames.get(x);
+            
+            String getAccessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
+            String setAccessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.SETTER);
+            Method getMethod = null;
+            Method setMethod = null;
+            try {
+                getMethod = wrapperType.getMethod(getAccessor, NO_PARAMS); 
+            } catch (NoSuchMethodException ex) {
+                //ignore for now
+            }
+
+            Field elField = getElField(partName, wrapperType);
+            if (getMethod == null
+                && elementType != null
+                && "boolean".equals(elementType.toLowerCase())
+                && (elField == null
+                    || (!Collection.class.isAssignableFrom(elField.getType())
+                    && !elField.getType().isArray()))) {
+        
                 try {
-                    method = wrapperType.getClass().getMethod(accessor.replaceFirst("get",
"is"),
-                                                              new Class[0]); 
+                    String newAcc = getAccessor.replaceFirst("get", "is");
+                    getMethod = wrapperType.getMethod(newAcc, NO_PARAMS); 
                 } catch (NoSuchMethodException ex) {
                     //ignore for now
                 }            
-            }
-        }
-        if (method == null 
-            && "return".equals(partName)) {
-            //RI generated code uses this
-            try {
-                method = wrapperType.getClass().getMethod("get_return", new Class[0]);
-            } catch (NoSuchMethodException ex) {
+            }                        
+            if (getMethod == null 
+                && "return".equals(partName)) {
+                //RI generated code uses this
                 try {
-                    method = wrapperType.getClass().getMethod("is_return",
-                                                              new Class[0]);
-                } catch (NoSuchMethodException ex2) {
-                    //ignore for now
+                    getMethod = wrapperType.getClass().getMethod("get_return", NO_PARAMS);
+                } catch (NoSuchMethodException ex) {
+                    try {
+                        getMethod = wrapperType.getClass().getMethod("is_return",
+                                                                  new Class[0]);
+                    } catch (NoSuchMethodException ex2) {
+                        //ignore for now
+                    } 
+                }                
+            }
+            String setAccessor2 = setAccessor;
+            if ("return".equals(partName)) {
+                //some versions of jaxb map "return" to "set_return" instead of "setReturn"
+                setAccessor2 = "set_return";
+            }
+
+            for (Method method : allMethods) {
+                if (method.getParameterTypes() != null && method.getParameterTypes().length
== 1
+                    && (setAccessor.equals(method.getName())
+                        || setAccessor2.equals(method.getName()))) {
+                    setMethod = method;
+                    break;
+                }
+            }
+            
+            getMethods.add(getMethod);
+            setMethods.add(setMethod);
+            if (setMethod != null
+                && JAXBElement.class.isAssignableFrom(setMethod.getParameterTypes()[0]))
{
+                
+                String methodName = "create" + wrapperType.getSimpleName()
+                    + setMethod.getName().substring(3);
+
+                for (Method m : allOFMethods) {
+                    if (m.getName().equals(methodName)) {
+                        jaxbMethods.add(m);
+                    }
+                }
+            } else {
+                jaxbMethods.add(null);
+            }
+            
+            if (elField != null) {
+                // JAXB Type get XmlElement Annotation
+                XmlElement el = elField.getAnnotation(XmlElement.class);
+                if (el != null
+                    && partName.equals(el.name())) {
+                    elField.setAccessible(true);
+                    fields.add(elField);
+                } else {
+                    fields.add(null);
                 } 
-            }                
-        }
-        
-        if (method != null) {
-            return getValue(method, wrapperType);
-        }
-        if (elField == null) {
-            elField = getElField(partName, wrapperType);
-        }
-        if (elField != null) {
-            // JAXB Type get XmlElement Annotation
-            XmlElement el = elField.getAnnotation(XmlElement.class);
-            if (el != null
-                && partName.equals(el.name())) {
-                elField.setAccessible(true);
-                return elField.get(wrapperType);
+            } else {
+                fields.add(null);
             }
-        } else if (nsex != null) {
-            throw nsex;
+            
         }
-        
-        return null;
+        return new WrapperHelper(wrapperType,
+                                 setMethods.toArray(new Method[setMethods.size()]),
+                                 getMethods.toArray(new Method[getMethods.size()]),
+                                 jaxbMethods.toArray(new Method[jaxbMethods.size()]),
+                                 fields.toArray(new Field[fields.size()]),
+                                 objectFactory);
     }
 
-    private static Field getElField(String partName, Object wrapperType) {
+    private static Field getElField(String partName, Class<?> wrapperType) {
         String fieldName = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.VARIABLE);
-        Field elField = null;
-        for (Field field : wrapperType.getClass().getDeclaredFields()) {
+        for (Field field : wrapperType.getDeclaredFields()) {
             if (field.getName().equals(fieldName)) {
-                elField = field;
-                break;
+                return field;
             }
         }        
-        return elField;
-    }
-    
-    public static Object getWrappedPart(String partName, Object wrapperType) throws IllegalAccessException,
-        NoSuchMethodException, InvocationTargetException {
-        String accessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
-
-        // TODO: There must be a way to determine the class by inspecting
-        // wrapperType
-        // if (partClazz.equals(boolean.class) ||
-        // partClazz.equals(Boolean.class)) {
-        // //JAXB Exception to get the Boolean property
-        // accessor = accessor.replaceFirst("get", "is");
-        // }
-        for (Method method : wrapperType.getClass().getMethods()) {
-            if (method.getParameterTypes().length == 0 && accessor.equals(method.getName()))
{
-                return getValue(method, wrapperType);
-            }
-        }
         return null;
     }
 

Modified: incubator/cxf/trunk/common/common/src/test/java/org/apache/cxf/jaxb/WrapperHelperTest.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/common/common/src/test/java/org/apache/cxf/jaxb/WrapperHelperTest.java?view=diff&rev=552502&r1=552501&r2=552502
==============================================================================
--- incubator/cxf/trunk/common/common/src/test/java/org/apache/cxf/jaxb/WrapperHelperTest.java
(original)
+++ incubator/cxf/trunk/common/common/src/test/java/org/apache/cxf/jaxb/WrapperHelperTest.java
Mon Jul  2 07:27:48 2007
@@ -18,6 +18,9 @@
  */
 package org.apache.cxf.jaxb;
 
+import java.util.Arrays;
+import java.util.List;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
@@ -34,25 +37,52 @@
     public void getBooleanTypeWrappedPart() throws Exception {
         SetIsOK ok = new SetIsOK();
         ok.setParameter3(new boolean[] {true, false});
-        Object object = WrapperHelper.getWrappedPart("Parameter1", ok, "boolean");
-        assertTrue(object instanceof Boolean);
-        object = WrapperHelper.getWrappedPart("Parameter3", ok, "boolean");
-        assertTrue(object instanceof boolean[]);
-        assertTrue(((boolean[])object)[0]);
-        assertFalse(((boolean[])object)[1]);
         
-        WrapperHelper.setWrappedPart("Parameter1", ok, true);
+        List<String> partNames = Arrays.asList(new String[] {
+            "Parameter1",
+            "Parameter2",
+            "Parameter3"
+        });
+        List<String> elTypeNames = Arrays.asList(new String[] {
+            "boolean",
+            "int",
+            "boolean"
+        });
+        List<Class<?>> partClasses = Arrays.asList(new Class<?>[] {
+            Boolean.TYPE,
+            Integer.TYPE,
+            boolean[].class
+        });
+        
+        WrapperHelper wh = WrapperHelper.createWrapperHelper(SetIsOK.class,
+                                          partNames,
+                                          elTypeNames,
+                                          partClasses);
+        
+        List<Object> lst = wh.getWrapperParts(ok);
+        assertEquals(3, lst.size());
+        assertTrue(lst.get(0) instanceof Boolean);
+        assertTrue(lst.get(1) instanceof Integer);
+        
+        
+        assertTrue(lst.get(2) instanceof boolean[]);
+        assertTrue(((boolean[])lst.get(2))[0]);
+        assertFalse(((boolean[])lst.get(2))[1]);
+
+        lst.set(0, Boolean.TRUE);
+        Object o = wh.createWrapperObject(lst);
+        assertNotNull(0);
+        ok = (SetIsOK)o;
         assertTrue(ok.isParameter1());
-        WrapperHelper.setWrappedPart("Parameter3", ok, new boolean[] {false, true});
-        assertTrue(ok.getParameter3()[1]);
-        assertFalse(ok.getParameter3()[0]);        
+        assertTrue(ok.getParameter3()[0]);
+        assertFalse(ok.getParameter3()[1]);
     }
 
 
     @XmlAccessorType(XmlAccessType.FIELD)
     @XmlType(name = "", propOrder = { "parameter1", "parameter2", "parameter3" })
     @XmlRootElement(name = "setIsOK")
-    class SetIsOK {
+    public static class SetIsOK {
 
         @XmlElement(name = "Parameter1")
         protected boolean parameter1;

Modified: incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassInInterceptor.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassInInterceptor.java?view=diff&rev=552502&r1=552501&r2=552502
==============================================================================
--- incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassInInterceptor.java
(original)
+++ incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassInInterceptor.java
Mon Jul  2 07:27:48 2007
@@ -86,6 +86,7 @@
             }
             Class<?> wrapperClass = null;
             Object wrappedObject = null;
+            MessagePartInfo wrapperPart = null;
             if (wrappedMessageInfo != null) {
                 for (MessagePartInfo part : wrappedMessageInfo.getMessageParts()) {
                     //headers should appear in both, find the part that doesn't
@@ -94,6 +95,7 @@
                         for (Object o : lst) {
                             if (wrapperClass.isInstance(o)) {
                                 wrappedObject = o;
+                                wrapperPart = part;
                                 break;
                             }
                         }
@@ -116,36 +118,63 @@
                 return;
             }
             
-            List<Object> newParams = new ArrayList<Object>();
-            for (MessagePartInfo part : messageInfo.getMessageParts()) {
-                if (wrappedMessageInfo.getMessagePart(part.getName()) != null) {
-                    newParams.add(lst.get(part.getIndex()));
-                } else {
-                    try {
-                        String elementType = null;
-                        if (part.isElement()) {
-                            elementType = part.getElementQName().getLocalPart();
-                        } else {
-                            if (part.getTypeQName() == null) {
-                                // handling anonymous complex type
-                                elementType = null;
-                            } else {
-                                elementType = part.getTypeQName().getLocalPart();
-                            }
-                        }
-                        Object obj = WrapperHelper.getWrappedPart(part.getName().getLocalPart(),

-                                                                  wrappedObject,
-                                                                  elementType);
-                    
-                        newParams.add(obj);
-                    } catch (Exception e) {
-                        // TODO - fault
-                        throw new Fault(e);
+            WrapperHelper helper = wrapperPart.getProperty("WRAPPER_CLASS", WrapperHelper.class);
+            if (helper == null) {
+                helper = createWrapperHelper(messageInfo, wrappedMessageInfo, wrapperClass);
+                wrapperPart.setProperty("WRAPPER_CLASS", helper);
+            }            
+            List<Object> newParams;
+            try {
+                newParams = helper.getWrapperParts(wrappedObject);
+                
+                int idx = 0;
+                for (MessagePartInfo part : messageInfo.getMessageParts()) {
+                    if (wrappedMessageInfo.getMessagePart(part.getName()) != null) {
+                        newParams.set(idx, lst.get(part.getIndex()));
                     }
+                    ++idx;
                 }
+            } catch (Exception e) {
+                throw new Fault(e);
             }
+            
             message.setContent(List.class, newParams);
         }
     }
-
+    
+    private WrapperHelper createWrapperHelper(MessageInfo messageInfo,
+                                              MessageInfo wrappedMessageInfo,
+                                              Class<?> wrapperClass) {
+        List<String> partNames = new ArrayList<String>();
+        List<String> elTypeNames = new ArrayList<String>();
+        List<Class<?>> partClasses = new ArrayList<Class<?>>();
+        
+        for (MessagePartInfo p : messageInfo.getMessageParts()) {
+            if (wrappedMessageInfo.getMessagePart(p.getName()) != null) {
+                elTypeNames.add(null);
+                partClasses.add(null);
+                partNames.add(null);
+            } else {
+                String elementType = null;
+                if (p.isElement()) {
+                    elementType = p.getElementQName().getLocalPart();
+                } else {
+                    if (p.getTypeQName() == null) {
+                        // handling anonymous complex type
+                        elementType = null;
+                    } else {
+                        elementType = p.getTypeQName().getLocalPart();
+                    }
+                }
+                
+                elTypeNames.add(elementType);
+                partClasses.add(p.getClass());
+                partNames.add(p.getName().getLocalPart());
+            }
+        }
+        return WrapperHelper.createWrapperHelper(wrapperClass,
+                                                  partNames,
+                                                  elTypeNames,
+                                                  partClasses);
+    }
 }

Modified: incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassOutInterceptor.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassOutInterceptor.java?view=diff&rev=552502&r1=552501&r2=552502
==============================================================================
--- incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassOutInterceptor.java
(original)
+++ incubator/cxf/trunk/rt/frontend/jaxws/src/main/java/org/apache/cxf/jaxws/interceptors/WrapperClassOutInterceptor.java
Mon Jul  2 07:27:48 2007
@@ -65,23 +65,45 @@
 
         if (wrapped != null) {
             List<Object> objs = CastUtils.cast(message.getContent(List.class));
-            
-            try {
-                Object wrapperType = wrapped.newInstance();
-                int i = 0;
-                for (MessagePartInfo p : messageInfo.getMessageParts()) {
-                    Object part = objs.get(i);
 
-                    WrapperHelper.setWrappedPart(p.getName().getLocalPart(), wrapperType,
part);
-
-                    i++;
-                }
+            WrapperHelper helper = parts.get(0).getProperty("WRAPPER_CLASS", WrapperHelper.class);
+            if (helper == null) {
+                List<String> partNames = new ArrayList<String>();
+                List<String> elTypeNames = new ArrayList<String>();
+                List<Class<?>> partClasses = new ArrayList<Class<?>>();
                 
+                for (MessagePartInfo p : messageInfo.getMessageParts()) {
+                    partNames.add(p.getName().getLocalPart());
+                    
+                    String elementType = null;
+                    if (p.isElement()) {
+                        elementType = p.getElementQName().getLocalPart();
+                    } else {
+                        if (p.getTypeQName() == null) {
+                            // handling anonymous complex type
+                            elementType = null;
+                        } else {
+                            elementType = p.getTypeQName().getLocalPart();
+                        }
+                    }
+                    
+                    elTypeNames.add(elementType);
+                    partClasses.add(p.getClass());
+                }
+                helper = WrapperHelper.createWrapperHelper(wrapped,
+                                                           partNames,
+                                                           elTypeNames,
+                                                           partClasses);
+
+                parts.get(0).setProperty("WRAPPER_CLASS", helper);
+            }
+            try {
+                Object o2 = helper.createWrapperObject(objs);
                 objs = new ArrayList<Object>(1);
-                objs.add(wrapperType);
+                objs.add(o2);
                 message.setContent(List.class, objs);
-            } catch (Exception exc) {
-                throw new Fault(exc);
+            } catch (Exception e) {
+                throw new Fault(e);
             }
             
             // we've now wrapped the object, so use the wrapped binding op



Mime
View raw message