diff options
Diffstat (limited to 'axiom/src/util')
| -rw-r--r-- | axiom/src/util/Makefile.am | 8 | ||||
| -rw-r--r-- | axiom/src/util/om_util.c | 1181 |
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; +} |