AXIS2_EXTERN void AXIS2_CALL
axiom_text_free(
axiom_text_t * om_text,
const axutil_env_t * env)
{
AXIS2_ENV_CHECK_VOID(env);
if(om_text->value)
{
axutil_string_free(om_text->value, env);
}
if(om_text->ns)
{
axiom_namespace_free(om_text->ns, env);
}
if(om_text->content_id)
{
AXIS2_FREE(env->allocator, om_text->content_id);
}
if(om_text->om_attribute)
{
axiom_attribute_free(om_text->om_attribute, env);
}
if(om_text->data_handler)
{
axiom_data_handler_free(om_text->data_handler, env);
}
AXIS2_FREE(env->allocator, om_text);
return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_fault_text_set_lang(
axiom_soap_fault_text_t * fault_text,
const axutil_env_t * env,
const axis2_char_t * lang)
{
int status = AXIS2_SUCCESS;
axiom_element_t *om_ele = NULL;
AXIS2_PARAM_CHECK(env->error, lang, AXIS2_FAILURE);
if(fault_text->lang_attribute)
{
axis2_char_t *attr_lang = NULL;
attr_lang = axiom_attribute_get_value(fault_text->lang_attribute, env);
if(attr_lang)
{
if(axutil_strcmp(attr_lang, lang) == 0)
{
/** this attribute already exists */
return AXIS2_SUCCESS;
}
}
axiom_attribute_set_value(fault_text->lang_attribute, env, lang);
return AXIS2_SUCCESS;
}
fault_text->lang_attribute = axiom_attribute_create(env,
AXIOM_SOAP12_SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME, lang, fault_text-> lang_namespace);
if(!fault_text->lang_attribute)
{
return AXIS2_FAILURE;
}
if(!fault_text->om_ele_node)
{
return AXIS2_FAILURE;
}
om_ele = (axiom_element_t *)axiom_node_get_data_element(fault_text->om_ele_node, env);
if(!om_ele)
{
return AXIS2_FAILURE;
}
status = axiom_element_add_attribute(om_ele, env, fault_text->lang_attribute,
fault_text->om_ele_node);
if(status == AXIS2_SUCCESS)
{
fault_text->lang_ns_used = AXIS2_TRUE;
}
else
{
axiom_attribute_free(fault_text->lang_attribute, env);
fault_text->lang_attribute = NULL;
}
return status;
}
AXIS2_EXTERN void AXIS2_CALL
axiom_attribute_free_void_arg(
void *attribute,
const axutil_env_t * env)
{
axiom_attribute_t *om_attribute_l = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
om_attribute_l = (axiom_attribute_t *)attribute;
axiom_attribute_free(om_attribute_l, env);
return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_text_serialize(
axiom_text_t * om_text,
const axutil_env_t * env,
axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
axis2_char_t *attribute_value = NULL;
const axis2_char_t *text = NULL;
axiom_xml_writer_t *om_output_xml_writer = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE);
if(!axiom_text_get_is_binary(om_text, env))
{
if(om_text->value)
{
status = axiom_output_write(om_output, env, AXIOM_TEXT, 1, axutil_string_get_buffer(
om_text->value, env));
}
}
else
{
om_output_xml_writer = axiom_output_get_xml_writer(om_output, env);
if(axiom_output_is_optimized(om_output, env) && om_text->optimize)
{
if(!(axiom_text_get_content_id(om_text, env)))
{
axis2_char_t *content_id = axiom_output_get_next_content_id(om_output, env);
if(content_id)
{
om_text->content_id = axutil_strdup(env, content_id);
}
}
attribute_value = axutil_stracat(env, "cid:", om_text->content_id);
/*send binary as MTOM optimised */
if(om_text->om_attribute)
{
axiom_attribute_free(om_text->om_attribute, env);
om_text->om_attribute = NULL;
}
om_text->om_attribute = axiom_attribute_create(env, "href", attribute_value, NULL);
AXIS2_FREE(env->allocator, attribute_value);
attribute_value = NULL;
if(!om_text->is_swa) /* This is a hack to get SwA working */
{
axiom_text_serialize_start_part(om_text, env, om_output);
}
else
{
status = axiom_output_write(om_output, env, AXIOM_TEXT, 1, om_text->content_id);
}
axiom_output_write_optimized(om_output, env, om_text);
axiom_output_write(om_output, env, AXIOM_ELEMENT, 0);
}
else
{
text = axiom_text_get_text(om_text, env);
axiom_xml_writer_write_characters(om_output_xml_writer, env, (axis2_char_t *)text);
}
}
return status;
}
/**
* Traverse thru the node and its descendents. Check if the node has a particular attribute with
* name as in @attr and namespace as in @ns. Returns the attribute value.
* @param env Environment. MUST NOT be NULL,
* @param node the node to be searched
* @param attribute_name the attribute name of the node
* @param ns namespace of the attribute
* @return the attribute value if found, else NULL
*/
AXIS2_EXTERN axis2_char_t* AXIS2_CALL
oxs_axiom_get_attribute_value_of_node_by_name(
const axutil_env_t *env,
axiom_node_t *node,
axis2_char_t *attribute_name,
axis2_char_t *ns_uri)
{
axis2_char_t *found_val = NULL;
axiom_element_t *ele = NULL;
axutil_hash_t *attr_list = NULL;
axutil_hash_index_t *hi = NULL;
ele = axiom_node_get_data_element(node, env);
/* Get attribute list of the element */
attr_list = axiom_element_extract_attributes(ele, env, node);
if(!attr_list)
{
return NULL;
}
/* namespace uri can be NULL. In that case, use empty string */
if(!ns_uri)
{
ns_uri = "";
}
/* Traverse thru all the attributes. If both localname and the nsuri matches return the val */
for (hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi))
{
void *attr = NULL;
axiom_attribute_t *om_attr = NULL;
axutil_hash_this(hi, NULL, NULL, &attr);
if (attr)
{
axis2_char_t *this_attr_name = NULL;
axis2_char_t *this_attr_ns_uri = NULL;
axiom_namespace_t *attr_ns = NULL;
om_attr = (axiom_attribute_t*)attr;
this_attr_name = axiom_attribute_get_localname(om_attr, env);
attr_ns = axiom_attribute_get_namespace(om_attr, env);
if(attr_ns)
{
this_attr_ns_uri = axiom_namespace_get_uri(attr_ns, env);
}
else
{
this_attr_ns_uri = "";
}
if((!axutil_strcmp(attribute_name, this_attr_name)) &&
(!axutil_strcmp(ns_uri, this_attr_ns_uri)))
{
/* Got it !!! */
found_val = axiom_attribute_get_value(om_attr, env);
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
for(hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi))
{
void *val = NULL;
axutil_hash_this(hi, NULL, NULL, &val);
if (val)
{
axiom_attribute_free((axiom_attribute_t *)val, env);
val = NULL;
}
}
axutil_hash_free(attr_list, env);
attr_list = NULL;
return found_val;
}
