You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by da...@apache.org on 2006/07/06 08:02:31 UTC
svn commit: r419452 [14/46] - in /webservices/axis2/trunk/c/woden: ./
include/ samples/ samples/wsdl10/ src/ src/builder/ src/builder/wsdl10/
src/schema/ src/types/ src/util/ src/wsdl/ src/wsdl/enumeration/
src/wsdl10/ src/wsdl10/enumeration/ src/wsdl1...
Added: webservices/axis2/trunk/c/woden/src/builder/wsdl10/wsdl10_reader.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/woden/src/builder/wsdl10/wsdl10_reader.c?rev=419452&view=auto
==============================================================================
--- webservices/axis2/trunk/c/woden/src/builder/wsdl10/wsdl10_reader.c (added)
+++ webservices/axis2/trunk/c/woden/src/builder/wsdl10/wsdl10_reader.c Wed Jul 5 23:02:19 2006
@@ -0,0 +1,3870 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ */
+
+#include <woden_wsdl10_reader.h>
+#include <woden_schema_constants.h>
+#include <woden_qname_util.h>
+
+#include <woden_binding_fault.h>
+#include <woden_binding_fault_ref.h>
+#include <woden_wsdl10_binding_msg_ref.h>
+#include <woden_wsdl10_binding_op.h>
+#include <woden_binding.h>
+#include <woden_configurable_component.h>
+#include <woden_configurable.h>
+#include <woden_wsdl10_desc.h>
+#include <woden_documentable.h>
+#include <woden_documentation.h>
+#include <woden_element_decl.h>
+#include <woden_wsdl10_endpoint.h>
+#include <woden_feature.h>
+#include <woden_import.h>
+#include <woden_include.h>
+#include <woden_interface_fault.h>
+#include <woden_wsdl10_interface_fault_ref.h>
+#include <woden_wsdl10_msg_ref.h>
+#include <woden_wsdl10_msg_ref_element.h>
+#include <woden_wsdl10_part.h>
+#include <woden_wsdl10_part_element.h>
+#include <woden_interface.h>
+#include <woden_wsdl10_interface_msg_ref.h>
+#include <woden_interface_op.h>
+#include <woden_nested_component.h>
+#include <woden_nested_configurable.h>
+#include <woden_property.h>
+#include <woden_wsdl10_svc.h>
+#include <woden_type_def.h>
+#include <woden_types.h>
+#include <woden_wsdl_component.h>
+#include <woden_wsdl_ref.h>
+
+#include <woden_attr_extensible.h>
+#include <woden_component_exts.h>
+#include <woden_element_extensible.h>
+#include <woden_ext_element.h>
+#include <woden_wsdl10_ext_registry.h>
+
+#include <woden_direction.h>
+#include <woden_msg_label.h>
+#include <woden_soap_fault_code.h>
+#include <woden_soap_fault_subcodes.h>
+
+#include <woden_binding_element.h>
+#include <woden_binding_fault_element.h>
+#include <woden_binding_fault_ref_element.h>
+#include <woden_wsdl10_binding_msg_ref_element.h>
+#include <woden_wsdl10_binding_op_element.h>
+#include <woden_configurable_element.h>
+#include <woden_wsdl10_desc_element.h>
+#include <woden_documentable_element.h>
+#include <woden_documentation_element.h>
+#include <woden_wsdl10_endpoint_element.h>
+#include <woden_fault_ref_element.h>
+#include <woden_feature_element.h>
+#include <woden_import_element.h>
+#include <woden_include_element.h>
+#include <woden_interface_element.h>
+#include <woden_interface_fault_element.h>
+#include <woden_wsdl10_interface_fault_ref_element.h>
+#include <woden_wsdl10_interface_msg_ref_element.h>
+#include <woden_interface_op_element.h>
+#include <woden_nested_element.h>
+#include <woden_property_element.h>
+#include <woden_wsdl10_svc_element.h>
+#include <woden_types_element.h>
+#include <woden_wsdl_element.h>
+
+#include <woden_bool_attr.h>
+#include <woden_qname_attr.h>
+#include <woden_qname_list_attr.h>
+#include <woden_qname_list_or_token_any_attr.h>
+#include <woden_qname_or_token_any_attr.h>
+#include <woden_string_attr.h>
+#include <woden_uri_attr.h>
+#include <woden_xml_attr.h>
+
+#include <woden_schema.h>
+#include <woden_imported_schema.h>
+#include <woden_inlined_schema.h>
+
+#include <woden_wsdl10_ext_deserializer.h>
+
+#include "../../wsdl10/woden_constants.h"
+#include "../../util/woden_om_util.h"
+
+#include <xml_schema.h>
+#include <xml_schema_collection.h>
+
+#include <axiom_node.h>
+#include <axiom_element.h>
+#include <axiom_attribute.h>
+#include <axiom_child_element_iterator.h>
+#include <axiom_namespace.h>
+#include <axiom_text.h>
+#include <axiom_document.h>
+#include <axiom_stax_builder.h>
+#include <axiom_xml_reader.h>
+#include <axiom_util.h>
+#include <axis2_utils.h>
+#include <axis2_generic_obj.h>
+
+#include <axis2_string_util.h>
+
+typedef struct woden_wsdl10_reader_impl woden_wsdl10_reader_impl_t;
+
+/**
+ * @brief Woden Wsdl Reader Struct Impl
+ * Woden Wsdl Reader
+ */
+struct woden_wsdl10_reader_impl
+{
+ woden_wsdl10_reader_t reader;
+
+ axiom_document_t *om_doc;
+ axiom_node_t *root_node;
+ /* A map of imported schema definitions keyed by schema location URI */
+ axis2_hash_t *f_imported_schemas;
+ woden_wsdl10_ext_registry_t *f_ext_reg;
+ axis2_uri_t *f_uri;
+
+};
+
+#define INTF_TO_IMPL(reader) ((woden_wsdl10_reader_impl_t *) reader)
+
+axis2_status_t AXIS2_CALL
+woden_wsdl10_reader_free(
+ void *reader,
+ const axis2_env_t *env);
+
+void *AXIS2_CALL
+woden_wsdl10_reader_read_wsdl(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_document_t *om_doc,
+ const axis2_char_t *uri);
+
+axis2_status_t AXIS2_CALL
+woden_wsdl10_reader_set_ext_registry(
+ void *reader,
+ const axis2_env_t *env,
+ woden_wsdl10_ext_registry_t *ext_reg);
+
+woden_wsdl10_ext_registry_t *AXIS2_CALL
+woden_wsdl10_reader_get_ext_registry(
+ void *reader,
+ const axis2_env_t *env);
+
+/* Parse the attributes and child elements of the <description> element.
+ * As per the WSDL 2.0 spec, the child elements must be in the
+ * following order if present:
+ * <documentation>
+ * <import> <include> or WSDL extension elements in any order
+ * <types>
+ * <interface> <binding> <service> or WSDL extension elements in any order.
+ * TODO validate that the elements are in correct order
+ */
+static void *
+parse_desc(
+ void *reader,
+ const axis2_env_t *env,
+ const axis2_char_t *document_base_uri,
+ axiom_node_t *desc_el_node,
+ axis2_hash_t *wsdl_modules);
+
+static void *
+parse_documentation(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *doc_el_node,
+ void *desc);
+
+static void *
+parse_import(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *import_el_node,
+ void *desc,
+ axis2_hash_t *wsdl_modules);
+
+static void *
+parse_include(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *include_el_node,
+ void *desc,
+ axis2_hash_t *wsdl_modules);
+
+/*
+ * TODO Initial schema parsing is specific to XML Schema.
+ * Need generic support for other type systems.
+ * Consider extension architecture with serializer/deserializer.
+ */
+
+static void *
+parse_types(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *types_el_node,
+ void *desc);
+
+static void *
+parse_schema_inline(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *schema_el_node,
+ void *desc);
+
+/*
+ * Parse the <xs:import> element and retrieve the imported
+ * schema document if schemaLocation specified. Failure to retrieve
+ * the schema will only matter if any WSDL components contain elements or
+ * constraints that refer to the schema, and typically this will be
+ * determined later by WSDL validation. So just report any such errors
+ * and return the Schema Import object (i.e. with a null schema property).
+ *
+ * WSDL 2.0 spec validation:
+ * - namespace attribute is REQUIRED
+ * - imported schema MUST have a targetNamespace
+ * - namespace and targetNamespace MUST be the same
+ */
+static void *
+parse_schema_import(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *import_el_node,
+ void *desc);
+
+static void *
+parse_part(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *part_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_msg_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *msg_el_node,
+ void *desc);
+
+static void *
+parse_interface(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *interface_el_node,
+ void *desc);
+
+static void *
+parse_interface_op(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *op_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_interface_fault_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *fault_ref_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_interface_msg_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *msg_ref_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_binding(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *binding_el_node,
+ void *desc);
+
+static void *
+parse_binding_op(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *op_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_binding_fault_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *fault_ref_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_binding_msg_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *msg_ref_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_svc(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *svc_el_node,
+ void *desc);
+
+static void *
+parse_endpoint(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *endpoint_el_node,
+ void *desc,
+ void *parent);
+
+static void *
+parse_feature(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *feature_el_node,
+ void *desc,
+ void *parent);
+
+/* ******************************************************************
+ * Parse the attributes and child elements of the <property> element.
+ *
+ * As per WSDL 2.0 spec, they must be in the following order if present:
+ * <documentation>
+ * <value> or <constraint>
+ * extension elements.
+ *
+ * TODO validate that the elements are in correct order
+ *
+ * Child elements may include either a <value> or a <constraint>,
+ * but not both. If a <value> element is present, a <constraint>
+ * may only be present if it contains the NMToken "#value", which
+ * indicates that this <property> specifies a value, not a constraint.
+ *
+ * This method will parse all child elements of <property> without
+ * checking for any erroneous use of <value> and <constraint>.
+ * This will be done later by validation, if it's enabled.
+ * If the NMToken "#value" is present in a <constraint> element,
+ * this will be flagged with a boolean field in PropertyElement
+ * and the constraint field will be set to null.
+ *
+ */
+
+static void *
+parse_property(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *property_el_node,
+ void *desc,
+ void *parent);
+
+/**
+ * @param om_el_node element node
+ * @param wsdl_class
+ * @param wsdl_obj wsdl_obj_t type object
+ * @param desc desc object
+ */
+axis2_status_t AXIS2_CALL
+parse_ext_attributes(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *om_el_node,
+ axis2_char_t *wsdl_class,
+ void *wsdl_obj,
+ void *desc);
+
+static void *
+parse_ext_element(
+ void *reader,
+ const axis2_env_t *env,
+ axis2_char_t *parent_type,
+ void *parent,
+ axiom_node_t *el_node,
+ void *desc);
+
+/* ************************************************************
+ * Utility/helper methods
+ * ************************************************************/
+
+/**
+ * Check the actual element encountered against the expected qname
+ *
+ * @param el actual element encountered
+ * @param qname expected element's qname
+ */
+static axis2_status_t
+check_element_qname(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *el_node,
+ axis2_qname_t *qname);
+
+/*
+ * Retrieve a WSDL document by resolving the location URI specified
+ * on a WSDL <import> or <include> element.
+ *
+ * TODO add support for a URL Catalog Resolver
+ */
+static void *
+get_wsdl_from_location(
+ void *reader,
+ const axis2_env_t *env,
+ axis2_char_t *location_uri_str,
+ void *desc,
+ axis2_hash_t *wsdl_modules);
+
+/*
+ * Convert a string of type xs:anyURI to a axis2_uri.
+ * An empty string argument will return an empty string URI.
+ * A null argument will return a null.
+ */
+static axis2_uri_t *
+get_uri(
+ void *reader,
+ const axis2_env_t *env,
+ const axis2_char_t *uri_str);
+
+static woden_wsdl10_reader_t *
+create(
+ const axis2_env_t *env)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ reader_impl = AXIS2_MALLOC(env->allocator,
+ sizeof(woden_wsdl10_reader_impl_t));
+
+ reader_impl->f_imported_schemas = NULL;
+ reader_impl->f_ext_reg = NULL;
+ reader_impl->f_uri = NULL;
+
+ reader_impl->reader.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(woden_wsdl10_reader_ops_t));
+
+ reader_impl->f_imported_schemas = axis2_hash_make(env);
+ if(!reader_impl->f_imported_schemas)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ reader_impl->reader.ops->free = woden_wsdl10_reader_free;
+ reader_impl->reader.ops->read_wsdl = woden_wsdl10_reader_read_wsdl;
+ reader_impl->reader.ops->set_ext_registry = woden_wsdl10_reader_set_ext_registry;
+ reader_impl->reader.ops->get_ext_registry = woden_wsdl10_reader_get_ext_registry;
+
+ return &(reader_impl->reader);
+}
+
+AXIS2_EXTERN woden_wsdl10_reader_t * AXIS2_CALL
+woden_wsdl10_reader_create(
+ const axis2_env_t *env)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ reader_impl = (woden_wsdl10_reader_impl_t *) create(env);
+
+ return &(reader_impl->reader);
+}
+
+axis2_status_t AXIS2_CALL
+woden_wsdl10_reader_free(
+ void *reader,
+ const axis2_env_t *env)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ if(reader_impl->f_imported_schemas)
+ {
+ axis2_hash_free(reader_impl->f_imported_schemas, env);
+ reader_impl->f_imported_schemas = NULL;
+ }
+
+ if(reader_impl->f_ext_reg)
+ {
+ WODEN_WSDL10_EXT_REGISTRY_FREE(reader_impl->f_ext_reg, env);
+ reader_impl->f_ext_reg = NULL;
+ }
+
+ if(reader_impl->f_uri)
+ {
+ AXIS2_URI_FREE(reader_impl->f_uri, env);
+ reader_impl->f_uri = NULL;
+ }
+
+ if((&(reader_impl->reader))->ops)
+ {
+ AXIS2_FREE(env->allocator, (&(reader_impl->reader))->ops);
+ (&(reader_impl->reader))->ops = NULL;
+ }
+
+ if(reader_impl)
+ {
+ AXIS2_FREE(env->allocator, reader_impl);
+ reader_impl = NULL;
+ }
+ return AXIS2_SUCCESS;
+}
+
+/* ************************************************************
+ * API public methods
+ * ************************************************************/
+axis2_status_t AXIS2_CALL
+woden_wsdl10_reader_set_ext_registry(
+ void *reader,
+ const axis2_env_t *env,
+ woden_wsdl10_ext_registry_t *ext_reg)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, ext_reg, AXIS2_FAILURE);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ if(reader_impl->f_ext_reg)
+ {
+ WODEN_WSDL10_EXT_REGISTRY_FREE(reader_impl->f_ext_reg, env);
+ reader_impl->f_ext_reg = NULL;
+ }
+ reader_impl->f_ext_reg = ext_reg;
+ return AXIS2_SUCCESS;
+}
+
+woden_wsdl10_ext_registry_t *AXIS2_CALL
+woden_wsdl10_reader_get_ext_registry(
+ void *reader,
+ const axis2_env_t *env)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ return reader_impl->f_ext_reg;
+}
+
+void *AXIS2_CALL
+woden_wsdl10_reader_read_wsdl(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_document_t *om_doc,
+ const axis2_char_t *uri)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+ void *desc = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, om_doc, NULL);
+ AXIS2_PARAM_CHECK(env->error, uri, NULL);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ /* TODO add WSDL locator for resolving URIs */
+ reader_impl->om_doc = om_doc;
+ reader_impl->root_node = AXIOM_DOCUMENT_GET_ROOT_ELEMENT(om_doc, env);
+ if(!reader_impl->root_node)
+ return NULL;
+ desc = parse_desc(reader, env, uri, reader_impl->root_node, NULL);
+
+ /* TODO Validate the model if validation is enabled. */
+
+ return desc;
+}
+
+/* ************************************************************
+ * Parsing methods - e.g. parse_xxxx()
+ * ************************************************************/
+
+/* Parse the attributes and child elements of the <description> element.
+ * As per the WSDL 2.0 spec, the child elements must be in the
+ * following order if present:
+ * <documentation>
+ * <import> <include> or WSDL extension elements in any order
+ * <types>
+ * <interface> <binding> <service> or WSDL extension elements in any order.
+ * TODO validate that the elements are in correct order
+ */
+static void *
+parse_desc(
+ void *reader,
+ const axis2_env_t *env,
+ const axis2_char_t *document_base_uri,
+ axiom_node_t *desc_el_node,
+ axis2_hash_t *wsdl_modules)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+ void *desc = NULL;
+ void *ext_reg = NULL;
+ axis2_uri_t *uri = NULL;
+ axis2_char_t *target_namespc = NULL;
+ axis2_uri_t *target_namespc_uri = NULL;
+ axiom_element_t *desc_el = NULL;
+ axis2_hash_t *attrs = NULL;
+ axis2_hash_index_t *index = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ void *types = NULL;
+ axis2_qname_t *qname = NULL;
+ void *schema = NULL;
+ axiom_attribute_t *attr_ns = NULL;
+ axiom_attribute_t *attr_loc = NULL;
+ axiom_element_t *schema_elem = NULL;
+ axiom_node_t *schema_elem_node = NULL;
+ axiom_namespace_t *schema_ns = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, document_base_uri, NULL);
+ AXIS2_PARAM_CHECK(env->error, desc_el_node, NULL);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ qname = axis2_qname_create_from_string(env, WODEN_Q_ELEM_DESCRIPTION);
+ check_element_qname(reader, env, desc_el_node, qname);
+
+ desc = woden_wsdl10_desc_create(env);
+ ext_reg = woden_wsdl10_ext_registry_create(env);
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ WODEN_WSDL10_DESC_ELEMENT_SET_EXT_REGISTRY(desc, env, ext_reg);
+
+ if(NULL == wsdl_modules)
+ {
+ /* This is the initial WSDL document. No imports or includes yet.
+ * TODO this might be the place to flag the initial Desc if necessary.
+ */
+ wsdl_modules = axis2_hash_make(env);
+ }
+ ext_reg = woden_wsdl10_reader_get_ext_registry(reader, env);
+ if(NULL != ext_reg)
+ {
+ WODEN_WSDL10_DESC_ELEMENT_SET_EXT_REGISTRY(desc, env, ext_reg);
+ }
+
+ uri = get_uri(reader, env, document_base_uri);
+ WODEN_WSDL10_DESC_ELEMENT_SET_DOCUMENT_BASE_URI(desc, env, uri);
+
+ desc_el = AXIOM_NODE_GET_DATA_ELEMENT(desc_el_node, env);
+ target_namespc = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(desc_el,
+ env, WODEN_ATTR_TARGET_NAMESPACE);
+
+ if(NULL != target_namespc)
+ {
+ target_namespc_uri = get_uri(reader, env, target_namespc);
+ WODEN_WSDL10_DESC_ELEMENT_SET_TARGET_NAMESPACE(desc, env, target_namespc_uri);
+ }
+
+ /* parse the namespace declarations */
+ attrs = AXIOM_ELEMENT_GET_ALL_ATTRIBUTES(desc_el, env);
+ for (index = axis2_hash_first (attrs, env); index; index = axis2_hash_next (
+ env, index))
+ {
+ void *v = NULL;
+ axiom_attribute_t *attr = NULL;
+ axiom_namespace_t *namespc = NULL;
+ axis2_char_t *namespc_uri = NULL;
+ axis2_char_t *local_part = NULL;
+ axis2_char_t *value = NULL;
+
+ axis2_hash_this (index, NULL, NULL, &v);
+ attr = (axiom_attribute_t *) v;
+ namespc = AXIOM_ATTRIBUTE_GET_NAMESPACE(attr, env);
+ if(!namespc)
+ continue;
+ namespc_uri = AXIOM_NAMESPACE_GET_URI(namespc, env);
+ local_part = AXIOM_ATTRIBUTE_GET_LOCALNAME(attr, env);
+ value = AXIOM_ATTRIBUTE_GET_VALUE(attr, env);
+ uri = get_uri(reader, env, value);
+ if(0 == AXIS2_STRCMP(WODEN_NS_URI_XMLNS, namespc_uri))
+ {
+ if(0 == AXIS2_STRCMP(WODEN_ATTR_XMLNS, local_part))
+ {
+ WODEN_WSDL10_DESC_ELEMENT_ADD_NAMESPACE(desc, env, local_part, uri);
+ /* a prefixed namespace */
+ }
+ else
+ {
+ WODEN_WSDL10_DESC_ELEMENT_ADD_NAMESPACE(desc, env, NULL, uri);
+ }
+ }
+
+ }
+ desc = woden_wsdl10_desc_to_attr_extensible(desc, env);
+ documentable = WODEN_WSDL10_DESC_GET_BASE_IMPL(desc, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ status = parse_ext_attributes(reader, env, desc_el_node,
+ "description_element", wsdl_obj, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ /* Parse the child elements */
+ temp_el = axiom_util_get_first_child_element(desc_el, env, desc_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_elem_import = NULL;
+ axis2_qname_t *q_elem_include = NULL;
+ axis2_qname_t *q_elem_types = NULL;
+ axis2_qname_t *q_elem_msg_ref = NULL;
+ axis2_qname_t *q_elem_interface = NULL;
+ axis2_qname_t *q_elem_binding = NULL;
+ axis2_qname_t *q_elem_svc = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env, WODEN_Q_ELEM_DOCUMENTATION);
+ q_elem_import = axis2_qname_create_from_string(env, WODEN_Q_ELEM_IMPORT);
+ q_elem_include = axis2_qname_create_from_string(env, WODEN_Q_ELEM_INCLUDE);
+ q_elem_types = axis2_qname_create_from_string(env, WODEN_Q_ELEM_TYPES);
+ q_elem_msg_ref = axis2_qname_create_from_string(env, WODEN_Q_ELEM_MSG_REF);
+ q_elem_interface = axis2_qname_create_from_string(env, WODEN_Q_ELEM_INTERFACE);
+ q_elem_binding = axis2_qname_create_from_string(env, WODEN_Q_ELEM_BINDING);
+ q_elem_svc = axis2_qname_create_from_string(env, WODEN_Q_ELEM_SERVICE);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+
+ desc = woden_wsdl10_desc_to_documentable(desc, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(desc, env, documentation);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_import, temp_el_node))
+ {
+ void *import_element = NULL;
+
+ if(NULL != document_base_uri && AXIS2_TRUE !=
+ axis2_hash_contains_key(wsdl_modules, env,
+ document_base_uri))
+ {
+ axis2_hash_set(wsdl_modules, document_base_uri,
+ AXIS2_HASH_KEY_STRING, desc);
+ }
+ import_element = parse_import(reader, env, temp_el_node, desc,
+ wsdl_modules);
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_IMPORT_ELEMENT(desc, env, import_element);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_include, temp_el_node))
+ {
+ void *include_element = NULL;
+
+ if(NULL != document_base_uri && AXIS2_TRUE !=
+ axis2_hash_contains_key(wsdl_modules, env,
+ document_base_uri))
+ {
+ axis2_hash_set(wsdl_modules, document_base_uri,
+ AXIS2_HASH_KEY_STRING, desc);
+ }
+ include_element = parse_include(reader, env, temp_el_node, desc,
+ wsdl_modules);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_INCLUDE_ELEMENT(desc, env, include_element);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_types, temp_el_node))
+ {
+ void *types = NULL;
+
+ types = parse_types(reader, env, temp_el_node, desc);
+ WODEN_WSDL10_DESC_ELEMENT_SET_TYPES_ELEMENT(desc, env, types);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_msg_ref, temp_el_node))
+ {
+ void *msg_ref = NULL;
+
+ msg_ref = parse_msg_ref(reader, env, temp_el_node, desc);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_MSG_ELEMENT(desc, env, msg_ref);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_interface, temp_el_node))
+ {
+ void *interface = NULL;
+
+ interface = parse_interface(reader, env, temp_el_node, desc);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_INTERFACE_ELEMENT(desc, env, interface);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_binding, temp_el_node))
+ {
+ void *binding = NULL;
+
+ binding = parse_binding(reader, env, temp_el_node, desc);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_BINDING_ELEMENT(desc, env, binding);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_svc, temp_el_node))
+ {
+ void *svc = NULL;
+
+ svc = parse_svc(reader, env, temp_el_node, desc);
+ WODEN_WSDL10_DESC_ELEMENT_ADD_SVC_ELEMENT(desc, env, svc);
+ }
+ else
+ {
+ void *ext_element = NULL;
+
+ ext_element = parse_ext_element(reader, env, "desc_element", desc, temp_el_node, desc);
+ if(ext_element)
+ {
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ documentable = WODEN_WSDL10_DESC_GET_BASE_IMPL(desc, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(desc, env, ext_element);
+ }
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ /*
+ * Parse the schema for schema to include the built in schema types in the Woden model.
+ * TODO: As there are a finite number of built in schema types it may be better to create
+ * constants rather than reading the schema for schema on the creation of every model.
+ * Also, this method currently requires that the schema elements exist in the types element.
+ * This may not be the best idea as it may imply that this schema contains an actual import
+ * statement in a WSDL 2.0 document. This method also does not work for when building the
+ * model programmatically.
+ * This method should be reevaluated at a later point.
+ */
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ types = WODEN_WSDL10_DESC_ELEMENT_GET_TYPES_ELEMENT(desc, env);
+ if(NULL == types)
+ {
+
+ types = WODEN_WSDL10_DESC_ELEMENT_CREATE_TYPES_ELEMENT(desc, env);
+ types = woden_types_to_types_element(types, env);
+ WODEN_TYPES_ELEMENT_SET_TYPE_SYSTEM(types, env, WODEN_TYPE_XSD_2001);
+ WODEN_WSDL10_DESC_ELEMENT_SET_TYPES_ELEMENT(desc, env, types);
+ }
+ schema_ns = axiom_namespace_create(env,
+ "http://www.w3.org/2001/XMLSchema", "import");
+ schema_elem = axiom_element_create(env, desc_el_node, "import",
+ schema_ns, &schema_elem_node);
+ attr_ns = axiom_attribute_create(env, "namespace",
+ "http://www.w3.org/2001/XMLSchema", NULL);
+ attr_loc = axiom_attribute_create(env, "schemaLocation",
+ "http://www.w3.org/2001/XMLSchema.xsd", NULL);
+ AXIOM_ELEMENT_ADD_ATTRIBUTE(schema_elem, env, attr_ns, schema_elem_node);
+ AXIOM_ELEMENT_ADD_ATTRIBUTE(schema_elem, env, attr_loc, schema_elem_node);
+
+ schema = parse_schema_import(reader, env, schema_elem_node, desc);
+ if(schema)
+ {
+ types = woden_types_to_types_element(types, env);
+ schema = woden_imported_schema_to_schema(schema, env);
+ WODEN_TYPES_ELEMENT_ADD_SCHEMA(types, env, schema);
+ }
+ return desc;
+}
+
+static void *
+parse_documentation(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *doc_el_node,
+ void *desc)
+{
+ void *documentation = NULL;
+ axiom_element_t *doc_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ documentation = WODEN_WSDL10_DESC_ELEMENT_CREATE_DOCUMENTATION_ELEMENT(desc,
+ env);
+
+ /* TODO store doc_el as below, or just extract any text? */
+ documentation = woden_documentation_to_documentation_element(
+ documentation, env);
+ WODEN_DOCUMENTATION_ELEMENT_SET_CONTENT(documentation, env, doc_el_node);
+
+ /* Now parse any extensibility attributes or elements */
+ documentation = woden_documentation_to_attr_extensible(documentation,
+ env);
+ status = parse_ext_attributes(reader, env, doc_el_node, "documentation_element",
+ documentation, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ doc_el = AXIOM_NODE_GET_DATA_ELEMENT(doc_el_node, env);
+ temp_el = axiom_util_get_first_child_element(doc_el, env, doc_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el)
+ {
+ void *ext_el = NULL;
+ void *wsdl_el = NULL;
+
+ ext_el = parse_ext_element(reader, env, "documentation_element",
+ documentation, temp_el_node, desc);
+
+ wsdl_el = WODEN_DOCUMENTATION_GET_BASE_IMPL(documentation, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(documentation, env,
+ ext_el);
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return documentation;
+}
+
+static void *
+parse_import(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *import_el_node,
+ void *desc,
+ axis2_hash_t *wsdl_modules)
+{
+ void *imp = NULL;
+ axiom_element_t *import_el = NULL;
+ axis2_char_t *namespc_uri = NULL;
+ axis2_char_t *location_uri = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ imp = WODEN_WSDL10_DESC_ELEMENT_CREATE_IMPORT_ELEMENT(desc, env);
+ import_el = AXIOM_NODE_GET_DATA_ELEMENT(import_el_node, env);
+
+ namespc_uri = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(import_el, env,
+ WODEN_ATTR_NAMESPACE);
+ location_uri = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(import_el, env,
+ WODEN_ATTR_LOCATION);
+
+ imp = woden_import_to_attr_extensible(imp, env);
+ status = parse_ext_attributes(reader, env, import_el_node, "import_element", imp, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ if(NULL != namespc_uri)
+ {
+ axis2_uri_t *uri = NULL;
+
+ /* TODO handle missing namespace attribute (REQUIRED attr) */
+ uri = get_uri(reader, env, namespc_uri);
+ WODEN_IMPORT_SET_NAMESPACE(imp, env, uri);
+ }
+
+ if(NULL != location_uri)
+ {
+ axis2_uri_t *uri = NULL;
+ void *imported_desc = NULL;
+
+ /* TODO handle missing locationURI (OPTIONAL attr) */
+ imp = woden_import_to_import_element(imp, env);
+ uri = get_uri(reader, env, location_uri);
+ WODEN_IMPORT_ELEMENT_SET_LOCATION(imp, env, uri);
+
+ imported_desc = get_wsdl_from_location(reader, env, location_uri, desc,
+ wsdl_modules);
+ WODEN_IMPORT_ELEMENT_SET_DESC_ELEMENT(imp, env, imported_desc);
+ }
+
+ return imp;
+}
+
+static void *
+parse_include(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *include_el_node,
+ void *desc,
+ axis2_hash_t *wsdl_modules)
+{
+ void *include = NULL;
+ axiom_element_t *include_el = NULL;
+ axis2_char_t *location_uri = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ include = WODEN_WSDL10_DESC_ELEMENT_CREATE_INCLUDE_ELEMENT(desc, env);
+ include_el = AXIOM_NODE_GET_DATA_ELEMENT(include_el_node, env);
+
+ location_uri = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(include_el, env,
+ WODEN_ATTR_LOCATION);
+
+ include = woden_include_to_attr_extensible(include, env);
+ status = parse_ext_attributes(reader, env, include_el_node, "include_element",
+ include, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ if(NULL != location_uri)
+ {
+ axis2_uri_t *uri = NULL;
+ void *included_desc = NULL;
+
+ uri = get_uri(reader, env, location_uri);
+ include = woden_include_to_include_element(include, env);
+ WODEN_INCLUDE_ELEMENT_SET_LOCATION(include, env, uri);
+
+ included_desc = get_wsdl_from_location(reader, env, location_uri, desc,
+ wsdl_modules);
+ WODEN_INCLUDE_ELEMENT_SET_DESC_ELEMENT(include, env, included_desc);
+ }
+
+ return include;
+}
+
+/*
+ * TODO Initial schema parsing is specific to XML Schema.
+ * Need generic support for other type systems.
+ * Consider extension architecture with serializer/deserializer.
+ */
+
+static void *
+parse_types(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *types_el_node,
+ void *desc)
+{
+ void *types = NULL;
+ axiom_element_t *types_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ types = WODEN_WSDL10_DESC_ELEMENT_CREATE_TYPES_ELEMENT(desc, env);
+ types = woden_types_to_types_element(types, env);
+ WODEN_TYPES_ELEMENT_SET_TYPE_SYSTEM(types, env, WODEN_TYPE_XSD_2001);
+
+ types = woden_types_to_attr_extensible(types, env);
+ status = parse_ext_attributes(reader, env, types_el_node, "types_element",
+ types, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ types_el = AXIOM_NODE_GET_DATA_ELEMENT(types_el_node, env);
+ temp_el = axiom_util_get_first_child_element(types_el, env, types_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_temp_el_type = NULL;
+
+ q_temp_el_type = axis2_qname_util_new_qname(env, temp_el_node);
+ q_elem_documentation = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_DOCUMENTATION);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ types = woden_types_to_documentable(types, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(types, env, documentation);
+ }
+ if(AXIS2_TRUE == woden_schema_constants_compare_import(q_temp_el_type, env))
+ {
+ void *schema = NULL;
+
+ schema = parse_schema_import(reader, env, temp_el_node, desc);
+ if(schema)
+ {
+ types = woden_types_to_types_element(types, env);
+ schema = woden_imported_schema_to_schema(schema, env);
+ WODEN_TYPES_ELEMENT_ADD_SCHEMA(types, env, schema);
+ }
+ }
+ if(AXIS2_TRUE == woden_schema_constants_compare_schema(q_temp_el_type, env))
+ {
+ void *schema = NULL;
+
+ schema = parse_schema_inline(reader, env, temp_el_node, desc);
+ if(schema)
+ {
+ types = woden_types_to_types_element(types, env);
+ schema = woden_inlined_schema_to_schema(schema, env);
+ WODEN_TYPES_ELEMENT_ADD_SCHEMA(types, env, schema);
+ }
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "types_element",
+ types, temp_el_node, desc);
+
+ documentable = WODEN_TYPES_GET_BASE_IMPL(types, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(types, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return types;
+}
+
+static void *
+parse_schema_inline(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *schema_el_node,
+ void *desc)
+{
+ void *schema = NULL;
+ axis2_char_t *attr_id = NULL;
+ axis2_char_t *tns = NULL;
+ axis2_uri_t *base_uri = NULL;
+ axis2_char_t *base_uri_str = NULL;
+ xml_schema_t *schema_def = NULL;
+ xml_schema_collection_t *xsc = NULL;
+ axiom_element_t *schema_el = NULL;
+
+ schema = woden_inlined_schema_create(env);
+ schema_el = AXIOM_NODE_GET_DATA_ELEMENT(schema_el_node, env);
+ attr_id = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(schema_el, env,
+ WODEN_ATTR_ID);
+ WODEN_INLINED_SCHEMA_SET_ID(schema, env, attr_id);
+ tns = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(schema_el, env,
+ WODEN_ATTR_TARGET_NAMESPACE);
+
+ if(NULL != tns)
+ {
+ void *base = WODEN_INLINED_SCHEMA_GET_BASE_IMPL(schema, env);
+ axis2_uri_t *uri = get_uri(reader, env, tns);
+ WODEN_SCHEMA_SET_NAMESPACE(base, env, uri);
+ }
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ base_uri = WODEN_WSDL10_DESC_ELEMENT_GET_DOCUMENT_BASE_URI(desc, env);
+ if(base_uri)
+ base_uri_str = AXIS2_URI_TO_STRING(base_uri, env,
+ AXIS2_URI_UNP_OMITUSERINFO);
+
+ xsc = xml_schema_collection_create(env);
+ /* TODO Temporarily assume that imported schemas are stored as files
+ * with the url as file name
+ */
+ schema_def = XML_SCHEMA_COLLECTION_READ_ELEMENT_WITH_URI(xsc,
+ env, schema_el_node, base_uri_str);
+ if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
+ {
+ return NULL;
+ }
+ if(schema_def)
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_INLINED_SCHEMA_GET_BASE_IMPL(schema, env);
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_TRUE);
+ WODEN_SCHEMA_SET_SCHEMA_DEF(base_schema, env, schema_def);
+ }
+ else
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_INLINED_SCHEMA_GET_BASE_IMPL(schema, env);
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_FALSE);
+ }
+
+ return schema;
+}
+
+/*
+ * Parse the <xs:import> element and retrieve the imported
+ * schema document if schemaLocation specified. Failure to retrieve
+ * the schema will only matter if any WSDL components contain elements or
+ * constraints that refer to the schema, and typically this will be
+ * determined later by WSDL validation. So just report any such errors
+ * and return the Schema Import object (i.e. with a null schema property).
+ *
+ * WSDL 2.0 spec validation:
+ * - namespace attribute is REQUIRED
+ * - imported schema MUST have a targetNamespace
+ * - namespace and targetNamespace MUST be the same
+ */
+static void *
+parse_schema_import(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *import_el_node,
+ void *desc)
+{
+ woden_wsdl10_reader_impl_t *reader_impl = NULL;
+ void *schema = NULL;
+ axis2_char_t *ns = NULL;
+ axis2_char_t *sloc = NULL;
+ axis2_char_t *schema_uri = NULL;
+ axis2_uri_t *uri = NULL;
+ void *schema_def = NULL;
+ axis2_uri_t *context_uri = NULL;
+ axis2_char_t *schema_loc = NULL;
+ axiom_element_t *import_el = NULL;
+ void *base_schema = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, desc, NULL);
+ reader_impl = INTF_TO_IMPL(reader);
+
+ schema = woden_imported_schema_create(env);
+ base_schema = WODEN_IMPORTED_SCHEMA_GET_BASE_IMPL(schema, env);
+ if(!schema)
+ return NULL;
+ import_el = AXIOM_NODE_GET_DATA_ELEMENT(import_el_node, env);
+ ns = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(import_el, env,
+ WODEN_ATTR_NAMESPACE);
+ if(NULL != ns)
+ {
+ uri = get_uri(reader, env, ns);
+ WODEN_SCHEMA_SET_NAMESPACE(base_schema, env, uri);
+ }
+ sloc = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(import_el, env,
+ WODEN_ATTR_SCHEMA_LOCATION);
+ if(NULL != sloc)
+ {
+ uri = get_uri(reader, env, sloc);
+ WODEN_IMPORTED_SCHEMA_SET_LOCATION(schema, env, uri);
+ }
+
+ if(NULL == WODEN_SCHEMA_GET_NAMESPACE(base_schema, env))
+ {
+
+ /* The namespace attribute is REQUIRED on xs:import, so don't continue. */
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_FALSE);
+ return schema;
+ }
+
+ if(NULL == WODEN_IMPORTED_SCHEMA_GET_LOCATION(schema, env))
+ {
+ /* This is a namespace-only import, no schema document to be retrieved so don't continue.*/
+
+ /* TODO investigate whether/how to try to resolve the imported namespace to known schema
+ * components from that namespace (e.g. via a URI catalog resolver). Currently, any attempt
+ * to resolve a QName against schema components from this namespace will search ALL
+ * schemas imported from this namespace (see methods in TypesImpl).
+ */
+
+ return schema;
+ }
+
+ /* Now try to retrieve the schema import using schemaLocation */
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ context_uri = WODEN_WSDL10_DESC_ELEMENT_GET_DOCUMENT_BASE_URI(desc, env);
+ uri = WODEN_IMPORTED_SCHEMA_GET_LOCATION(schema, env);
+ schema_loc = AXIS2_URI_TO_STRING(uri, env, AXIS2_URI_UNP_OMITUSERINFO);
+ uri = axis2_uri_parse_relative(env, context_uri, schema_loc);
+ if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_IMPORTED_SCHEMA_GET_BASE_IMPL(schema, env);
+ /* can't continue schema retrieval with a bad URL.*/
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_FALSE);
+ return schema;
+ }
+
+ schema_uri = AXIS2_URI_TO_STRING(uri, env, AXIS2_URI_UNP_OMITUSERINFO);
+
+ /* If the schema has already been imported, reuse it. */
+ schema_def = axis2_hash_get(reader_impl->f_imported_schemas, schema_uri,
+ AXIS2_HASH_KEY_STRING);
+ if(NULL != schema_def)
+ {
+ /* Not previously imported, so retrieve it now. */
+ xml_schema_collection_t *schema_col = NULL;
+ axiom_xml_reader_t *xml_reader = NULL;
+ axiom_document_t *imported_schema_doc = NULL;
+ axiom_stax_builder_t *xml_builder = NULL;
+
+ schema_col = xml_schema_collection_create(env);
+ /* TODO Temporarily assume that imported schemas are stored as files
+ * with the url as file name
+ */
+ xml_reader = axiom_xml_reader_create_for_file(env, schema_uri, NULL);
+ xml_builder = axiom_stax_builder_create(env, reader);
+ imported_schema_doc = axiom_document_create(env, NULL, xml_builder);
+ schema_def = XML_SCHEMA_COLLECTION_READ_DOCUMENT(schema_col,
+ env, imported_schema_doc);
+ if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error))
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_IMPORTED_SCHEMA_GET_BASE_IMPL(schema, env);
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_FALSE);
+ return schema;
+ }
+ axis2_hash_set(reader_impl->f_imported_schemas, schema_uri,
+ AXIS2_HASH_KEY_STRING, schema_def);
+
+ }
+
+ if(NULL != schema_def)
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_IMPORTED_SCHEMA_GET_BASE_IMPL(schema, env);
+ WODEN_SCHEMA_SET_SCHEMA_DEF(base_schema, env, schema_def);
+ } else
+ {
+ void *base_schema = NULL;
+
+ base_schema = WODEN_IMPORTED_SCHEMA_GET_BASE_IMPL(schema, env);
+ WODEN_SCHEMA_SET_REFERENCEABLE(base_schema, env, AXIS2_FALSE);
+ }
+
+ return schema;
+}
+
+static void *
+parse_msg_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *msg_el_node,
+ void *desc)
+{
+ void *msg = NULL;
+ axis2_char_t *name = NULL;
+ axiom_element_t *msg_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ msg = WODEN_WSDL10_DESC_ELEMENT_CREATE_MSG_ELEMENT(desc, env);
+
+ msg_el = AXIOM_NODE_GET_DATA_ELEMENT(msg_el_node, env);
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(msg_el, env, WODEN_ATTR_NAME);
+
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ msg = woden_wsdl10_msg_ref_to_msg_ref_element(msg, env);
+ WODEN_WSDL10_MSG_REF_ELEMENT_SET_QNAME(msg, env, qname);
+ }
+
+ /* TODO extends attribute */
+
+ msg = woden_wsdl10_msg_ref_to_attr_extensible(msg, env);
+ status = parse_ext_attributes(reader, env, msg_el_node, "msg_element",
+ msg, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ /* Parse the child elements of <msg>.
+ * As per WSDL 2.0 spec, they must be in the following order if present:
+ * <documentation>
+ * <part> or extension elements in any order
+ * TODO validate that the elements are in correct order
+ */
+ temp_el = axiom_util_get_first_child_element(msg_el, env, msg_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_elem_part = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env, WODEN_Q_ELEM_DOCUMENTATION);
+ q_elem_part = axis2_qname_create_from_string(env, WODEN_Q_ELEM_PART);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ msg = woden_wsdl10_msg_ref_to_documentable(msg, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(msg, env, documentation);
+ }
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_part, temp_el_node))
+ {
+ void *part = NULL;
+
+ part = parse_part(reader, env, temp_el_node, desc,
+ msg);
+ msg = woden_wsdl10_msg_ref_to_msg_ref_element(msg, env);
+ WODEN_WSDL10_MSG_REF_ELEMENT_SET_PART(msg, env, part);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *nested_confble = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "msg_element",
+ msg, temp_el_node, desc);
+
+ nested_confble = WODEN_WSDL10_MSG_REF_GET_BASE_IMPL(msg, env);
+ configurable = WODEN_NESTED_CONFIGURABLE_GET_BASE_IMPL(nested_confble, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(msg, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return msg;
+}
+
+static void *
+parse_part(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *part_el_node,
+ void *desc,
+ void *parent)
+{
+ void *part = NULL;
+ axis2_char_t *element = NULL;
+ axis2_char_t *name = NULL;
+ axiom_element_t *part_el;
+ axiom_element_t *temp_el;
+ axiom_node_t *temp_el_node;
+ void *types = NULL;
+ void *nested_configurable = NULL;
+ axis2_char_t *localname = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ part = WODEN_WSDL10_DESC_ELEMENT_CREATE_PART_ELEMENT(desc,
+ env);
+ nested_configurable = WODEN_WSDL10_PART_GET_BASE_IMPL(part, env);
+ nested_configurable = woden_nested_configurable_to_nested_element(
+ nested_configurable, env);
+ WODEN_NESTED_ELEMENT_SET_PARENT_ELEMENT(nested_configurable, env, parent);
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ types = WODEN_WSDL10_DESC_ELEMENT_GET_TYPES_ELEMENT(desc, env);
+ WODEN_WSDL10_PART_SET_TYPES(part, env, types);
+
+ part_el = AXIOM_NODE_GET_DATA_ELEMENT(part_el_node, env);
+ localname = AXIOM_ELEMENT_GET_LOCALNAME(part_el, env);
+ if(0 != AXIS2_STRCMP(WODEN_ELEM_PART, localname))
+ {
+ /* TODO Set No element error */
+ return NULL;
+ }
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(part_el, env, WODEN_ATTR_NAME);
+
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ part = woden_wsdl10_part_to_part_element(part, env);
+ WODEN_WSDL10_PART_ELEMENT_SET_QNAME(part, env, qname);
+ }
+ element = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(part_el, env, WODEN_ATTR_ELEMENT);
+
+ if(NULL != element)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_hash_t *namespcs = NULL;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ namespcs = WODEN_WSDL10_DESC_ELEMENT_GET_NAMESPACES(desc, env);
+
+ qname = woden_om_util_get_qname(env, part_el_node, element, namespcs);
+ part = woden_wsdl10_part_to_part_element(part, env);
+ WODEN_WSDL10_PART_ELEMENT_SET_ELEMENT_QNAME(part,
+ env, qname);
+ }
+
+ part = woden_wsdl10_part_to_attr_extensible(part, env);
+ status = parse_ext_attributes(reader, env, part_el_node, "interface_part_element",
+ part, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ temp_el = axiom_util_get_first_child_element(part_el, env, part_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_DOCUMENTATION);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ part = woden_wsdl10_part_to_documentable(part, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(part, env, documentation);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *nested_confble = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "interface_part_element",
+ part, temp_el_node, desc);
+
+ nested_confble = WODEN_WSDL10_PART_GET_BASE_IMPL(part, env);
+ configurable = WODEN_NESTED_CONFIGURABLE_GET_BASE_IMPL(nested_confble, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(part, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return part;
+}
+
+static void *
+parse_interface(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *interface_el_node,
+ void *desc)
+{
+ void *intface = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *style_default = NULL;
+ axiom_element_t *interface_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ intface = WODEN_WSDL10_DESC_ELEMENT_CREATE_INTERFACE_ELEMENT(desc, env);
+
+ interface_el = AXIOM_NODE_GET_DATA_ELEMENT(interface_el_node, env);
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(interface_el, env, WODEN_ATTR_NAME);
+
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ intface = woden_interface_to_interface_element(intface, env);
+ WODEN_INTERFACE_ELEMENT_SET_QNAME(intface, env, qname);
+ }
+
+ style_default = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(interface_el,
+ env, WODEN_ATTR_STYLE_DEFAULT);
+
+ if(NULL != style_default)
+ {
+ axis2_array_list_t *string_list = NULL;
+ axis2_char_t *uri_str = NULL;
+ int i = 0, size = 0;
+
+ string_list = axis2_tokenize(env, style_default, ' ');
+ if(string_list)
+ size = AXIS2_ARRAY_LIST_SIZE(string_list, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_uri_t *uri = NULL;
+ uri_str = AXIS2_ARRAY_LIST_GET(string_list, env, i);
+ intface = woden_interface_to_interface_element(intface, env);
+ uri = get_uri(reader, env, uri_str);
+ WODEN_INTERFACE_ELEMENT_ADD_STYLE_DEFAULT_URI(intface, env, uri);
+ }
+ }
+
+ /* TODO extends attribute */
+
+ intface = woden_interface_to_attr_extensible(intface, env);
+ status = parse_ext_attributes(reader, env, interface_el_node, "interface_element",
+ intface, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ /* Parse the child elements of <interface>.
+ * As per WSDL 2.0 spec, they must be in the following order if present:
+ * <documentation>
+ * <fault> <operation> <feature> <property> or extension elements in any order
+ * TODO validate that the elements are in correct order
+ */
+ temp_el = axiom_util_get_first_child_element(interface_el, env, interface_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_elem_op = NULL;
+ axis2_qname_t *q_elem_feature = NULL;
+ axis2_qname_t *q_elem_property = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env, WODEN_Q_ELEM_DOCUMENTATION);
+ q_elem_op = axis2_qname_create_from_string(env, WODEN_Q_ELEM_OPERATION);
+ q_elem_feature = axis2_qname_create_from_string(env, WODEN_Q_ELEM_FEATURE);
+ q_elem_property = axis2_qname_create_from_string(env, WODEN_Q_ELEM_PROPERTY);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ intface = woden_interface_to_documentable(intface, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(intface, env, documentation);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_op, temp_el_node))
+ {
+ void *intface_op = NULL;
+
+ intface_op = parse_interface_op(reader, env, temp_el_node, desc,
+ intface);
+ intface = woden_interface_to_interface_element(intface, env);
+ WODEN_INTERFACE_ELEMENT_ADD_INTERFACE_OP_ELEMENT(intface, env, intface_op);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_feature, temp_el_node))
+ {
+ void *feature = NULL;
+ void *configurable = NULL;
+
+ feature = parse_feature(reader, env, temp_el_node, desc, intface);
+ configurable = WODEN_INTERFACE_GET_BASE_IMPL(intface, env);
+ configurable = woden_configurable_to_configurable_element(configurable, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_FEATURE_ELEMENT(configurable, env, feature);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_property, temp_el_node))
+ {
+ void *property = NULL;
+ void *configurable = NULL;
+
+ property = parse_property(reader, env, temp_el_node, desc, intface);
+ configurable = WODEN_INTERFACE_GET_BASE_IMPL(intface, env);
+ configurable = woden_configurable_to_configurable_element(configurable, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_PROPERTY_ELEMENT(configurable, env, property);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "interface_element",
+ intface, temp_el_node, desc);
+
+ configurable = WODEN_INTERFACE_GET_BASE_IMPL(intface, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(intface, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return intface;
+}
+
+static void *
+parse_interface_op(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *op_el_node,
+ void *desc,
+ void *parent)
+{
+ void *op = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *style = NULL;
+ axis2_char_t *pat = NULL;
+ axiom_element_t *op_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ void *nested_configurable = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ op = WODEN_WSDL10_DESC_ELEMENT_CREATE_INTERFACE_OP_ELEMENT(desc, env);
+ nested_configurable = WODEN_INTERFACE_OP_GET_BASE_IMPL(op, env);
+ nested_configurable = woden_nested_configurable_to_nested_element(
+ nested_configurable, env);
+ WODEN_NESTED_ELEMENT_SET_PARENT_ELEMENT(nested_configurable, env, parent);
+
+ op_el = AXIOM_NODE_GET_DATA_ELEMENT(op_el_node, env);
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(op_el, env, WODEN_ATTR_NAME);
+
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *ns = NULL;
+ axis2_char_t *ns_str = NULL;
+
+ ns = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ ns_str = AXIS2_URI_TO_STRING(ns, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, ns_str, NULL);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_SET_QNAME(op, env, qname);
+ }
+
+ style = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(op_el, env, WODEN_ATTR_STYLE);
+
+ if(NULL != style)
+ {
+ axis2_array_list_t *str_list = NULL;
+ axis2_char_t *uri_str = NULL;
+ axis2_uri_t *uri = NULL;
+ int i = 0, size = 0;
+
+ size = AXIS2_ARRAY_LIST_SIZE(str_list, env);
+ axis2_tokenize(env, style, ' ');
+ for(i = 0; i < size; i++)
+ {
+ uri_str = AXIS2_ARRAY_LIST_GET(str_list, env, i);
+ uri = get_uri(reader, env, uri_str);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_ADD_STYLE_URI(op, env, uri);
+ }
+ }
+
+ pat = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(op_el, env, WODEN_ATTR_PATTERN);
+
+ if(NULL != pat)
+ {
+ axis2_uri_t *uri = NULL;
+
+ uri = get_uri(reader, env, pat);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_SET_PATTERN(op, env, uri);
+ }
+ op = woden_interface_op_to_attr_extensible(op, env);
+ status = parse_ext_attributes(reader, env, op_el_node, "interface_op_element",
+ op, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ /* Parse the child elements of interface <operation>.
+ * As per WSDL 2.0 spec, they must be in the following order if present:
+ * <documentation>
+ * <input> <output> <infault> <outfault> <feature> <property> or extension elements in any order
+ * TODO validate that the elements are in correct order
+ */
+ temp_el = axiom_util_get_first_child_element(op_el, env, op_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_elem_feature = NULL;
+ axis2_qname_t *q_elem_property = NULL;
+ axis2_qname_t *q_elem_input = NULL;
+ axis2_qname_t *q_elem_output = NULL;
+ axis2_qname_t *q_elem_infault = NULL;
+ axis2_qname_t *q_elem_outfault = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_DOCUMENTATION);
+ q_elem_feature = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_FEATURE);
+ q_elem_property = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_PROPERTY);
+ q_elem_input = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_INPUT);
+ q_elem_output = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_OUTPUT);
+ q_elem_infault = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_INFAULT);
+ q_elem_outfault = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_OUTFAULT);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ op = woden_interface_op_to_documentable(op, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(op, env, documentation);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_feature, temp_el_node))
+ {
+ void *feature = NULL;
+
+ feature = parse_feature(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_configurable_element(op, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_FEATURE_ELEMENT(op, env, feature);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_property, temp_el_node))
+ {
+ void *property = NULL;
+
+ property = parse_property(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_configurable_element(op, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_PROPERTY_ELEMENT(op, env, property);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_input, temp_el_node))
+ {
+ void *input = NULL;
+
+ input = parse_interface_msg_ref(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_ADD_INTERFACE_MSG_REF_ELEMENT(op, env, input);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_output, temp_el_node))
+ {
+ void *output = NULL;
+
+ output = parse_interface_msg_ref(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_ADD_INTERFACE_MSG_REF_ELEMENT(op, env, output);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_infault, temp_el_node))
+ {
+ void *infault = NULL;
+
+ infault = parse_interface_fault_ref(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_ADD_INTERFACE_FAULT_REF_ELEMENT(op, env, infault);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_outfault, temp_el_node))
+ {
+ void *outfault = NULL;
+
+ outfault = parse_interface_fault_ref(reader, env, temp_el_node, desc, op);
+ op = woden_interface_op_to_interface_op_element(op, env);
+ WODEN_INTERFACE_OP_ELEMENT_ADD_INTERFACE_FAULT_REF_ELEMENT(op, env, outfault);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *nested_confble = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "interface_op_element",
+ op, temp_el_node, desc);
+
+ nested_confble = WODEN_INTERFACE_OP_GET_BASE_IMPL(op, env);
+ configurable = WODEN_NESTED_CONFIGURABLE_GET_BASE_IMPL(nested_confble, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(op, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return op;
+}
+
+static void *
+parse_interface_fault_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *fault_ref_el_node,
+ void *desc,
+ void *parent)
+{
+ void *fault_ref = NULL;
+ axis2_char_t *localname = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *msg = NULL;
+ axiom_element_t *fault_ref_el = NULL;
+ axiom_element_t *temp_el = NULL;
+ axiom_node_t *temp_el_node = NULL;
+ void *nested_configurable = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ fault_ref = WODEN_WSDL10_DESC_ELEMENT_CREATE_INTERFACE_FAULT_REF_ELEMENT(desc,
+ env);
+ nested_configurable = WODEN_WSDL10_INTERFACE_FAULT_REF_GET_BASE_IMPL(fault_ref, env);
+ nested_configurable = woden_nested_configurable_to_nested_element(
+ nested_configurable, env);
+ WODEN_NESTED_ELEMENT_SET_PARENT_ELEMENT(nested_configurable, env, parent);
+
+ fault_ref_el = AXIOM_NODE_GET_DATA_ELEMENT(fault_ref_el_node, env);
+ localname = AXIOM_ELEMENT_GET_LOCALNAME(fault_ref_el, env);
+ if(0 == AXIS2_STRCMP(WODEN_ELEM_INFAULT, localname))
+ {
+ woden_direction_t *direction_in = NULL;
+
+ direction_in = woden_direction_get_direction_in(env);
+ WODEN_WSDL10_INTERFACE_FAULT_REF_ELEMENT_SET_DIRECTION(fault_ref, env, direction_in);
+ }
+ if(0 == AXIS2_STRCMP(WODEN_ELEM_OUTFAULT, localname))
+ {
+ woden_direction_t *direction_out = NULL;
+
+ direction_out = woden_direction_get_direction_out(env);
+ fault_ref = woden_wsdl10_interface_fault_ref_to_interface_fault_ref_element(
+ fault_ref, env);
+ WODEN_WSDL10_INTERFACE_FAULT_REF_ELEMENT_SET_DIRECTION(fault_ref, env, direction_out);
+ }
+
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(fault_ref_el, env, WODEN_ATTR_NAME);
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ fault_ref =
+ woden_wsdl10_interface_fault_ref_to_interface_fault_ref_element(
+ fault_ref, env);
+ WODEN_WSDL10_INTERFACE_FAULT_REF_ELEMENT_SET_QNAME(fault_ref, env, qname);
+ }
+
+ msg = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(fault_ref_el, env, WODEN_ATTR_MSG);
+ if(NULL != msg)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, msg, namespc_str, NULL);
+ fault_ref =
+ woden_wsdl10_interface_fault_ref_to_interface_fault_ref_element(
+ fault_ref, env);
+ WODEN_WSDL10_INTERFACE_FAULT_REF_ELEMENT_SET_MSG_QNAME(fault_ref, env, qname);
+ }
+
+ fault_ref = woden_wsdl10_interface_fault_ref_to_attr_extensible(fault_ref, env);
+ status = parse_ext_attributes(reader, env, fault_ref_el_node, "interface_fault_ref_element",
+ fault_ref, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ temp_el = axiom_util_get_first_child_element(fault_ref_el, env, fault_ref_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_DOCUMENTATION);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ fault_ref = woden_wsdl10_interface_fault_ref_to_documentable(fault_ref, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(fault_ref, env, documentation);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *nested_confble = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "interface_fault_ref_element",
+ fault_ref, temp_el_node, desc);
+
+ nested_confble = WODEN_WSDL10_INTERFACE_FAULT_REF_GET_BASE_IMPL(fault_ref, env);
+ configurable = WODEN_NESTED_CONFIGURABLE_GET_BASE_IMPL(nested_confble, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(fault_ref, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return fault_ref;
+}
+
+static void *
+parse_interface_msg_ref(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *msg_ref_el_node,
+ void *desc,
+ void *parent)
+{
+ void *msg_ref = NULL;
+ axis2_char_t *localname = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *msg = NULL;
+ axiom_element_t *msg_ref_el;
+ axiom_element_t *temp_el;
+ axiom_node_t *temp_el_node;
+ void *nested_configurable = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ msg_ref = WODEN_WSDL10_DESC_ELEMENT_CREATE_INTERFACE_MSG_REF_ELEMENT(desc,
+ env);
+ nested_configurable = WODEN_WSDL10_INTERFACE_MSG_REF_GET_BASE_IMPL(msg_ref, env);
+ nested_configurable = woden_nested_configurable_to_nested_element(
+ nested_configurable, env);
+ WODEN_NESTED_ELEMENT_SET_PARENT_ELEMENT(nested_configurable, env, parent);
+
+ msg_ref_el = AXIOM_NODE_GET_DATA_ELEMENT(msg_ref_el_node, env);
+ localname = AXIOM_ELEMENT_GET_LOCALNAME(msg_ref_el, env);
+ if(0 == AXIS2_STRCMP(WODEN_ELEM_INPUT, localname))
+ {
+ woden_direction_t *direction_in = NULL;
+
+ direction_in = woden_direction_get_direction_in(env);
+ msg_ref = woden_wsdl10_interface_msg_ref_to_interface_msg_ref_element(
+ msg_ref, env);
+ WODEN_WSDL10_INTERFACE_MSG_REF_ELEMENT_SET_DIRECTION(msg_ref, env, direction_in);
+ }
+ if(0 == AXIS2_STRCMP(WODEN_ELEM_OUTPUT, localname))
+ {
+ woden_direction_t *direction_out = NULL;
+
+ direction_out = woden_direction_get_direction_out(env);
+ msg_ref = woden_wsdl10_interface_msg_ref_to_interface_msg_ref_element(
+ msg_ref, env);
+ WODEN_WSDL10_INTERFACE_MSG_REF_ELEMENT_SET_DIRECTION(msg_ref, env, direction_out);
+ }
+
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(msg_ref_el, env, WODEN_ATTR_NAME);
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ msg_ref = woden_wsdl10_interface_msg_ref_to_interface_msg_ref_element(
+ msg_ref, env);
+ WODEN_WSDL10_INTERFACE_MSG_REF_ELEMENT_SET_QNAME(msg_ref, env, qname);
+ }
+
+ msg = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(msg_ref_el, env, WODEN_ATTR_MSG);
+ if(NULL != msg)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+ axis2_array_list_t *msgs = NULL;
+ int i = 0, size = 0;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, msg, namespc_str, NULL);
+ msg_ref = woden_wsdl10_interface_msg_ref_to_interface_msg_ref_element(
+ msg_ref, env);
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ msgs = WODEN_WSDL10_DESC_ELEMENT_GET_MSG_ELEMENTS(desc, env);
+ if(msgs)
+ size = AXIS2_ARRAY_LIST_SIZE(msgs, env);
+ for(i = 0; i < size; i++)
+ {
+ void *msg = NULL;
+ axis2_qname_t *msg_qname = NULL;
+
+ msg = AXIS2_ARRAY_LIST_GET(msgs, env, i);
+ msg_qname = WODEN_WSDL10_MSG_REF_GET_QNAME(msg, env);
+ if(AXIS2_TRUE == AXIS2_QNAME_EQUALS(msg_qname, env, qname))
+ {
+ WODEN_WSDL10_INTERFACE_MSG_REF_ELEMENT_SET_MSG(msg_ref, env, msg);
+ }
+ }
+ WODEN_WSDL10_INTERFACE_MSG_REF_ELEMENT_SET_MSG_QNAME(msg_ref, env, qname);
+ }
+ msg_ref = woden_wsdl10_interface_msg_ref_to_attr_extensible(msg_ref, env);
+ status = parse_ext_attributes(reader, env, msg_ref_el_node,
+ "interface_msg_ref_element", msg_ref, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ temp_el = axiom_util_get_first_child_element(msg_ref_el, env, msg_ref_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env,
+ WODEN_Q_ELEM_DOCUMENTATION);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ msg_ref = woden_wsdl10_interface_msg_ref_to_documentable(msg_ref, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(msg_ref, env, documentation);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *nested_confble = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "interface_msg_ref_element",
+ msg_ref, temp_el_node, desc);
+
+ nested_confble = WODEN_WSDL10_INTERFACE_MSG_REF_GET_BASE_IMPL(msg_ref, env);
+ configurable = WODEN_NESTED_CONFIGURABLE_GET_BASE_IMPL(nested_confble, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(msg_ref, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return msg_ref;
+}
+
+static void *
+parse_binding(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *binding_el_node,
+ void *desc)
+{
+ void *binding = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *type = NULL;
+ axis2_char_t *intface = NULL;
+ axiom_element_t *binding_el;
+ axiom_element_t *temp_el;
+ axiom_node_t *temp_el_node;
+ axis2_qname_t *intface_qn = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ binding = WODEN_WSDL10_DESC_ELEMENT_CREATE_BINDING_ELEMENT(desc, env);
+
+ binding_el = AXIOM_NODE_GET_DATA_ELEMENT(binding_el_node, env);
+ name = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(binding_el, env, WODEN_ATTR_NAME);
+
+ if(NULL != name)
+ {
+ axis2_qname_t *qname = NULL;
+ axis2_uri_t *namespc = NULL;
+ axis2_char_t *namespc_str = NULL;
+
+ namespc = WODEN_WSDL10_DESC_ELEMENT_GET_TARGET_NAMESPACE(desc, env);
+ namespc_str = AXIS2_URI_TO_STRING(namespc, env, AXIS2_URI_UNP_OMITUSERINFO);
+ qname = axis2_qname_create(env, name, namespc_str, NULL);
+ binding = woden_binding_to_binding_element(binding, env);
+ WODEN_BINDING_ELEMENT_SET_QNAME(binding, env, qname);
+ }
+
+ intface = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(binding_el, env, WODEN_ATTR_INTERFACE);
+ if(NULL != intface)
+ {
+ axis2_hash_t *namespcs = NULL;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ namespcs = WODEN_WSDL10_DESC_ELEMENT_GET_NAMESPACES(desc, env);
+ intface_qn = woden_om_util_get_qname(env, binding_el_node, intface, namespcs);
+ binding = woden_binding_to_binding_element(binding, env);
+ WODEN_BINDING_ELEMENT_SET_INTERFACE_QNAME(binding, env, intface_qn);
+ }
+ /* Dereference the interface qname */
+ if(NULL != intface_qn)
+ {
+ axis2_array_list_t *interfaces = NULL;
+ int i = 0, size = 0;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ interfaces = WODEN_WSDL10_DESC_ELEMENT_GET_INTERFACE_ELEMENTS(desc, env);
+ size = AXIS2_ARRAY_LIST_SIZE(interfaces, env);
+ for(i = 0; i < size; i++)
+ {
+ void *intface = NULL;
+ axis2_qname_t *qname = NULL;
+
+ intface = AXIS2_ARRAY_LIST_GET(interfaces, env, i);
+ intface = woden_interface_to_interface_element(intface, env);
+ qname = WODEN_INTERFACE_ELEMENT_GET_QNAME(intface, env);
+ if(AXIS2_TRUE == AXIS2_QNAME_EQUALS(intface_qn, env, qname))
+ {
+ WODEN_BINDING_SET_INTERFACE_ELEMENT(binding, env, intface);
+ }
+ }
+ }
+
+ type = AXIOM_ELEMENT_GET_ATTRIBUTE_VALUE_BY_NAME(binding_el, env, WODEN_ATTR_TYPE);
+
+ if(NULL != type)
+ {
+ axis2_uri_t *uri = NULL;
+
+ uri = get_uri(reader, env, type);
+ binding = woden_binding_to_binding_element(binding, env);
+ WODEN_BINDING_ELEMENT_SET_TYPE(binding, env, uri);
+ }
+
+ /* TODO extends attribute */
+
+ configurable = WODEN_BINDING_GET_BASE_IMPL(binding, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ status = parse_ext_attributes(reader, env, binding_el_node, "binding_element",
+ wsdl_obj, desc);
+ if(AXIS2_SUCCESS != status)
+ return NULL;
+
+ /* Parse the child elements of <binding>.
+ * As per WSDL 2.0 spec, they must be in the following order if present:
+ * <documentation>
+ * <fault> <operation> <feature> <property> or extension elements in any order
+ * TODO validate that the elements are in correct order
+ */
+ temp_el = axiom_util_get_first_child_element(binding_el, env, binding_el_node,
+ &temp_el_node);
+
+ while (NULL != temp_el && NULL != temp_el_node)
+ {
+ axis2_qname_t *q_elem_documentation = NULL;
+ axis2_qname_t *q_elem_op = NULL;
+ axis2_qname_t *q_elem_feature = NULL;
+ axis2_qname_t *q_elem_property = NULL;
+
+ q_elem_documentation = axis2_qname_create_from_string(env, WODEN_Q_ELEM_DOCUMENTATION);
+ q_elem_op = axis2_qname_create_from_string(env, WODEN_Q_ELEM_OPERATION);
+ q_elem_feature = axis2_qname_create_from_string(env, WODEN_Q_ELEM_FEATURE);
+ q_elem_property = axis2_qname_create_from_string(env, WODEN_Q_ELEM_PROPERTY);
+
+ if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_documentation, temp_el_node))
+ {
+ void *documentation = NULL;
+
+ documentation = parse_documentation(reader, env, temp_el_node, desc);
+ binding = woden_binding_to_documentable(binding, env);
+ WODEN_DOCUMENTABLE_ADD_DOCUMENTATION_ELEMENT(binding, env, documentation);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_op, temp_el_node))
+ {
+ void *binding_op = NULL;
+
+ binding_op = parse_binding_op(reader, env, temp_el_node, desc,
+ binding);
+ binding = woden_binding_to_binding_element(binding, env);
+ WODEN_BINDING_ELEMENT_ADD_BINDING_OP_ELEMENT(binding, env, binding_op);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_feature, temp_el_node))
+ {
+ void *feature = NULL;
+
+ feature = parse_feature(reader, env, temp_el_node, desc, binding);
+ binding = woden_binding_to_configurable_element(binding, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_FEATURE_ELEMENT(binding, env, feature);
+ }
+ else if(AXIS2_TRUE == axis2_qname_util_matches(env,
+ q_elem_property, temp_el_node))
+ {
+ void *property = NULL;
+
+ property = parse_property(reader, env, temp_el_node, desc, binding);
+ binding = woden_binding_to_configurable_element(binding, env);
+ WODEN_CONFIGURABLE_ELEMENT_ADD_PROPERTY_ELEMENT(binding, env, property);
+ }
+ else
+ {
+ void *ext_element = NULL;
+ void *configurable = NULL;
+ void *documentable = NULL;
+ void *wsdl_obj = NULL;
+ void *wsdl_el = NULL;
+
+ ext_element = parse_ext_element(reader, env, "binding_element",
+ binding, temp_el_node, desc);
+
+ configurable = WODEN_BINDING_GET_BASE_IMPL(binding, env);
+ documentable = WODEN_CONFIGURABLE_GET_BASE_IMPL(configurable, env);
+ wsdl_obj = WODEN_DOCUMENTABLE_GET_BASE_IMPL(documentable, env);
+ wsdl_el = WODEN_WSDL_OBJ_GET_BASE_IMPL(wsdl_obj, env);
+ wsdl_el = woden_wsdl_element_to_element_extensible(wsdl_el, env);
+ WODEN_ELEMENT_EXTENSIBLE_ADD_EXT_ELEMENT(wsdl_el, env, ext_element);
+ }
+
+ temp_el = axiom_util_get_next_sibling_element(temp_el, env,
+ temp_el_node, &temp_el_node);
+ }
+
+ return binding;
+}
+
+static void *
+parse_binding_op(
+ void *reader,
+ const axis2_env_t *env,
+ axiom_node_t *op_el_node,
+ void *desc,
+ void *parent)
+{
+ void *op = NULL;
+ axis2_char_t *name = NULL;
+ axiom_element_t *op_el;
+ axiom_element_t *temp_el;
+ axiom_node_t *temp_el_node;
+ axis2_qname_t *ref_qn = NULL;
+ void *nested_configurable = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ desc = woden_wsdl10_desc_to_desc_element(desc, env);
+ op = WODEN_WSDL10_DESC_ELEMENT_CREATE_BINDING_OP_ELEMENT(desc, env);
+ nested_configurable = WODEN_WSDL10_BINDING_OP_GET_BASE_IMPL(op, env);
+ nested_configurable = woden_nested_configurable_to_nested_element(
+ nested_configurable, env);
[... 1461 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org