blob: 6de7a451a5b25b3823c86c5115e36a9cf0dd6201 [file] [log] [blame]
/*
* 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_element.h>
#include "axiom_node_internal.h"
#include <axiom_attribute.h>
#include <axiom_namespace.h>
#include <axiom_xml_writer.h>
#include <axiom_stax_builder.h>
#include <string.h>
#include <stdio.h>
struct axiom_element
{
/** Element's namespace */
axiom_namespace_t *ns;
/** Element's local name */
axutil_string_t *localname;
/** List of attributes */
axutil_hash_t *attributes;
/** List of namespaces */
axutil_hash_t *namespaces;
axutil_qname_t *qname;
axiom_child_element_iterator_t *child_ele_iter;
axiom_children_iterator_t* children_iter;
axiom_children_qname_iterator_t *children_qname_iter;
axis2_char_t *text_value;
int next_ns_prefix_number;
};
AXIS2_EXTERN axiom_element_t *AXIS2_CALL
axiom_element_create(const axutil_env_t *env,
axiom_node_t *parent,
const axis2_char_t *localname,
axiom_namespace_t *ns,
axiom_node_t **node)
{
axiom_element_t *element;
AXIS2_ENV_CHECK(env, NULL);
if (!localname || !node)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
(*node) = axiom_node_create(env);
if (!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
element = (axiom_element_t *) AXIS2_MALLOC(env->allocator,
sizeof(axiom_element_t));
if (!element)
{
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
element->ns = NULL;
element->localname = NULL;
element->attributes = NULL;
element->namespaces = NULL;
element->qname = NULL;
element->child_ele_iter = NULL;
element->children_iter = NULL;
element->children_qname_iter = NULL;
element->text_value = NULL;
element->next_ns_prefix_number = 0;
element->localname = axutil_string_create(env, localname);
if (!element->localname)
{
AXIS2_FREE(env->allocator, element);
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
if (parent)
{
axiom_node_add_child(parent, env, (*node));
}
axiom_node_set_complete((*node), env, AXIS2_FALSE);
axiom_node_set_node_type((*node), env, AXIOM_ELEMENT);
axiom_node_set_data_element((*node), env, element);
if (ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
uri = axiom_namespace_get_uri(ns, env);
prefix = axiom_namespace_get_prefix(ns, env);
if (prefix && axutil_strcmp(prefix, "") == 0)
{
element->ns = NULL;
return element;
}
element->ns = axiom_element_find_namespace(element,
env, *node, uri, prefix);
if(element->ns)
{
if (ns != element->ns)
{
axiom_namespace_free(ns, env);
ns = NULL;
}
}
if (!(element->ns))
{
if (axiom_element_declare_namespace(element,
env, *node, ns) == AXIS2_SUCCESS)
{
element->ns = ns;
}
}
/*if (prefix && axutil_strcmp(prefix, "") == 0)
{
element->ns = NULL;
}
*/
}
return element;
}
AXIS2_EXTERN axiom_element_t *AXIS2_CALL
axiom_element_create_with_qname(const axutil_env_t *env,
axiom_node_t *parent,
const axutil_qname_t *qname,
axiom_node_t ** node)
{
axiom_element_t *element = NULL;
axis2_char_t *localpart = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (!qname || !node)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
localpart = axutil_qname_get_localpart(qname, env);
if (!localpart)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
element = axiom_element_create(env, parent, localpart, NULL, node);
if (!element)
{
return NULL;
}
if (*node)
{
axiom_element_t *om_element = NULL;
axis2_char_t *temp_nsuri = NULL;
axis2_char_t *temp_prefix = NULL;
axiom_namespace_t *ns = NULL;
om_element = ((axiom_element_t *)axiom_node_get_data_element((*node), env));
temp_nsuri = axutil_qname_get_uri(qname, env);
temp_prefix = axutil_qname_get_prefix(qname, env);
if (!om_element)
{
return NULL;
}
if ((!temp_nsuri) || (axutil_strcmp(temp_nsuri, "") == 0))
{
/** no namespace uri is available in given qname
no need to bother about it
*/
return om_element;
}
om_element->ns = axiom_element_find_namespace(om_element, env,
(*node), temp_nsuri, temp_prefix);
if (!(element->ns))
{
/** could not find a namespace so declare namespace */
ns = axiom_namespace_create(env, temp_nsuri, temp_prefix);
if (axiom_element_declare_namespace(om_element , env, *node, ns) == AXIS2_SUCCESS)
{
(element->ns) = ns;
return om_element;
}
else
{
axiom_namespace_free(ns, env);
axiom_element_free(om_element, env);
AXIS2_FREE(env->allocator, *node);
return NULL;
}
}
}
return element;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_find_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t * element_node,
const axis2_char_t * uri,
const axis2_char_t * prefix)
{
axiom_node_t *parent = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (!element_node || !om_element)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
if (!axiom_node_get_data_element(element_node, env) ||
axiom_node_get_node_type(element_node, env) != AXIOM_ELEMENT)
{
/* wrong element type or null node */
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
if (om_element->namespaces)
{
void *ns = NULL;
if (!prefix || axutil_strcmp(prefix, "") == 0)
{
/** check for a default namepsace */
axiom_namespace_t *default_ns = NULL;
axutil_hash_index_t *hashindex;
default_ns = axiom_element_get_default_namespace(om_element ,
env, element_node);
if (default_ns && NULL != uri)
{
axis2_char_t *default_uri = NULL;
default_uri = axiom_namespace_get_uri(default_ns, env);
if (default_uri && axutil_strcmp(uri, default_uri) == 0)
{
return default_ns;
}
else
{
return NULL;
}
}
/** prefix is null , so iterate the namespaces hash to find the namespace */
for (hashindex = axutil_hash_first(om_element->namespaces, env);
hashindex; hashindex = axutil_hash_next(env, hashindex))
{
axutil_hash_this(hashindex, NULL, NULL, &ns);
if (ns)
{
axiom_namespace_t *temp_ns = NULL;
axis2_char_t *temp_nsuri = NULL;
temp_ns = (axiom_namespace_t *)ns;
temp_nsuri = axiom_namespace_get_uri(temp_ns, env);
if (temp_nsuri && (axutil_strcmp(temp_nsuri, uri) == 0))
{
/** namespace uri matches , so free hashindex and return ns*/
AXIS2_FREE(env->allocator, hashindex);
return (axiom_namespace_t *)(ns);
}
temp_ns = NULL;
temp_nsuri = NULL;
ns = NULL;
}
}
ns = NULL;
}
else if (prefix)
{
/** prefix is not null get namespace directly if exist */
ns = axutil_hash_get(om_element->namespaces, prefix,
AXIS2_HASH_KEY_STRING);
if (ns)
{
axiom_namespace_t *found_ns = NULL;
axis2_char_t *found_uri = NULL;
found_ns = (axiom_namespace_t*)ns;
found_uri = axiom_namespace_get_uri(found_ns, env);
return found_ns;
}
}
}
/** could not find the namespace in current element scope
look in the parent */
parent = axiom_node_get_parent(element_node, env);
if (parent)
{
if (axiom_node_get_node_type(parent, env) == AXIOM_ELEMENT)
{
axiom_element_t *om_element = NULL;
om_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
if (om_element)
{ /** parent exist, parent is om element so find in parent*/
return axiom_element_find_namespace(om_element, env,
parent, uri, prefix);
}
}
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_declare_namespace_assume_param_ownership(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_namespace_t *ns)
{
axis2_char_t *prefix = NULL;
axis2_char_t *uri = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!ns || !om_element)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
uri = axiom_namespace_get_uri(ns, env);
prefix = axiom_namespace_get_prefix(ns, env);
if (!(om_element->namespaces))
{
om_element->namespaces = axutil_hash_make(env);
if (!(om_element->namespaces))
{
return AXIS2_FAILURE;
}
}
if (prefix)
{
axutil_hash_set(om_element->namespaces,
prefix, AXIS2_HASH_KEY_STRING, ns);
}
else
{
axis2_char_t *key = NULL;
key = AXIS2_MALLOC(env->allocator, sizeof(char) * 10);
memset(key, 0, sizeof(char)*10);
om_element->next_ns_prefix_number++;
key[0] = '\0';
axutil_hash_set(om_element->namespaces, key,
AXIS2_HASH_KEY_STRING, ns);
}
axiom_namespace_increment_ref(ns, env);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_declare_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *node,
axiom_namespace_t *ns)
{
axiom_namespace_t *declared_ns = NULL;
axis2_char_t *prefix = NULL;
axis2_char_t *uri = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!node || !ns || !om_element)
{
AXIS2_ERROR_SET(env->error,
AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
uri = axiom_namespace_get_uri(ns, env);
prefix = axiom_namespace_get_prefix(ns, env);
declared_ns = axiom_element_find_namespace(om_element,
env, node, uri, prefix);
if (declared_ns)
{
if (axiom_namespace_equals(ns, env, declared_ns) == AXIS2_TRUE)
{
/*Namespace already declared, so return */
return AXIS2_SUCCESS;
}
}
if (!(om_element->namespaces))
{
om_element->namespaces = axutil_hash_make(env);
if (!(om_element->namespaces))
{
return AXIS2_FAILURE;
}
}
if (prefix)
{
axutil_hash_set(om_element->namespaces,
prefix, AXIS2_HASH_KEY_STRING, ns);
}
else
{
axis2_char_t *key = NULL;
key = AXIS2_MALLOC(env->allocator, sizeof(char) * 10);
memset(key, 0, sizeof(char)*10);
om_element->next_ns_prefix_number++;
key[0] = '\0';
axutil_hash_set(om_element->namespaces, key,
AXIS2_HASH_KEY_STRING, ns);
}
axiom_namespace_increment_ref(ns, env);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_find_declared_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
const axis2_char_t * uri,
const axis2_char_t * prefix)
{
axutil_hash_index_t *hash_index = NULL;
void *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, uri, NULL);
if (!(om_element->namespaces))
{
return NULL;
}
if (!prefix || axutil_strcmp(prefix, "") == 0)
{
/** prefix null iterate the namespace hash for matching uri */
for (hash_index = axutil_hash_first(om_element->namespaces, env);
hash_index; hash_index = axutil_hash_next(env, hash_index))
{
axutil_hash_this(hash_index, NULL, NULL, &ns);
if (ns)
{
axiom_namespace_t *temp_ns = NULL;
axis2_char_t *temp_nsuri = NULL;
temp_ns = (axiom_namespace_t *)(ns);
temp_nsuri = axiom_namespace_get_uri(temp_ns, env);
if (temp_nsuri && axutil_strcmp(temp_nsuri, uri) == 0)
{
AXIS2_FREE(env->allocator, hash_index);
return temp_ns;
}
temp_ns = NULL;
temp_nsuri = NULL;
}
}
ns = NULL;
return NULL;
}
else if (prefix)
{
axiom_namespace_t *found_ns = NULL;
ns = axutil_hash_get(om_element->namespaces, prefix, AXIS2_HASH_KEY_STRING);
if (ns)
{
axis2_char_t *found_uri = NULL;
found_ns = (axiom_namespace_t *) ns;
found_uri = axiom_namespace_get_uri(found_ns, env);
if (found_uri && axutil_strcmp(found_uri, uri) == 0)
{
return found_ns;
}
}
}
return NULL;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_find_namespace_with_qname(axiom_element_t *element,
const axutil_env_t *env,
axiom_node_t *node,
axutil_qname_t *qname)
{
AXIS2_ENV_CHECK(env, NULL);
if (!element || !node || !qname)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
if (axutil_qname_get_uri(qname, env))
{
return axiom_element_find_namespace(element, env, node,
axutil_qname_get_uri(qname, env),
axutil_qname_get_prefix(qname, env));
}
else
{
return NULL;
}
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_add_attribute(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_attribute_t *attribute,
axiom_node_t *element_node)
{
axutil_qname_t *qname = NULL;
axiom_namespace_t *om_namespace = NULL;
axiom_namespace_t *temp_ns = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, attribute, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, element_node, AXIS2_FAILURE);
om_namespace = axiom_attribute_get_namespace(attribute, env);
if (om_namespace)
{
temp_ns = axiom_element_find_namespace(om_element, env,
element_node,
axiom_namespace_get_uri(om_namespace, env),
axiom_namespace_get_prefix(om_namespace, env));
if (!temp_ns)
{
axis2_status_t status = AXIS2_SUCCESS;
status = axiom_element_declare_namespace(om_element, env,
element_node, om_namespace);
if (status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
}
}
if (!(om_element->attributes))
{
om_element->attributes = axutil_hash_make(env);
if (!(om_element->attributes))
{
return AXIS2_FAILURE;
}
}
qname = axiom_attribute_get_qname(attribute, env);
if (qname)
{
axis2_char_t *name = axutil_qname_to_string(qname, env);
axutil_hash_set(om_element->attributes,
name, AXIS2_HASH_KEY_STRING,
attribute);
}
axiom_attribute_increment_ref(attribute, env);
return ((qname) ? AXIS2_SUCCESS : AXIS2_FAILURE);
}
AXIS2_EXTERN axiom_attribute_t *AXIS2_CALL
axiom_element_get_attribute(axiom_element_t *om_element,
const axutil_env_t *env,
axutil_qname_t *qname)
{
axis2_char_t *name = NULL;
axiom_attribute_t *attr = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, qname, NULL);
name = axutil_qname_to_string(qname, env);
if ((om_element->attributes) && name)
{
attr = (axiom_attribute_t*)(axutil_hash_get(om_element->attributes,
name, AXIS2_HASH_KEY_STRING));
}
return attr;
}
AXIS2_EXTERN void AXIS2_CALL
axiom_element_free(axiom_element_t *om_element,
const axutil_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!om_element)
{
return;
}
if (om_element->localname)
{
axutil_string_free(om_element->localname, env);
}
if (om_element->ns)
{
/* it is the responsibility of the element where the namespace is declared to free it */
}
if (om_element->attributes)
{
axutil_hash_index_t *hi;
void *val = NULL;
for (hi = axutil_hash_first(om_element->attributes, env); hi;
hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
axiom_attribute_free((axiom_attribute_t *)val, env);
}
}
axutil_hash_free(om_element->attributes, env);
}
if (om_element->namespaces)
{
axutil_hash_index_t *hi;
void *val = NULL;
for (hi = axutil_hash_first(om_element->namespaces, env); hi;
hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
axiom_namespace_free((axiom_namespace_t *)val, env);
}
}
axutil_hash_free(om_element->namespaces, env);
}
if (om_element->qname)
{
axutil_qname_free(om_element->qname, env);
}
if (om_element->children_iter)
{
axiom_children_iterator_free(om_element->children_iter, env);
}
if (om_element->child_ele_iter)
{
AXIOM_CHILD_ELEMENT_ITERATOR_FREE(om_element->child_ele_iter, env);
}
if (om_element->children_qname_iter)
{
axiom_children_qname_iterator_free(om_element->children_qname_iter, env);
}
if (om_element->text_value)
{
AXIS2_FREE(env->allocator, om_element->text_value);
}
AXIS2_FREE(env->allocator, om_element);
return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_serialize_start_part(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_output_t *om_output,
axiom_node_t *ele_node)
{
int status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
if (om_element->ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
uri = axiom_namespace_get_uri(om_element->ns, env);
prefix = axiom_namespace_get_prefix(om_element->ns, env);
if ((uri) && (prefix) && (axutil_strcmp(prefix, "") != 0))
{
status = axiom_output_write(om_output, env,
AXIOM_ELEMENT, 3, axutil_string_get_buffer(om_element->localname, env),
uri, prefix);
}
else if (uri)
{
status = axiom_output_write(om_output, env,
AXIOM_ELEMENT, 2, axutil_string_get_buffer(om_element->localname, env), uri);
}
}
else
{
status = axiom_output_write(om_output, env,
AXIOM_ELEMENT, 1, axutil_string_get_buffer(om_element->localname, env));
}
if (om_element->attributes)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(om_element->attributes, env); hi;
hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
status =
axiom_attribute_serialize((axiom_attribute_t *)val,
env, om_output);
}
else
{
status = AXIS2_FAILURE;
}
}
}
if (om_element->namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(om_element->namespaces, env); hi;
hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
status =
axiom_namespace_serialize((axiom_namespace_t *)val,
env, om_output);
}
else
{
status = AXIS2_FAILURE;
}
}
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_serialize_end_part(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
status = axiom_output_write(om_output, env, AXIOM_ELEMENT, 0);
return status;
}
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
axiom_element_get_localname(axiom_element_t *om_element,
const axutil_env_t *env)
{
if (om_element->localname)
return (axis2_char_t *)axutil_string_get_buffer(om_element->localname, env);
else
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_localname(axiom_element_t *om_element,
const axutil_env_t *env,
const axis2_char_t *localname)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE);
if (om_element->localname)
{
axutil_string_free(om_element->localname, env);
om_element->localname = NULL;
}
om_element->localname = axutil_string_create(env, localname);
if (!(om_element->localname))
{
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_get_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *ele_node)
{
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (om_element->ns)
{
ns = om_element->ns;
}
else
{
ns = axiom_element_get_default_namespace(
om_element, env, ele_node);
}
return ns;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_namespace_t *ns,
axiom_node_t *node)
{
axiom_namespace_t *om_ns = NULL;
axis2_status_t status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, ns , AXIS2_FAILURE);
om_ns = axiom_element_find_namespace(om_element, env, node,
axiom_namespace_get_uri(ns, env),
axiom_namespace_get_prefix(ns , env));
if (!om_ns)
{
status = axiom_element_declare_namespace(om_element, env, node, ns);
if (status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
om_element->ns = ns;
}
else
{
om_element->ns = om_ns;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_namespace_assume_param_ownership(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_namespace_t *ns)
{
om_element->ns = ns;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
axiom_element_get_all_attributes(axiom_element_t *om_element,
const axutil_env_t *env)
{
return om_element->attributes;
}
AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
axiom_element_get_namespaces(axiom_element_t *om_element,
const axutil_env_t *env)
{
return om_element->namespaces;
}
AXIS2_EXTERN axutil_qname_t *AXIS2_CALL
axiom_element_get_qname(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *ele_node)
{
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (om_element->qname)
{
return om_element->qname;
}
else
{
ns = axiom_element_get_namespace(om_element, env, ele_node);
if (ns)
{
if (axiom_namespace_get_prefix(ns, env))
{
om_element->qname = axutil_qname_create(env ,
axutil_string_get_buffer(om_element->localname, env),
axiom_namespace_get_uri(ns, env),
axiom_namespace_get_prefix(ns, env));
}
else
{
om_element->qname = axutil_qname_create(env,
axutil_string_get_buffer(om_element->localname, env),
axiom_namespace_get_uri(ns, env),
NULL);
}
}
else
{
om_element->qname = axutil_qname_create(env,
axutil_string_get_buffer(om_element->localname, env),
NULL, NULL);
}
}
return om_element->qname;
}
AXIS2_EXTERN axiom_children_iterator_t *AXIS2_CALL
axiom_element_get_children(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node)
{
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
if (om_element->children_iter)
{
return om_element->children_iter;
}
else
{
om_element->children_iter = axiom_children_iterator_create(env,
axiom_node_get_first_child(element_node, env));
return om_element->children_iter;
}
return NULL;
}
AXIS2_EXTERN axiom_children_qname_iterator_t *AXIS2_CALL
axiom_element_get_children_with_qname(axiom_element_t *om_element,
const axutil_env_t *env,
axutil_qname_t *element_qname,
axiom_node_t *element_node)
{
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
if (om_element->children_qname_iter)
{
axiom_children_qname_iterator_free(om_element->children_qname_iter, env);
om_element->children_qname_iter = NULL;
}
om_element->children_qname_iter = axiom_children_qname_iterator_create(env,
axiom_node_get_first_child(element_node, env),
element_qname);
return om_element->children_qname_iter;
}
AXIS2_EXTERN axiom_element_t *AXIS2_CALL
axiom_element_get_first_child_with_qname(axiom_element_t *om_element,
const axutil_env_t *env,
axutil_qname_t *element_qname,
axiom_node_t *element_node,
axiom_node_t **child_node)
{
axiom_node_t *om_node = NULL;
axiom_children_qname_iterator_t *children_iterator = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_qname, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
children_iterator = axiom_children_qname_iterator_create(env,
axiom_node_get_first_child(element_node, env),
element_qname);
if (!children_iterator)
{
return NULL;
}
if (axiom_children_qname_iterator_has_next(children_iterator, env))
{
om_node = axiom_children_qname_iterator_next(children_iterator, env);
}
if (om_node && (axiom_node_get_node_type(om_node, env) == AXIOM_ELEMENT))
{
axiom_children_qname_iterator_free(children_iterator, env);
if (child_node)
{
*child_node = om_node;
}
return (axiom_element_t*)axiom_node_get_data_element(om_node, env);
}
else
{
axiom_children_qname_iterator_free(children_iterator, env);
return NULL;
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_remove_attribute(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_attribute_t *om_attribute)
{
axutil_qname_t *qname = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_attribute, AXIS2_FAILURE);
qname = axiom_attribute_get_qname(om_attribute, env);
if (qname && (om_element->attributes))
{
axis2_char_t *name = NULL;
name = axutil_qname_to_string(qname, env);
if (name)
{
axutil_hash_set(om_element->attributes, name,
AXIS2_HASH_KEY_STRING, NULL);
return AXIS2_SUCCESS;
}
}
return AXIS2_FAILURE;
}
AXIS2_EXTERN axiom_element_t *AXIS2_CALL
axiom_element_get_first_element(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node,
axiom_node_t **first_ele_node)
{
axiom_node_t *temp_node = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
temp_node = axiom_node_get_first_child(element_node, env);
while (temp_node)
{
if (axiom_node_get_node_type(temp_node, env) == AXIOM_ELEMENT)
{
if (first_ele_node)
{
*first_ele_node = temp_node;
}
return (axiom_element_t *)axiom_node_get_data_element(temp_node, env);
}
else
{
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
}
return NULL;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_element_get_text(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node)
{
axis2_char_t *dest = NULL;
const axis2_char_t *temp_text = NULL;
axiom_text_t *text_node = NULL;
axiom_node_t *temp_node = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
if (om_element->text_value)
{
AXIS2_FREE(env->allocator, om_element->text_value);
om_element->text_value = NULL;
}
temp_node = axiom_node_get_first_child(element_node, env);
while (temp_node)
{
if (axiom_node_get_node_type(temp_node, env) == AXIOM_TEXT)
{
int dest_len = 0;
int curr_len = 0;
axis2_char_t *temp_dest = NULL;
text_node = (axiom_text_t *)axiom_node_get_data_element(temp_node, env);
if (text_node)
{
temp_text = axiom_text_get_value(text_node, env);
if (dest && temp_text && axutil_strcmp(temp_text, "") != 0)
{
dest_len = axutil_strlen(dest);
curr_len = dest_len + axutil_strlen(temp_text);
temp_dest = AXIS2_MALLOC(env->allocator,
(curr_len + 1) * sizeof(axis2_char_t));
memcpy(temp_dest, dest, dest_len*sizeof(axis2_char_t));
memcpy((temp_dest + dest_len * sizeof(axis2_char_t)),
temp_text, curr_len - dest_len);
temp_dest[curr_len] = '\0';
AXIS2_FREE(env->allocator, dest);
dest = NULL;
dest = temp_dest;
}
else if (!dest && temp_text && axutil_strcmp(temp_text, "") != 0)
{
dest = axutil_strdup(env, temp_text);
}
}
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
om_element->text_value = dest;
return om_element->text_value;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_text(axiom_element_t *om_element,
const axutil_env_t *env,
const axis2_char_t *text,
axiom_node_t *element_node)
{
axiom_node_t *temp_node = NULL;
axiom_text_t *om_text = NULL;
axiom_node_t *node_to_free = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, element_node, AXIS2_FAILURE);
temp_node = axiom_node_get_first_child(element_node, env);
while (temp_node)
{
if (axiom_node_get_node_type(temp_node, env) == AXIOM_TEXT)
{
node_to_free = axiom_node_detach(temp_node, env);
axiom_node_free_tree(node_to_free, env);
}
temp_node = axiom_node_get_next_sibling(temp_node, env);
}
temp_node = NULL;
om_text = axiom_text_create(env, NULL, text, &temp_node);
axiom_node_add_child(element_node, env, temp_node);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_element_to_string(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node)
{
int status = AXIS2_SUCCESS;
axiom_output_t *om_output = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axis2_char_t *xml = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
AXIS2_XML_PARSER_TYPE_BUFFER);
if (!xml_writer)
{
return NULL;
}
om_output = axiom_output_create(env, xml_writer);
if (!om_output)
{
return NULL;
}
status = axiom_node_serialize(element_node, env, om_output);
if (status == AXIS2_SUCCESS)
{
xml = (axis2_char_t*)axiom_xml_writer_get_xml(xml_writer, env);
}
axiom_output_free(om_output, env);
return xml;
}
AXIS2_EXTERN axiom_child_element_iterator_t *AXIS2_CALL
axiom_element_get_child_elements(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node)
{
axiom_node_t *first_node = NULL;
axiom_element_t *ele = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
ele = axiom_element_get_first_element(om_element, env, element_node, &first_node);
if (om_element->child_ele_iter)
{
return om_element->child_ele_iter;
}
else if (ele && first_node)
{
om_element->child_ele_iter = axiom_child_element_iterator_create(env, first_node);
return om_element->child_ele_iter;
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_build(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *om_ele_node)
{
axiom_stax_builder_t *builder = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_ele_node, AXIS2_FAILURE);
if (axiom_node_get_node_type(om_ele_node, env) != AXIOM_ELEMENT)
{
return AXIS2_FAILURE;
}
builder = axiom_node_get_builder(om_ele_node, env);
if (!builder)
{
return AXIS2_FAILURE;
}
while (!axiom_node_is_complete(om_ele_node, env) &&
!axiom_stax_builder_is_complete(builder, env))
{
void *value = NULL;
value = axiom_stax_builder_next(builder, env);
if (!value)
{
return AXIS2_FAILURE;
}
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_get_default_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *element_node)
{
axiom_node_t *parent_node = NULL;
axiom_namespace_t *default_ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
if (om_element->namespaces)
{
default_ns = axutil_hash_get(om_element->namespaces, "",
AXIS2_HASH_KEY_STRING);
if (default_ns)
{
return default_ns;
}
}
parent_node = axiom_node_get_parent(element_node, env);
if ((parent_node) &&
(axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT))
{
axiom_element_t *parent_ele = NULL;
parent_ele = (axiom_element_t *)
axiom_node_get_data_element(parent_node, env);
if (parent_ele)
{
return axiom_element_get_default_namespace(parent_ele, env, parent_node);
}
}
return NULL;
}
/**
* declared a default namespace explicitly
*/
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_declare_default_namespace(axiom_element_t *om_element,
const axutil_env_t *env,
axis2_char_t *uri)
{
axiom_namespace_t *default_ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, uri, NULL);
if (axutil_strcmp(uri, "") == 0)
{
return NULL;
}
default_ns = axiom_namespace_create(env, uri, "");
if (!default_ns)
{
return NULL;
}
if (om_element->namespaces)
{
om_element->namespaces = axutil_hash_make(env);
if (!(om_element->namespaces))
{
return NULL;
}
}
axutil_hash_set(om_element->namespaces, "",
AXIS2_HASH_KEY_STRING, default_ns);
axiom_namespace_increment_ref(default_ns, env);
return default_ns;
}
/**
* checks for the namespace in the context of this element
* with the given prefix
*/
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_find_namespace_uri(axiom_element_t *om_element,
const axutil_env_t *env,
axis2_char_t *prefix,
axiom_node_t *element_node)
{
axiom_node_t *parent_node = NULL;
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
AXIS2_PARAM_CHECK(env->error, prefix, NULL);
if (om_element->namespaces)
{
ns = axutil_hash_get(om_element->namespaces, prefix,
AXIS2_HASH_KEY_STRING);
if (ns)
{
return ns;
}
}
parent_node = axiom_node_get_parent(element_node, env);
if ((parent_node) &&
(axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT))
{
axiom_element_t *parent_ele = NULL;
parent_ele = (axiom_element_t *)
axiom_node_get_data_element(parent_node, env);
if (parent_ele)
{
return axiom_element_find_namespace_uri(parent_ele, env, prefix, parent_node);
}
}
return NULL;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_element_get_attribute_value(axiom_element_t *om_element,
const axutil_env_t *env,
axutil_qname_t *qname)
{
axis2_char_t *name = NULL;
axiom_attribute_t *attr = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, qname, NULL);
name = axutil_qname_to_string(qname, env);
if ((om_element->attributes) && (NULL != name))
{
attr = (axiom_attribute_t*) axutil_hash_get(om_element->attributes,
name, AXIS2_HASH_KEY_STRING);
if (attr)
{
return axiom_attribute_get_value(attr, env);
}
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_namespace_with_no_find_in_current_scope(
axiom_element_t *om_element,
const axutil_env_t *env,
axiom_namespace_t *om_ns)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_ns, AXIS2_FAILURE);
om_element->ns = om_ns;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
axiom_element_extract_attributes(axiom_element_t *om_element,
const axutil_env_t *env,
axiom_node_t *ele_node)
{
axutil_hash_index_t *hi = NULL;
axutil_hash_t *ht_cloned = NULL;
axiom_attribute_t *om_attr = NULL;
axiom_attribute_t *cloned_attr = NULL;
axiom_namespace_t *om_ns = NULL;
/*axiom_namespace_t *cloned_ns = NULL;*/
axis2_char_t *key = NULL;
axutil_qname_t *qn = NULL;
AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
if (!om_element->attributes)
{
return NULL;
}
ht_cloned = axutil_hash_make(env);
if (!ht_cloned)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
for (hi = axutil_hash_first(om_element->attributes, 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;
cloned_attr = axiom_attribute_clone(om_attr, env);
om_ns = axiom_attribute_get_namespace(om_attr, env);
if (om_ns)
{
/*cloned_ns = axiom_namespace_clone(om_ns, env);*/
/*axiom_attribute_set_namespace(cloned_attr, env, cloned_ns);*/
axiom_attribute_set_namespace(cloned_attr, env, om_ns);
}
qn = axiom_attribute_get_qname(cloned_attr, env);
key = axutil_qname_to_string(qn, env);
axutil_hash_set(ht_cloned, key, AXIS2_HASH_KEY_STRING, cloned_attr);
}
val = NULL;
key = NULL;
qn = NULL;
om_attr = NULL;
cloned_attr = NULL;
om_ns = NULL;
/*cloned_ns = NULL;*/
}
return ht_cloned;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_element_get_attribute_value_by_name(axiom_element_t *om_element,
const axutil_env_t *env,
axis2_char_t *attr_name)
{
axutil_hash_index_t *hi = NULL;
AXIS2_PARAM_CHECK(env->error, attr_name, NULL);
if (!om_element->attributes)
{
return NULL;
}
for (hi = axutil_hash_first(om_element->attributes, env); hi;
hi = axutil_hash_next(env, hi))
{
void *attr = NULL;
axiom_attribute_t *om_attr = NULL;
axutil_hash_this(hi, NULL, NULL, &attr);
if (attr)
{
axis2_char_t *this_attr_name;
axis2_char_t *this_attr_value;
axis2_char_t *attr_qn_str = NULL;
axiom_namespace_t *attr_ns = NULL;
axis2_char_t *prefix = NULL;
om_attr = (axiom_attribute_t*)attr;
this_attr_name = axiom_attribute_get_localname(om_attr, env);
this_attr_value = axiom_attribute_get_value(om_attr, env);
attr_ns = axiom_attribute_get_namespace(om_attr, env);
if (attr_ns)
{
prefix = axiom_namespace_get_prefix(attr_ns, env);
if (prefix)
{
axis2_char_t *tmp_val = NULL;
tmp_val = axutil_stracat(env, prefix, ":");
attr_qn_str = axutil_stracat(env, tmp_val, this_attr_name);
if (tmp_val)
{
AXIS2_FREE(env->allocator, tmp_val);
tmp_val = NULL;
}
}
}
else
{
attr_qn_str = axutil_strdup(env, this_attr_name);
}
if (attr_qn_str && axutil_strcmp(attr_qn_str, attr_name) == 0)
{
AXIS2_FREE(env->allocator, attr_qn_str);
attr_qn_str = NULL;
AXIS2_FREE(env->allocator, hi);
return this_attr_value;
}
AXIS2_FREE(env->allocator, attr_qn_str);
attr_qn_str = NULL;
}
}
return NULL;
}
AXIS2_EXTERN axiom_element_t *AXIS2_CALL
axiom_element_create_str(const axutil_env_t *env,
axiom_node_t *parent,
axutil_string_t *localname,
axiom_namespace_t *ns,
axiom_node_t **node)
{
axiom_element_t *element;
AXIS2_ENV_CHECK(env, NULL);
if (!localname || !node)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return NULL;
}
(*node) = axiom_node_create(env);
if (!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
element = (axiom_element_t *) AXIS2_MALLOC(env->allocator,
sizeof(axiom_element_t));
if (!element)
{
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
element->ns = NULL;
element->localname = NULL;
element->attributes = NULL;
element->namespaces = NULL;
element->qname = NULL;
element->child_ele_iter = NULL;
element->children_iter = NULL;
element->children_qname_iter = NULL;
element->text_value = NULL;
element->next_ns_prefix_number = 0;
element->localname = axutil_string_clone(localname, env);
if (!element->localname)
{
AXIS2_FREE(env->allocator, element);
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
if (parent)
{
axiom_node_add_child(parent, env, (*node));
}
axiom_node_set_complete((*node), env, AXIS2_FALSE);
axiom_node_set_node_type((*node), env, AXIOM_ELEMENT);
axiom_node_set_data_element((*node), env, element);
if (ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
uri = axiom_namespace_get_uri(ns, env);
prefix = axiom_namespace_get_prefix(ns, env);
element->ns = axiom_element_find_namespace(element,
env, *node, uri, prefix);
if (!(element->ns))
{
if (axiom_element_declare_namespace(element,
env, *node, ns) == AXIS2_SUCCESS)
{
element->ns = ns;
}
}
if (prefix && axutil_strcmp(prefix, "") == 0)
{
element->ns = NULL;
}
}
return element;
}
AXIS2_EXTERN axutil_string_t* AXIS2_CALL
axiom_element_get_localname_str(axiom_element_t *om_element,
const axutil_env_t *env)
{
return om_element->localname;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_element_set_localname_str(axiom_element_t *om_element,
const axutil_env_t *env,
axutil_string_t *localname)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE);
if (om_element->localname)
{
axutil_string_free(om_element->localname, env);
om_element->localname = NULL;
}
om_element->localname = axutil_string_clone(localname, env);
if (!(om_element->localname))
{
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}