| /* |
| * 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 = next_sibling; |
| 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_get_root_element(doc, env); |
| 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; |
| } |
