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 sa...@apache.org on 2007/09/28 12:22:36 UTC
svn commit: r580284 [3/12] - in /webservices/axis2/trunk/c/axiom:
src/attachments/ src/om/ src/parser/ src/parser/guththila/
src/parser/libxml2/ src/soap/ src/util/ test/om/ test/soap/
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=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_element.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_element.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -26,12 +27,16 @@
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;
@@ -39,7 +44,7 @@
axiom_child_element_iterator_t *child_ele_iter;
- axiom_children_iterator_t* children_iter;
+ axiom_children_iterator_t *children_iter;
axiom_children_qname_iterator_t *children_qname_iter;
@@ -50,18 +55,20 @@
};
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_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);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
+ AXIS2_FAILURE);
return NULL;
}
@@ -72,7 +79,7 @@
return NULL;
}
element = (axiom_element_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_element_t));
+ sizeof(axiom_element_t));
if (!element)
{
@@ -120,11 +127,11 @@
element->ns = NULL;
return element;
}
-
+
element->ns = axiom_element_find_namespace(element,
- env, *node, uri, prefix);
+ env, *node, uri, prefix);
- if(element->ns)
+ if (element->ns)
{
if (ns != element->ns)
{
@@ -136,26 +143,28 @@
if (!(element->ns))
{
if (axiom_element_declare_namespace(element,
- env, *node, ns) == AXIS2_SUCCESS)
+ env, *node,
+ ns) == AXIS2_SUCCESS)
{
element->ns = ns;
}
}
/*if (prefix && axutil_strcmp(prefix, "") == 0)
- {
- element->ns = NULL;
- }
- */
+ {
+ 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_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;
@@ -164,13 +173,15 @@
AXIS2_ENV_CHECK(env, NULL);
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);
return NULL;
}
localpart = axutil_qname_get_localpart(qname, env);
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);
return NULL;
}
element = axiom_element_create(env, parent, localpart, NULL, node);
@@ -184,9 +195,10 @@
axiom_element_t *om_element = NULL;
axis2_char_t *temp_nsuri = NULL;
axis2_char_t *temp_prefix = NULL;
- axiom_namespace_t *ns = 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)
@@ -196,6 +208,7 @@
if ((!temp_nsuri) || (axutil_strcmp(temp_nsuri, "") == 0))
{
+
/** no namespace uri is available in given qname
no need to bother about it
*/
@@ -203,13 +216,16 @@
}
om_element->ns = axiom_element_find_namespace(om_element, env,
- (*node), temp_nsuri, temp_prefix);
+ (*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)
+ if (axiom_element_declare_namespace(om_element, env, *node, ns) ==
+ AXIS2_SUCCESS)
{
(element->ns) = ns;
return om_element;
@@ -227,8 +243,9 @@
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
-axiom_element_find_namespace(axiom_element_t *om_element,
- const axutil_env_t *env,
+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)
@@ -239,14 +256,15 @@
if (!element_node || !om_element)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
+ 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);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
+ AXIS2_FAILURE);
return NULL;
}
@@ -256,12 +274,13 @@
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);
+ default_ns = axiom_element_get_default_namespace(om_element,
+ env, element_node);
if (default_ns && NULL != uri)
{
axis2_char_t *default_uri = NULL;
@@ -276,23 +295,25 @@
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))
+ 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_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);
+ return (axiom_namespace_t *) (ns);
}
temp_ns = NULL;
temp_nsuri = NULL;
@@ -303,14 +324,15 @@
}
else if (prefix)
{
+
/** prefix is not null get namespace directly if exist */
ns = axutil_hash_get(om_element->namespaces, prefix,
- AXIS2_HASH_KEY_STRING);
+ AXIS2_HASH_KEY_STRING);
if (ns)
{
- axiom_namespace_t *found_ns = NULL;
+ 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);
@@ -329,11 +351,13 @@
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);
+ 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);
+ parent, uri, prefix);
}
}
}
@@ -341,19 +365,20 @@
}
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)
+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_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);
+ AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -371,17 +396,16 @@
if (prefix)
{
axutil_hash_set(om_element->namespaces,
- prefix, AXIS2_HASH_KEY_STRING, ns);
+ 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);
+ 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);
+ axutil_hash_set(om_element->namespaces, key, AXIS2_HASH_KEY_STRING, ns);
}
axiom_namespace_increment_ref(ns, env);
@@ -389,21 +413,22 @@
}
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_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_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);
+ AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -411,7 +436,7 @@
prefix = axiom_namespace_get_prefix(ns, env);
declared_ns = axiom_element_find_namespace(om_element,
- env, node, uri, prefix);
+ env, node, uri, prefix);
if (declared_ns)
{
@@ -433,17 +458,16 @@
if (prefix)
{
axutil_hash_set(om_element->namespaces,
- prefix, AXIS2_HASH_KEY_STRING, ns);
+ 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);
+ 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);
+ axutil_hash_set(om_element->namespaces, key, AXIS2_HASH_KEY_STRING, ns);
}
axiom_namespace_increment_ref(ns, env);
@@ -451,8 +475,9 @@
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
-axiom_element_find_declared_namespace(axiom_element_t *om_element,
- const axutil_env_t *env,
+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)
{
@@ -467,16 +492,17 @@
}
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))
+ 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_ns = (axiom_namespace_t *) (ns);
temp_nsuri = axiom_namespace_get_uri(temp_ns, env);
if (temp_nsuri && axutil_strcmp(temp_nsuri, uri) == 0)
@@ -494,7 +520,8 @@
else if (prefix)
{
axiom_namespace_t *found_ns = NULL;
- ns = axutil_hash_get(om_element->namespaces, prefix, AXIS2_HASH_KEY_STRING);
+ ns = axutil_hash_get(om_element->namespaces, prefix,
+ AXIS2_HASH_KEY_STRING);
if (ns)
{
axis2_char_t *found_uri = NULL;
@@ -510,23 +537,26 @@
}
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)
+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);
+ 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));
+ axutil_qname_get_uri(qname, env),
+ axutil_qname_get_prefix(qname,
+ env));
}
else
{
@@ -535,10 +565,11 @@
}
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)
+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;
@@ -553,14 +584,17 @@
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));
+ 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);
+ element_node,
+ om_namespace);
if (status == AXIS2_FAILURE)
{
return AXIS2_FAILURE;
@@ -582,17 +616,17 @@
{
axis2_char_t *name = axutil_qname_to_string(qname, env);
axutil_hash_set(om_element->attributes,
- name, AXIS2_HASH_KEY_STRING,
- attribute);
+ 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)
+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;
@@ -603,15 +637,17 @@
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;
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_element_free(axiom_element_t *om_element,
- const axutil_env_t *env)
+axiom_element_free(
+ axiom_element_t * om_element,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!om_element)
@@ -633,13 +669,13 @@
void *val = NULL;
for (hi = axutil_hash_first(om_element->attributes, env); hi;
- hi = axutil_hash_next(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);
+ axiom_attribute_free((axiom_attribute_t *) val, env);
}
}
axutil_hash_free(om_element->attributes, env);
@@ -650,12 +686,12 @@
axutil_hash_index_t *hi;
void *val = NULL;
for (hi = axutil_hash_first(om_element->namespaces, env); hi;
- hi = axutil_hash_next(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);
+ axiom_namespace_free((axiom_namespace_t *) val, env);
}
}
axutil_hash_free(om_element->namespaces, env);
@@ -674,7 +710,8 @@
}
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)
{
@@ -686,10 +723,11 @@
}
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)
+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;
@@ -707,34 +745,42 @@
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);
+ 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);
+ 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));
+ 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))
+ 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);
+ axiom_attribute_serialize((axiom_attribute_t *) val,
+ env, om_output);
}
else
{
@@ -743,21 +789,20 @@
}
}
-
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))
+ 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);
+ axiom_namespace_serialize((axiom_namespace_t *) val,
+ env, om_output);
}
else
{
@@ -770,8 +815,9 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_element_serialize_end_part(axiom_element_t *om_element,
- const axutil_env_t *env,
+axiom_element_serialize_end_part(
+ axiom_element_t * om_element,
+ const axutil_env_t * env,
axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
@@ -780,21 +826,23 @@
return status;
}
-
-AXIS2_EXTERN axis2_char_t* AXIS2_CALL
-axiom_element_get_localname(axiom_element_t *om_element,
- const axutil_env_t *env)
+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);
+ 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)
+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);
@@ -812,10 +860,10 @@
}
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_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);
@@ -825,27 +873,27 @@
ns = om_element->ns;
}
else
- {
- ns = axiom_element_get_default_namespace(
- om_element, env, ele_node);
+ {
+ 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_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);
+ 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));
+ 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);
@@ -863,35 +911,39 @@
}
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)
+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)
+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)
+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_element_get_qname(
+ axiom_element_t * om_element,
+ const axutil_env_t * env,
+ axiom_node_t * ele_node)
{
- axiom_namespace_t *ns = NULL;
+ axiom_namespace_t *ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
if (om_element->qname)
@@ -905,33 +957,41 @@
{
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);
+ 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);
+ 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)
+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)
@@ -941,36 +1001,43 @@
else
{
om_element->children_iter = axiom_children_iterator_create(env,
- axiom_node_get_first_child(element_node, 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)
+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);
+ 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);
+ 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_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;
@@ -979,8 +1046,10 @@
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);
+ axiom_node_get_first_child
+ (element_node,
+ env),
+ element_qname);
if (!children_iterator)
{
return NULL;
@@ -998,7 +1067,7 @@
{
*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);
}
else
{
@@ -1009,9 +1078,10 @@
}
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)
+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);
@@ -1025,7 +1095,7 @@
if (name)
{
axutil_hash_set(om_element->attributes, name,
- AXIS2_HASH_KEY_STRING, NULL);
+ AXIS2_HASH_KEY_STRING, NULL);
return AXIS2_SUCCESS;
}
}
@@ -1033,10 +1103,11 @@
}
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_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);
@@ -1051,7 +1122,8 @@
{
*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
{
@@ -1062,9 +1134,10 @@
}
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)
+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;
@@ -1090,7 +1163,8 @@
int curr_len = 0;
axis2_char_t *temp_dest = NULL;
- text_node = (axiom_text_t *)axiom_node_get_data_element(temp_node, env);
+ 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);
@@ -1099,11 +1173,12 @@
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));
+ (curr_len +
+ 1) * sizeof(axis2_char_t));
- memcpy(temp_dest, dest, dest_len*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_text, curr_len - dest_len);
temp_dest[curr_len] = '\0';
@@ -1111,7 +1186,8 @@
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);
}
@@ -1125,10 +1201,11 @@
}
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_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;
@@ -1155,9 +1232,10 @@
}
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)
+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;
@@ -1167,7 +1245,7 @@
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);
+ AXIS2_XML_PARSER_TYPE_BUFFER);
if (!xml_writer)
{
return NULL;
@@ -1182,38 +1260,43 @@
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);
+ 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_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);
+ 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);
+ 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_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);
@@ -1230,9 +1313,9 @@
return AXIS2_FAILURE;
}
while (!axiom_node_is_complete(om_ele_node, env) &&
- !axiom_stax_builder_is_complete(builder, env))
+ !axiom_stax_builder_is_complete(builder, env))
{
- void *value = NULL;
+ void *value = NULL;
value = axiom_stax_builder_next(builder, env);
if (!value)
{
@@ -1243,9 +1326,10 @@
}
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_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;
@@ -1256,7 +1340,7 @@
if (om_element->namespaces)
{
default_ns = axutil_hash_get(om_element->namespaces, "",
- AXIS2_HASH_KEY_STRING);
+ AXIS2_HASH_KEY_STRING);
if (default_ns)
{
return default_ns;
@@ -1272,7 +1356,8 @@
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;
@@ -1282,9 +1367,10 @@
* 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_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);
@@ -1310,7 +1396,7 @@
}
axutil_hash_set(om_element->namespaces, "",
- AXIS2_HASH_KEY_STRING, default_ns);
+ AXIS2_HASH_KEY_STRING, default_ns);
axiom_namespace_increment_ref(default_ns, env);
return default_ns;
}
@@ -1321,10 +1407,11 @@
*/
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_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;
@@ -1336,7 +1423,7 @@
if (om_element->namespaces)
{
ns = axutil_hash_get(om_element->namespaces, prefix,
- AXIS2_HASH_KEY_STRING);
+ AXIS2_HASH_KEY_STRING);
if (ns)
{
return ns;
@@ -1352,16 +1439,18 @@
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;
}
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)
+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;
@@ -1372,8 +1461,9 @@
if ((om_element->attributes) && (NULL != 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);
if (attr)
{
return axiom_attribute_get_value(attr, env);
@@ -1384,9 +1474,9 @@
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)
+ 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);
@@ -1395,9 +1485,10 @@
}
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)
+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;
@@ -1406,7 +1497,7 @@
axiom_attribute_t *cloned_attr = NULL;
axiom_namespace_t *om_ns = NULL;
- /*axiom_namespace_t *cloned_ns = NULL;*/
+ /*axiom_namespace_t *cloned_ns = NULL; */
axis2_char_t *key = NULL;
axutil_qname_t *qn = NULL;
@@ -1424,21 +1515,21 @@
}
for (hi = axutil_hash_first(om_element->attributes, env);
- hi; hi = axutil_hash_next(env, hi))
+ hi; hi = axutil_hash_next(env, hi))
{
void *val = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
- om_attr = (axiom_attribute_t *)val;
+ om_attr = (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);
+ /*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);
@@ -1446,19 +1537,20 @@
}
val = NULL;
key = NULL;
- qn = NULL;
+ qn = NULL;
om_attr = NULL;
cloned_attr = NULL;
om_ns = NULL;
- /*cloned_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)
+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;
@@ -1481,7 +1573,7 @@
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);
@@ -1521,18 +1613,20 @@
}
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_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);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM,
+ AXIS2_FAILURE);
return NULL;
}
@@ -1543,7 +1637,7 @@
return NULL;
}
element = (axiom_element_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_element_t));
+ sizeof(axiom_element_t));
if (!element)
{
@@ -1587,11 +1681,12 @@
prefix = axiom_namespace_get_prefix(ns, env);
element->ns = axiom_element_find_namespace(element,
- env, *node, uri, prefix);
+ env, *node, uri, prefix);
if (!(element->ns))
{
if (axiom_element_declare_namespace(element,
- env, *node, ns) == AXIS2_SUCCESS)
+ env, *node,
+ ns) == AXIS2_SUCCESS)
{
element->ns = ns;
}
@@ -1605,27 +1700,29 @@
return element;
}
-AXIS2_EXTERN axutil_string_t* AXIS2_CALL
-axiom_element_get_localname_str(axiom_element_t *om_element,
- const axutil_env_t *env)
+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)
+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))
@@ -1634,4 +1731,3 @@
}
return AXIS2_SUCCESS;
}
-
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=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_namespace.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_namespace.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -21,8 +22,10 @@
struct axiom_namespace
{
+
/** namespace URI */
axutil_string_t *uri;
+
/** namespace prefix */
axutil_string_t *prefix;
@@ -32,7 +35,8 @@
};
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
-axiom_namespace_create(const axutil_env_t *env,
+axiom_namespace_create(
+ const axutil_env_t * env,
const axis2_char_t * uri,
const axis2_char_t * prefix)
{
@@ -41,14 +45,15 @@
AXIS2_ENV_CHECK(env, NULL);
if (!uri)
{
- uri = "";
+ uri = "";
}
om_namespace = (axiom_namespace_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_namespace_t));
+ sizeof
+ (axiom_namespace_t));
if (!om_namespace)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY , AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -77,12 +82,13 @@
}
}
- return om_namespace ;
+ return om_namespace;
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_namespace_free(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_free(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -112,9 +118,10 @@
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_namespace_equals(axiom_namespace_t *om_namespace,
- const axutil_env_t *env,
- axiom_namespace_t *om_namespace1)
+axiom_namespace_equals(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env,
+ axiom_namespace_t * om_namespace1)
{
int uris_differ = 0;
int prefixes_differ = 0;
@@ -130,8 +137,9 @@
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
{
@@ -141,8 +149,8 @@
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));
+ axutil_strcmp(axutil_string_get_buffer(om_namespace->prefix, env),
+ axutil_string_get_buffer(om_namespace1->prefix, env));
}
else
{
@@ -153,9 +161,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_namespace_serialize(axiom_namespace_t *om_namespace,
- const axutil_env_t *env,
- axiom_output_t *om_output)
+axiom_namespace_serialize(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env,
+ axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
if (!om_namespace)
@@ -167,53 +176,64 @@
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)
+ 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));
+ 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));
+ 2, NULL,
+ axutil_string_get_buffer(om_namespace->uri,
+ env));
}
return status;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axiom_namespace_get_uri(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_get_uri(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
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;
}
-
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axiom_namespace_get_prefix(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_get_prefix(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
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;
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
-axiom_namespace_clone(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_clone(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
- axiom_namespace_t *cloned_ns = NULL;
+ axiom_namespace_t *cloned_ns = NULL;
AXIS2_ENV_CHECK(env, NULL);
cloned_ns = axiom_namespace_create_str(env,
- om_namespace->uri, om_namespace->prefix);
+ om_namespace->uri,
+ om_namespace->prefix);
if (cloned_ns)
{
return cloned_ns;
@@ -222,8 +242,9 @@
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axiom_namespace_to_string(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_to_string(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
axis2_char_t *temp_str = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -234,10 +255,13 @@
}
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));
+ 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);
@@ -246,7 +270,9 @@
}
else if ((om_namespace->uri) && !(om_namespace->prefix))
{
- om_namespace->key = axutil_strdup(env, axutil_string_get_buffer(om_namespace->uri, env));
+ om_namespace->key =
+ axutil_strdup(env,
+ axutil_string_get_buffer(om_namespace->uri, env));
if (!(om_namespace->key))
{
return NULL;
@@ -255,11 +281,11 @@
return om_namespace->key;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_namespace_set_uri(axiom_namespace_t *om_namespace,
- const axutil_env_t *env,
- const axis2_char_t *uri)
+axiom_namespace_set_uri(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env,
+ const axis2_char_t * uri)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
@@ -279,9 +305,10 @@
return AXIS2_SUCCESS;
}
-AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_namespace_increment_ref(struct axiom_namespace *om_namespace,
- const axutil_env_t *env)
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_namespace_increment_ref(
+ struct axiom_namespace * om_namespace,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
om_namespace->ref++;
@@ -289,7 +316,8 @@
}
AXIS2_EXTERN axiom_namespace_t *AXIS2_CALL
-axiom_namespace_create_str(const axutil_env_t *env,
+axiom_namespace_create_str(
+ const axutil_env_t * env,
axutil_string_t * uri,
axutil_string_t * prefix)
{
@@ -298,14 +326,15 @@
AXIS2_ENV_CHECK(env, NULL);
if (!uri)
{
- uri = axutil_string_create(env, "");
+ uri = axutil_string_create(env, "");
}
om_namespace = (axiom_namespace_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_namespace_t));
+ sizeof
+ (axiom_namespace_t));
if (!om_namespace)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY , AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
@@ -334,13 +363,14 @@
}
}
- return om_namespace ;
+ return om_namespace;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_namespace_set_uri_str(axiom_namespace_t *om_namespace,
- const axutil_env_t *env,
- axutil_string_t *uri)
+axiom_namespace_set_uri_str(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env,
+ axutil_string_t * uri)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
@@ -362,16 +392,17 @@
}
AXIS2_EXTERN axutil_string_t *AXIS2_CALL
-axiom_namespace_get_uri_str(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_get_uri_str(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
return om_namespace->uri;
}
AXIS2_EXTERN axutil_string_t *AXIS2_CALL
-axiom_namespace_get_prefix_str(axiom_namespace_t *om_namespace,
- const axutil_env_t *env)
+axiom_namespace_get_prefix_str(
+ axiom_namespace_t * om_namespace,
+ const axutil_env_t * env)
{
return om_namespace->prefix;
}
-
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=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_navigator.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_navigator.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -17,9 +18,9 @@
#include <axiom_navigator.h>
-static void
-axiom_navigator_update_next_node(axiom_navigator_t *om_navigator,
- const axutil_env_t *env);
+static void axiom_navigator_update_next_node(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env);
struct axiom_navigator
{
@@ -40,15 +41,17 @@
};
AXIS2_EXTERN axiom_navigator_t *AXIS2_CALL
-axiom_navigator_create(const axutil_env_t *env,
- axiom_node_t *om_node)
+axiom_navigator_create(
+ const axutil_env_t * env,
+ axiom_node_t * om_node)
{
axiom_navigator_t *om_navigator = NULL;
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));
+ (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);
@@ -69,19 +72,20 @@
return om_navigator;
}
-
AXIS2_EXTERN void AXIS2_CALL
-axiom_navigator_free(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_free(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
- AXIS2_ENV_CHECK(env , AXIS2_FAILURE);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_FREE(env->allocator, om_navigator);
return;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_navigator_is_navigable(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_is_navigable(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
if (AXIS2_TRUE == om_navigator->end)
{
@@ -98,27 +102,29 @@
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_navigator_is_completed(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_is_completed(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
return om_navigator->end;
}
-
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_navigator_visited(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_visited(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
return om_navigator->visited;
}
AXIS2_EXTERN axiom_node_t *AXIS2_CALL
-axiom_navigator_next(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_next(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
- if (! om_navigator->next)
+ if (!om_navigator->next)
{
return NULL;
}
@@ -146,8 +152,9 @@
/** this method encapsulate searching logic */
static void
-axiom_navigator_update_next_node(axiom_navigator_t *om_navigator,
- const axutil_env_t *env)
+axiom_navigator_update_next_node(
+ axiom_navigator_t * om_navigator,
+ const axutil_env_t * env)
{
if (!om_navigator)
{
@@ -164,7 +171,8 @@
{
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))
{
@@ -177,7 +185,7 @@
}
else
{
- axiom_node_t *parent = NULL;
+ axiom_node_t *parent = NULL;
axiom_node_t *next_sibling = NULL;
next_sibling = axiom_node_get_next_sibling(om_navigator->next, env);
@@ -199,4 +207,3 @@
}
}
}
-
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org