Move Tuscany from Incubator to top level.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68

12 files changed, 1912 insertions, 0 deletions

diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/module/DataBindingModuleActivator.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/module/DataBindingModuleActivator.java
new file mode 100644
index 0000000000..ea1afbfc49
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/module/DataBindingModuleActivator.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.module;
+
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ModuleActivator;
+import org.apache.tuscany.sca.core.databinding.processor.DataBindingJavaInterfaceProcessor;
+import org.apache.tuscany.sca.core.databinding.transformers.Array2ArrayTransformer;
+import org.apache.tuscany.sca.core.databinding.transformers.Exception2ExceptionTransformer;
+import org.apache.tuscany.sca.core.databinding.transformers.Input2InputTransformer;
+import org.apache.tuscany.sca.core.databinding.transformers.Output2OutputTransformer;
+import org.apache.tuscany.sca.core.databinding.wire.DataBindingRuntimeWireProcessor;
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.TransformerExtensionPoint;
+import org.apache.tuscany.sca.databinding.impl.Group2GroupTransformer;
+import org.apache.tuscany.sca.databinding.impl.MediatorImpl;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.runtime.RuntimeWireProcessorExtensionPoint;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class DataBindingModuleActivator implements ModuleActivator {
+
+    public void start(ExtensionPointRegistry registry) {
+        DataBindingExtensionPoint dataBindings = registry.getExtensionPoint(DataBindingExtensionPoint.class);
+        TransformerExtensionPoint transformers = registry.getExtensionPoint(TransformerExtensionPoint.class);
+        
+        MediatorImpl mediator = new MediatorImpl(dataBindings, transformers);
+        Input2InputTransformer input2InputTransformer = new Input2InputTransformer();
+        input2InputTransformer.setMediator(mediator);
+        transformers.addTransformer(input2InputTransformer, true);
+
+        Output2OutputTransformer output2OutputTransformer = new Output2OutputTransformer();
+        output2OutputTransformer.setMediator(mediator);
+        transformers.addTransformer(output2OutputTransformer, true);
+
+        Exception2ExceptionTransformer exception2ExceptionTransformer = new Exception2ExceptionTransformer();
+        exception2ExceptionTransformer.setMediator(mediator);
+        transformers.addTransformer(exception2ExceptionTransformer, true);
+        
+        Array2ArrayTransformer array2ArrayTransformer = new Array2ArrayTransformer();
+        array2ArrayTransformer.setMediator(mediator);
+        transformers.addTransformer(array2ArrayTransformer, true);
+
+        Group2GroupTransformer group2GroupTransformer = new Group2GroupTransformer();
+        group2GroupTransformer.setMediator(mediator);
+        transformers.addTransformer(group2GroupTransformer, true);
+
+        ModelFactoryExtensionPoint modelFactories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        JavaInterfaceFactory javaFactory = modelFactories.getFactory(JavaInterfaceFactory.class);
+        javaFactory.addInterfaceVisitor(new DataBindingJavaInterfaceProcessor(dataBindings));
+
+        RuntimeWireProcessorExtensionPoint wireProcessorExtensionPoint = registry.getExtensionPoint(RuntimeWireProcessorExtensionPoint.class);
+        if (wireProcessorExtensionPoint != null) {
+            wireProcessorExtensionPoint.addWireProcessor(new DataBindingRuntimeWireProcessor(mediator, dataBindings));
+        }
+
+    }
+
+    public void stop(ExtensionPointRegistry registry) {
+    }
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessor.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessor.java
new file mode 100644
index 0000000000..f9683d828d
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessor.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.processor;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.annotation.DataBinding;
+import org.apache.tuscany.sca.databinding.javabeans.JavaBeansDataBinding;
+import org.apache.tuscany.sca.databinding.javabeans.SimpleJavaDataBinding;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceVisitor;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * The databinding annotation processor for java interfaces
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DataBindingJavaInterfaceProcessor implements JavaInterfaceVisitor {
+    private DataBindingExtensionPoint dataBindingRegistry;
+
+    public DataBindingJavaInterfaceProcessor(@Reference
+    DataBindingExtensionPoint dataBindingRegistry) {
+        super();
+        this.dataBindingRegistry = dataBindingRegistry;
+    }
+
+    public void visitInterface(JavaInterface javaInterface) throws InvalidInterfaceException {
+        if (!javaInterface.isRemotable()) {
+            return;
+        }
+        List<Operation> operations = javaInterface.getOperations();
+        processInterface(javaInterface, operations);
+    }
+
+    private void processInterface(JavaInterface javaInterface, List<Operation> operations) {
+        Class<?> clazz = javaInterface.getJavaClass();
+        DataBinding dataBinding = clazz.getAnnotation(DataBinding.class);
+        String dataBindingId = null;
+        boolean wrapperStyle = false;
+        if (dataBinding != null) {
+            dataBindingId = dataBinding.value();
+            wrapperStyle = dataBinding.wrapped();
+        }
+
+        Map<String, Operation> opMap = new HashMap<String, Operation>();
+        for (Operation op : javaInterface.getOperations()) {
+            opMap.put(op.getName(), op);
+            if (dataBindingId != null) {
+                op.setDataBinding(dataBindingId);
+                op.setWrapperStyle(wrapperStyle);
+            }
+        }
+        for (Method method : clazz.getMethods()) {
+            if (method.getDeclaringClass() == Object.class) {
+                continue;
+            }
+            Operation operation = opMap.get(method.getName());
+            DataBinding methodDataBinding = clazz.getAnnotation(DataBinding.class);
+            if (methodDataBinding == null) {
+                methodDataBinding = dataBinding;
+            }
+            dataBindingId = null;
+            wrapperStyle = false;
+            if (dataBinding != null) {
+                dataBindingId = dataBinding.value();
+                wrapperStyle = dataBinding.wrapped();
+                operation.setDataBinding(dataBindingId);
+                operation.setWrapperStyle(wrapperStyle);
+            }
+
+            // FIXME: We need a better way to identify simple java types
+            int i = 0;
+            for (org.apache.tuscany.sca.interfacedef.DataType<?> d : operation.getInputType().getLogical()) {
+                if (d.getDataBinding() == null) {
+                    d.setDataBinding(dataBindingId);
+                }
+                for (Annotation a : method.getParameterAnnotations()[i]) {
+                    if (a.annotationType() == org.apache.tuscany.sca.databinding.annotation.DataType.class) {
+                        String value = ((org.apache.tuscany.sca.databinding.annotation.DataType)a).value();
+                        d.setDataBinding(value);
+                    }
+                }
+                dataBindingRegistry.introspectType(d, method.getParameterAnnotations()[i]);
+                i++;
+            }
+            if (operation.getOutputType() != null) {
+                DataType<?> d = operation.getOutputType();
+                if (d.getDataBinding() == null) {
+                    d.setDataBinding(dataBindingId);
+                }
+                org.apache.tuscany.sca.databinding.annotation.DataType dt =
+                    method.getAnnotation(org.apache.tuscany.sca.databinding.annotation.DataType.class);
+                if (dt != null) {
+                    d.setDataBinding(dt.value());
+                }
+                dataBindingRegistry.introspectType(d, method.getAnnotations());
+            }
+            for (org.apache.tuscany.sca.interfacedef.DataType<?> d : operation.getFaultTypes()) {
+                if (d.getDataBinding() == null) {
+                    d.setDataBinding(dataBindingId);
+                }
+                // TODO: Handle exceptions
+                dataBindingRegistry.introspectType(d, method.getAnnotations(), true);
+            }
+
+            // JIRA: TUSCANY-842
+            if (operation.getDataBinding() == null) {
+                assignOperationDataBinding(operation);
+            }
+
+            // FIXME: Do we want to heuristically check the wrapper style?
+            // introspectWrapperStyle(operation);
+        }
+    }
+
+    /*
+     *  Assigns an operation DB if one of the input types, output type, fault types has a non-default DB.
+     *  However, if two of the input types, output type, fault types have two different non-default DBs 
+     *  ( e.g. SDO and JAXB), then we do nothing to the operation DB.
+     *  
+     *  The method logic assumes the JavaBeans DataBinding is the default 
+     */
+    private void assignOperationDataBinding(Operation operation) {
+
+        String nonDefaultDataBindingName = null;
+
+        // Can't use DataType<?> since operation.getInputType() returns: DataType<List<DataType>> 
+        List<DataType> opDataTypes = new LinkedList<DataType>();
+
+        opDataTypes.addAll(operation.getInputType().getLogical());
+        opDataTypes.add(operation.getOutputType());
+        opDataTypes.addAll(operation.getFaultTypes());
+
+        for (DataType<?> d : opDataTypes) {
+            if (d != null) {
+                String dataBinding = d.getDataBinding();
+                // Assumes JavaBeans DB is default
+                if (dataBinding != null && !dataBinding.equals(JavaBeansDataBinding.NAME)
+                    && !dataBinding.equals(SimpleJavaDataBinding.NAME)) {
+                    if (nonDefaultDataBindingName != null) {
+                        if (!nonDefaultDataBindingName.equals(dataBinding)) {
+                            // We've seen two different non-default DBs, e.g. SDO and JAXB
+                            // so unset the string and break out of the loop 
+                            nonDefaultDataBindingName = null;
+                            break;
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        nonDefaultDataBindingName = dataBinding;
+                    }
+                }
+            }
+        }
+
+        // We have a DB worthy of promoting to operation level.
+        if (nonDefaultDataBindingName != null) {
+            operation.setDataBinding(nonDefaultDataBindingName);
+        }
+    }
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Array2ArrayTransformer.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Array2ArrayTransformer.java
new file mode 100644
index 0000000000..c138aba825
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Array2ArrayTransformer.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.core.databinding.transformers;
+
+import java.lang.reflect.Array;
+
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.databinding.impl.BaseTransformer;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * This is a special transformer to transform the output from one IDL to the
+ * other one
+ */
+public class Array2ArrayTransformer extends BaseTransformer<Object, Object> implements PullTransformer<Object, Object> {
+
+    protected Mediator mediator;
+
+    public Array2ArrayTransformer() {
+        super();
+    }
+
+    /**
+     * @param mediator the mediator to set
+     */
+    @Reference
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    @Override
+    public String getSourceDataBinding() {
+        return "java:array";
+    }
+
+    @Override
+    public String getTargetDataBinding() {
+        return "java:array";
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getSourceType()
+     */
+    @Override
+    protected Class getSourceType() {
+        return Object.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getTargetType()
+     */
+    @Override
+    protected Class getTargetType() {
+        return Object.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.Transformer#getWeight()
+     */
+    @Override
+    public int getWeight() {
+        return 10;
+    }
+
+    @SuppressWarnings("unchecked")
+    public Object transform(Object array, TransformationContext context) {
+        try {
+            if (array == null) {
+                return null;
+            }
+            DataType<DataType> sourceType = context.getSourceDataType();
+            DataType<DataType> targetType = context.getTargetDataType();
+            int length = Array.getLength(array);
+            Object targetArray = Array.newInstance(targetType.getPhysical().getComponentType(), length);
+            for (int i = 0; i < length; i++) {
+                Object sourceItem = Array.get(array, i);
+                Object targetItem =
+                    mediator.mediate(sourceItem, sourceType.getLogical(), targetType.getLogical(), context
+                        .getMetadata());
+                Array.set(targetArray, i, targetItem);
+            }
+            return targetArray;
+        } catch (Exception e) {
+            throw new TransformationException(e);
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Exception2ExceptionTransformer.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Exception2ExceptionTransformer.java
new file mode 100644
index 0000000000..d51d26a80b
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Exception2ExceptionTransformer.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.transformers;
+
+import org.apache.tuscany.sca.databinding.DataBinding;
+import org.apache.tuscany.sca.databinding.ExceptionHandler;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.impl.BaseTransformer;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * This is a special transformer to transform the exception from one IDL to the
+ * other one
+ */
+public class Exception2ExceptionTransformer extends BaseTransformer<Object[], Object[]> implements
+    PullTransformer<Exception, Exception> {
+
+    protected Mediator mediator;
+
+    public Exception2ExceptionTransformer() {
+        super();
+    }
+
+    @Override
+    public String getSourceDataBinding() {
+        return DataBinding.IDL_FAULT;
+    }
+
+    @Override
+    public String getTargetDataBinding() {
+        return DataBinding.IDL_FAULT;
+    }
+
+    /**
+     * @param mediator the mediator to set
+     */
+    @Reference
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getSourceType()
+     */
+    @Override
+    protected Class getSourceType() {
+        return Exception.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getTargetType()
+     */
+    @Override
+    protected Class getTargetType() {
+        return Exception.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.Transformer#getWeight()
+     */
+    @Override
+    public int getWeight() {
+        return 10000;
+    }
+
+    @SuppressWarnings("unchecked")
+    public Exception transform(Exception source, TransformationContext context) {
+        DataType<DataType> sourceType = context.getSourceDataType();
+
+        DataType<DataType> targetType = context.getTargetDataType();
+
+        ExceptionHandler exceptionHandler = getExceptionHandler(sourceType);
+        if (exceptionHandler == null) {
+            return source;
+        }
+
+        Object sourceFaultInfo = exceptionHandler.getFaultInfo(source);
+        Object targetFaultInfo =
+            mediator.mediate(sourceFaultInfo, sourceType.getLogical(), targetType.getLogical(), context.getMetadata());
+
+        ExceptionHandler targetHandler = getExceptionHandler(targetType);
+
+        if (targetHandler != null) {
+            Exception targetException =
+                targetHandler.createException(targetType, source.getMessage(), targetFaultInfo, source.getCause());
+            return targetException;
+        }
+
+        // FIXME
+        return source;
+
+    }
+
+    private ExceptionHandler getExceptionHandler(DataType<DataType> targetType) {
+        DataType targetFaultType = (DataType)targetType.getLogical();
+        DataBinding targetDataBinding =
+            mediator.getDataBindings().getDataBinding(targetFaultType.getDataBinding());
+        if (targetDataBinding == null) {
+            return null;
+        }
+        ExceptionHandler targetHandler = targetDataBinding.getExceptionHandler();
+        return targetHandler;
+    }
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Input2InputTransformer.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Input2InputTransformer.java
new file mode 100644
index 0000000000..2effaaa95a
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Input2InputTransformer.java
@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.transformers;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.tuscany.sca.databinding.DataBinding;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.databinding.WrapperHandler;
+import org.apache.tuscany.sca.databinding.impl.BaseTransformer;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.util.ElementInfo;
+import org.apache.tuscany.sca.interfacedef.util.WrapperInfo;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * This is a special transformer to transform the input from one IDL to the
+ * other one
+ */
+public class Input2InputTransformer extends BaseTransformer<Object[], Object[]> implements
+    PullTransformer<Object[], Object[]> {
+    private static final Logger logger = Logger.getLogger(Input2InputTransformer.class.getName());
+
+    protected Mediator mediator;
+
+    public Input2InputTransformer() {
+        super();
+    }
+
+    @Override
+    public String getSourceDataBinding() {
+        return DataBinding.IDL_INPUT;
+    }
+
+    @Override
+    public String getTargetDataBinding() {
+        return DataBinding.IDL_INPUT;
+    }
+
+    /**
+     * @param mediator the mediator to set
+     */
+    @Reference
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getSourceType()
+     */
+    @Override
+    protected Class getSourceType() {
+        return Object[].class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getTargetType()
+     */
+    @Override
+    protected Class getTargetType() {
+        return Object[].class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.Transformer#getWeight()
+     */
+    @Override
+    public int getWeight() {
+        return 10000;
+    }
+
+    @SuppressWarnings("unchecked")
+    public Object[] transform(Object[] source, TransformationContext context) {
+        DataType<List<DataType>> sourceType = context.getSourceDataType();
+        Operation sourceOp = context.getSourceOperation();
+        boolean sourceWrapped = sourceOp != null && sourceOp.isWrapperStyle();
+
+        WrapperHandler sourceWrapperHandler = null;
+        String sourceDataBinding = getDataBinding(sourceOp);
+        sourceWrapperHandler = getWrapperHandler(sourceDataBinding, sourceWrapped);
+
+        DataType<List<DataType>> targetType = context.getTargetDataType();
+        Operation targetOp = (Operation)context.getTargetOperation();
+        boolean targetWrapped = targetOp != null && targetOp.isWrapperStyle();
+        WrapperHandler targetWrapperHandler = null;
+        String targetDataBinding = getDataBinding(targetOp);
+        targetWrapperHandler = getWrapperHandler(targetDataBinding, targetWrapped);
+
+        if ((!sourceWrapped) && targetWrapped) {
+            // Unwrapped --> Wrapped
+            WrapperInfo wrapper = targetOp.getWrapper();
+            ElementInfo wrapperElement = wrapper.getInputWrapperElement();
+
+            if (source == null) {
+                Object targetWrapper = targetWrapperHandler.create(wrapperElement, context);
+                return new Object[] {targetWrapper};
+            }
+
+            // If the source can be wrapped, wrapped it first
+            if (sourceWrapperHandler != null) {
+                DataType sourceWrapperType =
+                    sourceWrapperHandler.getWrapperType(wrapperElement, wrapper.getInputChildElements(), context);
+                if (sourceWrapperType != null) {
+                    Object sourceWrapper = sourceWrapperHandler.create(wrapperElement, context);
+                    if (sourceWrapper != null) {
+                        for (int i = 0; i < source.length; i++) {
+                            ElementInfo argElement = wrapper.getInputChildElements().get(i);
+                            sourceWrapperHandler.setChild(sourceWrapper, i, argElement, source[i]);
+                        }
+                        Object targetWrapper =
+                            mediator.mediate(sourceWrapper, sourceWrapperType, targetType.getLogical().get(0), context
+                                .getMetadata());
+                        return new Object[] {targetWrapper};
+                    }
+                }
+            }
+            // Fall back to child by child transformation
+            Object targetWrapper = targetWrapperHandler.create(wrapperElement, context);
+            List<DataType> argTypes = wrapper.getUnwrappedInputType().getLogical();
+
+            for (int i = 0; i < source.length; i++) {
+                ElementInfo argElement = wrapper.getInputChildElements().get(i);
+                DataType<XMLType> argType = argTypes.get(i);
+                Object child = source[i];
+                child = mediator.mediate(source[i], sourceType.getLogical().get(i), argType, context.getMetadata());
+                targetWrapperHandler.setChild(targetWrapper, i, argElement, child);
+            }
+            return new Object[] {targetWrapper};
+
+        } else if (sourceWrapped && (!targetWrapped)) {
+            // Wrapped to Unwrapped
+            Object sourceWrapper = source[0];
+            Object[] target = null;
+
+            List<ElementInfo> childElements = sourceOp.getWrapper().getInputChildElements();
+            if (targetWrapperHandler != null) {
+                ElementInfo wrapperElement = sourceOp.getWrapper().getInputWrapperElement();
+                // FIXME: This is a workaround for the wsdless support as it passes in child elements
+                // under the wrapper that only matches by position
+                if (sourceWrapperHandler.isInstance(sourceWrapper, wrapperElement, childElements, context)) {
+                    DataType targetWrapperType =
+                        targetWrapperHandler.getWrapperType(wrapperElement, childElements, context);
+                    if (targetWrapperType != null) {
+                        Object targetWrapper =
+                            mediator.mediate(sourceWrapper, sourceType.getLogical().get(0), targetWrapperType, context
+                                .getMetadata());
+                        target = targetWrapperHandler.getChildren(targetWrapper, childElements, context).toArray();
+                        return target;
+                    }
+                }
+            }
+            Object[] sourceChildren = sourceWrapperHandler.getChildren(sourceWrapper, childElements, context).toArray();
+            target = new Object[sourceChildren.length];
+            for (int i = 0; i < sourceChildren.length; i++) {
+                DataType<XMLType> childType = sourceOp.getWrapper().getUnwrappedInputType().getLogical().get(i);
+                target[i] =
+                    mediator.mediate(sourceChildren[i], childType, targetType.getLogical().get(i), context
+                        .getMetadata());
+            }
+            return target;
+        } else {
+            // Assuming wrapper to wrapper conversion can be handled here as well
+            Object[] newArgs = new Object[source.length];
+            for (int i = 0; i < source.length; i++) {
+                Object child =
+                    mediator.mediate(source[i], sourceType.getLogical().get(i), targetType.getLogical().get(i), context
+                        .getMetadata());
+                newArgs[i] = child;
+            }
+            return newArgs;
+        }
+    }
+
+    private WrapperHandler getWrapperHandler(String dataBindingId, boolean required) {
+        WrapperHandler wrapperHandler = null;
+        if (dataBindingId != null) {
+            DataBinding dataBinding = mediator.getDataBindings().getDataBinding(dataBindingId);
+            wrapperHandler = dataBinding == null ? null : dataBinding.getWrapperHandler();
+        }
+        if (wrapperHandler == null && required) {
+            throw new TransformationException("No wrapper handler is provided for databinding: " + dataBindingId);
+        }
+        return wrapperHandler;
+    }
+
+    private String getDataBinding(Operation operation) {
+        return operation.getDataBinding();
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Output2OutputTransformer.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Output2OutputTransformer.java
new file mode 100644
index 0000000000..d057207991
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/transformers/Output2OutputTransformer.java
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.core.databinding.transformers;
+
+import java.util.List;
+
+import org.apache.tuscany.sca.databinding.DataBinding;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.PullTransformer;
+import org.apache.tuscany.sca.databinding.TransformationContext;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.databinding.WrapperHandler;
+import org.apache.tuscany.sca.databinding.impl.BaseTransformer;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.util.ElementInfo;
+import org.apache.tuscany.sca.interfacedef.util.WrapperInfo;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+import org.osoa.sca.annotations.Reference;
+
+/**
+ * This is a special transformer to transform the output from one IDL to the
+ * other one
+ */
+public class Output2OutputTransformer extends BaseTransformer<Object, Object> implements
+    PullTransformer<Object, Object> {
+
+    protected Mediator mediator;
+
+    /**
+     * @param wrapperHandler
+     */
+    public Output2OutputTransformer() {
+        super();
+    }
+
+    /**
+     * @param mediator the mediator to set
+     */
+    @Reference
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    @Override
+    public String getSourceDataBinding() {
+        return DataBinding.IDL_OUTPUT;
+    }
+
+    @Override
+    public String getTargetDataBinding() {
+        return DataBinding.IDL_OUTPUT;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getSourceType()
+     */
+    @Override
+    protected Class getSourceType() {
+        return Object.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.impl.BaseTransformer#getTargetType()
+     */
+    @Override
+    protected Class getTargetType() {
+        return Object.class;
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.databinding.Transformer#getWeight()
+     */
+    @Override
+    public int getWeight() {
+        return 10;
+    }
+
+    private String getDataBinding(Operation operation) {
+        return operation.getDataBinding();
+    }
+
+    private WrapperHandler getWrapperHandler(String dataBindingId, boolean required) {
+        WrapperHandler wrapperHandler = null;
+        if (dataBindingId != null) {
+            DataBinding dataBinding = mediator.getDataBindings().getDataBinding(dataBindingId);
+            wrapperHandler = dataBinding == null ? null : dataBinding.getWrapperHandler();
+        }
+        if (wrapperHandler == null && required) {
+            throw new TransformationException("No wrapper handler is provided for databinding: " + dataBindingId);
+        }
+        return wrapperHandler;
+    }
+
+    @SuppressWarnings("unchecked")
+    public Object transform(Object response, TransformationContext context) {
+        try {
+            DataType<DataType> sourceType = context.getSourceDataType();
+            Operation sourceOp = context.getSourceOperation();
+            boolean sourceWrapped = sourceOp != null && sourceOp.isWrapperStyle();
+
+            WrapperHandler sourceWrapperHandler = null;
+            String sourceDataBinding = getDataBinding(sourceOp);
+            sourceWrapperHandler = getWrapperHandler(sourceDataBinding, sourceWrapped);
+
+            DataType<DataType> targetType = context.getTargetDataType();
+            Operation targetOp = (Operation)context.getTargetOperation();
+            boolean targetWrapped = targetOp != null && targetOp.isWrapperStyle();
+            WrapperHandler targetWrapperHandler = null;
+            String targetDataBinding = getDataBinding(targetOp);
+            targetWrapperHandler = getWrapperHandler(targetDataBinding, targetWrapped);
+
+            if ((!sourceWrapped) && targetWrapped) {
+                // Unwrapped --> Wrapped
+                WrapperInfo wrapper = targetOp.getWrapper();
+                ElementInfo wrapperElement = wrapper.getOutputWrapperElement();
+                List<ElementInfo> childElements = wrapper.getOutputChildElements();
+
+                // If the source can be wrapped, wrapped it first
+                if (sourceWrapperHandler != null) {
+                    DataType sourceWrapperType =
+                        sourceWrapperHandler.getWrapperType(wrapperElement, childElements, context);
+                    if (sourceWrapperType != null) {
+                        Object sourceWrapper = sourceWrapperHandler.create(wrapperElement, context);
+                        if (sourceWrapper != null) {
+                            if (!childElements.isEmpty()) {
+                                // Set the return value
+                                ElementInfo returnElement = wrapper.getOutputChildElements().get(0);
+                                sourceWrapperHandler.setChild(sourceWrapper, 0, returnElement, response);
+                            }
+                            Object targetWrapper =
+                                mediator.mediate(sourceWrapper, sourceWrapperType, targetType.getLogical(), context
+                                    .getMetadata());
+                            return targetWrapper;
+                        }
+                    }
+                }
+                Object targetWrapper = targetWrapperHandler.create(wrapper.getOutputWrapperElement(), context);
+
+                if (childElements.isEmpty()) {
+                    // void output
+                    return targetWrapper;
+                }
+                ElementInfo argElement = childElements.get(0);
+                DataType<XMLType> argType = wrapper.getUnwrappedOutputType();
+                Object child = response;
+                child = mediator.mediate(response, sourceType.getLogical(), argType, context.getMetadata());
+                targetWrapperHandler.setChild(targetWrapper, 0, argElement, child);
+                return targetWrapper;
+            } else if (sourceWrapped && (!targetWrapped)) {
+                // Wrapped to Unwrapped
+                Object sourceWrapper = response;
+                List<ElementInfo> childElements = sourceOp.getWrapper().getOutputChildElements();
+                if (childElements.isEmpty()) {
+                    // The void output
+                    return null;
+                }
+                if (targetWrapperHandler != null) {
+                    ElementInfo wrapperElement = sourceOp.getWrapper().getOutputWrapperElement();
+
+                    // FIXME: This is a workaround for the wsdless support as it passes in child elements
+                    // under the wrapper that only matches by position
+                    if (sourceWrapperHandler.isInstance(sourceWrapper, wrapperElement, childElements, context)) {
+                        DataType targetWrapperType =
+                            targetWrapperHandler.getWrapperType(wrapperElement, childElements, context);
+                        if (targetWrapperType != null) {
+                            Object targetWrapper =
+                                mediator.mediate(sourceWrapper, sourceType.getLogical(), targetWrapperType, context
+                                    .getMetadata());
+                            return targetWrapperHandler.getChildren(targetWrapper, childElements, context).get(0);
+                        }
+                    }
+                }
+                Object child = sourceWrapperHandler.getChildren(sourceWrapper, childElements, context).get(0);
+                DataType<?> childType = sourceOp.getWrapper().getUnwrappedOutputType();
+                return mediator.mediate(child, childType, targetType.getLogical(), context.getMetadata());
+            } else {
+                // FIXME: Do we want to handle wrapped to wrapped?
+                return mediator.mediate(response, sourceType.getLogical(), targetType.getLogical(), context
+                    .getMetadata());
+            }
+        } catch (Exception e) {
+            throw new TransformationException(e);
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataBindingRuntimeWireProcessor.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataBindingRuntimeWireProcessor.java
new file mode 100644
index 0000000000..d0a2dbc003
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataBindingRuntimeWireProcessor.java
@@ -0,0 +1,220 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.wire;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.InvocationChain;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+import org.apache.tuscany.sca.runtime.RuntimeWireProcessor;
+
+/**
+ * This processor is responsible to add an interceptor to invocation chain if
+ * the source and target operations have different databinding requirements
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DataBindingRuntimeWireProcessor implements RuntimeWireProcessor {
+    private Mediator mediator;
+    private DataBindingExtensionPoint dataBindings;
+
+    public DataBindingRuntimeWireProcessor(Mediator mediator, DataBindingExtensionPoint dataBindings) {
+        super();
+        this.mediator = mediator;
+        this.dataBindings = dataBindings;
+    }
+
+    public boolean isTransformationRequired(DataType source, DataType target) {
+        if (source == null || target == null) { // void return type
+            return false;
+        }
+        if (source == target) {
+            return false;
+        }
+        
+        // Output type can be null
+        if (source == null && target == null) {
+            return false;
+        } else if (source == null || target == null) {
+            return true;
+        }
+        String sourceDataBinding = source.getDataBinding();
+        String targetDataBinding = target.getDataBinding();
+        if (sourceDataBinding == targetDataBinding) {
+            return false;
+        }
+        if (sourceDataBinding == null || targetDataBinding == null) {
+            // TODO: If any of the databinding is null, then no transformation
+            return false;
+        }
+        return !sourceDataBinding.equals(targetDataBinding);
+    }
+
+    public boolean isTransformationRequired(Operation source, Operation target) {
+        if (source == target) {
+            return false;
+        }
+        
+        if (source.isWrapperStyle() != target.isWrapperStyle()) {
+            return true;
+        }
+
+        // Check output type
+        DataType sourceOutputType = source.getOutputType();
+        DataType targetOutputType = target.getOutputType();
+
+        // Note the target output type is now the source for checking
+        // compatibility
+        if (isTransformationRequired(targetOutputType, sourceOutputType)) {
+            return true;
+        }
+
+        List<DataType> sourceInputType = source.getInputType().getLogical();
+        List<DataType> targetInputType = target.getInputType().getLogical();
+
+        int size = sourceInputType.size();
+        if (size != targetInputType.size()) {
+            // TUSCANY-1682: The wrapper style may have different arguments
+            return true;
+        }
+        for (int i = 0; i < size; i++) {
+            if (isTransformationRequired(sourceInputType.get(i), targetInputType.get(i))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean isTransformationRequired(InterfaceContract sourceContract,
+                                             Operation sourceOperation,
+                                             InterfaceContract targetContract,
+                                             Operation targetOperation) {
+        if (targetContract == null) {
+            targetContract = sourceContract;
+        }
+        if (sourceContract == targetContract) {
+            return false;
+        }
+        return isTransformationRequired(sourceOperation, targetOperation);
+    }
+
+    public void process(RuntimeWire wire) {
+        InterfaceContract sourceContract = wire.getSource().getInterfaceContract();
+        InterfaceContract targetContract = wire.getTarget().getInterfaceContract();
+        if (targetContract == null) {
+            targetContract = sourceContract;
+        }
+
+        if (!sourceContract.getInterface().isRemotable()) {
+            return;
+        }
+        List<InvocationChain> chains = wire.getInvocationChains();
+        for (InvocationChain chain : chains) {
+            Operation sourceOperation = chain.getSourceOperation();
+            Operation targetOperation = chain.getTargetOperation();
+
+            Interceptor interceptor = null;
+            if (isTransformationRequired(sourceContract, sourceOperation, targetContract, targetOperation)) {
+                // Add the interceptor to the source side because multiple
+                // references can be wired to the same service
+                interceptor = new DataTransformationInterceptor(wire, sourceOperation, targetOperation, mediator);
+            } else {
+                // assume pass-by-values copies are required if interfaces are remotable and there is no data binding
+                // transformation, i.e. a transformation will result in a copy so another pass-by-value copy is unnecessary
+                if (requiresCopy(wire, sourceOperation, targetOperation)) {
+                    interceptor = new PassByValueInterceptor(dataBindings, targetOperation);
+                }
+            }
+            if (interceptor != null) {
+                chain.addInterceptor(0, interceptor);
+            }
+        }
+
+    }
+
+    /**
+     * Pass-by-value copies are required if the interfaces are remotable unless the
+     * implementation uses the @AllowsPassByReference annotation.
+     */
+    protected boolean requiresCopy(RuntimeWire wire, Operation sourceOperation, Operation targetOperation) {
+        if (!sourceOperation.getInterface().isRemotable()) {
+            return false;
+        }
+        if (!targetOperation.getInterface().isRemotable()) {
+            return false;
+        }
+
+        if (allowsPassByReference(wire.getSource().getComponent(), sourceOperation)) {
+            return false;
+        }
+        
+        if (allowsPassByReference(wire.getTarget().getComponent(), sourceOperation)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Does the implementation use the @AllowsPassByReference annotation for the operation.
+     * Uses reflection to avoid a dependency on JavaImplementation because the isAllowsPassByReference
+     * and getAllowsPassByReference methods are not on the Implementation interface.
+     * TODO: move isAllowsPassByReference/getAllowsPassByReference to Implementation interface 
+     */
+    protected boolean allowsPassByReference(RuntimeComponent component, Operation operation) {
+        if (component == null || component.getImplementation() == null) {
+            return true; // err on the side of no copies
+        }
+        Implementation impl = component.getImplementation();
+        try {
+
+            Method m = impl.getClass().getMethod("isAllowsPassByReference", new Class[] {});
+            if ((Boolean)m.invoke(impl, new Object[]{})) {
+                return true;
+            }
+
+            m = impl.getClass().getMethod("getAllowsPassByReferenceMethods", new Class[] {});
+            List<Method> ms = (List<Method>)m.invoke(impl, new Object[]{});
+            if (ms != null) {
+                for (Method m2 : ms) {
+                    // simple name matching is ok as its a remote operation so no overloading 
+                    if (operation.getName().equals(m2.getName()))
+                        return true;
+                }
+            }
+            
+        } catch (Exception e) {
+            // ignore, assume the impl has no isAllowsPassByReference method
+        }
+
+        return false;
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataTransformationInterceptor.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataTransformationInterceptor.java
new file mode 100644
index 0000000000..461e281a82
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/DataTransformationInterceptor.java
@@ -0,0 +1,257 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.wire;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.databinding.DataBinding;
+import org.apache.tuscany.sca.databinding.ExceptionHandler;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.TransformationException;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl;
+import org.apache.tuscany.sca.interfacedef.util.FaultException;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+
+/**
+ * An interceptor to transform data accross databindings on the wire
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DataTransformationInterceptor implements Interceptor {
+    private Invoker next;
+
+    private Operation sourceOperation;
+
+    private Operation targetOperation;
+    private RuntimeWire wire;
+    private Mediator mediator;
+
+    public DataTransformationInterceptor(RuntimeWire wire,
+                                         Operation sourceOperation,
+                                         Operation targetOperation,
+                                         Mediator mediator) {
+        super();
+        this.sourceOperation = sourceOperation;
+        this.targetOperation = targetOperation;
+        this.mediator = mediator;
+        this.wire = wire;
+    }
+
+    public Invoker getNext() {
+        return next;
+    }
+
+    public Message invoke(Message msg) {
+        Object input = transform(msg.getBody(), sourceOperation.getInputType(), targetOperation.getInputType(), false);
+        msg.setBody(input);
+        Message resultMsg = next.invoke(msg);
+        Object result = resultMsg.getBody();
+        if (sourceOperation.isNonBlocking()) {
+            // Not to reset the message body
+            return resultMsg;
+        }
+
+        // FIXME: Should we fix the Operation model so that getOutputType
+        // returns DataType<DataType<T>>?
+        DataType<DataType> targetType =
+            new DataTypeImpl<DataType>(DataBinding.IDL_OUTPUT, Object.class, targetOperation.getOutputType());
+
+        DataType<DataType> sourceType =
+            new DataTypeImpl<DataType>(DataBinding.IDL_OUTPUT, Object.class, sourceOperation.getOutputType());
+
+        if (resultMsg.isFault()) {
+
+            // FIXME: We need to figure out what fault type it is and then
+            // transform it
+            // back the source fault type
+            // throw new InvocationRuntimeException((Throwable) result);
+
+            if ((result instanceof Exception) && !(result instanceof RuntimeException)) {
+                // FIXME: How to match fault data to a fault type for the
+                // operation?
+
+                // If the result is from an InvocationTargetException look at
+                // the actual cause.
+                if (result instanceof InvocationTargetException) {
+                    result = ((InvocationTargetException)result).getCause();
+                }
+                DataType targetDataType = null;
+                for (DataType exType : targetOperation.getFaultTypes()) {
+                    if (((Class)exType.getPhysical()).isInstance(result)) {
+                        if (result instanceof FaultException) {
+                            if (((FaultException)result).isMatchingType(exType.getLogical())) {
+                                targetDataType = exType;
+                                break;
+                            }
+                        } else {
+                            targetDataType = exType;
+                            break;
+                        }
+                    }
+                }
+
+                if (targetDataType == null) {
+                    // Not a business exception
+                    return resultMsg;
+                }
+
+                DataType targetFaultType = getFaultType(targetDataType);
+                if (targetFaultType == null) {
+                    throw new TransformationException("Target fault type cannot be resolved: " + targetDataType);
+                }
+
+                // FIXME: How to match a source fault type to a target fault
+                // type?
+                DataType sourceDataType = null;
+                DataType sourceFaultType = null;
+                for (DataType exType : sourceOperation.getFaultTypes()) {
+                    DataType faultType = getFaultType(exType);
+                    // Match by the QName (XSD element) of the fault type
+                    if (faultType != null && typesMatch(targetFaultType.getLogical(), faultType.getLogical())) {
+                        sourceDataType = exType;
+                        sourceFaultType = faultType;
+                        break;
+                    }
+                }
+
+                if (sourceFaultType == null) {
+                    throw new TransformationException("No matching source fault type is found: " + targetFaultType);
+                }
+
+                Object newResult =
+                    transformException(result, targetDataType, sourceDataType, targetFaultType, sourceFaultType);
+                if (newResult != result) {
+                    resultMsg.setFaultBody(newResult);
+                }
+            }
+
+        } else {
+            assert !(result instanceof Throwable) : "Expected messages that are not throwable " + result;
+
+            Object newResult = transform(result, targetType, sourceType, true);
+            if (newResult != result) {
+                resultMsg.setBody(newResult);
+            }
+        }
+
+        return resultMsg;
+    }
+
+    private Object transform(Object source, DataType sourceType, DataType targetType, boolean isResponse) {
+        if (sourceType == targetType || (sourceType != null && sourceType.equals(targetType))) {
+            return source;
+        }
+        Map<String, Object> metadata = new HashMap<String, Object>();
+        metadata.put("source.operation", isResponse ? targetOperation : sourceOperation);
+        metadata.put("target.operation", isResponse ? sourceOperation : targetOperation);
+        metadata.put("wire", wire);
+        return mediator.mediate(source, sourceType, targetType, metadata);
+    }
+
+    private DataType getFaultType(DataType exceptionType) {
+        // FIXME: We cannot assume the exception will have a databinding set
+        DataBinding targetDataBinding = mediator.getDataBindings().getDataBinding(exceptionType.getDataBinding());
+        if (targetDataBinding == null) {
+            return null;
+        }
+        ExceptionHandler targetHandler = targetDataBinding.getExceptionHandler();
+        if (targetHandler == null) {
+            return null;
+        }
+        return targetHandler.getFaultType(exceptionType);
+    }
+
+    private boolean typesMatch(Object first, Object second) {
+        if (first.equals(second)) {
+            return true;
+        }
+        if (first instanceof XMLType && second instanceof XMLType) {
+            XMLType t1 = (XMLType)first;
+            XMLType t2 = (XMLType)second;
+            return matches(t1.getElementName(), t2.getElementName()) && matches(t1.getTypeName(), t2.getTypeName());
+        }
+        return false;
+    }
+
+    /**
+     * @param qn1
+     * @param qn2
+     */
+    private boolean matches(QName qn1, QName qn2) {
+        if (qn1 == qn2) {
+            return true;
+        }
+        if (qn1 == null || qn2 == null) {
+            return false;
+        }
+        String ns1 = qn1.getNamespaceURI();
+        String ns2 = qn2.getNamespaceURI();
+        String e1 = qn1.getLocalPart();
+        String e2 = qn2.getLocalPart();
+        if (e1.equals(e2) && (ns1.equals(ns2) || ns1.equals(ns2 + "/") || ns2.equals(ns1 + "/"))) {
+            // Tolerating the trailing / which is required by JAX-WS java package --> xml ns mapping
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param source The source exception
+     * @param sourceExType The data type for the source exception
+     * @param targetExType The data type for the target exception
+     * @param sourceType The fault type for the source
+     * @param targetType The fault type for the target
+     * @return
+     */
+    private Object transformException(Object source,
+                                      DataType sourceExType,
+                                      DataType targetExType,
+                                      DataType sourceType,
+                                      DataType targetType) {
+        if (sourceType == targetType || (sourceType != null && sourceType.equals(targetType))) {
+            return source;
+        }
+        Map<String, Object> metadata = new HashMap<String, Object>();
+        metadata.put("source.operation", targetOperation);
+        metadata.put("target.operation", sourceOperation);
+        metadata.put("wire", wire);
+        DataType<DataType> eSourceDataType =
+            new DataTypeImpl<DataType>("idl:fault", sourceExType.getPhysical(), sourceType);
+        DataType<DataType> eTargetDataType =
+            new DataTypeImpl<DataType>("idl:fault", targetExType.getPhysical(), targetType);
+
+        return mediator.mediate(source, eSourceDataType, eTargetDataType, metadata);
+    }
+
+    public void setNext(Invoker next) {
+        this.next = next;
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/PassByValueInterceptor.java b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/PassByValueInterceptor.java
new file mode 100644
index 0000000000..0e3f3947ec
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/java/org/apache/tuscany/sca/core/databinding/wire/PassByValueInterceptor.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.wire;
+
+import java.io.Serializable;
+import java.lang.reflect.Array;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.databinding.DataBinding;
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.javabeans.JavaBeansDataBinding;
+import org.apache.tuscany.sca.databinding.jaxb.JAXBDataBinding;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+
+/**
+ * Implementation of an interceptor that enforces pass-by-value semantics
+ * on operation invocations by copying the operation input and output data.
+ *
+ * @version $Rev$ $Date$
+ */
+public class PassByValueInterceptor implements Interceptor {
+
+    private DataBindingExtensionPoint dataBindings;
+    private DataBinding[] inputDataBindings;
+    private DataBinding outputDataBinding;
+    private DataBinding javaBeanDataBinding;
+    private DataBinding jaxbDataBinding;
+    private Operation operation;
+    private Invoker nextInvoker;
+
+    /**
+     * Constructs a new PassByValueInterceptor.
+     * @param dataBindings databinding extension point
+     * @param operation the intercepted operation
+     */
+    public PassByValueInterceptor(DataBindingExtensionPoint dataBindings, Operation operation) {
+        this.operation = operation;
+        
+        // Cache data bindings to use
+        this.dataBindings = dataBindings;
+        jaxbDataBinding = dataBindings.getDataBinding(JAXBDataBinding.NAME);
+        javaBeanDataBinding = dataBindings.getDataBinding(JavaBeansDataBinding.NAME);
+        
+        // Determine the input databindings
+        if (operation.getInputType() != null) {
+            List<DataType> inputTypes = operation.getInputType().getLogical();
+            inputDataBindings = new DataBinding[inputTypes.size()];
+            int i = 0;
+            for (DataType inputType: inputTypes) {
+                String id = inputType.getDataBinding(); 
+                inputDataBindings[i++] = dataBindings.getDataBinding(id);
+            }
+        }
+        
+        // Determine the output databinding
+        if (operation.getOutputType() != null) {
+            String id = operation.getOutputType().getDataBinding();
+            outputDataBinding = dataBindings.getDataBinding(id);
+        }
+    }
+
+    public Message invoke(Message msg) {
+        msg.setBody(copy((Object[])msg.getBody(), inputDataBindings));
+
+        Message resultMsg = nextInvoker.invoke(msg);
+
+        if (!msg.isFault() && operation.getOutputType() != null) {
+            resultMsg.setBody(copy(resultMsg.getBody(), outputDataBinding));
+        }
+        return resultMsg;
+    }
+
+    /**
+     * Copy an array of data objects passed to an operation
+     * @param data array of objects to copy
+     * @return the copy
+     */
+    private Object[] copy(Object[] data, DataBinding[] dataBindings) {
+        if (data == null) {
+            return null;
+        }
+        Object[] copy = new Object[data.length];
+        Map<Object, Object> map = new IdentityHashMap<Object, Object>();
+        for (int i = 0; i < data.length; i++) {
+            Object arg = data[i];
+            if (arg == null) {
+                copy[i] = null;
+            } else {
+                Object copiedArg = map.get(arg);
+                if (copiedArg != null) {
+                    copy[i] = copiedArg;
+                } else {
+                    copiedArg = copy(arg, dataBindings[i]);
+                    map.put(arg, copiedArg);
+                    copy[i] = copiedArg;
+                }
+            }
+        }
+        return copy;
+    }
+
+    /**
+     * Copy data using the specified databinding.
+     * @param data input data
+     * @param dataBinding databinding to use
+     * @return a copy of the data
+     */
+    private Object copy(Object data, DataBinding dataBinding) {
+        if (data == null) {
+            return null;
+        }
+
+        // If no databinding was specified, introspect the given arg to
+        // determine its databinding
+        if (dataBinding == null) {
+            DataType<?> dataType = dataBindings.introspectType(data);
+            if (dataType != null) {
+                String db = dataType.getDataBinding();
+                dataBinding = dataBindings.getDataBinding(db);
+                if (dataBinding == null && db != null) {
+                    return data;
+                }
+            }
+            if (dataBinding == null) {
+                
+                // Default to the JavaBean databinding
+                dataBinding = javaBeanDataBinding;            
+            }
+        }
+        
+        // Use the JAXB databinding to copy non-Serializable data
+        if (dataBinding == javaBeanDataBinding) {
+            
+            // If the input data is an array containing non serializable elements
+            // use JAXB
+            Class<?> clazz = data.getClass();
+            if (clazz.isArray()) {
+                if (Array.getLength(data) != 0) {
+                    Object element = Array.get(data, 0);
+                    if (element != null && !(element instanceof Serializable)) {
+                        dataBinding = jaxbDataBinding;
+                    }
+                }
+            } else {
+
+                // If the input data is not serializable use JAXB
+                if (!(data instanceof Serializable)) {
+                    dataBinding = jaxbDataBinding;
+                }
+            }
+        }
+        
+        Object copy = dataBinding.copy(data);
+        return copy;
+    }
+
+    public Invoker getNext() {
+        return nextInvoker;
+    }
+
+    public void setNext(Invoker next) {
+        this.nextInvoker = next;
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator b/branches/sca-java-1.1/modules/core-databinding/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
new file mode 100644
index 0000000000..baba638c9b
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one

+# or more contributor license agreements.  See the NOTICE file

+# distributed with this work for additional information

+# regarding copyright ownership.  The ASF licenses this file

+# to you under the Apache License, Version 2.0 (the

+# "License"); you may not use this file except in compliance

+# with the License.  You may obtain a copy of the License at

+# 

+#   http://www.apache.org/licenses/LICENSE-2.0

+# 

+# Unless required by applicable law or agreed to in writing,

+# software distributed under the License is distributed on an

+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+# KIND, either express or implied.  See the License for the

+# specific language governing permissions and limitations

+# under the License. 

+# Implementation class for the ExtensionActivator

+org.apache.tuscany.sca.core.databinding.module.DataBindingModuleActivator

diff --git a/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessorTestCase.java b/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessorTestCase.java
new file mode 100644
index 0000000000..c5ab064716
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/processor/DataBindingJavaInterfaceProcessorTestCase.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.core.databinding.processor;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.DefaultDataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.annotation.DataBinding;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
+import org.apache.tuscany.sca.interfacedef.java.DefaultJavaInterfaceFactory;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.osoa.sca.annotations.Remotable;
+import org.w3c.dom.Node;
+
+/**
+ * 
+ */
+public class DataBindingJavaInterfaceProcessorTestCase extends TestCase {
+
+    /**
+     * @see junit.framework.TestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+    }
+
+    /**
+     * @throws InvalidServiceContractException
+     */
+    public final void testVisitInterface() throws InvalidInterfaceException {
+        DataBindingExtensionPoint registry = new DefaultDataBindingExtensionPoint();
+        DataBindingJavaInterfaceProcessor processor = new DataBindingJavaInterfaceProcessor(registry);
+        JavaInterfaceFactory javaFactory = new DefaultJavaInterfaceFactory();
+        
+        JavaInterface contract = javaFactory.createJavaInterface();
+        contract.setJavaClass(MockInterface.class);
+        JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract();
+        interfaceContract.setInterface(contract);
+        Operation operation = new OperationImpl("call");
+        Operation operation1 = new OperationImpl("call1");
+        contract.getOperations().add(operation);
+        contract.getOperations().add(operation1);
+        contract.setRemotable(true);
+        processor.visitInterface(contract);
+        // Assert.assertEquals("org.w3c.dom.Node", contract.getDataBinding());
+        // Assert.assertEquals("org.w3c.dom.Node",
+        // contract.getOperations().get("call").getDataBinding());
+        // Assert.assertEquals("xml:string",
+        // contract.getOperations().get("call1").getDataBinding());
+    }
+
+    @DataBinding("org.w3c.dom.Node")
+    @Remotable
+    public static interface MockInterface {
+        Node call(Node msg);
+
+        @DataBinding("xml:string")
+        String call1(String msg);
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/transformers/IDLTransformerTestCase.java.fixme b/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/transformers/IDLTransformerTestCase.java.fixme
new file mode 100644
index 0000000000..ecae54188c
--- /dev/null
+++ b/branches/sca-java-1.1/modules/core-databinding/src/test/java/org/apache/tuscany/sca/core/databinding/transformers/IDLTransformerTestCase.java.fixme
@@ -0,0 +1,229 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.core.databinding.transformers;
+
+import static org.apache.tuscany.spi.databinding.DataBinding.IDL_INPUT;
+import static org.apache.tuscany.spi.databinding.DataBinding.IDL_OUTPUT;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.namespace.QName;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.databinding.impl.DataBindingRegistryImpl;
+import org.apache.tuscany.databinding.impl.MediatorImpl;
+import org.apache.tuscany.databinding.impl.TransformationContextImpl;
+import org.apache.tuscany.databinding.impl.TransformerRegistryImpl;
+import org.apache.tuscany.databinding.javabeans.DOMNode2JavaBeanTransformer;
+import org.apache.tuscany.databinding.javabeans.JavaBean2DOMNodeTransformer;
+import org.apache.tuscany.databinding.xml.DOMDataBinding;
+import org.apache.tuscany.databinding.xml.Node2String;
+import org.apache.tuscany.databinding.xml.String2Node;
+import org.apache.tuscany.interfacedef.DataType;
+import org.apache.tuscany.interfacedef.Operation;
+import org.apache.tuscany.interfacedef.impl.DataTypeImpl;
+import org.apache.tuscany.interfacedef.impl.OperationImpl;
+import org.apache.tuscany.interfacedef.util.ElementInfo;
+import org.apache.tuscany.interfacedef.util.TypeInfo;
+import org.apache.tuscany.interfacedef.util.WrapperInfo;
+import org.apache.tuscany.interfacedef.util.XMLType;
+import org.apache.tuscany.spi.databinding.DataBindingRegistry;
+import org.apache.tuscany.spi.databinding.TransformationContext;
+import org.apache.tuscany.spi.databinding.extension.DOMHelper;
+import org.apache.tuscany.spi.databinding.extension.SimpleTypeMapperExtension;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+public class IDLTransformerTestCase extends TestCase {
+    private static final String IPO_XML = "<?xml version=\"1.0\"?>" + "<order1"
+                                          + "  xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                                          + "  xmlns:ipo=\"http://www.example.com/IPO\""
+                                          + "  xsi:schemaLocation=\"http://www.example.com/IPO ipo.xsd\""
+                                          + "  orderDate=\"1999-12-01\">"
+                                          + "  <shipTo exportCode=\"1\" xsi:type=\"ipo:UKAddress\">"
+                                          + "    <name>Helen Zoe</name>"
+                                          + "    <street>47 Eden Street</street>"
+                                          + "    <city>Cambridge</city>"
+                                          + "    <postcode>CB1 1JR</postcode>"
+                                          + "  </shipTo>"
+                                          + "  <billTo xsi:type=\"ipo:USAddress\">"
+                                          + "    <name>Robert Smith</name>"
+                                          + "    <street>8 Oak Avenue</street>"
+                                          + "    <city>Old Town</city>"
+                                          + "    <state>PA</state>"
+                                          + "    <zip>95819</zip>"
+                                          + "  </billTo>"
+                                          + "  <items>"
+                                          + "    <item partNum=\"833-AA\">"
+                                          + "      <productName>Lapis necklace</productName>"
+                                          + "      <quantity>1</quantity>"
+                                          + "      <USPrice>99.95</USPrice>"
+                                          + "      <ipo:comment>Want this for the holidays</ipo:comment>"
+                                          + "      <shipDate>1999-12-05</shipDate>"
+                                          + "    </item>"
+                                          + "  </items>"
+                                          + "</order1>";
+
+    private static final String URI_ORDER_XSD = "http://example.com/order.xsd";
+
+    /**
+     * @see junit.framework.TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+    }
+
+    public void testTransform() throws Exception {
+        List<DataType> types0 = new ArrayList<DataType>();
+        DataType<XMLType> wrapperType = new DataTypeImpl<XMLType>(null, Object.class,
+                                                                  new XMLType(new QName(URI_ORDER_XSD,
+                                                                                        "checkOrderStatus"), null));
+        types0.add(wrapperType);
+        DataType<List<DataType>> inputType0 = new DataTypeImpl<List<DataType>>(IDL_INPUT,
+                                                                                                 Object[].class, types0);
+
+        List<DataType> types1 = new ArrayList<DataType>();
+        DataType<XMLType> customerIdType = new DataTypeImpl<XMLType>(
+                                                                     null,
+                                                                     Object.class,
+                                                                     new XMLType(
+                                                                                 new QName(URI_ORDER_XSD, "customerId"),
+                                                                                 null));
+        DataType<XMLType> orderType = new DataTypeImpl<XMLType>(null, Object.class,
+                                                                new XMLType(new QName(URI_ORDER_XSD, "order"), null));
+        DataType<XMLType> flagType = new DataTypeImpl<XMLType>(null, Object.class, new XMLType(new QName(URI_ORDER_XSD,
+                                                                                                         "flag"), null));
+        types1.add(customerIdType);
+        types1.add(orderType);
+        types1.add(flagType);
+
+        DataType<XMLType> statusType = new DataTypeImpl<XMLType>(null, Object.class,
+                                                                 new XMLType(new QName(URI_ORDER_XSD, "status"), null));
+        DataType<XMLType> responseType = new DataTypeImpl<XMLType>(null, Object.class,
+                                                                   new XMLType(new QName(URI_ORDER_XSD,
+                                                                                         "checkOrderStatusResponse"),
+                                                                               null));
+
+        Operation op = new OperationImpl("checkOrderStatus");
+        op.setInputType(inputType0);
+        op.setOutputType(responseType);
+//        op.setDataBinding(DOMDataBinding.NAME);
+//
+//        inputType0.setOperation(op);
+        op.setWrapperStyle(true);
+        ElementInfo inputElement = new ElementInfo(new QName(URI_ORDER_XSD, "checkOrderStatus"), new TypeInfo(null,
+                                                                                                              false,
+                                                                                                              null));
+//        wrapperType.setMetadata(ElementInfo.class.getName(), inputElement);
+
+        ElementInfo customerId = new ElementInfo(new QName("", "customerId"),
+                                                 SimpleTypeMapperExtension.XSD_SIMPLE_TYPES.get("string"));
+        ElementInfo order = new ElementInfo(new QName("", "order"), new TypeInfo(new QName(URI_ORDER_XSD), false, null));
+        ElementInfo flag = new ElementInfo(new QName("", "flag"), SimpleTypeMapperExtension.XSD_SIMPLE_TYPES.get("int"));
+
+//        customerIdType.setMetadata(ElementInfo.class.getName(), customerId);
+//        orderType.setMetadata(ElementInfo.class.getName(), order);
+//        flagType.setMetadata(ElementInfo.class.getName(), flag);
+//
+//        customerIdType.setOperation(op);
+//        orderType.setOperation(op);
+//        flagType.setOperation(op);
+
+        List<ElementInfo> inputElements = new ArrayList<ElementInfo>();
+        inputElements.add(customerId);
+        inputElements.add(order);
+        inputElements.add(flag);
+
+        ElementInfo statusElement = new ElementInfo(new QName("", "status"), SimpleTypeMapperExtension.XSD_SIMPLE_TYPES
+            .get("string"));
+
+//        statusType.setMetadata(ElementInfo.class.getName(), statusElement);
+//        statusType.setOperation(op);
+
+        List<ElementInfo> outputElements = new ArrayList<ElementInfo>();
+        outputElements.add(statusElement);
+
+        ElementInfo outputElement = new ElementInfo(new QName(URI_ORDER_XSD, "checkOrderStatusResponse"),
+                                                    new TypeInfo(null, false, null));
+
+//        responseType.setMetadata(ElementInfo.class.getName(), inputElement);
+//        responseType.setOperation(op);
+
+        WrapperInfo wrapperInfo = new WrapperInfo(DOMDataBinding.NAME, inputElement, outputElement, inputElements,
+                                                  outputElements);
+        op.setWrapper(wrapperInfo);
+//        op.setDataBinding(DOMDataBinding.NAME);
+
+        MediatorImpl m = new MediatorImpl();
+        TransformerRegistryImpl tr = new TransformerRegistryImpl();
+        tr.registerTransformer(new String2Node());
+        tr.registerTransformer(new Node2String());
+        tr.registerTransformer(new DOMNode2JavaBeanTransformer());
+        tr.registerTransformer(new JavaBean2DOMNodeTransformer());
+        m.setTransformerRegistry(tr);
+        DataBindingRegistry dataBindingRegistry = new DataBindingRegistryImpl();
+        dataBindingRegistry.register(new DOMDataBinding());
+        m.setDataBindingRegistry(dataBindingRegistry);
+
+        Object[] source = new Object[] {"cust001", IPO_XML, Integer.valueOf(1)};
+        Input2InputTransformer t = new Input2InputTransformer();
+        t.setMediator(m);
+
+        TransformationContext context = new TransformationContextImpl();
+        context.setSourceOperation(op);
+        List<DataType<Class>> types = new ArrayList<DataType<Class>>();
+        types.add(new DataTypeImpl<Class>(Object.class.getName(), String.class, String.class));
+        types.add(new DataTypeImpl<Class>("java.lang.String", String.class, String.class));
+        types.add(new DataTypeImpl<Class>(Object.class.getName(), int.class, int.class));
+        DataType<List<DataType<Class>>> inputType1 = new DataTypeImpl<List<DataType<Class>>>(IDL_INPUT, Object[].class,
+                                                                                             types);
+        context.setSourceDataType(inputType1);
+        context.setTargetDataType(op.getInputType());
+        Object[] results = t.transform(source, context);
+        assertEquals(1, results.length);
+        assertTrue(results[0] instanceof Element);
+        Element element = (Element)results[0];
+        assertEquals("http://example.com/order.xsd", element.getNamespaceURI());
+        assertEquals("checkOrderStatus", element.getLocalName());
+
+        TransformationContext context1 = new TransformationContextImpl();
+        DataType<DataType> sourceType = new DataTypeImpl<DataType>(IDL_OUTPUT, Object.class, op.getOutputType());
+
+        context1.setSourceDataType(sourceType);
+        DataType<DataType> targetType = new DataTypeImpl<DataType>(IDL_OUTPUT, Object.class,
+                                                                   new DataTypeImpl<Class>("java.lang.Object",
+                                                                                           String.class, String.class));
+        context1.setTargetDataType(targetType);
+
+        Document factory = DOMHelper.newDocument();
+        Element responseElement = factory
+            .createElementNS("http://example.com/order.wsdl", "p:checkOrderStatusResponse");
+        Element status = factory.createElement("status");
+        responseElement.appendChild(status);
+        status.appendChild(factory.createTextNode("shipped"));
+        Output2OutputTransformer t2 = new Output2OutputTransformer();
+        t2.setMediator(m);
+        Object st = t2.transform(responseElement, context1);
+        assertEquals("shipped", st);
+
+    }
+
+}