org.apache.axis2.schema.template.CADBBeanTemplateSource.xsl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of axis2-adb-codegen Show documentation
Show all versions of axis2-adb-codegen Show documentation
ADB code generation support for Axis2
adb_
/**
*
_
adb_
1
0
/*
* This type was generated from the piece of schema that had
* name =
/*
* implmentation of the | element
*/
struct
axutil_qname_t* qname;
axutil_array_list_t*
axiom_node_t*
property_axis2_bool_t is_valid_
axutil_array_list_t*
property_axis2_bool_t is_valid_
axis2_char_t *current_choice;
/* for unions we are keeping members in a union */
union {
_
} member_type;
/* here too we keep the choice */
axis2_char_t *current_value;
};
/************************* Private Function prototypes ********************************/
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
axiom_node_t*
*
Array of s.
axis2_status_t AXIS2_CALL
axis2_status_t AXIS2_CALL
/************************* Function Implmentations ********************************/
axutil_qname_t* qname = NULL;
AXIS2_ENV_CHECK(env, NULL);
qname = axutil_qname_create (env,
"
qname = axutil_qname_create (env,
"
return
axutil_array_list_t*
axiom_node_t*
_
,
_
status =
/* this function is not implemented for union types */
return adb_obj;
}
axutil_array_list_t*
axiom_node_t*
/* this function is not completely implemented for union types */
value =
void* AXIS2_CALL
axis2_status_t AXIS2_CALL
return axis2_extension_mapper_free(
(adb_type_t*)
return
}
axis2_status_t AXIS2_CALL
int i = 0;
int count = 0;
void *element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
if(
if(
axis2_status_t AXIS2_CALL
void *element = NULL;
void *element = NULL;
const axis2_char_t *cp_ro = NULL;
axis2_bool_t prefix_found = AXIS2_FALSE;
axiom_namespace_t *qname_ns;
int i;
axis2_char_t *token_value = NULL;
axis2_char_t *original_node_value = NULL;
axis2_char_t *dupd_node_value = NULL;
axis2_bool_t the_last_token = AXIS2_FALSE;
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
prefix_found = AXIS2_FALSE;
for(cp_ro = node_value; *cp_ro; cp_ro ++)
{
if(*cp_ro == ':')
{
cp_ro ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
char *prefix_value = AXIS2_MALLOC(env->allocator, (cp_ro - node_value - 1) + 1);
strncpy(prefix_value, node_value, (cp_ro - node_value - 1));
prefix_value[cp_ro - node_value - 1] = '\0';
qname_ns = axiom_element_find_namespace_uri((axiom_element_t*)axiom_node_get_data_element(parent, env), env, prefix_value, parent);
AXIS2_FREE(env->allocator, prefix_value);
}
else
{
/* Then it is the default namespace */
cp_ro = node_value;
qname_ns = axiom_element_get_default_namespace((axiom_element_t*)axiom_node_get_data_element(parent, env), env, parent);
}
if (!axutil_strcmp(node_value, "TRUE") || !axutil_strcmp(node_value, "true"))
{
element = (void*)axutil_date_time_create(env);
axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
node_value);
element = (void*)axutil_base64_binary_create(env);
axutil_base64_binary_set_encoded_binary((
element = (void*)
/* can not handle the attribute type
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
*
(
element
/* just to make sure we are not altering the original */
dupd_node_value = original_node_value = (axis2_char_t*)axutil_strdup(env, node_value);
for(token_value = dupd_node_value, the_last_token = AXIS2_FALSE; !the_last_token; dupd_node_value ++)
{
if(*dupd_node_value == ' ' || *dupd_node_value == '\t' || *dupd_node_value == '\r'
|| *dupd_node_value == '\n' || *dupd_node_value == '\0')
{
if(*dupd_node_value == '\0')
{
the_last_token = AXIS2_TRUE;
}
else
{
*dupd_node_value = '\0';
}
prefix_found = AXIS2_FALSE;
for(cp = token_value; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri((axiom_element_t*)axiom_node_get_data_element(parent, env), env, token_value, parent);
}
else
{
/* Then it is the default namespace */
cp = token_value;
qname_ns = axiom_element_get_default_namespace((axiom_element_t*)axiom_node_get_data_element(parent, env), env, parent);
}
if (!axutil_strcmp(token_value, "TRUE") || !axutil_strcmp(token_value, "true"))
{
element = (void*)axutil_date_time_create(env);
axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
token_value);
element = (void*)axutil_base64_binary_create(env);
axutil_base64_binary_set_encoded_binary((
element = (void*)
/* can not handle the attribute type
token_value = dupd_node_value + 1;
}
}
AXIS2_FREE(env->allocator, original_node_value);
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "type", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
axiom_element_t *current_element = NULL;
current_element = (axiom_element_t*)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "type|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "type");
}
if(attrib_text)
{
/* skipping the namespace prefix */
axis2_char_t *temp_attrib = NULL;
temp_attrib = strchr(attrib_text, ':');
if(temp_attrib)
{
/* take the string after the ':' character */
attrib_text = temp_attrib + 1;
}
}
if(!attrib_text) {
/* nothing is here, reset things */
status =
prefix_found = AXIS2_FALSE;
for(cp = attrib_text; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri((axiom_element_t*)axiom_node_get_data_element(parent, env), env, attrib_text, parent);
}
else
{
/* Then it is the default namespace */
cp = attrib_text;
qname_ns = axiom_element_get_default_namespace((axiom_element_t*)axiom_node_get_data_element(parent, env), env, parent);
}
if (!axutil_strcmp(attrib_text, "TRUE") || !axutil_strcmp(token_value, "true"))
{
element = (void*)axutil_date_time_create(env);
axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
attrib_text);
element = (void*)axutil_base64_binary_create(env);
axutil_base64_binary_set_encoded_binary((
element = (void*)
/* can not handle the attribute type
}
return status;
}
axis2_status_t AXIS2_CALL
return axis2_extension_mapper_deserialize(
(adb_type_t*)
return
}
axis2_status_t AXIS2_CALL
axiom_attribute_t *parent_attri = NULL;
axiom_element_t *parent_element = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
axis2_char_t *cp = NULL;
axis2_bool_t prefix_found = AXIS2_FALSE;
axiom_namespace_t *qname_ns;
status = AXIS2_FAILURE;
if(parent)
{
axis2_char_t *attrib_text = NULL;
attrib_text = axiom_element_get_attribute_value_by_name(axiom_node_get_data_element(parent, env), env, "nil");
if (attrib_text != NULL && !axutil_strcasecmp(attrib_text, "true"))
{
/* but the wsdl says that, this is non nillable */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
status =
}
else
{
axiom_node_t *text_node = NULL;
axiom_text_t *text_element = NULL;
text_node = axiom_node_get_first_child(parent, env);
if (text_node &&
axiom_node_get_node_type(text_node, env) == AXIOM_TEXT)
text_element = (axiom_text_t*)axiom_node_get_data_element(text_node, env);
text_value = "";
if(text_element && axiom_text_get_value(text_element, env))
{
text_value = (axis2_char_t*)axiom_text_get_value(text_element, env);
}
status =
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
yes
axutil_qname_t *element_qname = NULL;
axiom_node_t *first_node = NULL;
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for
current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
qname = axiom_element_get_qname(current_element, env, parent);
if (axutil_qname_equals(qname, env, || !axutil_strcmp(" )
{
first_node = axiom_node_get_first_child(parent, env);
first_node = parent;
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for
first_node = parent;
first_node = axiom_node_get_first_child(parent, env);
parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
attribute_hash = axiom_element_get_all_attributes(parent_element, env);
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
(
element
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
axis2_char_t *dup_key;
char *seperator = NULL;
axis2_char_t *uri = NULL;
axiom_namespace_t *namespace = NULL;
axiom_attribute_t *new_attrib = NULL;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
dup_key = axutil_strdup(env, key);
seperator = strstr(dup_key, "|");
uri = NULL;
if(seperator) /* this means the attribute is qualified with a namespace */
{
*seperator = '\0';
seperator ++; /* represent the namespace */
uri = seperator;
}
namespace = axiom_namespace_create(env, uri, NULL);
parent_attri = (axiom_attribute_t*)val;
attrib_text = axiom_attribute_get_value(parent_attri, env);
new_attrib = axiom_attribute_create(env, dup_key, attrib_text, namespace);
parent_attri = NULL;
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "
if(!strcmp((axis2_char_t*)key, "
{
parent_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "
prefix_found = AXIS2_FALSE;
for(cp = attrib_text; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri((axiom_element_t*)axiom_node_get_data_element(parent, env), env, attrib_text, parent);
}
else
{
/* Then it is the default namespace */
cp = attrib_text;
qname_ns = axiom_element_get_default_namespace((axiom_element_t*)axiom_node_get_data_element(parent, env), env, parent);
}
if (!axutil_strcmp(attrib_text, "TRUE") || !axutil_strcmp(attrib_text, "true"))
{
element = (void*)axutil_date_time_create(env);
axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
attrib_text);
element = (void*)axutil_base64_binary_create(env);
axutil_base64_binary_set_encoded_binary((
element = (void*)
/* can not handle the attribute type
}
/*
* building
/*
* building
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
/*
* because elements are ordered this works fine
*/
if(current_node != NULL && is_early_node_valid)
{
current_node = axiom_node_get_next_sibling(current_node, env);
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
}
if(current_node != NULL)
{
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
}
}
is_early_node_valid = AXIS2_FALSE;
element_qname = axutil_qname_create(env, "
element_qname = axutil_qname_create(env, "
/*
* because elements are not ordered we should surf all the sibling to pick the right one
*/
for (current_node = first_node; current_node != NULL;
current_node = axiom_node_get_next_sibling(current_node, env))
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
element_qname = axutil_qname_create(env, "
element_qname = axutil_qname_create(env, "
if (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp(" )
{
/* found the requried element */
break;
}
}
if ( && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp(" ) ))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp(" ) )
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "AXIS2_TRUE AXIS2_FALSE
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
prefix_found = AXIS2_FALSE;
for(cp = (axis2_char_t*)text_value; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri(current_element, env, text_value, current_node);
}
else
{
/* Then it is the default namespace */
cp = (axis2_char_t*)text_value;
qname_ns = axiom_element_get_default_namespace(current_element, env, current_node);
}
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
status =
if(axiom_node_get_first_child(current_node, env))
{
axiom_node_t *current_property_node = axiom_node_get_first_child(current_node, env);
axiom_node_detach(current_property_node, env);
status =
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
if (!axutil_strcasecmp(text_value , "true"))
{
status =
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = (void*)axutil_date_time_create(env);
status = axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
if(element != NULL)
{
axutil_date_time_free((axutil_date_time_t*)element, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = (void*)axutil_base64_binary_create(env);
status = axutil_base64_binary_set_encoded_binary((axutil_base64_binary_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
if(element != NULL)
{
axutil_base64_binary_free((axutil_base64_binary_t*)element, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* Imposible to handle the request type - so please do it manually */
text_value = NULL;
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for
else if(!dont_care_minoccurs)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
/* this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element
/* 'any' arrays are not handling correctly when there are other elements mixed with the 'any' element. */
element_qname = axutil_qname_create(env, "
element_qname = axutil_qname_create(env, "
for (i = 0, sequence_broken = 0, current_node =
first_node
(is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node) ; !sequence_broken && current_node != NULL;)
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node =axiom_node_get_next_sibling(current_node, env);
is_early_node_valid = AXIS2_FALSE;
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
if ( || !axutil_strcmp(" )))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp(" ))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "AXIS2_TRUE AXIS2_FALSE
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
prefix_found = AXIS2_FALSE;
for(cp = (axis2_char_t*)text_value; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri(current_element, env, text_value, current_node);
}
else
{
/* Then it is the default namespace */
cp = (axis2_char_t*)text_value;
qname_ns = axiom_element_get_default_namespace(current_element, env, current_node);
}
axutil_array_list_add_at(arr_list, env, i, (void*)
axutil_qname_create(
env,
cp, /* cp contain the localname */
axiom_namespace_get_uri(qname_ns, env),
axiom_namespace_get_prefix(qname_ns, env)));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, (void*)axutil_uri_parse_string(env, text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, (void*)axutil_duration_create_from_string(env, text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, 64);
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(int));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(axis2_byte_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(short));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(float));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps float in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(double));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps int64_t in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(int64_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps int64_t in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(uint64_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
if(axiom_node_get_first_child(current_node, env))
{
axiom_node_t *current_property_node = axiom_node_get_first_child(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
else
{
status =
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
if (!axutil_strcasecmp (text_value , "true"))
{
element = AXIS2_MALLOC(env->allocator,sizeof(axis2_bool_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = (void*)axutil_date_time_create(env);
status = axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = (void*)axutil_base64_binary_create(env);
status = axutil_base64_binary_set_encoded_binary((axutil_base64_binary_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* imposible to handle the request type - so please do it manually */
text_value = NULL;
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i <
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status =
element_qname = axutil_qname_create(env, "
element_qname = axutil_qname_create(env, "
/*
* because elements are not ordered we should surf all the sibling to pick the right one
*/
for (i = 0, current_node = first_node; current_node != NULL; current_node = axiom_node_get_next_sibling(current_node, env) )
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node = axiom_node_get_next_sibling(current_node, env);
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
if (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp(" )
{
/* found the requried element */
is_early_node_valid = AXIS2_TRUE;
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "AXIS2_TRUE AXIS2_FALSE
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
}
else
{
/*
* axis2_qname_t *qname = NULL;
* axiom_attribute_t *the_attri = NULL;
*
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
* the_attri = axiom_element_get_attribute(current_element, env, qname);
*/
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
axiom_attribute_t *the_attri = NULL;
axis2_char_t *attrib_text = NULL;
axutil_hash_t *attribute_hash = NULL;
attribute_hash = axiom_element_get_all_attributes(current_element, env);
attrib_text = NULL;
if(attribute_hash)
{
axutil_hash_index_t *hi;
void *val;
const void *key;
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, &key, NULL, &val);
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
{
the_attri = (axiom_attribute_t*)val;
break;
}
}
}
if(the_attri)
{
attrib_text = axiom_attribute_get_value(the_attri, env);
}
else
{
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
}
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
prefix_found = AXIS2_FALSE;
for(cp = (axis2_char_t*)text_value; *cp; cp ++)
{
if(*cp == ':')
{
*cp = '\0';
cp ++;
prefix_found = AXIS2_TRUE;
break;
}
}
if(prefix_found)
{
/* node value contain the prefix */
qname_ns = axiom_element_find_namespace_uri(current_element, env, text_value, current_node);
}
else
{
/* Then it is the default namespace */
cp = (axis2_char_t*)text_value;
qname_ns = axiom_element_get_default_namespace(current_element, env, current_node);
}
axutil_array_list_add_at(arr_list, env, i, (void*)
axutil_qname_create(
env,
cp, /* cp contain the localname */
axiom_namespace_get_uri(qname_ns, env),
axiom_namespace_get_prefix(qname_ns, env)));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, (void*)axutil_uri_parse_string(env, text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
axutil_array_list_add_at(arr_list, env, i, (void*)axutil_duration_create_from_string(env, text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, 64);
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(int));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(int));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
/* we keeps ints in arrays from their pointers */
element = AXIS2_MALLOC(env-> allocator, sizeof(short));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* we keeps float in arrays from their pointers */
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = AXIS2_MALLOC(env-> allocator, sizeof(float));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* we keeps float in arrays from their pointers */
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = AXIS2_MALLOC(env-> allocator, sizeof(double));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* we keeps int64_t in arrays from their pointers */
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = AXIS2_MALLOC(env-> allocator, sizeof(int64_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* we keeps int64_t in arrays from their pointers */
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
element = AXIS2_MALLOC(env-> allocator, sizeof(uint64_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
text_value = NULL; /* just to avoid warning */
{
axiom_node_t *current_property_node = current_node;
current_node = axiom_node_get_next_sibling(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
if(axiom_node_get_first_child(current_node, env))
{
axiom_node_t *current_property_node = axiom_node_get_first_child(current_node, env);
axiom_node_detach(current_property_node, env);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
if (!axutil_strcasecmp (text_value , "true"))
{
element = AXIS2_MALLOC(env->allocator,sizeof(axis2_bool_t));
(*(
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
element = (void*)axutil_date_time_create(env);
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
element = (void*)axutil_base64_binary_create(env);
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = axutil_base64_binary_set_encoded_binary((axutil_base64_binary_t*)element, env,
text_value);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element
/* imposible to handle the request type - so please do it manually */
text_value = NULL;
if(AXIS2_FAILURE == status)
{
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for
}
}
status =
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
*dp_parent = current_node;
*dp_is_early_node_valid = is_early_node_valid;
return status;
}
axis2_bool_t AXIS2_CALL
return AXIS2_TRUE;
return AXIS2_FALSE;
}
void AXIS2_CALL
yes
axiom_namespace_t *element_ns = NULL;
axis2_char_t *qname_uri;
axis2_char_t *qname_prefix;
/* Here this is an empty function, Nothing to declare */
axiom_node_t*
(
qname_uri = axutil_qname_get_uri(
}
axis2_char_t* AXIS2_CALL
int i;
int allocated_len = 0;
axis2_char_t *tmp_value;
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
(
element
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%c",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_UINT64_FORMAT_SPECIFIER, (uint64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value = (axis2_char_t*)axutil_xml_quote_string(env,
text_value = axutil_uri_to_string(
text_value = axutil_duration_serialize_duration(
qname_uri = axutil_qname_get_uri(
text_value = (axis2_char_t*)(axutil_strdup(env, (
text_value = axutil_date_time_serialize_date_time(
text_value = axutil_base64_binary_get_encoded_binary(
if(
/* can not handle the property type
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
*
(
element
for(i = 0, allocated_len = 2, text_value = (axis2_char_t*) axutil_strdup(env, "");
i <
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%d%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%d%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%c%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%d%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s" AXIS2_PRINTF_INT64_FORMAT_SPECIFIER "%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s" AXIS2_PRINTF_UINT64_FORMAT_SPECIFIER "%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%f%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%f%s", text_value, element, seperator);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(element) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, element, seperator);
tmp_value = axutil_uri_to_string(element, env, AXIS2_URI_UNP_OMITUSERINFO);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
tmp_value = axutil_duration_serialize_duration(element, env);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
qname_uri = axutil_qname_get_uri(element, env);
if(qname_uri == NULL)
{
tmp_value = axutil_qname_get_localpart(element, env);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
}
else
{
qname_prefix = (axis2_char_t*)axutil_hash_get(namespaces, qname_uri, AXIS2_HASH_KEY_STRING);
if(qname_prefix != NULL)
{
tmp_value = axutil_qname_get_localpart(element, env);
allocated_len += sizeof (axis2_char_t) * (ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT + 1 +
axutil_strlen(tmp_value) + 2);
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf(text_value, "%s%s:%s%s", text_value, qname_prefix,
tmp_value, seperator);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in serialize_to_string value for
tmp_value = (axis2_char_t*)((element)?"true":"false");
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
tmp_value = axutil_date_time_serialize_date_time(element, env);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
tmp_value = axutil_base64_binary_get_encoded_binary(element, env);
allocated_len += sizeof (axis2_char_t) * axutil_strlen(tmp_value) + 1;
text_value = (axis2_char_t*) AXIS2_REALLOC (env-> allocator, text_value, allocated_len);
sprintf (text_value, "%s%s%s", text_value, tmp_value, seperator);
if(element)
{
text_value =
/* can not handle the property type
}
void *element = NULL;
if(!
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%c",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_UINT64_FORMAT_SPECIFIER, (uint64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value = (axis2_char_t*)axutil_strdup(env,
text_value = axutil_uri_to_string(
text_value = axutil_duration_serialize_duration(
qname_uri = axutil_qname_get_uri(
text_value = (axis2_char_t*)(axutil_strdup(env, (
text_value = axutil_date_time_serialize_date_time(
text_value = axutil_base64_binary_get_encoded_binary(
if(
/* can not handle the property type
}
return text_value;
}
axiom_node_t* AXIS2_CALL
if (
return
}
axiom_node_t* AXIS2_CALL
axiom_attribute_t *text_attri = NULL;
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axis2_char_t* type_attrib = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
axis2_char_t *text_value;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *p_prefix = NULL;
axiom_namespace_t *ns1 = NULL;
axis2_char_t *qname_uri = NULL;
axis2_char_t *qname_prefix = NULL;
axis2_char_t *p_prefix = NULL;
axis2_bool_t ns_already_defined;
int i = 0;
int count = 0;
void *element = NULL;
axis2_char_t *text_value_
axis2_char_t text_value_
axis2_char_t *text_value = NULL;
axis2_char_t *start_input_str = NULL;
axis2_char_t *end_input_str = NULL;
unsigned int start_input_str_len = 0;
unsigned int end_input_str_len = 0;
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = NULL;
int next_ns_index_value = 0;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error,
namespaces = axutil_hash_make(env);
next_ns_index = &next_ns_index_value;
ns1 = axiom_namespace_create (env,
"
ns1 = NULL;
parent_element = axiom_element_create (env, NULL, "
current_node = parent;
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
if (!data_source)
return NULL;
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
if (!stream)
return NULL;
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
if(!parent_tag_closed)
{
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
(
element
:
if(
int i = 0;
for( i = 0; i < axutil_array_list_size(
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "
p_prefix = NULL;
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(ADB_DEFAULT_DIGIT_LIMIT + 5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen("
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen(
text_value = axutil_uri_to_string(
text_value = axutil_duration_serialize_duration(
qname_uri = axutil_qname_get_uri(
text_value = (axis2_char_t*)((
text_value = axutil_date_time_serialize_date_time(
text_value = axutil_base64_binary_get_encoded_binary(
/* can not handle the attribute type
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"
}
else {
/* if the parent tag closed we would be able to declare the type directly on the parent element */
if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING)))
{
/* it is better to stick with the standard prefix */
xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi");
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
}
}
}
xsi_ns = axiom_namespace_create (env,
"
/* here we need to declare the union type in the xsi:type field */
if(axutil_strcmp(
}
if(!parent_tag_closed && !tag_closed)
{
text_value = ">";
axutil_stream_write(stream, env, text_value, axutil_strlen(text_value));
}
text_value =
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
(
element
if(parent_tag_closed)
{
if(
int i = 0;
for( i = 0; i < axutil_array_list_size(
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "
p_prefix = NULL;
ns1 = NULL;
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%c",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%d",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, AXIS2_PRINTF_UINT64_FORMAT_SPECIFIER, (uint64_t)
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * ADB_DEFAULT_DIGIT_LIMIT);
sprintf (text_value, "%f",
text_value =
text_value = axutil_uri_to_string(
text_value = axutil_duration_serialize_duration(
qname_uri = axutil_qname_get_uri(
text_value = (axis2_char_t*)((
text_value = axutil_date_time_serialize_date_time(
text_value = axutil_base64_binary_get_encoded_binary(
/* Can not handle the attribute type
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute
}
if(0 == axutil_strcmp(
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "
p_prefix = NULL;
if (!
/* no need to complain for minoccurs=0 element */
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) +
axutil_strlen("
/* no need to complain for minoccurs=0 element */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("
/*
* Parsing
sprintf(start_input_str, "<%s%s
sprintf(start_input_str, "<%s%s
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%s
/*
* parsing
sprintf(start_input_str, "<%s%s
sprintf(start_input_str, "<%s%s
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%s
if(!
AXIS2_FALSE
AXIS2_FALSE
AXIS2_TRUE
if(!
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
sprintf (text_value_
sprintf (text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
qname_uri = axutil_qname_get_uri(
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
strcpy(text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
text_value_
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
/* This is an unknown type or a primitive. handle this manually for unknown type */
}
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
}
if(namespaces)
{
axutil_hash_index_t *hi;
void *val;
for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi))
{
axutil_hash_this(hi, NULL, NULL, &val);
AXIS2_FREE(env->allocator, val);
}
axutil_hash_free(namespaces, env);
}
return parent;
}
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
axiom_node_t*
*
(
element
const
/**
* Getter for
AXIS2_ENV_CHECK(env, (
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error,
return arg_
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
return AXIS2_SUCCESS;
}
size = axutil_array_list_size(arg_
if (size >
if (size <
if(!non_nil_exists)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of
if(NULL == arg_
if(NULL == arg_
return AXIS2_SUCCESS;
}
adb_
/**
* specialized enum getter for
if (axutil_strcmp(
/* Error: none of the strings matched; invalid enum value */
return -1;
}
/**
* specialized enum setter for arg_
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
case
default:
return AXIS2_SUCCESS;
}
/**
* Get ith element of
AXIS2_ENV_CHECK(env, (
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error,
if(
if(ret_val)
{
return *ret_val;
}
return (
return ret_val;
}
/**
* Set the ith element of arg_
ptr_param_
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
arg_
arg_
{
return AXIS2_SUCCESS;
}
non_nil_exists = AXIS2_TRUE; /* no way to check for nill for each elements for primitive types */
if(NULL != arg_
if( non_nil_count <
}
}
if(!non_nil_exists)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of
if(
/* we keep primtives as pointers in arrasy, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
}
if(!non_nil_exists)
{
return AXIS2_SUCCESS;
}
ptr_param_ *ptr_param_ arg_ ptr_param_
axutil_array_list_set(arg_
axutil_array_list_set(arg_
return AXIS2_SUCCESS;
}
/**
* Add to arg_
ptr_param_
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
if(NULL == arg_
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of
return AXIS2_SUCCESS;
}
if(
ptr_param_ *ptr_param_ arg_ ptr_param_
axutil_array_list_add(arg_
axutil_array_list_add(arg_
/**
* resetter for
if (
if(
/* we keep primtives as pointers in arrasy, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
}
axutil_array_list_free(
/**
* Check whether
if(!non_nil_exists)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of
if( k <
/* we keep primtives as pointers in arrasy, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
}
if(!non_nil_exists)
{
axutil_array_list_set(
axutil_array_list_t*
axiom_node_t*
axiom_node_t*
*
(
element
const
/**
* Get the ith element of
AXIS2_ENV_CHECK(env, (
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error,
if(
if(ret_val)
{
return *ret_val;
}
return (
return ret_val;
}
/**
* Set the ith element of arg_
ptr_param_
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
arg_
arg_
{
return AXIS2_SUCCESS;
}
if(
/* we keep primtives as pointers in arrasy, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
}
ptr_param_ *ptr_param_ arg_ ptr_param_
axutil_array_list_set(arg_
axutil_array_list_set(arg_
arg_
ptr_param_
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error,
ptr_param_ *ptr_param_ arg_ ptr_param_
axutil_array_list_add(arg_
axutil_array_list_add(arg_
/* we keep primtives as pointers in arrasy, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
}
axutil_array_list_set(
AXIS2_ENV_CHECK(env, (
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error,
return arg_
return AXIS2_SUCCESS;
}
if(NULL == arg_
/* we keep primtives as pointers in arrays, so need to free them */
AXIS2_FREE(env-> allocator, element);
AXIS2_FREE(env-> allocator,
axiom_node_free_tree (
axutil_qname_free(
axutil_uri_free(
axutil_duration_free(
axutil_date_time_free(
axutil_base64_binary_free (
axutil_duration_free (
/* This is an unknown type or a primitive. Please free this manually*/
axis2_status_t AXIS2_CALL
AXIS2_FREE(env->allocator,
}
axis2_
/**
* #include "adb_
struct adb_type
{
axis2_char_t *property_Type;
};
/**
* Auxiliary function to determine an ADB object type from its Axiom node.
* @param env pointer to environment struct
* @param node double pointer to the parent node to deserialize
* @return type name on success, else NULL
*/
axis2_char_t *AXIS2_CALL
axis2_extension_mapper_type_from_node(
const axutil_env_t *env,
axiom_node_t** node)
{
axiom_node_t *parent = *node;
axutil_qname_t *element_qname = NULL;
axiom_element_t *element = NULL;
axutil_hash_index_t *hi;
void *val;
axiom_attribute_t *type_attr;
axutil_hash_t *ht;
axis2_char_t *temp;
axis2_char_t *type;
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
{
parent = axiom_node_get_next_sibling(parent, env);
}
if (NULL == parent)
{
/* This should be checked before everything */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
ht = axiom_element_get_all_attributes(element, env);
if (ht == NULL)
return NULL;
for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
axis2_char_t *localpart;
axutil_hash_this(hi, NULL, NULL, &val);
type_attr = (axiom_attribute_t *)val;
localpart = axutil_qname_get_localpart(axiom_attribute_get_qname(type_attr, env), env);
if (axutil_strcmp(localpart, "type") == 0) break;
}
type = axiom_attribute_get_value(type_attr, env);
if (type != NULL && (temp = axutil_strchr(type, ':')) != NULL)
{
if (axutil_strchr(temp, ':') != NULL)
type = temp + 1; /* Pointer arithmetic */
}
return type;
}
axis2_char_t* AXIS2_CALL
adb_type_get_type(const adb_type_t *object)
{
if (object != NULL)
return object->property_Type;
return NULL;
}
adb_type_t* AXIS2_CALL
axis2_extension_mapper_create_from_node(
const axutil_env_t *env,
axiom_node_t** node,
axis2_char_t *default_type)
{
axis2_char_t *type = axis2_extension_mapper_type_from_node(env, node);
if (type != NULL)
{
if (axutil_strcmp(type, "
}
if (axutil_strcmp(default_type, "adb_
return NULL;
}
axis2_status_t AXIS2_CALL
axis2_extension_mapper_free(
adb_type_t* _object,
const axutil_env_t *env,
axis2_char_t *default_type)
{
if (_object != NULL && adb_type_get_type(_object) != NULL)
{
if (axutil_strcmp(adb_type_get_type(_object), "adb_
}
if (axutil_strcmp(default_type, "adb_
return AXIS2_FAILURE;
}
axis2_status_t AXIS2_CALL
axis2_extension_mapper_deserialize(
adb_type_t* _object,
const axutil_env_t *env,
axiom_node_t** dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs,
axis2_char_t *default_type)
{
if (_object != NULL && adb_type_get_type(_object) != NULL)
{
if (axutil_strcmp(adb_type_get_type(_object), "adb_
}
if (axutil_strcmp(default_type, "adb_
return AXIS2_FAILURE;
}
axiom_node_t* AXIS2_CALL
axis2_extension_mapper_serialize(
adb_type_t* _object,
const axutil_env_t *env,
axiom_node_t* om_node,
axiom_element_t *om_element,
int tag_closed,
axutil_hash_t *namespaces,
int *next_ns_index,
axis2_char_t *default_type)
{
if (_object != NULL && adb_type_get_type(_object) != NULL)
{
if (axutil_strcmp(adb_type_get_type(_object), "adb_
}
if (axutil_strcmp(default_type, "adb_
return AXIS2_FAILURE;
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy