You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by sh...@apache.org on 2009/08/18 13:08:44 UTC
svn commit: r805360 [4/13] - in /webservices/axis2/trunk/c/axiom/src:
attachments/ om/ parser/ parser/guththila/ parser/libxml2/ soap/ util/ xpath/
Modified: webservices/axis2/trunk/c/axiom/src/om/om_element.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_element.c?rev=805360&r1=805359&r2=805360&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_element.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_element.c Tue Aug 18 11:08:42 2009
@@ -1,4 +1,3 @@
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -67,25 +66,23 @@
axiom_element_t *element;
AXIS2_ENV_CHECK(env, NULL);
- if (!localname || !node)
+ if(!localname || !node)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "localname or node is NULL");
return NULL;
}
(*node) = axiom_node_create(env);
- if (!(*node))
+ if(!(*node))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No Memory");
return NULL;
}
- element = (axiom_element_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_element_t));
+ element = (axiom_element_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_element_t));
- if (!element)
+ if(!element)
{
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -105,14 +102,14 @@
element->is_empty = AXIS2_FALSE;
element->localname = axutil_string_create(env, localname);
- if (!element->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)
+ if(parent)
{
axiom_node_add_child(parent, env, (*node));
}
@@ -120,7 +117,7 @@
axiom_node_set_node_type((*node), env, AXIOM_ELEMENT);
axiom_node_set_data_element((*node), env, element);
- if (ns)
+ if(ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
@@ -129,38 +126,35 @@
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 (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(element->ns)
{
- if (ns != element->ns)
+ if(ns != element->ns)
{
axiom_namespace_free(ns, env);
ns = NULL;
}
}
- if (!(element->ns))
+ if(!(element->ns))
{
- if (axiom_element_declare_namespace(element,
- env, *node,
- ns) == AXIS2_SUCCESS)
+ if(axiom_element_declare_namespace(element, env, *node, ns) == AXIS2_SUCCESS)
{
element->ns = ns;
}
}
/*if (prefix && axutil_strcmp(prefix, "") == 0)
- {
- element->ns = NULL;
- }
+ {
+ element->ns = NULL;
+ }
*/
}
@@ -178,71 +172,65 @@
axis2_char_t *localpart = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (!qname || !node)
+ if(!qname || !node)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "qname or node is NULL");
return NULL;
}
localpart = axutil_qname_get_localpart(qname, env);
- if (!localpart)
+ if(!localpart)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "localpart is NULL");
return NULL;
}
element = axiom_element_create(env, parent, localpart, NULL, node);
- if (!element)
+ if(!element)
{
return NULL;
}
- if (*node)
+ 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));
+ 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)
+ if(!om_element)
{
return NULL;
}
- if ((!temp_nsuri) || (axutil_strcmp(temp_nsuri, "") == 0))
+ if((!temp_nsuri) || (axutil_strcmp(temp_nsuri, "") == 0))
{
/** no namespace uri is available in given qname
- no need to bother about it
+ no need to bother about it
*/
return om_element;
}
- om_element->ns = axiom_element_find_namespace(om_element, env,
- (*node), temp_nsuri,
- temp_prefix);
+ om_element->ns = axiom_element_find_namespace(om_element, env, (*node), temp_nsuri,
+ temp_prefix);
- if (!(element->ns))
+ if(!(element->ns))
{
/** could not find a namespace so declare namespace */
ns = axiom_namespace_create(env, temp_nsuri, temp_prefix);
- if (ns &&
- axiom_element_declare_namespace(om_element, env, *node, ns) ==
- AXIS2_SUCCESS)
+ if(ns && axiom_element_declare_namespace(om_element, env, *node, ns) == AXIS2_SUCCESS)
{
(element->ns) = ns;
return om_element;
}
else
{
- if (ns)
+ if(ns)
{
axiom_namespace_free(ns, env);
}
@@ -266,44 +254,39 @@
axiom_node_t *parent = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (!element_node || !om_element)
+ if(!element_node || !om_element)
{
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "element_node or om_element is NULL");
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "element_node or om_element is NULL");
return NULL;
}
- if (!axiom_node_get_data_element(element_node, env) ||
- axiom_node_get_node_type(element_node, env) != AXIOM_ELEMENT)
+ 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);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "Wrong element type or null node");
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Wrong element type or null node");
return NULL;
}
- if (om_element->namespaces)
+ if(om_element->namespaces)
{
void *ns = NULL;
- if (uri && (!prefix || axutil_strcmp(prefix, "") == 0))
+ if(uri && (!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)
+ default_ns = axiom_element_get_default_namespace(om_element, env, element_node);
+ if(default_ns)
{
axis2_char_t *default_uri = NULL;
default_uri = axiom_namespace_get_uri(default_ns, env);
- if (axutil_strcmp(uri, default_uri) == 0)
+ if(axutil_strcmp(uri, default_uri) == 0)
{
return default_ns;
}
@@ -314,22 +297,22 @@
}
/** 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))
+ 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)
+ if(ns)
{
axiom_namespace_t *temp_ns = NULL;
axis2_char_t *temp_nsuri = NULL;
- temp_ns = (axiom_namespace_t *) ns;
+ temp_ns = (axiom_namespace_t *)ns;
temp_nsuri = axiom_namespace_get_uri(temp_ns, env);
- if (axutil_strcmp(temp_nsuri, uri) == 0)
+ if(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);
+ return (axiom_namespace_t *)(ns);
}
temp_ns = NULL;
temp_nsuri = NULL;
@@ -338,19 +321,18 @@
}
ns = NULL;
}
- else if (prefix)
+ 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)
+ 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_ns = (axiom_namespace_t *)ns;
found_uri = axiom_namespace_get_uri(found_ns, env);
- if (uri)
+ if(uri)
{
/* if uri provided, return found ns only if uri matches */
return (axutil_strcmp(found_uri, uri) == 0) ? found_ns : NULL;
@@ -361,22 +343,20 @@
}
/** could not find the namespace in current element scope
- look in the parent */
+ look in the parent */
parent = axiom_node_get_parent(element_node, env);
- if (parent)
+ if(parent)
{
- if (axiom_node_get_node_type(parent, env) == AXIOM_ELEMENT)
+ 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);
+ 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);
}
}
}
@@ -394,30 +374,27 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if (!ns || !om_element)
+ if(!ns || !om_element)
{
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "namespace or om_element is NULL");
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "namespace or om_element is NULL");
return AXIS2_FAILURE;
}
uri = axiom_namespace_get_uri(ns, env);
prefix = axiom_namespace_get_prefix(ns, env);
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
om_element->namespaces = axutil_hash_make(env);
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
return AXIS2_FAILURE;
}
}
- if (prefix)
+ if(prefix)
{
- axutil_hash_set(om_element->namespaces,
- prefix, AXIS2_HASH_KEY_STRING, ns);
+ axutil_hash_set(om_element->namespaces, prefix, AXIS2_HASH_KEY_STRING, ns);
}
else
{
@@ -446,42 +423,38 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if (!node || !ns || !om_element)
+ if(!node || !ns || !om_element)
{
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "node or namespace or om_element is NULL");
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "node or namespace or om_element is NULL");
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);
+ declared_ns = axiom_element_find_namespace(om_element, env, node, uri, prefix);
- if (declared_ns)
+ if(declared_ns)
{
- if (axiom_namespace_equals(ns, env, declared_ns) == AXIS2_TRUE)
+ if(axiom_namespace_equals(ns, env, declared_ns) == AXIS2_TRUE)
{
/*Namespace already declared, so return */
return AXIS2_SUCCESS;
}
}
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
om_element->namespaces = axutil_hash_make(env);
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
return AXIS2_FAILURE;
}
}
- if (prefix)
+ if(prefix)
{
- axutil_hash_set(om_element->namespaces,
- prefix, AXIS2_HASH_KEY_STRING, ns);
+ axutil_hash_set(om_element->namespaces, prefix, AXIS2_HASH_KEY_STRING, ns);
}
else
{
@@ -508,24 +481,24 @@
void *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
return NULL;
}
- if (uri && (!prefix || axutil_strcmp(prefix, "") == 0))
+ if(uri && (!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))
+ 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)
+ if(ns)
{
axiom_namespace_t *temp_ns = NULL;
axis2_char_t *temp_nsuri = NULL;
- temp_ns = (axiom_namespace_t *) (ns);
+ temp_ns = (axiom_namespace_t *)(ns);
temp_nsuri = axiom_namespace_get_uri(temp_ns, env);
- if (axutil_strcmp(temp_nsuri, uri) == 0)
+ if(axutil_strcmp(temp_nsuri, uri) == 0)
{
AXIS2_FREE(env->allocator, hash_index);
return temp_ns;
@@ -537,18 +510,17 @@
ns = NULL;
return NULL;
}
- else if (prefix)
+ else if(prefix)
{
axiom_namespace_t *found_ns = NULL;
- ns = axutil_hash_get(om_element->namespaces, prefix,
- AXIS2_HASH_KEY_STRING);
- if (ns)
+ 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_ns = (axiom_namespace_t *)ns;
found_uri = axiom_namespace_get_uri(found_ns, env);
/* If uri provided, ensure this namespace found by prefix matches the uri */
- if (uri && axutil_strcmp(found_uri, uri) == 0)
+ if(uri && axutil_strcmp(found_uri, uri) == 0)
{
return found_ns;
}
@@ -565,21 +537,17 @@
axutil_qname_t * qname)
{
AXIS2_ENV_CHECK(env, NULL);
- if (!element || !node || !qname)
+ if(!element || !node || !qname)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
- AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "element or node or qname is NULL");
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "element or node or qname is NULL");
return NULL;
}
- if (axutil_qname_get_uri(qname, env))
+ 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));
+ return axiom_element_find_namespace(element, env, node, axutil_qname_get_uri(qname, env),
+ axutil_qname_get_prefix(qname, env));
}
else
{
@@ -604,43 +572,39 @@
/* ensure the attribute's namespace structure is declared */
om_namespace = axiom_attribute_get_namespace(attribute, env);
- if (om_namespace)
+ 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 != 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 != om_namespace)
{
axis2_status_t status;
/* as the attribute's namespace structure is not declared in scope,
- declare it here */
+ declare it here */
status = axiom_element_declare_namespace_assume_param_ownership(om_element, env,
- om_namespace);
- if (status != AXIS2_SUCCESS)
+ om_namespace);
+ if(status != AXIS2_SUCCESS)
{
return status;
}
}
}
- if (!(om_element->attributes))
+ if(!(om_element->attributes))
{
om_element->attributes = axutil_hash_make(env);
- if (!(om_element->attributes))
+ if(!(om_element->attributes))
{
return AXIS2_FAILURE;
}
}
qname = axiom_attribute_get_qname(attribute, env);
- if (qname)
+ if(qname)
{
axis2_char_t *name = axutil_qname_to_string(qname, env);
- axutil_hash_set(om_element->attributes,
- name, AXIS2_HASH_KEY_STRING, attribute);
+ axutil_hash_set(om_element->attributes, name, AXIS2_HASH_KEY_STRING, attribute);
axiom_attribute_increment_ref(attribute, env);
}
return ((qname) ? AXIS2_SUCCESS : AXIS2_FAILURE);
@@ -659,11 +623,10 @@
name = axutil_qname_to_string(qname, env);
- if ((om_element->attributes) && name)
+ if((om_element->attributes) && name)
{
- attr = (axiom_attribute_t *) (axutil_hash_get(om_element->attributes,
- name,
- AXIS2_HASH_KEY_STRING));
+ attr = (axiom_attribute_t *)(axutil_hash_get(om_element->attributes, name,
+ AXIS2_HASH_KEY_STRING));
}
return attr;
}
@@ -674,70 +637,67 @@
const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if (!om_element)
+ if(!om_element)
{
return;
}
- if (om_element->localname)
+ if(om_element->localname)
{
axutil_string_free(om_element->localname, env);
}
- if (om_element->ns)
+ if(om_element->ns)
{
/* it is the responsibility of the element where the namespace is declared to free it */
}
- if (om_element->attributes)
+ 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))
+ 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)
+ if(val)
{
- axiom_attribute_free((axiom_attribute_t *) val, env);
+ axiom_attribute_free((axiom_attribute_t *)val, env);
}
}
axutil_hash_free(om_element->attributes, env);
}
- if (om_element->namespaces)
+ 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))
+ 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)
+ if(val)
{
- axiom_namespace_free((axiom_namespace_t *) val, env);
+ axiom_namespace_free((axiom_namespace_t *)val, env);
}
}
axutil_hash_free(om_element->namespaces, env);
}
- if (om_element->qname)
+ if(om_element->qname)
{
axutil_qname_free(om_element->qname, env);
}
- if (om_element->children_iter)
+ if(om_element->children_iter)
{
axiom_children_iterator_free(om_element->children_iter, env);
}
- if (om_element->child_ele_iter)
+ if(om_element->child_ele_iter)
{
AXIOM_CHILD_ELEMENT_ITERATOR_FREE(om_element->child_ele_iter, env);
}
- if (om_element->children_qname_iter)
+ if(om_element->children_qname_iter)
{
- axiom_children_qname_iterator_free(om_element->children_qname_iter,
- env);
+ axiom_children_qname_iterator_free(om_element->children_qname_iter, env);
}
- if (om_element->text_value)
+ if(om_element->text_value)
{
AXIS2_FREE(env->allocator, om_element->text_value);
}
@@ -758,10 +718,9 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
-
- if (om_element->is_empty)
+ if(om_element->is_empty)
{
- if (om_element->ns)
+ if(om_element->ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
@@ -769,38 +728,26 @@
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))
+ if((uri) && (prefix) && (axutil_strcmp(prefix, "") != 0))
{
- status = axiom_output_write(om_output, env,
- AXIOM_ELEMENT, 4,
- axutil_string_get_buffer(om_element->
- localname,
- env), uri,
- prefix, NULL);
- }
- else if (uri)
- {
- status = axiom_output_write(om_output, env,
- AXIOM_ELEMENT, 4,
- axutil_string_get_buffer(om_element->
- localname,
- env), uri,
- NULL, NULL);
+ status = axiom_output_write(om_output, env, AXIOM_ELEMENT, 4,
+ axutil_string_get_buffer(om_element-> localname, env), uri, prefix, NULL);
+ }
+ else if(uri)
+ {
+ status = axiom_output_write(om_output, env, AXIOM_ELEMENT, 4,
+ axutil_string_get_buffer(om_element-> localname, env), uri, NULL, NULL);
}
}
else
{
- status = axiom_output_write(om_output, env,
- AXIOM_ELEMENT, 4,
- axutil_string_get_buffer(om_element->
- localname, env), NULL,
- NULL, NULL);
+ status = axiom_output_write(om_output, env, AXIOM_ELEMENT, 4, axutil_string_get_buffer(
+ om_element-> localname, env), NULL, NULL, NULL);
}
}
else
{
- if (om_element->ns)
+ if(om_element->ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
@@ -808,46 +755,34 @@
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))
+ 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, 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);
+ 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));
+ status = axiom_output_write(om_output, env, AXIOM_ELEMENT, 1, axutil_string_get_buffer(
+ om_element-> localname, env));
}
}
- if (om_element->attributes)
+ 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))
+ 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)
+ if(val)
{
- status =
- axiom_attribute_serialize((axiom_attribute_t *) val,
- env, om_output);
+ status = axiom_attribute_serialize((axiom_attribute_t *)val, env, om_output);
}
else
{
@@ -856,20 +791,17 @@
}
}
- if (om_element->namespaces)
+ 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))
+ 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)
+ if(val)
{
- status =
- axiom_namespace_serialize((axiom_namespace_t *) val,
- env, om_output);
+ status = axiom_namespace_serialize((axiom_namespace_t *)val, env, om_output);
}
else
{
@@ -898,9 +830,8 @@
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);
+ if(om_element->localname)
+ return (axis2_char_t *)axutil_string_get_buffer(om_element->localname, env);
else
return NULL;
}
@@ -913,13 +844,13 @@
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE);
- if (om_element->localname)
+ 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))
+ if(!(om_element->localname))
{
return AXIS2_FAILURE;
}
@@ -935,7 +866,7 @@
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (om_element->ns)
+ if(om_element->ns)
{
ns = om_element->ns;
}
@@ -958,13 +889,12 @@
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)
+ 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)
+ if(status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
}
@@ -1013,42 +943,31 @@
axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (om_element->qname)
+ if(om_element->qname)
{
return om_element->qname;
}
else
{
ns = axiom_element_get_namespace(om_element, env, ele_node);
- if (ns)
+ if(ns)
{
- if (axiom_namespace_get_prefix(ns, env))
+ 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));
+ 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);
+ 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);
+ om_element->qname = axutil_qname_create(env, axutil_string_get_buffer(
+ om_element->localname, env), NULL, NULL);
}
}
return om_element->qname;
@@ -1062,12 +981,10 @@
{
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
- if (!om_element->children_iter)
+ if(!om_element->children_iter)
{
- om_element->children_iter = axiom_children_iterator_create(env,
- axiom_node_get_first_child
- (element_node,
- env));
+ om_element->children_iter = axiom_children_iterator_create(env, axiom_node_get_first_child(
+ element_node, env));
}
return om_element->children_iter;
}
@@ -1080,17 +997,13 @@
axiom_node_t * element_node)
{
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
- if (om_element->children_qname_iter)
+ if(om_element->children_qname_iter)
{
- axiom_children_qname_iterator_free(om_element->children_qname_iter,
- env);
+ 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);
+ axiom_node_get_first_child(element_node, env), element_qname);
return om_element->children_qname_iter;
}
@@ -1109,32 +1022,31 @@
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
om_node = axiom_node_get_first_child(element_node, env);
- if (!om_node)
+ if(!om_node)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "There are no child elements for the node");
return NULL;
}
- children_iterator = axiom_children_qname_iterator_create(env, om_node,
- element_qname);
- if (!children_iterator)
+ children_iterator = axiom_children_qname_iterator_create(env, om_node, element_qname);
+ if(!children_iterator)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Could not create children qname iterator");
return NULL;
}
om_node = NULL;
- if (axiom_children_qname_iterator_has_next(children_iterator, env))
+ 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))
+ if(om_node && (axiom_node_get_node_type(om_node, env) == AXIOM_ELEMENT))
{
axiom_children_qname_iterator_free(children_iterator, env);
- if (child_node)
+ if(child_node)
{
*child_node = om_node;
}
- return (axiom_element_t *) axiom_node_get_data_element(om_node, env);
+ return (axiom_element_t *)axiom_node_get_data_element(om_node, env);
}
axiom_children_qname_iterator_free(children_iterator, env);
@@ -1153,14 +1065,13 @@
AXIS2_PARAM_CHECK(env->error, om_attribute, AXIS2_FAILURE);
qname = axiom_attribute_get_qname(om_attribute, env);
- if (qname && (om_element->attributes))
+ if(qname && (om_element->attributes))
{
axis2_char_t *name = NULL;
name = axutil_qname_to_string(qname, env);
- if (name)
+ if(name)
{
- axutil_hash_set(om_element->attributes, name,
- AXIS2_HASH_KEY_STRING, NULL);
+ axutil_hash_set(om_element->attributes, name, AXIS2_HASH_KEY_STRING, NULL);
return AXIS2_SUCCESS;
}
}
@@ -1179,16 +1090,15 @@
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
temp_node = axiom_node_get_first_child(element_node, env);
- while (temp_node)
+ while(temp_node)
{
- if (axiom_node_get_node_type(temp_node, env) == AXIOM_ELEMENT)
+ if(axiom_node_get_node_type(temp_node, env) == AXIOM_ELEMENT)
{
- if (first_ele_node)
+ if(first_ele_node)
{
*first_ele_node = temp_node;
}
- return (axiom_element_t *) axiom_node_get_data_element(temp_node,
- env);
+ return (axiom_element_t *)axiom_node_get_data_element(temp_node, env);
}
else
{
@@ -1212,7 +1122,7 @@
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
- if (om_element->text_value)
+ if(om_element->text_value)
{
AXIS2_FREE(env->allocator, om_element->text_value);
om_element->text_value = NULL;
@@ -1220,30 +1130,27 @@
temp_node = axiom_node_get_first_child(element_node, env);
- while (temp_node)
+ while(temp_node)
{
- if (axiom_node_get_node_type(temp_node, env) == AXIOM_TEXT)
+ 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)
+ 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)
+ 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));
+ 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);
+ memcpy((temp_dest + dest_len * sizeof(axis2_char_t)), temp_text, curr_len
+ - dest_len);
temp_dest[curr_len] = '\0';
@@ -1251,8 +1158,7 @@
dest = NULL;
dest = temp_dest;
}
- else if (!dest && temp_text &&
- axutil_strcmp(temp_text, "") != 0)
+ else if(!dest && temp_text && axutil_strcmp(temp_text, "") != 0)
{
dest = axutil_strdup(env, temp_text);
}
@@ -1279,11 +1185,11 @@
AXIS2_PARAM_CHECK(env->error, element_node, AXIS2_FAILURE);
next_node = axiom_node_get_first_child(element_node, env);
- while (next_node)
+ while(next_node)
{
temp_node = next_node;
next_node = axiom_node_get_next_sibling(temp_node, env);
- if (axiom_node_get_node_type(temp_node, env) == AXIOM_TEXT)
+ if(axiom_node_get_node_type(temp_node, env) == AXIOM_TEXT)
{
axiom_node_free_tree(temp_node, env);
}
@@ -1313,17 +1219,14 @@
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)
+ 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)
+ else if(ele && first_node)
{
- om_element->child_ele_iter =
- axiom_child_element_iterator_create(env, first_node);
+ om_element->child_ele_iter = axiom_child_element_iterator_create(env, first_node);
return om_element->child_ele_iter;
}
return NULL;
@@ -1339,22 +1242,22 @@
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)
+ 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)
+ if(!builder)
{
return AXIS2_FAILURE;
}
- while (!axiom_node_is_complete(om_ele_node, env) &&
- !axiom_stax_builder_is_complete(builder, env))
+ 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)
+ if(!value)
{
return AXIS2_FAILURE;
}
@@ -1374,35 +1277,31 @@
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
- if (om_element->namespaces)
+ if(om_element->namespaces)
{
- default_ns = axutil_hash_get(om_element->namespaces, "",
- AXIS2_HASH_KEY_STRING);
- if (default_ns)
+ 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))
+ 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)
+ 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 axiom_element_get_default_namespace(parent_ele, env, parent_node);
}
}
return NULL;
}
/**
-* declared a default namespace explicitly
-*/
+ * declared a default namespace explicitly
+ */
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
axiom_element_declare_default_namespace(
axiom_element_t * om_element,
@@ -1413,36 +1312,35 @@
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, uri, NULL);
- if (axutil_strcmp(uri, "") == 0)
+ if(axutil_strcmp(uri, "") == 0)
{
return NULL;
}
default_ns = axiom_namespace_create(env, uri, "");
- if (!default_ns)
+ if(!default_ns)
{
return NULL;
}
- if (!om_element->namespaces)
+ if(!om_element->namespaces)
{
om_element->namespaces = axutil_hash_make(env);
- if (!(om_element->namespaces))
+ if(!(om_element->namespaces))
{
axiom_namespace_free(default_ns, env);
return NULL;
}
}
- axutil_hash_set(om_element->namespaces, "",
- AXIS2_HASH_KEY_STRING, default_ns);
+ 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
-*/
+ * 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(
@@ -1458,27 +1356,23 @@
AXIS2_PARAM_CHECK(env->error, element_node, NULL);
AXIS2_PARAM_CHECK(env->error, prefix, NULL);
- if (om_element->namespaces)
+ if(om_element->namespaces)
{
- ns = axutil_hash_get(om_element->namespaces, prefix,
- AXIS2_HASH_KEY_STRING);
- if (ns)
+ 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))
+ 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)
+ 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 axiom_element_find_namespace_uri(parent_ele, env, prefix, parent_node);
}
}
return NULL;
@@ -1497,12 +1391,11 @@
name = axutil_qname_to_string(qname, env);
- if ((om_element->attributes) && (NULL != name))
+ if((om_element->attributes) && (NULL != name))
{
- attr = (axiom_attribute_t *) axutil_hash_get(om_element->attributes,
- name,
- AXIS2_HASH_KEY_STRING);
- if (attr)
+ attr = (axiom_attribute_t *)axutil_hash_get(om_element->attributes, name,
+ AXIS2_HASH_KEY_STRING);
+ if(attr)
{
return axiom_attribute_get_value(attr, env);
}
@@ -1541,29 +1434,28 @@
axutil_qname_t *qn = NULL;
AXIS2_PARAM_CHECK(env->error, ele_node, NULL);
- if (!om_element->attributes)
+ if(!om_element->attributes)
{
return NULL;
}
ht_cloned = axutil_hash_make(env);
- if (!ht_cloned)
+ 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))
+ 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)
+ if(val)
{
- om_attr = (axiom_attribute_t *) 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)
+ if(om_ns)
{
/*cloned_ns = axiom_namespace_clone(om_ns, env); */
/*axiom_attribute_set_namespace(cloned_attr, env, cloned_ns); */
@@ -1593,17 +1485,16 @@
axutil_hash_index_t *hi = NULL;
AXIS2_PARAM_CHECK(env->error, attr_name, NULL);
- if (!om_element->attributes)
+ if(!om_element->attributes)
{
return NULL;
}
- for (hi = axutil_hash_first(om_element->attributes, env); hi;
- hi = axutil_hash_next(env, hi))
+ 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)
+ if(attr)
{
axis2_char_t *this_attr_name;
axis2_char_t *this_attr_value;
@@ -1611,19 +1502,19 @@
axiom_namespace_t *attr_ns = NULL;
axis2_char_t *prefix = NULL;
- om_attr = (axiom_attribute_t *) attr;
+ 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)
+ if(attr_ns)
{
prefix = axiom_namespace_get_prefix(attr_ns, env);
- if (prefix)
+ 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)
+ if(tmp_val)
{
AXIS2_FREE(env->allocator, tmp_val);
tmp_val = NULL;
@@ -1635,7 +1526,7 @@
attr_qn_str = axutil_strdup(env, this_attr_name);
}
- if (attr_qn_str && axutil_strcmp(attr_qn_str, attr_name) == 0)
+ if(attr_qn_str && axutil_strcmp(attr_qn_str, attr_name) == 0)
{
AXIS2_FREE(env->allocator, attr_qn_str);
attr_qn_str = NULL;
@@ -1661,24 +1552,22 @@
axiom_element_t *element;
AXIS2_ENV_CHECK(env, NULL);
- if (!localname || !node)
+ if(!localname || !node)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "localname or node is NULL");
return NULL;
}
(*node) = axiom_node_create(env);
- if (!(*node))
+ 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));
+ element = (axiom_element_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_element_t));
- if (!element)
+ if(!element)
{
AXIS2_FREE(env->allocator, (*node));
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
@@ -1694,17 +1583,17 @@
element->children_qname_iter = NULL;
element->text_value = NULL;
element->next_ns_prefix_number = 0;
- element->is_empty = AXIS2_FALSE;
+ element->is_empty = AXIS2_FALSE;
element->localname = axutil_string_clone(localname, env);
- if (!element->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)
+ if(parent)
{
axiom_node_add_child(parent, env, (*node));
}
@@ -1712,7 +1601,7 @@
axiom_node_set_node_type((*node), env, AXIOM_ELEMENT);
axiom_node_set_data_element((*node), env, element);
- if (ns)
+ if(ns)
{
axis2_char_t *uri = NULL;
axis2_char_t *prefix = NULL;
@@ -1720,18 +1609,15 @@
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 = 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)
+ if(prefix && axutil_strcmp(prefix, "") == 0)
{
element->ns = NULL;
}
@@ -1757,7 +1643,7 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE);
- if (om_element->localname)
+ if(om_element->localname)
{
axutil_string_free(om_element->localname, env);
om_element->localname = NULL;
@@ -1765,7 +1651,7 @@
om_element->localname = axutil_string_clone(localname, env);
- if (!(om_element->localname))
+ if(!(om_element->localname))
{
return AXIS2_FAILURE;
}
@@ -1802,35 +1688,37 @@
axutil_hash_t *inscope_namespaces = NULL;
axiom_node_t *parent_node = om_node;
- while ((parent_node = axiom_node_get_parent(parent_node, env)) &&
- (axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT))
+ while((parent_node = axiom_node_get_parent(parent_node, env)) && (axiom_node_get_node_type(
+ parent_node, env) == AXIOM_ELEMENT))
{
- axiom_element_t *parent_element = (axiom_element_t *)axiom_node_get_data_element(parent_node, env);
+ axiom_element_t *parent_element = (axiom_element_t *)axiom_node_get_data_element(
+ parent_node, env);
axutil_hash_t *parent_namespaces = axiom_element_get_namespaces(parent_element, env);
- if (parent_namespaces)
+ if(parent_namespaces)
{
axutil_hash_index_t *hi;
void *val;
- for (hi = axutil_hash_first(parent_namespaces, env); hi;
- hi = axutil_hash_next(env, hi))
+ for(hi = axutil_hash_first(parent_namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
- if (val)
+ if(val)
{
/* Check if prefix is already associated with some namespace in node being detached */
- if (!axiom_element_find_declared_namespace(om_element, env, NULL,
- axiom_namespace_get_prefix((axiom_namespace_t *)val, env)))
+ if(!axiom_element_find_declared_namespace(om_element, env, NULL,
+ axiom_namespace_get_prefix((axiom_namespace_t *)val, env)))
{
- axis2_char_t *key = axiom_namespace_get_prefix((axiom_namespace_t *)val, env);
- if (!key)
+ axis2_char_t *key = axiom_namespace_get_prefix((axiom_namespace_t *)val,
+ env);
+ if(!key)
key = "";
/* Check if prefix already associated with some namespace in a parent node */
- if (!(inscope_namespaces && axutil_hash_get(inscope_namespaces, key, AXIS2_HASH_KEY_STRING)))
+ if(!(inscope_namespaces && axutil_hash_get(inscope_namespaces, key,
+ AXIS2_HASH_KEY_STRING)))
{
/* Remember this namespace as needing to be declared, if used */
- if (!inscope_namespaces)
+ if(!inscope_namespaces)
inscope_namespaces = axutil_hash_make(env);
- if (inscope_namespaces)
+ if(inscope_namespaces)
axutil_hash_set(inscope_namespaces, key, AXIS2_HASH_KEY_STRING, val);
}
}
@@ -1855,25 +1743,23 @@
axiom_element_t * root_element,
axutil_hash_t *inscope_namespaces)
{
- if (ns && inscope_namespaces)
+ if(ns && inscope_namespaces)
{
axiom_namespace_t *parent_ns;
axis2_char_t *key = axiom_namespace_get_prefix(ns, env);
- if (!key)
+ if(!key)
key = "";
parent_ns = axutil_hash_get(inscope_namespaces, key, AXIS2_HASH_KEY_STRING);
/* Check if namespace is a namespace declared in a parent and not also
- declared at an intermediate level */
- if (parent_ns && (parent_ns == ns) &&
- (ns != axiom_element_find_namespace(om_element, env, om_node,
- axiom_namespace_get_uri(ns, env),
- axiom_namespace_get_prefix(ns, env))))
+ declared at an intermediate level */
+ if(parent_ns && (parent_ns == ns) && (ns != axiom_element_find_namespace(om_element, env,
+ om_node, axiom_namespace_get_uri(ns, env), axiom_namespace_get_prefix(ns, env))))
{
/* Redeclare this parent namespace at the level of the element being detached */
axiom_element_declare_namespace_assume_param_ownership(root_element, env, parent_ns);
/* Remove the namespace from the inscope parent namespaces now that it has
- been redeclared. */
+ been redeclared. */
axutil_hash_set(inscope_namespaces, key, AXIS2_HASH_KEY_STRING, NULL);
}
}
@@ -1894,40 +1780,39 @@
axiom_node_t *child_node;
axutil_hash_t * attributes;
- if (!om_element || !om_node || !inscope_namespaces)
+ if(!om_element || !om_node || !inscope_namespaces)
return;
/* ensure the element's namespace is declared */
- axiom_element_use_parent_namespace(om_element, env, om_node,
- om_element->ns, root_element, inscope_namespaces);
+ axiom_element_use_parent_namespace(om_element, env, om_node, om_element->ns, root_element,
+ inscope_namespaces);
/* for each attribute, ensure the attribute's namespace is declared */
attributes = om_element->attributes;
- if (attributes)
+ if(attributes)
{
axutil_hash_index_t *hi;
void *val;
- for (hi = axutil_hash_first(attributes, env); hi;
- hi = axutil_hash_next(env, hi))
+ for(hi = axutil_hash_first(attributes, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
- if (val)
+ if(val)
{
axiom_element_use_parent_namespace(om_element, env, om_node,
- axiom_attribute_get_namespace((axiom_attribute_t *)val, env),
- root_element, inscope_namespaces);
+ axiom_attribute_get_namespace((axiom_attribute_t *)val, env), root_element,
+ inscope_namespaces);
}
}
}
/* ensure the namespaces in all the children are declared */
child_node = axiom_node_get_first_child(om_node, env);
- while (child_node && (axutil_hash_count(inscope_namespaces) > 0))
+ while(child_node && (axutil_hash_count(inscope_namespaces) > 0))
{
- if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
+ if(axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT)
{
axiom_element_redeclare_parent_namespaces(axiom_node_get_data_element(child_node, env),
- env, child_node, root_element, inscope_namespaces);
+ env, child_node, root_element, inscope_namespaces);
}
child_node = axiom_node_get_next_sibling(child_node, env);
}
Modified: webservices/axis2/trunk/c/axiom/src/om/om_namespace.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_namespace.c?rev=805360&r1=805359&r2=805360&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_namespace.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_namespace.c Tue Aug 18 11:08:42 2009
@@ -1,4 +1,3 @@
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -43,15 +42,13 @@
axiom_namespace_t *om_namespace = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (!uri)
+ if(!uri)
{
uri = "";
}
- om_namespace = (axiom_namespace_t *) AXIS2_MALLOC(env->allocator,
- sizeof
- (axiom_namespace_t));
- if (!om_namespace)
+ om_namespace = (axiom_namespace_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_namespace_t));
+ if(!om_namespace)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
@@ -63,17 +60,17 @@
om_namespace->key = NULL;
om_namespace->uri = axutil_string_create(env, uri);
- if (!om_namespace->uri)
+ if(!om_namespace->uri)
{
AXIS2_FREE(env->allocator, om_namespace);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- if (prefix)
+ if(prefix)
{
om_namespace->prefix = axutil_string_create(env, prefix);
- if (!om_namespace->prefix)
+ if(!om_namespace->prefix)
{
AXIS2_FREE(env->allocator, om_namespace);
AXIS2_FREE(env->allocator, om_namespace->uri);
@@ -92,22 +89,22 @@
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- if (--om_namespace->ref > 0)
+ if(--om_namespace->ref > 0)
{
return;
}
- if (om_namespace->prefix)
+ if(om_namespace->prefix)
{
axutil_string_free(om_namespace->prefix, env);
}
- if (om_namespace->uri)
+ if(om_namespace->uri)
{
axutil_string_free(om_namespace->uri, env);
}
- if (om_namespace->key)
+ if(om_namespace->key)
{
AXIS2_FREE(env->allocator, om_namespace->key);
}
@@ -130,27 +127,25 @@
AXIS2_PARAM_CHECK(env->error, om_namespace, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_namespace1, AXIS2_FAILURE);
- if (!om_namespace || !om_namespace1)
+ if(!om_namespace || !om_namespace1)
{
return AXIS2_FALSE;
}
- if (om_namespace->uri && om_namespace1->uri)
+ if(om_namespace->uri && om_namespace1->uri)
{
- uris_differ =
- axutil_strcmp(axutil_string_get_buffer(om_namespace->uri, env),
- axutil_string_get_buffer(om_namespace1->uri, env));
+ uris_differ = axutil_strcmp(axutil_string_get_buffer(om_namespace->uri, env),
+ axutil_string_get_buffer(om_namespace1->uri, env));
}
else
{
uris_differ = (om_namespace->uri || om_namespace1->uri);
}
- if (om_namespace->prefix && om_namespace1->prefix)
+ if(om_namespace->prefix && om_namespace1->prefix)
{
- prefixes_differ =
- axutil_strcmp(axutil_string_get_buffer(om_namespace->prefix, env),
- axutil_string_get_buffer(om_namespace1->prefix, env));
+ prefixes_differ = axutil_strcmp(axutil_string_get_buffer(om_namespace->prefix, env),
+ axutil_string_get_buffer(om_namespace1->prefix, env));
}
else
{
@@ -167,7 +162,7 @@
axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
- if (!om_namespace)
+ if(!om_namespace)
{
return AXIS2_FAILURE;
}
@@ -175,23 +170,16 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
- if (om_namespace->uri && NULL != om_namespace->prefix &&
- axutil_strcmp(axutil_string_get_buffer(om_namespace->prefix, env),
- "") != 0)
- {
- status = axiom_output_write(om_output, env, AXIOM_NAMESPACE,
- 2,
- axutil_string_get_buffer(om_namespace->
- prefix, env),
- axutil_string_get_buffer(om_namespace->uri,
- env));
- }
- else if (om_namespace->uri)
- {
- status = axiom_output_write(om_output, env, AXIOM_NAMESPACE,
- 2, NULL,
- axutil_string_get_buffer(om_namespace->uri,
- env));
+ if(om_namespace->uri && NULL != om_namespace->prefix && axutil_strcmp(axutil_string_get_buffer(
+ om_namespace->prefix, env), "") != 0)
+ {
+ status = axiom_output_write(om_output, env, AXIOM_NAMESPACE, 2, axutil_string_get_buffer(
+ om_namespace-> prefix, env), axutil_string_get_buffer(om_namespace->uri, env));
+ }
+ else if(om_namespace->uri)
+ {
+ status = axiom_output_write(om_output, env, AXIOM_NAMESPACE, 2, NULL,
+ axutil_string_get_buffer(om_namespace->uri, env));
}
return status;
}
@@ -201,10 +189,9 @@
axiom_namespace_t * om_namespace,
const axutil_env_t * env)
{
- if (om_namespace->uri)
+ if(om_namespace->uri)
{
- return (axis2_char_t *) axutil_string_get_buffer(om_namespace->uri,
- env);
+ return (axis2_char_t *)axutil_string_get_buffer(om_namespace->uri, env);
}
return NULL;
}
@@ -214,10 +201,9 @@
axiom_namespace_t * om_namespace,
const axutil_env_t * env)
{
- if (om_namespace->prefix)
+ if(om_namespace->prefix)
{
- return (axis2_char_t *) axutil_string_get_buffer(om_namespace->prefix,
- env);
+ return (axis2_char_t *)axutil_string_get_buffer(om_namespace->prefix, env);
}
return NULL;
}
@@ -231,10 +217,8 @@
AXIS2_ENV_CHECK(env, NULL);
- cloned_ns = axiom_namespace_create_str(env,
- om_namespace->uri,
- om_namespace->prefix);
- if (cloned_ns)
+ cloned_ns = axiom_namespace_create_str(env, om_namespace->uri, om_namespace->prefix);
+ if(cloned_ns)
{
return cloned_ns;
}
@@ -248,32 +232,26 @@
{
axis2_char_t *temp_str = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (om_namespace->key)
+ if(om_namespace->key)
{
AXIS2_FREE(env->allocator, om_namespace->key);
om_namespace->key = NULL;
}
- if ((om_namespace->uri) && (NULL != om_namespace->prefix))
+ if((om_namespace->uri) && (NULL != om_namespace->prefix))
{
- temp_str =
- axutil_stracat(env,
- axutil_string_get_buffer(om_namespace->uri, env),
- "|");
- om_namespace->key =
- axutil_stracat(env, temp_str,
- axutil_string_get_buffer(om_namespace->prefix, env));
- if (temp_str)
+ temp_str = axutil_stracat(env, axutil_string_get_buffer(om_namespace->uri, env), "|");
+ om_namespace->key = axutil_stracat(env, temp_str, axutil_string_get_buffer(
+ om_namespace->prefix, env));
+ if(temp_str)
{
AXIS2_FREE(env->allocator, temp_str);
temp_str = NULL;
}
}
- else if ((om_namespace->uri) && !(om_namespace->prefix))
+ else if((om_namespace->uri) && !(om_namespace->prefix))
{
- om_namespace->key =
- axutil_strdup(env,
- axutil_string_get_buffer(om_namespace->uri, env));
- if (!(om_namespace->key))
+ om_namespace->key = axutil_strdup(env, axutil_string_get_buffer(om_namespace->uri, env));
+ if(!(om_namespace->key))
{
return NULL;
}
@@ -290,14 +268,14 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
- if (om_namespace->uri)
+ if(om_namespace->uri)
{
axutil_string_free(om_namespace->uri, env);
om_namespace->uri = NULL;
}
om_namespace->uri = axutil_string_create(env, uri);
- if (!(om_namespace->uri))
+ if(!(om_namespace->uri))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
@@ -324,15 +302,13 @@
axiom_namespace_t *om_namespace = NULL;
AXIS2_ENV_CHECK(env, NULL);
- if (!uri)
+ if(!uri)
{
uri = axutil_string_create(env, "");
}
- om_namespace = (axiom_namespace_t *) AXIS2_MALLOC(env->allocator,
- sizeof
- (axiom_namespace_t));
- if (!om_namespace)
+ om_namespace = (axiom_namespace_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_namespace_t));
+ if(!om_namespace)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
@@ -344,17 +320,17 @@
om_namespace->key = NULL;
om_namespace->uri = axutil_string_clone(uri, env);
- if (!om_namespace->uri)
+ if(!om_namespace->uri)
{
AXIS2_FREE(env->allocator, om_namespace);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- if (prefix)
+ if(prefix)
{
om_namespace->prefix = axutil_string_clone(prefix, env);
- if (!om_namespace->prefix)
+ if(!om_namespace->prefix)
{
AXIS2_FREE(env->allocator, om_namespace);
AXIS2_FREE(env->allocator, om_namespace->uri);
@@ -375,19 +351,19 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
- if (om_namespace->uri)
+ if(om_namespace->uri)
{
axutil_string_free(om_namespace->uri, env);
om_namespace->uri = NULL;
}
om_namespace->uri = axutil_string_clone(uri, env);
- if (!(om_namespace->uri))
+ if(!(om_namespace->uri))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
-
+
return AXIS2_SUCCESS;
}
Modified: webservices/axis2/trunk/c/axiom/src/om/om_navigator.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_navigator.c?rev=805360&r1=805359&r2=805360&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_navigator.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_navigator.c Tue Aug 18 11:08:42 2009
@@ -1,4 +1,3 @@
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -18,7 +17,8 @@
#include <axiom_navigator.h>
-static void axiom_navigator_update_next_node(
+static void
+axiom_navigator_update_next_node(
axiom_navigator_t * om_navigator,
const axutil_env_t * env);
@@ -49,10 +49,8 @@
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, om_node, NULL);
- om_navigator =
- (axiom_navigator_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_navigator_t));
- if (!om_navigator)
+ om_navigator = (axiom_navigator_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_navigator_t));
+ if(!om_navigator)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
@@ -87,13 +85,13 @@
axiom_navigator_t * om_navigator,
const axutil_env_t * env)
{
- if (AXIS2_TRUE == om_navigator->end)
+ if(AXIS2_TRUE == om_navigator->end)
{
return AXIS2_FALSE;
}
else
{
- if (om_navigator->next)
+ if(om_navigator->next)
{
return AXIS2_TRUE;
}
@@ -124,7 +122,7 @@
{
AXIS2_ENV_CHECK(env, NULL);
- if (!om_navigator->next)
+ if(!om_navigator->next)
{
return NULL;
}
@@ -136,9 +134,9 @@
axiom_navigator_update_next_node(om_navigator, env);
/** set the starting and ending flags */
- if (om_navigator->root == om_navigator->next)
+ if(om_navigator->root == om_navigator->next)
{
- if (!(om_navigator->start))
+ if(!(om_navigator->start))
{
om_navigator->end = AXIS2_TRUE;
}
@@ -156,25 +154,24 @@
axiom_navigator_t * om_navigator,
const axutil_env_t * env)
{
- if (!om_navigator)
+ if(!om_navigator)
{
return;
}
- if (!om_navigator->next)
+ if(!om_navigator->next)
{
return;
}
- if ((AXIOM_ELEMENT == axiom_node_get_node_type(om_navigator->next, env)) &&
- !(om_navigator->visited))
+ if((AXIOM_ELEMENT == axiom_node_get_node_type(om_navigator->next, env))
+ && !(om_navigator->visited))
{
- if (axiom_node_get_first_child(om_navigator->next, env))
+ if(axiom_node_get_first_child(om_navigator->next, env))
{
- om_navigator->next =
- axiom_node_get_first_child(om_navigator->next, env);
+ om_navigator->next = axiom_node_get_first_child(om_navigator->next, env);
}
- else if (AXIS2_TRUE == axiom_node_is_complete(om_navigator->next, env))
+ else if(AXIS2_TRUE == axiom_node_is_complete(om_navigator->next, env))
{
om_navigator->backtracked = AXIS2_TRUE;
}
@@ -192,11 +189,11 @@
parent = axiom_node_get_parent(om_navigator->next, env);
- if (next_sibling)
+ if(next_sibling)
{
om_navigator->next = next_sibling;
}
- else if ((parent) && axiom_node_is_complete(parent, env))
+ else if((parent) && axiom_node_is_complete(parent, env))
{
om_navigator->next = parent;
om_navigator->backtracked = AXIS2_TRUE;