Move Tuscany from Incubator to top level.

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

9 files changed, 1464 insertions, 0 deletions

diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/Makefile.am b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/Makefile.am
new file mode 100644
index 0000000000..208af0e15a
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/Makefile.am
@@ -0,0 +1,49 @@
+#  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.
+
+libdir=$(prefix)/extensions/ws/reference/lib
+lib_LTLIBRARIES = libtuscany_sca_ws_reference.la
+
+noinst_HEADERS = tuscany/sca/ws/*.h tuscany/sca/ws/model/*.h
+
+libtuscany_sca_ws_reference_la_SOURCES = \
+tuscany/sca/ws/WSServiceBindingExtension.cpp \
+tuscany/sca/ws/model/WSServiceBinding.cpp \
+tuscany/sca/ws/WSServiceWrapper.cpp \
+tuscany/sca/ws/Axis2Client.cpp
+
+libtuscany_sca_ws_reference_la_LIBADD = \
+	-L${TUSCANY_SDOCPP}/lib -ltuscany_sdo -ltuscany_sdo_axiom \
+					-L$(top_builddir)/runtime/core/src -ltuscany_sca \
+	                -L$(AXIS2C_HOME)/lib \
+					-laxis2_util \
+                    -laxis2_axiom \
+                    -laxis2_wsdl \
+                    -laxis2_engine \
+                    -laxis2_parser \
+                    -laxis2_minizip \
+                    -lpthread \
+                    -lwoden \
+                    -laxis2_http_sender \
+                    -laxis2_http_receiver
+
+INCLUDES = -I$(top_builddir)/runtime/core/src \
+           -I${TUSCANY_SDOCPP}/include \
+           -I${AXIS2C_HOME}/include
+                   
+AM_CPPFLAGS = $(CPPFLAGS) -D_DEBUG
+                   
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.cpp b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.cpp
new file mode 100644
index 0000000000..4dfb3e7efd
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.cpp
@@ -0,0 +1,717 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+
+#if defined(WIN32)  || defined (_WINDOWS)
+#pragma warning(disable: 4091)
+#pragma warning(disable: 4786)
+#endif
+
+#include <axis2_client.h>
+
+#include <axis2_error_default.h>
+#include <axis2_log_default.h>
+#include <axis2_defines.h>
+#include <axiom_soap_const.h>
+#include <platforms/axis2_platform_auto_sense.h>
+
+#include <sdo_axiom.h>
+#include "Axis2Client.h"
+
+#include "tuscany/sca/core/SCARuntime.h"
+#include "tuscany/sca/util/Logging.h"
+#include "tuscany/sca/util/Utils.h"
+#include "model/WSServiceBinding.h"
+#include "tuscany/sca/util/Utils.h"
+#include "tuscany/sca/util/Exceptions.h"
+#include "tuscany/sca/model/Service.h"
+#include "tuscany/sca/model/ServiceType.h"
+#include "tuscany/sca/model/Composite.h"
+#include "tuscany/sca/model/WSDLDefinition.h"
+#include "tuscany/sca/model/WSDLInterface.h"
+#include "tuscany/sca/model/WSDLOperation.h"
+
+#include <sstream>
+
+using namespace tuscany::sca::ws;
+
+
+using namespace commonj::sdo;
+using namespace commonj::sdo_axiom;
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+            
+            Axis2Client::Axis2Client(CompositeReference* compositeReference)
+                : compositeReference(compositeReference)
+            {
+            }
+            
+            Axis2Client::~Axis2Client()
+            {
+            }
+            
+            void Axis2Client::invoke(tuscany::sca::Operation& operation)
+            {
+                LOGENTRY(1, "Axis2Client::invoke");
+
+                // Initialize Axis2 stuff
+                axis2_allocator_t *allocator = axis2_allocator_init (NULL);
+                axis2_log_t *log = axis2_log_create(allocator, NULL, "tuscany_client.log");
+                axis2_error_t *error = axis2_error_create(allocator);
+                axis2_env_t *env = axis2_env_create_with_error_log(allocator, error, log);
+                env->log->level = AXIS2_LOG_LEVEL_TRACE;
+                axis2_error_init();
+                
+                // Get the WS service binding and WSDLOperation
+                Composite* composite=compositeReference->getComposite();
+                Service* service = compositeReference->getService();
+                WSServiceBinding* binding = (WSServiceBinding *)service->getBinding();
+                const string& operationName = operation.getName();
+                WSDLOperation wsdlOperation;
+                
+                // Get the WSDL namespace
+                string wsdlNamespace = binding->getWSDLNamespaceURL();
+                if (wsdlNamespace != "")
+                {
+                
+                    // Lookup the wsdl model from the composite, keyed on the namespace 
+                    // (the wsdl will have been loaded at startup)
+                    WSDLDefinition* wsdlDefinition = composite->findWSDLDefinition(wsdlNamespace);
+                    if (wsdlDefinition == 0)
+                    {
+                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,  "WSDL description %s not found\n", wsdlNamespace.c_str());
+                        string msg = "WSDL not found for " + wsdlNamespace;
+                        throw SystemConfigurationException(msg.c_str());
+                    }
+                    
+                    // Match the operation in Operation to the operation in the wsdl port type.
+                    try
+                    {
+                        wsdlOperation =  wsdlDefinition->findOperation(
+                            binding->getServiceName(),
+                            binding->getEndpointName(),
+                            operationName);
+                    }
+                    catch(SystemConfigurationException &ex)
+                    {   
+                        AXIS2_LOG_ERROR((env)->log, AXIS2_LOG_SI, "SystemConfigurationException has been caught: %s\n", ex.getMessageText());
+                        throw;
+                    }
+                    
+                }
+                else
+                {
+                    Interface* iface = service->getType()->getInterface();
+                    if (iface != NULL &&
+                        iface->getInterfaceTypeQName() == WSDLInterface::typeQName)
+                    {
+                        WSDLInterface* wsdlInterface = (WSDLInterface*)iface;
+                        wsdlNamespace = wsdlInterface->getNamespaceURI();
+                        
+                        if (wsdlNamespace != "")
+                        {
+                            
+                            WSDLDefinition* wsdl = composite->findWSDLDefinition(wsdlNamespace);
+                            if (wsdl == 0)
+                            {
+                                AXIS2_LOG_ERROR((env)->log, AXIS2_LOG_SI, "WSDL description %s not found\n", wsdlNamespace.c_str());
+                                string msg = "WSDL not found for " + wsdlNamespace;
+                                throw SystemConfigurationException(msg.c_str());
+                            }
+                    
+                            try
+                            {
+                                wsdlOperation = wsdl->findOperation(wsdlInterface->getName(), operationName);
+                            }
+                            catch(SystemConfigurationException &ex)
+                            {   
+                                AXIS2_LOG_ERROR((env)->log, AXIS2_LOG_SI, "SystemConfigurationException has been caught: %s\n", ex.getMessageText());
+                                throw;
+                            }
+                        }
+                    }
+                }
+                
+                if (wsdlNamespace == "")
+                {
+                    
+                    // Create a default document literal wrapped WSDL operation
+                    wsdlNamespace = compositeReference->getName();
+                    wsdlOperation = WSDLOperation();
+                    wsdlOperation.setOperationName(operationName);
+                    wsdlOperation.setSoapAction(wsdlNamespace+ "#" +operationName);
+                    wsdlOperation.setEndpoint("");
+                    wsdlOperation.setSoapVersion(WSDLOperation::SOAP11);
+                    wsdlOperation.setDocumentStyle(true);
+                    wsdlOperation.setWrappedStyle(true);
+                    wsdlOperation.setEncoded(false);
+                    wsdlOperation.setInputType(wsdlNamespace + "#" + operationName);
+                    wsdlOperation.setOutputType(wsdlNamespace + "#" + operationName + "Response");
+                }
+                    
+                // Get the target endpoint address
+                // The URI specified in the binding overrides the address specified in
+                // the WSDL
+                axis2_char_t* address;
+                if (binding->getURI() != "")
+                {
+                    address = (axis2_char_t*)binding->getURI().c_str();
+                }
+                else
+                {
+                    address = (axis2_char_t*)wsdlOperation.getEndpoint().c_str();
+                }
+                
+                axis2_char_t* opName = (axis2_char_t*)operationName.c_str();
+                axis2_char_t* soap_action = (axis2_char_t*)wsdlOperation.getSoapAction().c_str();
+                axis2_char_t* serviceName = (axis2_char_t*)binding->getServiceName().c_str();
+                
+                // create OM from Operation and wsdlOperation
+                axiom_node_t* payload = createPayload(operation, wsdlOperation, env);
+                
+                /* Create EPR with given address */
+                axis2_endpoint_ref_t* endpoint_ref = axis2_endpoint_ref_create(env, address);
+                
+                /* Setup options */
+                axis2_options_t* options = axis2_options_create(env);
+                AXIS2_OPTIONS_SET_TO(options, env, endpoint_ref);
+                int soap_version = AXIOM_SOAP11;
+                if (binding->getSOAPVersion() == "1.2")
+                {
+                    soap_version = AXIOM_SOAP12;
+                }
+                else
+                {
+                    if (wsdlOperation.getSoapVersion() == WSDLOperation::SOAP12)
+                    {
+                        soap_version = AXIOM_SOAP12;
+                    }
+                }
+                
+                AXIS2_OPTIONS_SET_SOAP_VERSION(options, env, soap_version);
+                AXIS2_OPTIONS_SET_ACTION(options, env, soap_action);
+                
+                /* Create service client */
+                
+                axis2_char_t* client_home = AXIS2_GETENV("AXIS2C_HOME");
+                if (!client_home)
+                {
+                    throw SystemConfigurationException("Environment error: AXIS2C_HOME not set");
+                }
+                axis2_svc_client_t* svc_client = axis2_svc_client_create(env, client_home);
+                if (!svc_client)
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "invoke FAILED: Error code:"
+                        " %d :: %s", env->error->error_number,
+                        AXIS2_ERROR_GET_MESSAGE(env->error));
+                    
+                    throw SystemConfigurationException("Axis2Client: axis2_svc_client_create failed");
+                }
+                
+                /* Set service client options */
+                AXIS2_SVC_CLIENT_SET_OPTIONS(svc_client, env, options);    
+                
+                /* Send request */
+                axiom_node_t* ret_node = AXIS2_SVC_CLIENT_SEND_RECEIVE(svc_client, env, payload);
+                if(ret_node)
+                {
+                    setReturn(ret_node, operation, wsdlOperation, env);
+                }
+                else
+                {
+                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoke failed: Error code:"
+                        " %d :: %s", env->error->error_number,
+                        AXIS2_ERROR_GET_MESSAGE(env->error));
+                    throw SystemConfigurationException("Axis2Client: Invoke failed");
+                }
+                
+                LOGINFO(2, "Warning: Have not freed Axis2C service client memory due to Jira AXIS2C-209");
+                // Uncommenting this code causes crash when invoking a composite with both Axis2C ws.binding 
+                // service and reference. See Jiras TUSCANY-536 and AXIS2C-209
+                //if (svc_client)
+                //{
+                //    AXIS2_SVC_CLIENT_FREE(svc_client, env);
+                //    svc_client = NULL;
+                //} 
+                
+                LOGEXIT(1, "Axis2Client::invoke");
+            }
+            
+            axiom_node_t* Axis2Client::createPayload(Operation& operation, 
+                const WSDLOperation& wsdlOperation,
+                axis2_env_t* env)
+            {	
+                LOGENTRY(1, "Axis2Client::createPayload");
+                axiom_node_t* request_node = NULL;
+                
+                // map the operation request to the wsdl
+                if (wsdlOperation.isDocumentStyle())
+                {
+                    // Document style 
+                    // only support single part messages - WS-I compliant
+                    
+                    // Build up the payload as an SDO
+                    
+                    // Get the data factory for the composite (it will already have the typecreates loaded for the xsds)
+                    DataFactoryPtr dataFactory = compositeReference->getComposite()->getDataFactory();
+                    
+                    DataObjectPtr inputDataObject;
+                    try
+                    {
+                        
+                        // Create the input wrapper
+                        const Type& rootType = dataFactory->getType(wsdlOperation.getInputTypeUri().c_str(), "RootType");
+                        const Property& prop = rootType.getProperty(wsdlOperation.getInputTypeName().c_str());
+                        const Type& inputType = prop.getType();
+                        inputDataObject = dataFactory->create(inputType);
+                    }
+                    catch (SDORuntimeException e)
+                    {
+                        try
+                        {
+                            // Create the input wrapper
+                            const Type& inputType = dataFactory->getType(wsdlOperation.getInputTypeUri().c_str(), 
+                                wsdlOperation.getInputTypeName().c_str());
+                            inputDataObject = dataFactory->create(inputType);
+                        }
+                        catch (SDORuntimeException e2)
+                        {
+                            
+                            // The input wrapper type is not known, create an open DataObject 
+                            inputDataObject = dataFactory->create(Type::SDOTypeNamespaceURI, "OpenDataObject");
+                        }
+                    }
+                            
+                    // Go through data object to set the input parameters
+                    PropertyList pl = inputDataObject->getType().getProperties();
+                
+                    if(pl.size() == 0)
+                    {
+                        if(inputDataObject->getType().isOpenType() && inputDataObject->getType().isDataObjectType())
+                        {
+                            /*
+                             * This code deals with sending xsd:any elements
+                             */
+                            for (int i=0; i<operation.getNParms(); i++)
+                            {
+                                ostringstream pname;
+                                pname << "param" << (i+1);
+                                DataObjectList& l = inputDataObject->getList(pname.str());
+                                
+                                const Operation::Parameter& parm = operation.getParameter(i);
+                                switch(parm.getType())
+                                {
+                                case Operation::BOOL: 
+                                    {
+                                        l.append(*(bool*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::SHORT: 
+                                    {
+                                        l.append(*(short*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::INT: 
+                                    {
+                                        l.append(*(long*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::LONG: 
+                                    {
+                                        l.append(*(long*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::USHORT: 
+                                    {
+                                        l.append(*(short*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::UINT: 
+                                    {
+                                        l.append(*(long*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::ULONG: 
+                                    {
+                                        l.append(*(long*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::FLOAT: 
+                                    {
+                                        l.append(*(float*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::DOUBLE: 
+                                    {
+                                        l.append(*(long double*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::LONGDOUBLE: 
+                                    {
+                                        l.append(*(long double*)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::CHARS: 
+                                    {
+                                        l.append(*(char**)parm.getValue());
+                                        break;
+                                    }
+                                case Operation::STRING: 
+                                    {
+                                        l.append((*(string*)parm.getValue()).c_str());
+                                        break;
+                                    }
+                                case Operation::DATAOBJECT: 
+                                    {
+                                        l.append(*(DataObjectPtr*)parm.getValue());
+                                        break;
+                                    }
+                                default: throw "unsupported parameter type";
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        
+                        // Each parameter in the operation should be a property on the request dataobject
+                        for (int i=0; i<operation.getNParms(); i++)
+                        {
+                            const Operation::Parameter& parm = operation.getParameter(i);
+                            switch(parm.getType())
+                            {
+                            case Operation::BOOL: 
+                                {
+                                    inputDataObject->setBoolean(i, *(bool*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::SHORT: 
+                                {
+                                    inputDataObject->setShort(i, *(short*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::INT: 
+                                {
+                                    inputDataObject->setInteger(i, *(int*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::LONG: 
+                                {
+                                    inputDataObject->setLong(i, *(long*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::USHORT: 
+                                {
+                                    inputDataObject->setInteger(i, *(unsigned short*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::UINT: 
+                                {
+                                    inputDataObject->setInteger(i, *(unsigned int*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::ULONG: 
+                                {
+                                    inputDataObject->setInteger(i, *(unsigned long*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::FLOAT: 
+                                {
+                                    inputDataObject->setFloat(i, *(float*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::DOUBLE: 
+                                {
+                                    inputDataObject->setDouble(i, *(double*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::LONGDOUBLE: 
+                                {
+                                    inputDataObject->setDouble(i, *(long double*)parm.getValue());
+                                    break;
+                                }
+                            case Operation::CHARS: 
+                                {
+                                    inputDataObject->setCString(i, *(char**)parm.getValue());
+                                    break;
+                                }
+                            case Operation::STRING: 
+                                {
+                                    inputDataObject->setCString(i, (*(string*)parm.getValue()).c_str());
+                                    break;
+                                }
+                            case Operation::DATAOBJECT: 
+                                {
+                                    inputDataObject->setDataObject(i, *(DataObjectPtr*)parm.getValue());
+                                    break;
+                                }
+                            default: throw "unsupported parameter type";
+                            }
+                        }
+                    }
+                    
+                    // Create the Axiom object from the request dataobject
+                    AxiomHelper* axiomHelper = AxiomHelper::getHelper();
+                    request_node = axiomHelper->toAxiomNode(inputDataObject,
+                        wsdlOperation.getInputTypeUri().c_str(), wsdlOperation.getInputTypeName().c_str());
+                    AxiomHelper::releaseHelper(axiomHelper);
+                }
+                else
+                {
+                    // RPC
+                }
+                
+                char* str =  AXIOM_NODE_TO_STRING(request_node, env);
+                LOGINFO_1(3, "Sending this OM node in XML : %s \n",  str); 
+                
+                LOGEXIT(1, "Axis2Client::createPayload");
+                return request_node;
+             }
+             
+             void Axis2Client::setReturn(axiom_node_t* ret_node,
+                 Operation& operation, 
+                 const WSDLOperation& wsdlOperation,
+                 axis2_env_t* env)
+             {	
+                 LOGENTRY(1, "Axis2Client::setReturn");
+                 
+                 if (wsdlOperation.isDocumentStyle())
+                 {
+                     // Document style 
+                    DataFactoryPtr dataFactory = compositeReference->getComposite()->getDataFactory();
+
+                    // Get the AXIOM node representing the SOAP Body 
+                    axiom_node_t* body = AXIOM_NODE_GET_PARENT(ret_node, env);
+                     
+                    // Convert the AXIOM node to an SDO DataObject
+                    char* str = NULL;
+                    str = AXIOM_NODE_TO_STRING(body, env);
+                    if (str)
+                    {
+                        AXIS2_LOG_INFO((env)->log, "Axis2Client invoke has response OM: %s\n", str);
+                    }
+
+                    // Convert the SOAP body to an SDO DataObject
+                    AxiomHelper* axiomHelper = AxiomHelper::getHelper();
+                    DataObjectPtr outputBodyDataObject = axiomHelper->toSdo(body, dataFactory);
+                    AxiomHelper::releaseHelper(axiomHelper);
+
+                    if(!outputBodyDataObject)
+                    {
+                        AXIS2_LOG_ERROR((env)->log, AXIS2_LOG_SI, "Axis2Service invoke: Could not convert received Axiom node to SDO");
+                        /** TODO: return a SOAP fault here */
+                        return;
+                    }                    
+
+                    // Get the first body part representing the doc-lit-wrapped wrapper element
+                    DataObjectPtr outputDataObject = NULL; 
+                    PropertyList bpl = outputBodyDataObject->getInstanceProperties();
+                    if (bpl.size()!=0)
+                    {
+                        if (bpl[0].isMany())
+                        {
+                            DataObjectList& parts = outputBodyDataObject->getList((unsigned int)0);
+                            outputDataObject = parts[0];
+                        }
+                        else
+                        {
+                            outputDataObject = outputBodyDataObject->getDataObject(bpl[0]);
+                        }
+                    }
+                    if (outputDataObject == NULL)
+                    {
+                        AXIS2_LOG_ERROR((env)->log, AXIS2_LOG_SI, "Axis2Client invoke: Could not convert body part to SDO");
+                        return;
+                    }
+                     
+                    PropertyList pl = outputDataObject->getInstanceProperties();
+                    unsigned int i = 0;
+                     
+                    switch(pl[i].getTypeEnum())
+                    {
+                    case Type::BooleanType:
+                        {
+                            bool* boolData = new bool;
+                            *boolData = outputDataObject->getBoolean(pl[i]);
+                            operation.setReturnValue(boolData);
+                        }
+                        break;
+                    case Type::ByteType:
+                        {
+                            char* byteData = new char;
+                            *byteData = outputDataObject->getByte(pl[i]);
+                            operation.setReturnValue(byteData);
+                        }
+                        break;
+                    case Type::BytesType:
+                        {
+                            int len = outputDataObject->getLength(pl[i]);
+                            char* bytesData = new char[len+1];
+                            int bytesWritten = outputDataObject->getBytes(pl[i], bytesData, len);
+                            // Ensure the bytes end with the null char. Not sure if this is neccessary
+                            if(bytesWritten <= len)
+                            {
+                                bytesData[bytesWritten] = 0;
+                            }
+                            else
+                            {
+                                bytesData[len] = 0;
+                            }
+                            //printf("outputDataObject has BytesType named %s with length %d\n", name, bytesWritten);
+                            operation.setReturnValue(&bytesData);
+                        }
+                        break;
+                    case Type::CharacterType:
+                        {
+                            // This code should work but won't be used as there is no mapping from an XSD type to the SDO CharacterType
+                            wchar_t* charData = new wchar_t;
+                            *charData = outputDataObject->getCharacter(pl[i]);
+                            operation.setReturnValue(charData);
+                        }
+                        break;
+                    case Type::DoubleType:
+                        {
+                            long double* doubleData = new long double;
+                            *doubleData = outputDataObject->getDouble(pl[i]);
+                            operation.setReturnValue(doubleData);
+                        }
+                        break;
+                    case Type::FloatType:
+                        {
+                            float* floatData = new float;
+                            *floatData = outputDataObject->getFloat(pl[i]);
+                            operation.setReturnValue(floatData); 
+                        }
+                        break;
+                    case Type::IntegerType:
+                        {
+                            long* intData = new long;
+                            *intData = outputDataObject->getInteger(pl[i]);
+                            operation.setReturnValue(intData);
+                        }
+                        break;
+                    case Type::ShortType:
+                        {
+                            short* shortData = new short;
+                            *shortData = outputDataObject->getShort(pl[i]);
+                            operation.setReturnValue(shortData);
+                        }
+                        break;
+                    case Type::StringType:
+                        {
+                            string* str = new string(outputDataObject->getCString(pl[i]));
+                            operation.setReturnValue(str);
+                        }
+                        break;
+                    case Type::DataObjectType:
+                        {
+                            DataObjectPtr dataObjectData = outputDataObject->getDataObject(pl[i]);
+                            if(!dataObjectData)
+                            {
+                                LOGINFO(4, "SDO DataObject return value was null");
+                            }
+                            operation.setReturnValue(&dataObjectData);
+                        }
+                        break;
+                    case Type::OpenDataObjectType:
+                        {         
+                            /*
+                             * This code deals with xsd:any element parameters
+                             */
+            
+                            DataObjectList& dataObjectList = outputDataObject->getList(pl[i]);
+                            
+                            for(int j=0; j<dataObjectList.size(); j++)
+                            {
+                                DataObjectPtr dataObjectData = dataObjectList[j];
+                                if(!dataObjectData)
+                                {
+                                    operation.setReturnValue(&dataObjectData);
+                                    LOGINFO(4, "SDO OpenDataObject return value was null");
+                                }
+                                else 
+                                {
+                                    
+                                    SequencePtr sequence = dataObjectData->getSequence();
+                                    if (sequence->size()!=0)
+                                    {
+                                        // Return a text element        
+                                        if (sequence->isText(0))
+                                        {                                        
+                                            string* stringData = new string(sequence->getCStringValue(0));
+                                            operation.setReturnValue(stringData);
+                                        }
+                                        else
+                                        {
+                                            // Return a DataObject representing a complex element
+                                            DataObjectPtr dob = sequence->getDataObjectValue(0);
+                                            if(!dob)
+                                            {
+                                                LOGINFO(4, "SDO DataObject return value was null");
+                                            }
+                                            operation.setReturnValue(&dob);
+                                        }
+                                    }
+                                    else
+                                    {
+                                        // Empty content, add an empty string
+                                        LOGINFO(4, "SDO OpenDataObject return value was empy");
+                                        string *stringData = new string(""); 
+                                        operation.setReturnValue(stringData);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case Type::DateType:
+                        LOGERROR(0, "SDO DateType return values are not yet supported");
+                        break;
+                    case Type::LongType:
+                        LOGERROR(0, "SDO LongType (int64_t) return values are not yet supported");
+                        break;
+                    case Type::UriType:
+                        LOGERROR(0, "SDO UriType return values are not yet supported");
+                        break;
+                    case Type::BigDecimalType:
+                        LOGERROR(0, "SDO BigDecimalType return values are not yet supported");
+                        break;
+                    case Type::BigIntegerType:
+                        LOGERROR(0, "SDO BigIntegerType return values are not yet supported");
+                        break;
+                    default:
+                        LOGERROR(0, "Unknown SDO type has been found in return value. Unknown types are not yet supported");
+                        break;
+                    }         
+                 }
+                 else
+                 {
+                     // RPC
+                 }
+                 LOGEXIT(1, "Axis2Client::setReturn");
+             }
+             
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.h b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.h
new file mode 100644
index 0000000000..5ec302f0c8
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/Axis2Client.h
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+
+#ifndef tuscany_sca_extension_ws_axis2client_h
+#define tuscany_sca_extension_ws_axis2client_h
+
+#include <axiom.h>
+
+#include "tuscany/sca/core/Operation.h"
+#include "tuscany/sca/model/CompositeReference.h"
+#include "tuscany/sca/model/WSDLOperation.h"
+
+using namespace tuscany::sca::model;
+
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+        
+            class Axis2Client
+            {
+            public:
+                Axis2Client(CompositeReference* externalService);
+                virtual    ~Axis2Client();
+
+                virtual void invoke(Operation& operation);    
+                
+            private:
+                CompositeReference* compositeReference;
+                              
+                axiom_node_t* createPayload(Operation& operation, 
+                                               const WSDLOperation& wsdlOp,
+                                               axis2_env_t* env);
+                                                 
+                void setReturn(axiom_node_t* returnNode,
+                               Operation& operation, 
+                               const WSDLOperation& wsdlOp,
+                               axis2_env_t* env);
+                
+            };
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
+
+#endif // tuscany_sca_extension_ws_axis2client_h
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.cpp b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.cpp
new file mode 100644
index 0000000000..c260445b60
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.cpp
@@ -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.
+ */
+
+/* $Rev$ $Date$ */
+
+#include "WSServiceBindingExtension.h"
+#include "model/WSServiceBinding.h"
+#include "tuscany/sca/util/Logging.h"
+#include "tuscany/sca/util/Utils.h"
+#include "tuscany/sca/core/SCARuntime.h"
+
+extern "C"
+{
+    #if defined(WIN32) || defined(_WINDOWS)
+    __declspec(dllexport) 
+    #endif
+        void tuscany_sca_extension_initialize()
+    {
+        tuscany::sca::ws::WSServiceBindingExtension::initialize();
+    }
+}
+
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+            // ===================================================================
+            // Constructor for the WSServiceBinding class. 
+            // ===================================================================
+            WSServiceBindingExtension::WSServiceBindingExtension()
+            { 
+                LOGENTRY(1, "WSServiceBindingExtension::constructor");     
+                LOGEXIT(1, "WSServiceBindingExtension::constructor");
+            }
+            
+            // ===================================================================
+            // Destructor for the WSServiceBindingExtension class.
+            // ===================================================================
+            WSServiceBindingExtension::~WSServiceBindingExtension()
+            { 
+                LOGENTRY(1, "WSServiceBindingExtension::destructor");;           
+                LOGEXIT(1, "WSServiceBindingExtension::destructor");
+            }
+
+            const string WSServiceBindingExtension::extensionName("ws");
+            const string WSServiceBindingExtension::typeQName("http://www.osoa.org/xmlns/sca/1.0#WebServiceBinding");
+                                                                                                    
+
+            // ===================================================================
+            // loadModelElement - load the info from binding.ws
+            // ===================================================================
+            ServiceBinding* WSServiceBindingExtension::getServiceBinding(Composite *composite, Service* service, DataObjectPtr scdlBinding)
+            {
+                string bindingType = scdlBinding->getType().getName();
+                if (bindingType == "WebServiceBinding")
+                {
+                    string uri = scdlBinding->getCString("uri");
+                    string endpoint = scdlBinding->getCString("endpoint");
+                    commonj::sdo::DataObjectList& soap = scdlBinding->getList("soapbinding");
+                    string version;
+                    if (soap.size()!=0)
+                    {
+                        version = soap.getCString(0);
+                    }
+                    else
+                    {
+                        version = "";
+                    }
+
+                    WSServiceBinding* serviceBinding = new WSServiceBinding(service, uri, endpoint, version);
+                    
+                    return serviceBinding;
+                }
+                else
+                {
+                    return NULL;
+                }
+            }
+
+            void WSServiceBindingExtension::initialize()
+            { 
+                LOGENTRY(1, "WSServiceBindingExtension::initialize");;           
+                SCARuntime::getInstance()->registerServiceBindingExtension(new WSServiceBindingExtension());
+                LOGEXIT(1, "WSServiceBindingExtension::initialize");;           
+            }
+
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.h b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.h
new file mode 100644
index 0000000000..db2c0c791f
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceBindingExtension.h
@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+
+#ifndef tuscany_sca_extension_ws_wsservicebindingextension_h
+#define tuscany_sca_extension_ws_wsservicebindingextension_h
+
+#include "tuscany/sca/extension/ServiceBindingExtension.h"
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+            
+            class WSServiceBindingExtension : public ServiceBindingExtension 
+            {
+            public:
+            /**
+            * Default constructor
+                */
+                WSServiceBindingExtension();
+                
+                /**
+                * Destructor
+                */
+                virtual ~WSServiceBindingExtension();            
+                
+                /**
+                * return the name of the extension
+                */
+                virtual const string& getExtensionName() {return extensionName;}
+                
+                /**
+                * return the QName of schema elemant for this implementation extension
+                * (e.g. "http://www.osoa.org/xmlns/sca/1.0#binding.ws")
+                */
+                virtual const string& getExtensionTypeQName() {return typeQName;}
+                
+                virtual ServiceBinding* getServiceBinding(Composite* composite, Service* service, DataObjectPtr scdlBinding);
+                
+                static void initialize();
+
+            private:
+                static const string extensionName;
+                static const string typeQName;
+                
+            };
+            
+            
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
+
+#endif //tuscany_sca_extension_ws_wsservicebindingextension_h
+
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.cpp b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.cpp
new file mode 100644
index 0000000000..5839aa8722
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.cpp
@@ -0,0 +1,110 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+#if defined(WIN32)  || defined (_WINDOWS)
+#pragma warning(disable: 4091)
+#endif
+
+#include "tuscany/sca/util/Logging.h"
+#include "Axis2Client.h"
+#include "WSServiceWrapper.h"
+#include "tuscany/sca/core/Operation.h"
+#include "tuscany/sca/model/Service.h"
+#include "tuscany/sca/model/Component.h"
+#include "tuscany/sca/model/Composite.h"
+#include "tuscany/sca/model/ServiceType.h"
+
+#include "commonj/sdo/SDO.h"
+using namespace commonj::sdo;
+
+using namespace tuscany::sca;
+using namespace tuscany::sca::model;
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+            
+            WSServiceWrapper::WSServiceWrapper(Service* service) : ServiceWrapper(service)
+            {
+                // Define the SOAP Body type and element to allow a SOAP body to
+                // be loaded in a DataObject
+                DataFactoryPtr dataFactory = service->getComponent()->getComposite()->getDataFactory();
+                try {
+                    const Type& bodyType = dataFactory->getType("http://www.w3.org/2003/05/soap-envelope", "Body");
+                } catch (SDORuntimeException e)
+                {
+                    dataFactory->addType("http://www.w3.org/2003/05/soap-envelope", "RootType", false, false, false);                
+                    dataFactory->addType("http://www.w3.org/2003/05/soap-envelope", "Body", false, true, false);                
+                    dataFactory->addPropertyToType(
+                        "http://www.w3.org/2003/05/soap-envelope", "RootType",
+                        "Body",
+                        "http://www.w3.org/2003/05/soap-envelope", "Body",
+                        false, false, true);
+    
+                    dataFactory->addType("http://schemas.xmlsoap.org/soap/envelope/", "RootType", false, false, false);
+                    dataFactory->addType("http://schemas.xmlsoap.org/soap/envelope/", "Body", false, true, false);
+                    dataFactory->addPropertyToType(
+                        "http://schemas.xmlsoap.org/soap/envelope/", "RootType",
+                        "Body",
+                        "http://schemas.xmlsoap.org/soap/envelope/", "Body",
+                        false, false, true);
+                }
+            }
+            
+            WSServiceWrapper::~WSServiceWrapper()
+            {
+            }
+            
+            ///
+            /// This method will be called when a web service call needs to be made.
+            ///
+            void WSServiceWrapper::invoke(Operation& operation) 
+            {
+                LOGENTRY(1, "WSServiceWrapper::invoke");
+            
+                const string& operationName = operation.getName();
+            
+                LOGINFO_2(2,"Service: %s, Operation: %s", getService()->getType()->getName().c_str() , operationName.c_str());
+            
+                for (unsigned int i=0; i<operation.getNParms(); i++)
+                {
+                    LOGINFO_2(2, "Parameter %p, Type %u", operation.getParameterValue(i),(int) operation.getParameterType(i));
+                }
+
+                // Create the Axis2 client that will handle the Web Service invocation
+                Service* service = getService();
+                CompositeReference* compositeReference = (CompositeReference*)service->getComponent();
+                
+                Axis2Client client(compositeReference);
+                client.invoke(operation);
+                
+                LOGEXIT(1, "WSServiceWrapper::invoke");
+            }
+
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
+    
+
+
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.h b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.h
new file mode 100644
index 0000000000..93607db4a2
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/WSServiceWrapper.h
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+#ifndef tuscany_sca_extension_ws_wsservicewrapper_h
+#define tuscany_sca_extension_ws_wsservicewrapper_h
+
+#include "tuscany/sca/core/ServiceWrapper.h"
+#include "tuscany/sca/core/Operation.h"
+#include "tuscany/sca/model/Service.h"
+
+using namespace tuscany::sca::model;
+
+
+namespace tuscany
+{
+    namespace sca
+    {
+        
+        namespace ws
+        {
+        
+            class WSServiceWrapper : public ServiceWrapper
+            {
+            public:
+
+                /**
+                 * Constructor.
+                 * @param target The service wrapper represents a Web service.
+                 */
+                WSServiceWrapper(Service* service);
+                
+                /**
+                 * Destructor
+                 */
+                virtual    ~WSServiceWrapper();
+
+                /**
+                 * All business method calls on the target service are performed through
+                 * this invoke method.
+                 * @param operation The details of the method, paramaters and return value for the
+                 * business method to be called on the target service.
+                 */
+                virtual void invoke(Operation& operation);
+            };
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
+
+#endif // tuscany_sca_ws_wsservicewrapper_h
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.cpp b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.cpp
new file mode 100644
index 0000000000..8980ec489b
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.cpp
@@ -0,0 +1,134 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+#include "tuscany/sca/util/Logging.h"
+#include "tuscany/sca/ws/model/WSServiceBinding.h"
+#include "tuscany/sca/core/ServiceWrapper.h"
+#include "tuscany/sca/ws/WSServiceWrapper.h"
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+
+            // Constructor
+            WSServiceBinding::WSServiceBinding(Service* service, const string& uri, const string& endpoint, const string& version)
+                : ServiceBinding(service, uri), endpoint(endpoint), soapVersion(version)
+            {
+                parseEndpoint();
+                
+                serviceWrapper = new WSServiceWrapper(service);
+            }
+
+            void WSServiceBinding::parseEndpoint()
+            {
+                // Endpoint is of the form: <wsdl-namepace-uri>#wsdl.endpoint(<service-name>/<endpoint-name>)
+                string::size_type hash = endpoint.find("#");
+                if (hash != string::npos)
+                {
+                    // Found a hash
+
+                    // Namepace is the part before the #
+                    wsdlNamespaceURL = endpoint.substr(0, hash);
+
+                    
+                    if ( (hash+1) < endpoint.length())
+                    {
+                        // Check the next part is wsdl.endpoint( 
+                        int ending = hash+15;
+                        string check = endpoint.substr(hash+1, 14);
+                        if (check.compare("wsdl.endpoint(") == 0)
+                        {
+                            // Find the matching )
+                            int endBracket = endpoint.find(")",ending);
+                            if (endBracket-1 > ending+1)
+                            {
+                                string serviceAndEndpoint = endpoint.substr(ending, endBracket-ending);
+                                // Look for a '/'
+                                string::size_type slash = serviceAndEndpoint.find("/");
+                                if (slash != string::npos)
+                                {
+                                    serviceName = serviceAndEndpoint.substr(0, slash);
+
+                                    if ( (slash+1) < serviceAndEndpoint.length())
+                                    {
+                                        endpointName = serviceAndEndpoint.substr(slash+1);
+                                    }
+                                    else
+                                    {
+                                        endpointName = "";
+                                    }
+
+                                }
+                                else
+                                {
+                                    // No '/' so all of it is the service name
+                                    serviceName = serviceAndEndpoint;
+                                    endpointName = "";
+
+                                }
+                            }
+                            else
+                            {
+                                // Nothing between the ()
+                                serviceName = "";
+                                endpointName = "";
+                            }
+                        }
+                        else
+                        {
+                            // not the correct characters after the #, ignore the rest
+                            serviceName = "";
+                            endpointName = "";
+                        }
+                        
+                    }
+                    else
+                    {
+                        // Nothing after the hash
+                        serviceName = "";
+                        endpointName = "";
+                    }
+                }
+                else
+                {
+                    // No hash at all
+                    wsdlNamespaceURL = endpoint;
+                    serviceName = "";
+                    endpointName = "";
+                }
+            }
+
+            // Destructor
+            WSServiceBinding::~WSServiceBinding()
+            {
+            }
+            
+            ServiceWrapper* WSServiceBinding::getServiceWrapper()
+            {
+                return serviceWrapper;
+            }
+                
+        } // End namespace ws
+    } // End namespace sca
+} // End namespace tuscany
diff --git a/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.h b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.h
new file mode 100644
index 0000000000..15691ce6eb
--- /dev/null
+++ b/tags/cpp-1.0-incubating-M2-RC3/sca/runtime/extensions/ws/reference/axis2c/src/tuscany/sca/ws/model/WSServiceBinding.h
@@ -0,0 +1,137 @@
+/*
+ * 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.
+ */
+
+/* $Rev$ $Date$ */
+
+#ifndef tuscany_sca_extension_ws_model_wsservicebinding_h
+#define tuscany_sca_extension_ws_model_wsservicebinding_h
+
+#include "tuscany/sca/model/ServiceBinding.h"
+#include "tuscany/sca/model/Service.h"
+
+#include <string>
+using std::string;
+
+namespace tuscany
+{
+    namespace sca
+    {
+        namespace ws
+        {
+            /**
+             * Information about a web service binding for service or a reference.
+             */
+            class WSServiceBinding : public model::ServiceBinding
+            {    
+            public:
+
+                /**
+                 * Constructor.
+                 * @param uri The uri of the binding.
+                 * @param endpoint The definition of the endpoint to which the service
+                 * or reference is to be bound. This is of the form
+                 * "namespace"#endpoint("service"/"endpoint")
+                 */
+                WSServiceBinding(model::Service* service, const string& uri, const string& endpoint, const string& version);  
+
+                /**
+                 * Destructor.
+                 */
+                virtual ~WSServiceBinding();
+                            
+                /**
+                 * Returns the type of binding.
+                 */                
+                virtual string getType() { return "http://www.osoa.org/xmlns/sca/1.0#WebServiceBinding"; };
+                            
+                /**
+                 * Create a wrapper for the service configured by this
+                 * binding.
+                 */
+                 virtual ServiceWrapper* getServiceWrapper();
+                                
+                /**
+                 * Return the part of the endpoint definition describing the wsdl 
+                 * namespace.
+                 * @return The wsdl namespace.
+                 */
+                string getWSDLNamespaceURL() const { return wsdlNamespaceURL; };
+
+                /**
+                 * Return the service part of the endpoint definition.
+                 * @return The service to use.
+                 */
+                string getServiceName() const { return serviceName; };
+
+                /**
+                 * Return the endpoint name part of the endpoint definition.
+                 * @return The endpoint name to use.
+                 */
+                string getEndpointName() const { return endpointName; };
+                
+                /**
+                 * Return the SOAP version.
+                 * @return The SOAP version to use.
+                 */
+                string getSOAPVersion() const { return soapVersion; };
+                
+            private:
+            
+                /**
+                 * Parse the endpoint specification.
+                 */
+                void parseEndpoint();
+            
+                /**
+                 * The full endpoint string.
+                 */
+                string endpoint;
+
+                /**
+                 * Namespace from the endpoint.
+                 */
+                string wsdlNamespaceURL;
+
+                /**
+                 * Service name from the endpoint.
+                 */
+                string serviceName;
+
+                /**
+                 * WSDL Endpoint name.
+                 */
+                string endpointName;
+
+                /**
+                 * SOAP version.
+                 */
+                string soapVersion;
+
+                /**
+                 * The wrapper for the service configured by this binding.
+                 */            
+                ServiceWrapper* serviceWrapper;
+            
+            };
+            
+        } // End namespace model
+    } // End namespace sca
+} // End namespace tuscany
+
+#endif // tuscany_sca_extension_ws_model_wsservicebinding_h