summaryrefslogtreecommitdiffstats
path: root/axiom/src/util
diff options
context:
space:
mode:
authorGravatar gmcdonald2010-02-13 01:32:03 +0000
committerGravatar gmcdonald2010-02-13 01:32:03 +0000
commit0425aadc78680e53000fd0108b540d6eca048516 (patch)
tree8ec7ab8e015d454c5ec586dfc91e05a2dce1cfc0 /axiom/src/util
downloadaxis2c-0425aadc78680e53000fd0108b540d6eca048516.tar.gz
axis2c-0425aadc78680e53000fd0108b540d6eca048516.tar.bz2
Moving axis svn, part of TLP move INFRA-2441
git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'axiom/src/util')
-rw-r--r--axiom/src/util/Makefile.am8
-rw-r--r--axiom/src/util/om_util.c1181
2 files changed, 1189 insertions, 0 deletions
diff --git a/axiom/src/util/Makefile.am b/axiom/src/util/Makefile.am
new file mode 100644
index 0000000..ea76b68
--- /dev/null
+++ b/axiom/src/util/Makefile.am
@@ -0,0 +1,8 @@
+noinst_LTLIBRARIES = libaxis2_axiom_util.la
+libaxis2_axiom_util_la_SOURCES = om_util.c
+
+libaxis2_axiom_util_la_LIBADD =
+INCLUDES = -I$(top_builddir)/include \
+ -I$(top_builddir)/src/parser \
+ -I$(top_builddir)/src/om \
+ -I ../../../util/include
diff --git a/axiom/src/util/om_util.c b/axiom/src/util/om_util.c
new file mode 100644
index 0000000..fcdd90b
--- /dev/null
+++ b/axiom/src/util/om_util.c
@@ -0,0 +1,1181 @@
+/*
+ * 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.
+ */
+
+#include <axiom_node.h>
+#include <axiom_element.h>
+#include <axiom_document.h>
+#include <axutil_array_list.h>
+#include <axutil_uri.h>
+#include <axiom_util.h>
+
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axiom_util_get_child_text(
+ axiom_node_t *node,
+ const axutil_env_t * env)
+{
+ axiom_element_t *ele = NULL;
+ axis2_char_t *txt = NULL;
+
+ ele = (axiom_element_t*)axiom_node_get_data_element(node, env);
+ txt = axiom_element_get_text(ele, env, node);
+
+ return txt;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element_with_uri(
+ axiom_node_t * ele_node,
+ const axutil_env_t * env,
+ axis2_char_t * uri,
+ axiom_node_t ** child)
+{
+ axiom_node_t *child_node = NULL;
+
+ if(!ele_node || !uri)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Element node or uri is NULL");
+ return NULL;
+ }
+
+ child_node = axiom_node_get_first_child(ele_node, env);
+ while(child_node)
+ {
+ if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+ {
+ axiom_element_t *child_ele = NULL;
+ axiom_namespace_t *ns = NULL;
+
+ child_ele = (axiom_element_t *)axiom_node_get_data_element(child_node, env);
+ ns = axiom_element_get_namespace(child_ele, env, child_node);
+ if(ns)
+ {
+ axis2_char_t *child_uri = NULL;
+ child_uri = axiom_namespace_get_uri(ns, env);
+ if(child_uri && axutil_strcmp(child_uri, uri) == 0)
+ {
+ (*child) = child_node;
+ return child_ele;
+ }
+ }
+ }
+ child_node = axiom_node_get_next_sibling(child_node, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_sibling_element_with_uri(
+ axiom_node_t * ele_node,
+ const axutil_env_t * env,
+ axis2_char_t * uri,
+ axiom_node_t ** next_node)
+{
+ axiom_node_t *next_sib_node = NULL;
+ if(!ele_node || !uri)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Element node or uri is NULL");
+ return NULL;
+ }
+
+ next_sib_node = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sib_node)
+ {
+ if(axiom_node_get_node_type(next_sib_node, env) == AXIOM_ELEMENT)
+ {
+ axiom_element_t *sib_ele = NULL;
+ axiom_namespace_t *ns = NULL;
+
+ sib_ele = (axiom_element_t *)axiom_node_get_data_element(next_sib_node, env);
+ ns = axiom_element_get_namespace(sib_ele, env, next_sib_node);
+ if(ns)
+ {
+ axis2_char_t *sib_uri = NULL;
+ sib_uri = axiom_namespace_get_uri(ns, env);
+ if(sib_uri && axutil_strcmp(sib_uri, uri) == 0)
+ {
+ (*next_node) = next_sib_node;
+ return sib_ele;
+ }
+ }
+ }
+ next_sib_node = axiom_node_get_next_sibling(next_sib_node, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axiom_node_t ** child_node)
+{
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+
+ return axiom_element_get_first_element(ele, env, ele_node, child_node);
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_last_child_element(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *last_node = NULL;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+
+ last_node = axiom_node_get_last_child(ele_node, env);
+ while(last_node)
+ {
+ if(axiom_node_get_node_type(last_node, env) == AXIOM_ELEMENT)
+ {
+ *child_node = last_node;
+ return (axiom_element_t *)axiom_node_get_data_element(last_node, env);
+
+ }
+ last_node = axiom_node_get_previous_sibling(ele_node, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_sibling_element(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axiom_node_t ** next_node)
+{
+ axiom_node_t *next_sibling = NULL;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+
+ next_sibling = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ *next_node = next_sibling;
+ return (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element_with_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_node_t *next_sibling = NULL;
+ axis2_char_t *child_localname = NULL;
+ axiom_element_t *om_ele = NULL;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+
+ child = axiom_node_get_first_child(ele_node, env);
+ if(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ }
+
+ next_sibling = axiom_node_get_next_sibling(child, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ *child_node = next_sibling;
+ return om_ele;
+ }
+
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_last_child_element_with_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *child_localname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+
+ child = axiom_node_get_last_child(ele_node, env);
+ while(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(ele_node, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ *child_node = child;
+ return om_ele;
+ }
+
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ }
+ child = axiom_node_get_previous_sibling(child, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axiom_node_t ** next_node)
+{
+ axiom_node_t *next_sibling = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *ele_localname = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+
+ next_sibling = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ ele_localname = axiom_element_get_localname(om_ele, env);
+ if(ele_localname && axutil_strcmp(localname, ele_localname) == 0)
+ {
+ *next_node = next_sibling;
+ return om_ele;
+ }
+ }
+ om_ele = NULL;
+ ele_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element_with_uri_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * uri,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_node_t *next_sibling = NULL;
+ axis2_char_t *child_localname = NULL;
+ axiom_element_t *om_ele = NULL;
+ axiom_namespace_t *ns = NULL;
+ axis2_char_t *ns_uri = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+ AXIS2_PARAM_CHECK(env->error, uri, NULL);
+
+ child = axiom_node_get_first_child(ele_node, env);
+ if(!child)
+ {
+ return NULL;
+
+ }
+ if(axiom_node_get_node_type(ele_node, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ ns = axiom_element_get_namespace(om_ele, env, child);
+ if(ns)
+ {
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ }
+
+ if((child_localname) && (axutil_strcmp(child_localname, localname) == 0) && (ns_uri)
+ && (axutil_strcmp(ns_uri, uri) == 0))
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ ns = NULL;
+ ns_uri = NULL;
+
+ next_sibling = axiom_node_get_next_sibling(child, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ ns = axiom_element_get_namespace(om_ele, env, next_sibling);
+ if(ns)
+ {
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ }
+
+ if((child_localname) && (axutil_strcmp(child_localname, localname) == 0)
+ && (ns_uri) && (axutil_strcmp(ns_uri, uri) == 0))
+ {
+ *child_node = next_sibling;
+ return om_ele;
+ }
+
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ ns = NULL;
+ ns_uri = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_last_child_element_with_uri_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * uri,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *child_localname = NULL;
+ axiom_namespace_t *ns = NULL;
+ axis2_char_t *ns_uri = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, uri, NULL);
+
+ child = axiom_node_get_last_child(ele_node, env);
+ while(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(ele_node, env);
+ if(om_ele)
+ {
+ ns = axiom_element_get_namespace(om_ele, env, ele_node);
+ if(ns)
+ {
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ }
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && (axutil_strcmp(child_localname, localname) == 0) && (ns_uri)
+ && (axutil_strcmp(ns_uri, uri) == 0))
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ ns = NULL;
+ ns_uri = NULL;
+ }
+ child = axiom_node_get_previous_sibling(child, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_sibling_element_with_uri_localname(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * uri,
+ axiom_node_t ** next_node)
+{
+ axiom_node_t *next_sibling = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *ele_localname = NULL;
+ axiom_namespace_t *ns = NULL;
+ axis2_char_t *ns_uri = NULL;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+
+ next_sibling = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ ns = axiom_element_get_namespace(om_ele, env, next_sibling);
+ if(ns)
+ {
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ }
+ ele_localname = axiom_element_get_localname(om_ele, env);
+ if(ele_localname && (axutil_strcmp(localname, ele_localname) == 0) && (ns)
+ && (axutil_strcmp(ns_uri, uri) == 0))
+ {
+ *next_node = next_sibling;
+ return om_ele;
+ }
+ }
+ om_ele = NULL;
+ ele_localname = NULL;
+ ns_uri = NULL;
+ ns = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element_with_localnames(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axutil_array_list_t * names,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_node_t *next_sibling = NULL;
+ axis2_char_t *child_localname = NULL;
+ axis2_char_t *given_localname = NULL;
+ axiom_element_t *om_ele = NULL;
+ int size = 0;
+ int i = 0;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, names, NULL);
+
+ child = axiom_node_get_first_child(ele_node, env);
+ if(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
+ if(om_ele)
+ {
+ size = axutil_array_list_size(names, env);
+ child_localname = axiom_element_get_localname(om_ele, env);
+
+ for(i = 0; i < size; i++)
+ {
+ given_localname = (axis2_char_t *)axutil_array_list_get(names, env, i);
+
+ if((child_localname) && (NULL != given_localname) && axutil_strcmp(
+ child_localname, given_localname) == 0)
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ given_localname = NULL;
+ }
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ given_localname = NULL;
+ size = 0;
+ }
+
+ next_sibling = axiom_node_get_next_sibling(child, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ size = axutil_array_list_size(names, env);
+ child_localname = axiom_element_get_localname(om_ele, env);
+ for(i = 0; i < size; i++)
+ {
+ given_localname = (axis2_char_t *)axutil_array_list_get(names, env, i);
+ if((child_localname) && (NULL != given_localname) && (axutil_strcmp(
+ child_localname, given_localname) == 0))
+ {
+ *child_node = next_sibling;
+ return om_ele;
+ }
+ given_localname = NULL;
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ given_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_last_child_element_with_localnames(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axutil_array_list_t * names,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *child_localname = NULL;
+ axis2_char_t *given_localname = NULL;
+ int size = 0;
+ int i = 0;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, names, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+
+ child = axiom_node_get_last_child(ele_node, env);
+ while(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(ele_node, env);
+ if(om_ele)
+ {
+ size = axutil_array_list_size(names, env);
+ for(i = 0; i < size; i++)
+ {
+ given_localname = (axis2_char_t *)axutil_array_list_get(names, env, i);
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && (NULL != given_localname) && (axutil_strcmp(
+ child_localname, given_localname) == 0))
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ given_localname = NULL;
+ }
+ child = axiom_node_get_previous_sibling(child, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localnames(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axutil_array_list_t * names,
+ axiom_node_t ** next_node)
+{
+ axiom_node_t *next_sibling = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *ele_localname = NULL;
+ axis2_char_t *given_localname = NULL;
+ int size = 0;
+ int i = 0;
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, names, NULL);
+ AXIS2_PARAM_CHECK(env->error, next_node, NULL);
+
+ next_sibling = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ size = axutil_array_list_size(names, env);
+ for(i = 0; i < size; i++)
+ {
+ given_localname = (axis2_char_t *)axutil_array_list_get(names, env, i);
+ ele_localname = axiom_element_get_localname(om_ele, env);
+ if((ele_localname) && (NULL != given_localname) && (axutil_strcmp(
+ given_localname, ele_localname) == 0))
+ {
+ *next_node = next_sibling;
+ return om_ele;
+ }
+
+ }
+ }
+ om_ele = NULL;
+ ele_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_first_child_element_with_localname_attr(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * attr_name,
+ axis2_char_t * attr_value,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_node_t *next_sibling = NULL;
+ axis2_char_t *child_localname = NULL;
+ axiom_element_t *om_ele = NULL;
+ axiom_attribute_t *om_attr = NULL;
+ axutil_hash_t *attr_ht = NULL;
+ axutil_hash_index_t *hi = NULL;
+ axis2_char_t *om_attr_value = NULL;
+ axis2_char_t *om_attr_name = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+ AXIS2_PARAM_CHECK(env->error, attr_name, NULL);
+ AXIS2_PARAM_CHECK(env->error, attr_value, NULL);
+
+ child = axiom_node_get_first_child(ele_node, env);
+
+ if(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
+ if(om_ele)
+ {
+
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ attr_ht = axiom_element_get_all_attributes(om_ele, env);
+ if(attr_ht)
+ {
+ for(hi = axutil_hash_first(attr_ht, env); hi; hi
+ = axutil_hash_next(env, hi))
+ {
+ void *val = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ if(val)
+ {
+ om_attr = (axiom_attribute_t *)val;
+ om_attr_name = axiom_attribute_get_localname(om_attr, env);
+
+ om_attr_value = axiom_attribute_get_value(om_attr, env);
+ if(om_attr_name && NULL != om_attr_value && axutil_strcmp(
+ om_attr_name, attr_name) == 0 && axutil_strcmp(om_attr_value,
+ attr_value) == 0)
+ {
+ AXIS2_FREE(env->allocator, hi);
+ *child_node = child;
+ return om_ele;
+ }
+ om_attr = NULL;
+ om_attr_name = NULL;
+ om_attr_value = NULL;
+ }
+ }
+ }
+ }
+ }
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ hi = NULL;
+ }
+
+ next_sibling = axiom_node_get_next_sibling(child, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ attr_ht = axiom_element_get_all_attributes(om_ele, env);
+ if(attr_ht)
+ {
+
+ for(hi = axutil_hash_first(attr_ht, env); hi; hi
+ = axutil_hash_next(env, hi))
+ {
+ void *val = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ if(val)
+ {
+ om_attr = (axiom_attribute_t *)val;
+ om_attr_name = axiom_attribute_get_localname(om_attr, env);
+
+ om_attr_value = axiom_attribute_get_value(om_attr, env);
+
+ if(om_attr_name && NULL != om_attr_value && axutil_strcmp(
+ om_attr_name, attr_name) == 0 && axutil_strcmp(om_attr_value,
+ attr_value) == 0)
+ {
+ *child_node = child;
+ return om_ele;
+ }
+ om_attr = NULL;
+ om_attr_name = NULL;
+ om_attr_value = NULL;
+ }
+ }
+ }
+ }
+
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_last_child_element_with_localname_attr(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * attr_name,
+ axis2_char_t * attr_value,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *child = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *child_localname = NULL;
+ axiom_attribute_t *om_attr = NULL;
+ axis2_char_t *om_attr_name = NULL;
+ axis2_char_t *om_attr_value = NULL;
+ axutil_hash_index_t *hi = NULL;
+ axutil_hash_t *attr_ht = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, localname, NULL);
+ AXIS2_PARAM_CHECK(env->error, child_node, NULL);
+
+ child = axiom_node_get_last_child(ele_node, env);
+ while(child)
+ {
+ if(axiom_node_get_node_type(child, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(ele_node, env);
+ if(om_ele)
+ {
+ child_localname = axiom_element_get_localname(om_ele, env);
+ if(child_localname && axutil_strcmp(child_localname, localname) == 0)
+ {
+ attr_ht = axiom_element_get_all_attributes(om_ele, env);
+ if(attr_ht)
+ {
+ for(hi = axutil_hash_first(attr_ht, env); hi; hi
+ = axutil_hash_next(env, hi))
+ {
+ void *val = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ if(val)
+ {
+ om_attr = (axiom_attribute_t *)val;
+ om_attr_name = axiom_attribute_get_localname(om_attr, env);
+
+ om_attr_value = axiom_attribute_get_value(om_attr, env);
+
+ if(om_attr_name && NULL != om_attr_value && axutil_strcmp(
+ om_attr_name, attr_name) == 0 && axutil_strcmp(om_attr_value,
+ attr_value) == 0)
+ {
+ AXIS2_FREE(env->allocator, hi);
+ *child_node = child;
+ return om_ele;
+ }
+ om_attr = NULL;
+ om_attr_name = NULL;
+ om_attr_value = NULL;
+ }
+ }
+ }
+ }
+
+ }
+ om_ele = NULL;
+ child_localname = NULL;
+ }
+ child = axiom_node_get_previous_sibling(child, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_element_t *AXIS2_CALL
+axiom_util_get_next_siblng_element_with_localname_attr(
+ axiom_element_t * ele,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node,
+ axis2_char_t * localname,
+ axis2_char_t * attr_name,
+ axis2_char_t * attr_value,
+ axiom_node_t ** child_node)
+{
+ axiom_node_t *next_sibling = NULL;
+ axiom_element_t *om_ele = NULL;
+ axis2_char_t *ele_localname = NULL;
+ axiom_attribute_t *om_attr = NULL;
+ axis2_char_t *om_attr_value = NULL;
+ axis2_char_t *om_attr_name = NULL;
+ axutil_hash_t *attr_ht = NULL;
+ axutil_hash_index_t *hi = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
+
+ next_sibling = axiom_node_get_next_sibling(ele_node, env);
+ while(next_sibling)
+ {
+ if(axiom_node_get_node_type(next_sibling, env) == AXIOM_ELEMENT)
+ {
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(next_sibling, env);
+ if(om_ele)
+ {
+ ele_localname = axiom_element_get_localname(om_ele, env);
+ if(ele_localname && axutil_strcmp(localname, ele_localname) == 0)
+ {
+ attr_ht = axiom_element_get_all_attributes(om_ele, env);
+ if(attr_ht)
+ {
+ for(hi = axutil_hash_first(attr_ht, env); hi; hi
+ = axutil_hash_next(env, hi))
+ {
+ void *val = NULL;
+ axutil_hash_this(hi, NULL, NULL, &val);
+ if(val)
+ {
+ om_attr = (axiom_attribute_t *)val;
+ om_attr_name = axiom_attribute_get_localname(om_attr, env);
+
+ om_attr_value = axiom_attribute_get_value(om_attr, env);
+
+ if(om_attr_name && NULL != om_attr_value && axutil_strcmp(
+ om_attr_name, attr_name) == 0 && axutil_strcmp(om_attr_value,
+ attr_value) == 0)
+ {
+ AXIS2_FREE(env->allocator, hi);
+ *child_node = next_sibling;
+ return om_ele;
+ }
+ om_attr = NULL;
+ om_attr_name = NULL;
+ om_attr_value = NULL;
+ }
+ }
+ }
+ }
+ }
+ om_ele = NULL;
+ ele_localname = NULL;
+ }
+ next_sibling = axiom_node_get_next_sibling(next_sibling, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axiom_util_get_child_node_text(
+ axiom_node_t * om_node,
+ const axutil_env_t * env)
+{
+ axiom_element_t *om_ele = NULL;
+ if(!om_node)
+ {
+ return NULL;
+ }
+ if(axiom_node_get_node_type(om_node, env) != AXIOM_ELEMENT)
+ {
+ return NULL;
+ }
+
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(om_node, env);
+
+ if(om_ele)
+ {
+ return axiom_element_get_text(om_ele, env, om_node);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axiom_util_get_localname(
+ axiom_node_t * node,
+ const axutil_env_t * env)
+{
+ axiom_element_t *om_ele = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ if(!node)
+ {
+ return NULL;
+ }
+ if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
+ {
+ return NULL;
+ }
+ om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+ if(om_ele)
+ {
+ return axiom_element_get_localname(om_ele, env);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+axiom_util_get_node_namespace_uri(
+ axiom_node_t * om_node,
+ const axutil_env_t * env)
+{
+ axiom_element_t *om_ele = NULL;
+ axiom_namespace_t *om_ns = NULL;
+ if(!om_node)
+ {
+ return NULL;
+ }
+ if(axiom_node_get_node_type(om_node, env) == AXIOM_ELEMENT)
+ {
+ om_ele = axiom_node_get_data_element(om_node, env);
+ if(!om_ele)
+ {
+ return NULL;
+ }
+ om_ns = axiom_element_get_namespace(om_ele, env, om_node);
+ if(om_ns)
+ {
+ return axiom_namespace_get_uri(om_ns, env);
+ }
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_child_element_iterator_t *AXIS2_CALL
+axiom_util_get_child_elements(
+ axiom_element_t * om_ele,
+ const axutil_env_t * env,
+ axiom_node_t * om_node)
+{
+ axiom_element_t *first_ele = NULL;
+ axiom_node_t *first_node = NULL;
+ AXIS2_PARAM_CHECK(env->error, om_node, NULL);
+ AXIS2_PARAM_CHECK(env->error, om_ele, NULL);
+ first_ele = axiom_element_get_first_element(om_ele, env, om_node, &first_node);
+ if(first_ele)
+ {
+ return axiom_child_element_iterator_create(env, first_node);
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axiom_document_t *AXIS2_CALL
+axiom_util_new_document(
+ const axutil_env_t * env,
+ const axutil_uri_t * uri)
+{
+ axis2_char_t *path = NULL;
+ axiom_xml_reader_t *reader = NULL;
+ axiom_stax_builder_t *om_builder = NULL;
+ axiom_document_t *doc = NULL;
+
+ AXIS2_PARAM_CHECK(env->error, uri, NULL);
+ /* This is temporary code. Later complete the code to read from uri and build
+ * the document
+ */
+ if(uri)
+ {
+ path = axutil_uri_get_path((axutil_uri_t *)uri, env);
+ }
+ else
+ {
+ return NULL;
+ }
+ if(path)
+ {
+ reader = axiom_xml_reader_create_for_file(env, path, NULL);
+ }
+ else
+ {
+ return NULL;
+ }
+ if(reader)
+ {
+ om_builder = axiom_stax_builder_create(env, reader);
+ }
+ else
+ {
+ return NULL;
+ }
+ if(om_builder)
+ {
+ doc = axiom_stax_builder_get_document(om_builder, env);
+ }
+ else
+ {
+ return NULL;
+ }
+ if(doc)
+ {
+ axiom_document_build_all(doc, env);
+ }
+ else
+ {
+ return NULL;
+ }
+
+ return doc;
+}
+
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+axiom_util_get_node_by_local_name(
+ const axutil_env_t *env,
+ axiom_node_t *node,
+ axis2_char_t *local_name)
+{
+ axis2_char_t *temp_name = NULL;
+
+ if(!node)
+ {
+ return NULL;
+ }
+
+ if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT)
+ {
+ return NULL;
+ }
+
+ temp_name = axiom_util_get_localname(node, env);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart]Checking node %s for %s", temp_name,
+ local_name);
+
+ if(!axutil_strcmp(temp_name, local_name))
+ {
+ /* Gottcha.. return this node */
+ return node;
+ }
+ else
+ {
+ /* Doesn't match? Get the children and search for them */
+ axiom_node_t *temp_node = NULL;
+
+ temp_node = axiom_node_get_first_element(node, env);
+ while(temp_node)
+ {
+ axiom_node_t *res_node = NULL;
+ res_node = axiom_util_get_node_by_local_name(env, temp_node, local_name);
+ if(res_node)
+ {
+ return res_node;
+ }
+ temp_node = axiom_node_get_next_sibling(temp_node, env);
+ }
+ }
+ return NULL;
+}
+
+/**
+ * Creates a clone of given node
+ * @param env environment, MUST not be NULL
+ * @param node node to be cloned
+ * @return cloned node
+ */
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+axiom_util_clone_node(
+ const axutil_env_t *env,
+ axiom_node_t *node)
+{
+ axis2_char_t* node_string = NULL;
+ axiom_node_t *clone = NULL;
+
+ if(!node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+ "Could not be able to clone the node. Given node is not valid.");
+ return NULL;
+ }
+
+ node_string = axiom_node_sub_tree_to_string(node, env);
+ clone = axiom_node_create_from_buffer(env, node_string);
+
+ if(node_string)
+ {
+ AXIS2_FREE(env->allocator, node_string);
+ }
+
+ return clone;
+}