axis2_status_t AXIS2_CALL
adb_type_deserialize_obj(
adb_type_t* _type,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _type, AXIS2_FAILURE);
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 type : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _type-> qname))
{
first_node = parent;
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for type : "
"Expected %s but returned %s",
axutil_qname_to_string(_type-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building type element
*/
current_node = first_node;
is_early_node_valid = AXIS2_FALSE;
if (
(current_node ))
{
if( current_node )
{
is_early_node_valid = AXIS2_TRUE;
}
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 = adb_type_set_type(_type, env,
current_property_node);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for type ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 type missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_changePassword_deserialize_obj(
adb_changePassword_t* _changePassword,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _changePassword, AXIS2_FAILURE);
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 changePassword : "******"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _changePassword-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for changePassword : "******"Expected %s but returned %s",
axutil_qname_to_string(_changePassword-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building userName element
*/
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);
}
element_qname = axutil_qname_create(env, "userName", "http://service.mgt.user.carbon.wso2.org", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_changePassword_set_userName(_changePassword, env,
text_value);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userName ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building newPassword element
*/
/*
* 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, "newPassword", "http://service.mgt.user.carbon.wso2.org", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_changePassword_set_newPassword(_changePassword, env,
text_value);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for newPassword ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t
create_recipient_node(neethi_options_t *options,
const axutil_env_t *env,
axiom_node_t *parent_node)
{
axiom_node_t *rec_token_node = NULL;
axiom_node_t *rec_policy_node = NULL;
axiom_node_t *x509_node = NULL;
axiom_node_t *x509_policy_node = NULL;
axiom_node_t *x509_type_node = NULL;
axiom_element_t *rec_token_ele = NULL;
axiom_element_t *x509_ele = NULL;
axiom_element_t *parent_ele = NULL;
axiom_attribute_t *attr = NULL;
/*axiom_namespace_t *sp_ns = NULL;*/
/*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/
parent_ele = axiom_node_get_data_element(parent_node, env);
if(!parent_ele)
{
return AXIS2_FAILURE;
}
/*sp_ns = axiom_element_find_namespace(
parent_ele, env, parent_node, RP_SP_NS_12, RP_SP_PREFIX);*/
rec_token_ele = axiom_element_create(env, parent_node, RP_RECIPIENT_TOKEN, sp_ns, &rec_token_node);
if(!rec_token_ele)
{
return AXIS2_FAILURE;
}
rec_policy_node = neethi_options_create_policy_node(env, rec_token_node);
x509_ele = axiom_element_create(env, rec_policy_node, RP_X509_TOKEN, sp_ns, &x509_node);
if(!x509_ele)
{
return AXIS2_FAILURE;
}
attr = axiom_attribute_create(env, RP_INCLUDE_TOKEN, RP_INCLUDE_NEVER,
sp_ns);
axiom_element_add_attribute(x509_ele, env, attr, x509_node);
x509_policy_node = neethi_options_create_policy_node(env, x509_node);
if(x509_policy_node)
{
if(options->keyidentifier && !(options->server_side))
{
axiom_node_t *key_identifier_node = NULL;
axiom_element_create(env, x509_policy_node, options->keyidentifier, sp_ns, &key_identifier_node);
}
axiom_element_create(env, x509_policy_node, RP_WSS_X509_V3_TOKEN_10, sp_ns, &x509_type_node);
return AXIS2_SUCCESS;
}
else return AXIS2_FAILURE;
}
static void
ngx_squ_xml_parse_children(squ_State *l, axutil_env_t *env,
axiom_node_t *parent, axiom_element_t *parent_elem)
{
int n;
char *uri, *prefix, *name, *text, *value;
axiom_node_t *node;
axutil_hash_t *attrs;
axiom_element_t *elem;
ngx_squ_thread_t *thr;
axiom_attribute_t *attr;
axiom_namespace_t *ns;
axutil_hash_index_t *hi;
axiom_child_element_iterator_t *it;
thr = ngx_squ_thread(l);
ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse children");
it = axiom_element_get_child_elements(parent_elem, env, parent);
if (it == NULL) {
return;
}
n = 1;
do {
node = axiom_child_element_iterator_next(it, env);
elem = axiom_node_get_data_element(node, env);
name = axiom_element_get_localname(elem, env);
squ_createtable(l, 2, 4);
squ_pushstring(l, name);
squ_setfield(l, -2, "name");
ns = axiom_element_get_namespace(elem, env, node);
if (ns != NULL) {
uri = axiom_namespace_get_uri(ns, env);
if (uri != NULL) {
squ_pushstring(l, uri);
squ_setfield(l, -2, "uri");
}
prefix = axiom_namespace_get_prefix(ns, env);
if (prefix != NULL) {
squ_pushstring(l, prefix);
squ_setfield(l, -2, "prefix");
}
}
attrs = axiom_element_get_all_attributes(elem, env);
if (attrs != NULL) {
squ_newtable(l);
hi = axutil_hash_first(attrs, env);
do {
if (hi == NULL) {
break;
}
axutil_hash_this(hi, NULL, NULL, (void **) &attr);
name = axiom_attribute_get_localname(attr, env);
value = axiom_attribute_get_value(attr, env);
squ_pushstring(l, value);
squ_setfield(l, -2, name);
hi = axutil_hash_next(env, hi);
} while (1);
squ_setfield(l, -2, "attributes");
}
text = axiom_element_get_text(elem, env, node);
if (text != NULL) {
squ_pushstring(l, text);
squ_setfield(l, -2, "text");
} else {
squ_newtable(l);
ngx_squ_xml_parse_children(l, env, node, elem);
squ_setfield(l, -2, "children");
}
squ_setfield(l, -2, name);
squ_getfield(l, -1, name);
squ_rawseti(l, -2, n++);
} while (axiom_child_element_iterator_has_next(it, env) == AXIS2_TRUE);
}
axis2_status_t AXIS2_CALL
prf_queryPackageListResponseType_deserialize_obj(
prf_queryPackageListResponseType_t* _queryPackageListResponseType,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _queryPackageListResponseType, AXIS2_FAILURE);
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 queryPackageListResponseType : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building packageListResult element
*/
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);
}
element_qname = axutil_qname_create(env, "packageListResult", "http://www.pratsam.org/ns/profile/", NULL);
if (prf_packageListType_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_prf_extension_mapper_create_from_node(env, ¤t_node, "prf_packageListType");
status = prf_packageListType_deserialize((prf_packageListType_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element packageListResult");
}
else
{
status = prf_queryPackageListResponseType_set_packageListResult(_queryPackageListResponseType, env,
(prf_packageListType_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for packageListResult ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 packageListResult missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axiom_node_t* AXIS2_CALL
adb_TransportData_serialize_obj(
adb_TransportData_t* _TransportData,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
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_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;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t text_value_2[ADB_DEFAULT_DIGIT_LIMIT];
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;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _TransportData, 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;
if(!parent_tag_closed)
{
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=\"TransportData\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
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,
"http://mgt.transport.carbon.wso2.org/xsd",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "TransportData", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://mgt.transport.carbon.wso2.org/xsd", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://mgt.transport.carbon.wso2.org/xsd", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://mgt.transport.carbon.wso2.org/xsd",
p_prefix));
}
if (!_TransportData->is_valid_details)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("details")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("details")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing details element
*/
sprintf(start_input_str, "<%s%sdetails",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sdetails>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_TransportDetails_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_TransportDetails_serialize(_TransportData->property_details,
env, current_node, parent_element,
adb_TransportDetails_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_TransportDetails_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://mgt.transport.carbon.wso2.org/xsd", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://mgt.transport.carbon.wso2.org/xsd", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://mgt.transport.carbon.wso2.org/xsd",
p_prefix));
}
if (!_TransportData->is_valid_summary)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("summary")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("summary")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing summary element
*/
sprintf(start_input_str, "<%s%ssummary",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%ssummary>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_TransportSummary_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_TransportSummary_serialize(_TransportData->property_summary,
env, current_node, parent_element,
adb_TransportSummary_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_TransportSummary_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
axis2_status_t AXIS2_CALL
adb_getServiceAnnouncementsResponse_deserialize_obj(
adb_getServiceAnnouncementsResponse_t* _getServiceAnnouncementsResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _getServiceAnnouncementsResponse, AXIS2_FAILURE);
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 getServiceAnnouncementsResponse : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _getServiceAnnouncementsResponse-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for getServiceAnnouncementsResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_getServiceAnnouncementsResponse-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building announcements element
*/
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);
}
element_qname = axutil_qname_create(env, "announcements", "http://www.daisy.org/ns/daisy-online/", NULL);
if (adb_announcements_type0_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_announcements_type0");
status = adb_announcements_type0_deserialize((adb_announcements_type0_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element announcements");
}
else
{
status = adb_getServiceAnnouncementsResponse_set_announcements(_getServiceAnnouncementsResponse, env,
(adb_announcements_type0_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for announcements ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 announcements missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
axis2_MarketInfo_deserialize(
axis2_MarketInfo_t* MarketInfo,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
axis2_char_t* text_value = NULL;
/*axutil_qname_t *qname = NULL;*/
axiom_node_t *first_node = NULL;
axiom_node_t *current_node = NULL;
axiom_element_t *current_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if ( NULL == parent )
{
/** This should be checked above */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL elemenet for MarketInfo"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
first_node = parent;
/**
* building totalTraded element
*/
current_node = first_node;
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_totalTraded( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for totalTraded "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element totalTraded missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building avgPrice element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_avgPrice( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for avgPrice "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element avgPrice missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building avgPriceOfTrade element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_avgPriceOfTrade( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for avgPriceOfTrade "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element avgPriceOfTrade missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
/**
* building marketCap element
*/
/**
* because elements are ordered this works fine
*/
if( current_node != NULL)
{
current_node = axiom_node_get_next_sibling( current_node, env);
}
if ( current_node != NULL)
{
current_element = axiom_node_get_data_element( current_node, env);
text_value = axiom_element_get_text(current_element, env, current_node );
status = axis2_MarketInfo_set_marketCap( MarketInfo, env,
atof( text_value));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for marketCap "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
}
else
{
/** this is not a nillable element*/
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element marketCap missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_getServicesResponse_deserialize(
adb_getServicesResponse_t* _getServicesResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
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, _getServicesResponse, AXIS2_FAILURE);
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 getServicesResponse : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building service array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building service element
*/
element_qname = axutil_qname_create(env, "service", NULL, NULL);
for (i = 0, sequence_broken = 0, current_node = first_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_qname_equals(element_qname, env, qname) || !axutil_strcmp("service", axiom_element_get_localname(current_element, env)))
{
is_early_node_valid = AXIS2_TRUE;
element = (void*)adb_service_create(env);
status = adb_service_deserialize((adb_service_t*)element, env,
¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element service ");
}
else
{
axutil_array_list_add_at(arr_list, env, i, element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for service ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i < 0)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "service (@minOccurs = '0') only have %d elements", i);
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_getServicesResponse_set_service(_getServicesResponse, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axiom_node_t* AXIS2_CALL
adb_additionalTransferProtocols_type0_serialize_obj(
adb_additionalTransferProtocols_type0_t* _additionalTransferProtocols_type0,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = 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_1;
axis2_char_t *text_value_1_temp;
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;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _additionalTransferProtocols_type0, 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;
if(!parent_tag_closed)
{
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
p_prefix));
}
if (!_additionalTransferProtocols_type0->is_valid_protocol)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property protocol");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("protocol")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("protocol")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* Parsing protocol array
*/
if (_additionalTransferProtocols_type0->property_protocol != NULL)
{
sprintf(start_input_str, "<%s%sprotocol>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sprotocol>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
count = axutil_array_list_size(_additionalTransferProtocols_type0->property_protocol, env);
for(i = 0; i < count; i ++)
{
element = axutil_array_list_get(_additionalTransferProtocols_type0->property_protocol, env, i);
if(NULL == element)
{
continue;
}
/*
* parsing protocol element
*/
text_value_1 = (axis2_char_t*)element;
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
if (text_value_1_temp)
{
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
AXIS2_FREE(env->allocator, text_value_1_temp);
}
else
{
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
}
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
axiom_node_t* AXIS2_CALL
axis2_MarketInfo_serialize(
axis2_MarketInfo_t* MarketInfo,
const axutil_env_t *env, axiom_node_t* parent, int has_parent)
{
axiom_namespace_t *ns1 = NULL;
axis2_char_t text_value_1[64];
axis2_char_t text_value_2[64];
axis2_char_t text_value_3[64];
axis2_char_t text_value_4[64];
axiom_node_t *current_node = NULL;
/*axiom_element_t *current_element = NULL;*/
axiom_data_source_t *data_source = NULL;
axutil_stream_t *stream = 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;
AXIS2_ENV_CHECK(env, NULL);
ns1 = axiom_namespace_create (env,
"http://www.wso2.org/types",
"ns1");
if(has_parent)
{
data_source = axiom_node_get_data_element(parent, 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;
current_node = parent;
}
else
{
data_source = axiom_data_source_create(env, parent, ¤t_node);
stream = axiom_data_source_get_stream(data_source, env);
}
/**
* parsing totalTraded element
*/
start_input_str = "<ns1:totalTraded>";
start_input_str_len = axutil_strlen(start_input_str);
end_input_str = "</ns1:totalTraded>";
end_input_str_len = axutil_strlen(end_input_str);
sprintf ( text_value_1, "%f", MarketInfo->attrib_totalTraded );
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
/**
* parsing avgPrice element
*/
start_input_str = "<ns1:avgPrice>";
start_input_str_len = axutil_strlen(start_input_str);
end_input_str = "</ns1:avgPrice>";
end_input_str_len = axutil_strlen(end_input_str);
sprintf ( text_value_2, "%f", MarketInfo->attrib_avgPrice );
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
/**
* parsing avgPriceOfTrade element
*/
start_input_str = "<ns1:avgPriceOfTrade>";
start_input_str_len = axutil_strlen(start_input_str);
end_input_str = "</ns1:avgPriceOfTrade>";
end_input_str_len = axutil_strlen(end_input_str);
sprintf ( text_value_3, "%f", MarketInfo->attrib_avgPriceOfTrade );
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
/**
* parsing marketCap element
*/
start_input_str = "<ns1:marketCap>";
start_input_str_len = axutil_strlen(start_input_str);
end_input_str = "</ns1:marketCap>";
end_input_str_len = axutil_strlen(end_input_str);
sprintf ( text_value_4, "%f", MarketInfo->attrib_marketCap );
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
return parent;
}
axis2_status_t AXIS2_CALL
adb_additionalTransferProtocols_type0_deserialize_obj(
adb_additionalTransferProtocols_type0_t* _additionalTransferProtocols_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
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, _additionalTransferProtocols_type0, AXIS2_FAILURE);
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 additionalTransferProtocols_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building protocol array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building protocol element
*/
element_qname = axutil_qname_create(env, "protocol", "http://www.daisy.org/ns/daisy-online/", NULL);
for (i = 0, sequence_broken = 0, current_node = first_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 (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
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 protocol");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for protocol ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i < 1)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "protocol (@minOccurs = '1') only have %d elements", i);
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_additionalTransferProtocols_type0_set_protocol(_additionalTransferProtocols_type0, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_UserNotRegisteredException1_deserialize(
adb_UserNotRegisteredException1_t* _UserNotRegisteredException1,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _UserNotRegisteredException1, AXIS2_FAILURE);
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 UserNotRegisteredException : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _UserNotRegisteredException1-> qname))
{
first_node = parent;
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for UserNotRegisteredException : "
"Expected %s but returned %s",
axutil_qname_to_string(_UserNotRegisteredException1-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building UserNotRegisteredException element
*/
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);
}
element_qname = axutil_qname_create(env, "UserNotRegisteredException", "http://esb.callbackservice.services.hdviper.psnc.pl/", NULL);
if (adb_UserNotRegisteredException_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)adb_UserNotRegisteredException_create(env);
status = adb_UserNotRegisteredException_deserialize((adb_UserNotRegisteredException_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element UserNotRegisteredException");
}
else
{
status = adb_UserNotRegisteredException1_set_UserNotRegisteredException(_UserNotRegisteredException1, env,
(adb_UserNotRegisteredException_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for UserNotRegisteredException ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 UserNotRegisteredException missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_populate_rstr(
trust_rstr_t *rstr,
const axutil_env_t *env,
axiom_node_t *rstr_node)
{
axiom_element_t *rstr_ele = NULL;
axutil_qname_t *attr_ctx_qname = NULL;
axis2_char_t *attr_ctx = NULL;
axiom_node_t *requested_security_token_node = NULL;
axiom_element_t *requested_security_token_ele = NULL;
axutil_qname_t *requested_security_token_qname = NULL;
axiom_node_t *proof_token_node = NULL;
axiom_element_t *proof_token_ele = NULL;
axutil_qname_t *proof_token_qname = NULL;
axiom_node_t *attached_reference_node = NULL;
axiom_element_t *attached_reference_ele = NULL;
axutil_qname_t *attached_reference_qname = NULL;
axiom_node_t *unattached_reference_node = NULL;
axiom_element_t *unattached_reference_ele = NULL;
axutil_qname_t *unattached_reference_qname = NULL;
axiom_node_t *token_type_node = NULL;
axiom_element_t *token_type_ele = NULL;
axutil_qname_t *token_type_qname = NULL;
axis2_char_t *token_type = NULL;
axutil_qname_t *applies_to_qname = NULL;
axiom_node_t *appliesto_node = NULL;
axiom_element_t *appliesto_ele = NULL;
axiom_node_t *first_node = NULL;
axiom_element_t *first_ele = NULL;
trust_entropy_t *entropy = NULL;
axiom_node_t *entropy_node = NULL;
axiom_element_t *entropy_ele = NULL;
axutil_qname_t *entropy_qname = NULL;
axiom_node_t *lifetime_node = NULL;
axiom_element_t *lifetime_ele = NULL;
axutil_qname_t *lifetime_qname = NULL;
axiom_node_t *key_size_node = NULL;
axiom_element_t *key_size_ele = NULL;
axutil_qname_t *key_size_qname = NULL;
axis2_char_t *key_size = NULL;
rstr_ele = (axiom_element_t*)axiom_node_get_data_element(rstr_node, env);
/*@Context RSTR*/
attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rstr->wst_ns_uri, TRUST_WST);
if (!attr_ctx_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Context Attribute Qname creation failed.");
return AXIS2_FAILURE;
}
attr_ctx = axiom_element_get_attribute_value(rstr_ele, env, attr_ctx_qname);
if (attr_ctx)
{
rstr->attr_context = attr_ctx;
}
axutil_qname_free(attr_ctx_qname, env);
/*TokenType*/
token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rstr->wst_ns_uri, TRUST_WST);
if (!token_type_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Qname creation failed.");
return AXIS2_FAILURE;
}
token_type_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, token_type_qname, rstr_node, &token_type_node);
if (token_type_ele)
{
token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
if(token_type)
{
rstr->token_type = token_type;
}
}
axutil_qname_free(token_type_qname, env);
/*RequestedSecurityToken*/
requested_security_token_qname = axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN, rstr->wst_ns_uri, TRUST_WST);
if(!requested_security_token_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedSecurityToken Qname creation failed.");
return AXIS2_FAILURE;
}
requested_security_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, requested_security_token_qname,
rstr_node, &requested_security_token_node);
if(requested_security_token_ele)
{
axiom_element_get_first_element(requested_security_token_ele, env, requested_security_token_node, &rstr->requested_sec_token);
}
axutil_qname_free(requested_security_token_qname, env);
/*RequestedProofToken*/
proof_token_qname = axutil_qname_create(env, TRUST_REQUESTED_PROOF_TOKEN, rstr->wst_ns_uri, TRUST_WST);
if(!proof_token_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken Qname creation failed.");
return AXIS2_FAILURE;
}
proof_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, proof_token_qname, rstr_node, &proof_token_node);
if(proof_token_ele)
{
axiom_element_get_first_element(proof_token_ele, env, proof_token_node, &rstr->requested_proof_token);
}
axutil_qname_free(proof_token_qname, env);
/*AppliesTo*/
applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
if (!applies_to_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed.");
return AXIS2_FAILURE;
}
appliesto_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, applies_to_qname, rstr_node, &appliesto_node);
if(appliesto_ele)
{
first_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &first_node);
if(first_ele)
{
rstr->applies_to = axiom_element_get_text(first_ele, env, first_node);
}
}
axutil_qname_free(applies_to_qname, env);
/*Entropy*/
entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rstr->wst_ns_uri, TRUST_WST);
if (!entropy_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Qname creation failed.");
return AXIS2_FAILURE;
}
entropy_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, entropy_qname, rstr_node, &entropy_node);
if(entropy_ele)
{
entropy = trust_entropy_create(env);
trust_entropy_set_ns_uri(entropy, env, rstr->wst_ns_uri);
if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node))
{
rstr->entropy = entropy;
}
}
axutil_qname_free(entropy_qname, env);
/*LifeTime*/
lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rstr->wst_ns_uri, TRUST_WST);
if(!lifetime_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime Qname creation failed.");
return AXIS2_FAILURE;
}
lifetime_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, lifetime_qname, rstr_node, &lifetime_node);
if(lifetime_ele)
{
rstr->life_time = trust_life_time_create(env);
if(AXIS2_SUCCESS == trust_life_time_deserialize(rstr->life_time, env, lifetime_node))
{
}
}
axutil_qname_free(lifetime_qname, env);
/* KeySize */
key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rstr->wst_ns_uri, TRUST_WST);
key_size_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, key_size_qname, rstr_node, &key_size_node);
if(key_size_ele)
{
key_size = axiom_element_get_text(key_size_ele, env, key_size_node);
if(key_size)
{
rstr->key_size = atoi(key_size);
}
}
axutil_qname_free(key_size_qname, env);
/*Attached reference*/
attached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_ATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
if(!attached_reference_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedAttachedReference Qname creation failed.");
return AXIS2_FAILURE;
}
attached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, attached_reference_qname, rstr_node, &attached_reference_node);
if(attached_reference_ele)
{
axiom_element_get_first_element(attached_reference_ele, env, attached_reference_node, &rstr->requested_attached_ref);
}
axutil_qname_free(attached_reference_qname, env);
/*Unattached reference*/
unattached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_UNATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
if(!unattached_reference_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedUnattachedReference Qname creation failed.");
return AXIS2_FAILURE;
}
unattached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, unattached_reference_qname, rstr_node, &unattached_reference_node);
if(unattached_reference_ele)
{
axiom_element_get_first_element(unattached_reference_ele, env, unattached_reference_node, &rstr->requested_unattached_ref);
}
axutil_qname_free(unattached_reference_qname, env);
return AXIS2_SUCCESS;
}
axiom_node_t* AXIS2_CALL
adb_serviceProvider_type0_serialize_obj(
adb_serviceProvider_type0_t* _serviceProvider_type0,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
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;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = 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;
axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
axis2_char_t *text_value_2;
axis2_char_t *text_value_2_temp;
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;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _serviceProvider_type0, 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;
if(!parent_tag_closed)
{
if(_serviceProvider_type0->is_valid_id)
{
p_prefix = NULL;
text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) *
(5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT +
axutil_strlen(_serviceProvider_type0->property_id) +
axutil_strlen("id")));
sprintf(text_value, " %s%s%s=\"%s\"", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":"",
"id", _serviceProvider_type0->property_id);
axutil_stream_write(stream, env, text_value, axutil_strlen(text_value));
AXIS2_FREE(env-> allocator, text_value);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute id");
return NULL;
}
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.daisy.org/ns/daisy-online/",
p_prefix));
}
if (!_serviceProvider_type0->is_valid_label)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("label")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("label")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing label element
*/
sprintf(start_input_str, "<%s%slabel",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%slabel>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!adb_label_type0_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_label_type0_serialize(_serviceProvider_type0->property_label,
env, current_node, parent_element,
adb_label_type0_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_label_type0_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
if(parent_tag_closed)
{
if(_serviceProvider_type0->is_valid_id)
{
p_prefix = NULL;
ns1 = NULL;
text_value = _serviceProvider_type0->property_id;
text_attri = axiom_attribute_create (env, "id", text_value, ns1);
axiom_element_add_attribute (parent_element, env, text_attri, parent);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute id");
return NULL;
}
}
return parent;
}
axiom_node_t* AXIS2_CALL
adb_getServicesResponse_serialize(
adb_getServicesResponse_t* _getServicesResponse,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t *current_node = NULL;
int tag_closed = 0;
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_1[64];
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;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _getServicesResponse, 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;
if(!parent_tag_closed)
{
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
p_prefix = NULL;
if (!_getServicesResponse->is_valid_service)
{
/* no need to complain for minoccurs=0 element */
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("service")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("service")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* Parsing service array
*/
if (_getServicesResponse->property_service != NULL)
{
sprintf(start_input_str, "<%s%sservice",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%sservice>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
count = axutil_array_list_size(_getServicesResponse->property_service, env);
for(i = 0; i < count; i ++)
{
element = axutil_array_list_get(_getServicesResponse->property_service, env, i);
if(NULL == element)
{
continue;
}
/*
* parsing service element
*/
if(!adb_service_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
adb_service_serialize((adb_service_t*)element,
env, current_node, parent_element,
adb_service_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!adb_service_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
}
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
axis2_status_t AXIS2_CALL
adb_TransportData_deserialize_obj(
adb_TransportData_t* _TransportData,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _TransportData, AXIS2_FAILURE);
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 TransportData : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building details element
*/
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);
}
element_qname = axutil_qname_create(env, "details", "http://mgt.transport.carbon.wso2.org/xsd", NULL);
if (adb_TransportDetails_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_TransportDetails");
status = adb_TransportDetails_deserialize((adb_TransportDetails_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element details");
}
else
{
status = adb_TransportData_set_details(_TransportData, env,
(adb_TransportDetails_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for details ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building summary element
*/
/*
* 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, "summary", "http://mgt.transport.carbon.wso2.org/xsd", NULL);
if (adb_TransportSummary_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_TransportSummary");
status = adb_TransportSummary_deserialize((adb_TransportSummary_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element summary");
}
else
{
status = adb_TransportData_set_summary(_TransportData, env,
(adb_TransportSummary_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for summary ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
AXIS2_EXTERN void AXIS2_CALL
remote_registry_resource_load_metadata_from_feed_node(const axutil_env_t *env,
remote_registry_resource_t *resource,
axiom_node_t *feed_node)
{
axiom_children_iterator_t *node_it = NULL;
axiom_element_t *feed_ele = NULL;
feed_ele = axiom_node_get_data_element(feed_node, env);
node_it = axiom_element_get_children(feed_ele, env, feed_node);
/* iterate all the children */
while(axiom_children_iterator_has_next(node_it, env))
{
axiom_node_t *child = NULL;
axiom_element_t *child_ele = NULL;
axis2_char_t *local_name = NULL;
child = axiom_children_iterator_next(node_it, env);
if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT)
{
continue;
}
child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
local_name = axiom_element_get_localname(child_ele, env);
/* retriving the attribute one by one */
if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_ID))
{
axis2_char_t *id_text = NULL;
id_text = axiom_element_get_text(child_ele, env, child);
resource->id = id_text;
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_MEDIA_TYPE))
{
axis2_char_t *media_type = NULL;
media_type = axiom_element_get_text(child_ele, env, child);
/* for the root feed the feed xml is NULL */
if(media_type != NULL) {
if(!axutil_strcmp(media_type, REMOTE_REGISTRY_FEED_KEY_DIR))
{
resource->is_collection = 1;
}
resource->media_type = media_type;
}
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_ENTRY))
{
/* now iterate through the entries */
axutil_array_list_t *entry_arr = NULL;
remote_registry_resource_t *entry_resource = NULL;
axis2_char_t *child_path = NULL;
entry_arr = resource->entries;
if(!entry_arr) {
entry_arr = axutil_array_list_create(env, 5);
resource->entries = entry_arr;
}
entry_resource = remote_registry_resource_create_from_entry_node(env, child);
axutil_array_list_add(entry_arr, env, entry_resource);
/* adding child as a path */
child_path = entry_resource->link_path;
if(!resource->child_paths)
{
resource->child_paths = axutil_array_list_create(env, 10);
}
axutil_array_list_add(resource->child_paths, env, child_path);
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_LINK))
{
/* loading all the links */
axis2_char_t *href = NULL;
axis2_char_t *rel = NULL;
href = axiom_element_get_attribute_value_by_name(child_ele, env, REMOTE_REGISTRY_FEED_ATTR_HREF);
rel = axiom_element_get_attribute_value_by_name(child_ele, env, REMOTE_REGISTRY_FEED_ATTR_REL);
if(!axutil_strcmp(rel, REMOTE_REGISTRY_FEED_ATTR_SELF))
{
resource->link_self = axutil_strdup(env, href);
}
else if(!axutil_strcmp(rel, REMOTE_REGISTRY_FEED_ATTR_ALTERNATE))
{
resource->link_alternate = axutil_strdup(env, href);
}
else if(!axutil_strcmp(rel, REMOTE_REGISTRY_FEED_ATTR_PATH))
{
remote_registry_resource_set_link_path(resource, env, href);
}
else if(!axutil_strcmp(rel, REMOTE_REGISTRY_FEED_ATTR_EDIT))
{
resource->link_edit = axutil_strdup(env, href);
}
else if(!axutil_strcmp(rel, REMOTE_REGISTRY_FEED_ATTR_EDIT_MEDIA))
{
resource->link_edit_media = axutil_strdup(env, href);
}
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_CONTENT))
{
axis2_char_t *content_src_url = NULL;
content_src_url = axiom_element_get_attribute_value_by_name(child_ele, env, REMOTE_REGISTRY_FEED_ATTR_SRC);
remote_registry_resource_set_content_src_url(resource, env, content_src_url);
if(content_src_url != NULL) {
resource->is_collection = 0;
}
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_AUTHOR))
{
axiom_node_t *name_node = NULL;
axiom_element_t *name_element = NULL;
name_node = axiom_node_get_first_child(child, env);
/* get the first child (with type AXIOM_ELEMENT) where we can find the name */
if(name_node && axiom_node_get_node_type(name_node, env) != AXIOM_ELEMENT)
{
name_node = axiom_node_get_next_sibling(name_node, env);
}
if(name_node)
{
axis2_char_t *name = NULL;
name_element = axiom_node_get_data_element(name_node, env);
name = axiom_element_get_text(name_element, env, name_node);
remote_registry_resource_set_author_name(resource, env, name);
}
}
else if(!axutil_strcmp(local_name, REMOTE_REGISTRY_FEED_KEY_PROPERTIES))
{
axiom_children_iterator_t *properties_it = NULL;
axiom_element_t *properties_ele = NULL;
if(!resource->properties)
{
resource->properties = axutil_hash_make(env);
}
properties_ele = axiom_node_get_data_element(child, env);
properties_it = axiom_element_get_children(properties_ele, env, child);
/* iterate all the properties */
while(axiom_children_iterator_has_next(properties_it, env))
{
axiom_node_t *property_node = NULL;
axiom_node_t *name_node = NULL;
axiom_node_t *value_node = NULL;
axiom_element_t *name_element = NULL;
axiom_element_t *value_element = NULL;
axis2_char_t *name = NULL;
axis2_char_t *value = NULL;
property_node = axiom_children_iterator_next(properties_it, env);
if(axiom_node_get_node_type(property_node, env) != AXIOM_ELEMENT)
{
continue;
}
name_node = axiom_node_get_first_child(property_node, env);
while(name_node && axiom_node_get_node_type(name_node, env) != AXIOM_ELEMENT)
{
name_node = axiom_node_get_next_sibling(name_node, env);
}
if(!name_node)
{
continue;
}
value_node = axiom_node_get_next_sibling(name_node, env);
while(value_node && axiom_node_get_node_type(value_node, env) != AXIOM_ELEMENT)
{
value_node = axiom_node_get_next_sibling(value_node, env);
}
if(!value_node)
{
continue;
}
name_element = axiom_node_get_data_element(name_node, env);
value_element = axiom_node_get_data_element(value_node, env);
name = axiom_element_get_text(name_element, env, name_node);
value = axiom_element_get_text(value_element, env, value_node);
axutil_hash_set(resource->properties, name, AXIS2_HASH_KEY_STRING, value);
}
}
}
}
axis2_status_t AXIS2_CALL
adb_unsubscribeResponse_deserialize_obj(
adb_unsubscribeResponse_t* _unsubscribeResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _unsubscribeResponse, AXIS2_FAILURE);
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 unsubscribeResponse : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _unsubscribeResponse-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for unsubscribeResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_unsubscribeResponse-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building message element
*/
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);
}
element_qname = axutil_qname_create(env, "message", NULL, NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env)))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env))))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_unsubscribeResponse_set_message(_unsubscribeResponse, 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 message");
status = AXIS2_FAILURE;
}
else
{
/* after all, we found this is a empty string */
status = adb_unsubscribeResponse_set_message(_unsubscribeResponse, env,
"");
}
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for message ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 message missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_lang_type0_deserialize_from_string(
adb_lang_type0_t* _lang_type0,
const axutil_env_t *env,
const axis2_char_t *node_value,
axiom_node_t *parent)
{
axis2_status_t status = AXIS2_SUCCESS;
/*
* 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, "lang|http://www.w3.org/XML/1998/namespace"))
{
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 = adb_lang_type0_reset_members(_lang_type0, env);
}
else
{
status = adb_lang_type0_set_language(_lang_type0,
env, attrib_text);
}
return status;
}
axis2_status_t AXIS2_CALL
adb_changeRolePermissionsResponse_deserialize_obj(
adb_changeRolePermissionsResponse_t* _changeRolePermissionsResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _changeRolePermissionsResponse, AXIS2_FAILURE);
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 changeRolePermissionsResponse : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _changeRolePermissionsResponse-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for changeRolePermissionsResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_changeRolePermissionsResponse-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building return element
*/
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);
}
element_qname = axutil_qname_create(env, "return", "http://services.resource.ui.mgt.registry.carbon.wso2.org", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
if (!axutil_strcasecmp(text_value , "true"))
{
status = adb_changeRolePermissionsResponse_set_return(_changeRolePermissionsResponse, env,
AXIS2_TRUE);
}
else
{
status = adb_changeRolePermissionsResponse_set_return(_changeRolePermissionsResponse, env,
AXIS2_FALSE);
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
status = AXIS2_FAILURE;
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axiom_node_t* AXIS2_CALL
adb_lang_type0_serialize_obj(
adb_lang_type0_t* _lang_type0,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = 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;
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;
/* here we need to declare the union type in the xsi:type field */
if(axutil_strcmp(_lang_type0->current_value, ""))
{
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);
}
}
if(!axutil_strcmp(_lang_type0->current_value, "language"))
{
axis2_char_t *ns_prefix = NULL;
if(!(ns_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema", AXIS2_HASH_KEY_STRING)))
{
ns_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(ns_prefix, "q%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema", AXIS2_HASH_KEY_STRING, ns_prefix);
if(parent_element)
{
axiom_namespace_t *element_ns = NULL;
element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema",
ns_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns);
}
}
/* now we will set the xsi:type="ns:type" value */
if(!parent_tag_closed && !tag_closed)
{
text_value = axutil_strcat(env, xsi_prefix, ":type=", ns_prefix, ":", _lang_type0->current_value, NULL);
axutil_stream_write(stream, env, text_value, axutil_strlen(text_value));
AXIS2_FREE(env->allocator, text_value);
}
else
{
/* otherwise set it to the prarent itself */
axiom_namespace_t *ns1 = NULL;
axiom_attribute_t *attrib = NULL;
ns1 = axiom_namespace_create (env,
"http://www.w3.org/2001/XMLSchema-instance",
xsi_prefix);
text_value = axutil_strcat(env, ns_prefix, ":", _lang_type0->current_value, NULL);
attrib = axiom_attribute_create (env, "type", text_value, ns1);
axiom_element_add_attribute (parent_element, env, attrib, parent);
AXIS2_FREE(env->allocator, text_value);
}
}
}
if(!parent_tag_closed && !tag_closed)
{
text_value = ">";
axutil_stream_write(stream, env, text_value, axutil_strlen(text_value));
}
text_value = adb_lang_type0_serialize_to_string(_lang_type0, env, namespaces);
if(text_value)
{
axutil_stream_write(stream, env, text_value, axutil_strlen(text_value));
AXIS2_FREE(env->allocator, text_value);
}
return parent;
}
axis2_status_t AXIS2_CALL
adb_DSAKeyValueTypeSequence_type1_deserialize_obj(
adb_DSAKeyValueTypeSequence_type1_t* _DSAKeyValueTypeSequence_type1,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _DSAKeyValueTypeSequence_type1, AXIS2_FAILURE);
first_node = parent;
/*
* building Seed element
*/
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);
}
element_qname = axutil_qname_create(env, "Seed", "http://www.w3.org/2000/09/xmldsig#", NULL);
if (adb_CryptoBinary_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_CryptoBinary");
status = adb_CryptoBinary_deserialize((adb_CryptoBinary_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element Seed");
}
else
{
status = adb_DSAKeyValueTypeSequence_type1_set_Seed(_DSAKeyValueTypeSequence_type1, env,
(adb_CryptoBinary_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for Seed ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 Seed missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building PgenCounter element
*/
/*
* 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, "PgenCounter", "http://www.w3.org/2000/09/xmldsig#", NULL);
if (adb_CryptoBinary_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_CryptoBinary");
status = adb_CryptoBinary_deserialize((adb_CryptoBinary_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element PgenCounter");
}
else
{
status = adb_DSAKeyValueTypeSequence_type1_set_PgenCounter(_DSAKeyValueTypeSequence_type1, env,
(adb_CryptoBinary_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for PgenCounter ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
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 PgenCounter missing");
return AXIS2_FAILURE;
}
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_status_t AXIS2_CALL
adb_ServerException_deserialize_obj(
adb_ServerException_t* _ServerException,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _ServerException, AXIS2_FAILURE);
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 ServerException : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building Exception element
*/
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);
}
element_qname = axutil_qname_create(env, "Exception", "http://org.apache.axis2/xsd", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = NULL; /* just to avoid warning */
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 = adb_ServerException_set_Exception(_ServerException, env,
current_property_node);
}
else
{
status = adb_ServerException_set_Exception(_ServerException, env,
NULL);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for Exception ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axiom_node_t* AXIS2_CALL
prf_queryPackageListResponseType_serialize_obj(
prf_queryPackageListResponseType_t* _queryPackageListResponseType,
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
{
axis2_char_t *string_to_stream;
axiom_node_t* current_node = NULL;
int tag_closed = 0;
axis2_char_t* xsi_prefix = NULL;
axiom_namespace_t* xsi_ns = NULL;
axiom_attribute_t* xsi_type_attri = NULL;
axis2_char_t* type_attrib = 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;
axis2_char_t text_value_1[PRF_DEFAULT_DIGIT_LIMIT];
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;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, _queryPackageListResponseType, 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;
if(!parent_tag_closed)
{
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);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"queryPackageListResponseType\"", NULL);
axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib));
AXIS2_FREE(env->allocator, type_attrib);
string_to_stream = ">";
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
tag_closed = 1;
}
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);
if(element_ns)
{
axiom_namespace_free(element_ns, env);
}
}
}
}
xsi_ns = axiom_namespace_create (env,
"http://www.pratsam.org/ns/profile/",
xsi_prefix);
xsi_type_attri = axiom_attribute_create (env, "type", "queryPackageListResponseType", xsi_ns);
axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent);
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING)))
{
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * PRF_DEFAULT_NAMESPACE_PREFIX_LIMIT);
sprintf(p_prefix, "n%d", (*next_ns_index)++);
axutil_hash_set(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING, p_prefix);
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
"http://www.pratsam.org/ns/profile/",
p_prefix));
}
if (!_queryPackageListResponseType->is_valid_packageListResult)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property packageListResult");
return NULL;
}
else
{
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(4 + axutil_strlen(p_prefix) +
axutil_strlen("packageListResult")));
/* axutil_strlen("<:>") + 1 = 4 */
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
(5 + axutil_strlen(p_prefix) + axutil_strlen("packageListResult")));
/* axutil_strlen("</:>") + 1 = 5 */
/*
* parsing packageListResult element
*/
sprintf(start_input_str, "<%s%spackageListResult",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
start_input_str_len = axutil_strlen(start_input_str);
sprintf(end_input_str, "</%s%spackageListResult>",
p_prefix?p_prefix:"",
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
end_input_str_len = axutil_strlen(end_input_str);
if(!prf_packageListType_is_particle())
{
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
}
prf_packageListType_serialize(_queryPackageListResponseType->property_packageListResult,
env, current_node, parent_element,
prf_packageListType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
if(!prf_packageListType_is_particle())
{
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
}
AXIS2_FREE(env->allocator,start_input_str);
AXIS2_FREE(env->allocator,end_input_str);
}
return parent;
}
axis2_status_t AXIS2_CALL
adb_ProductComplete_deserialize(
adb_ProductComplete_t* _ProductComplete,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
void *element = NULL;
axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _ProductComplete, AXIS2_FAILURE);
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 ProductComplete : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _ProductComplete-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for ProductComplete : "
"Expected %s but returned %s",
axutil_qname_to_string(_ProductComplete-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building productInfo element
*/
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);
}
element_qname = axutil_qname_create(env, "productInfo", "http://webser.com", NULL);
if (adb_ProductCompleteType_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)adb_ProductCompleteType_create(env);
status = adb_ProductCompleteType_deserialize((adb_ProductCompleteType_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element productInfo");
}
else
{
status = adb_ProductComplete_set_productInfo(_ProductComplete, env,
(adb_ProductCompleteType_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for productInfo ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_listControlOperations_deserialize_obj(
adb_listControlOperations_t* _listControlOperations,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _listControlOperations, AXIS2_FAILURE);
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 listControlOperations : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _listControlOperations-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for listControlOperations : "
"Expected %s but returned %s",
axutil_qname_to_string(_listControlOperations-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building serviceName element
*/
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);
}
element_qname = axutil_qname_create(env, "serviceName", "http://org.apache.axis2/xsd", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_listControlOperations_set_serviceName(_listControlOperations, env,
text_value);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceName ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_serviceProvider_type0_deserialize_obj(
adb_serviceProvider_type0_t* _serviceProvider_type0,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
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;
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, _serviceProvider_type0, AXIS2_FAILURE);
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 serviceProvider_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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);
/*
* building label element
*/
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);
}
element_qname = axutil_qname_create(env, "label", "http://www.daisy.org/ns/daisy-online/", NULL);
if (adb_label_type0_is_particle() ||
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
element = (void*)axis2_extension_mapper_create_from_node(env, ¤t_node, "adb_label_type0");
status = adb_label_type0_deserialize((adb_label_type0_t*)element,
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element label");
}
else
{
status = adb_serviceProvider_type0_set_label(_serviceProvider_type0, env,
(adb_label_type0_t*)element);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for label ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
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(!strcmp((axis2_char_t*)key, "id"))
{
parent_attri = (axiom_attribute_t*)val;
AXIS2_FREE(env->allocator, hi);
break;
}
}
}
if(parent_attri)
{
attrib_text = axiom_attribute_get_value(parent_attri, env);
}
else
{
/* this is hoping that attribute is stored in "id", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "id");
}
if(attrib_text != NULL)
{
adb_serviceProvider_type0_set_id(_serviceProvider_type0,
env, attrib_text);
}
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, "required attribute id missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_Metric_deserialize(
adb_Metric_t* _Metric,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
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, _Metric, AXIS2_FAILURE);
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 Metric : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building unit element
*/
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);
}
element_qname = axutil_qname_create(env, "unit", "http://util.services.statistics.carbon.wso2.org/xsd", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_Metric_set_unit(_Metric, env,
text_value);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for unit ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building value element
*/
/*
* 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, "value", "http://util.services.statistics.carbon.wso2.org/xsd", NULL);
if (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
text_value = axiom_element_get_text(current_element, env, current_node);
if(text_value != NULL)
{
status = adb_Metric_set_value(_Metric, env,
atof(text_value));
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element value");
status = AXIS2_FAILURE;
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for value ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
return AXIS2_FAILURE;
}
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_getInternalUsersResponse_deserialize_obj(
adb_getInternalUsersResponse_t* _getInternalUsersResponse,
const axutil_env_t *env,
axiom_node_t **dp_parent,
axis2_bool_t *dp_is_early_node_valid,
axis2_bool_t dont_care_minoccurs)
{
axiom_node_t *parent = *dp_parent;
axis2_status_t status = AXIS2_SUCCESS;
const axis2_char_t* text_value = NULL;
axutil_qname_t *qname = NULL;
int i = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
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, _getInternalUsersResponse, AXIS2_FAILURE);
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 getInternalUsersResponse : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
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, _getInternalUsersResponse-> qname))
{
first_node = axiom_node_get_first_child(parent, env);
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed in building adb object for getInternalUsersResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_getInternalUsersResponse-> qname, env),
axutil_qname_to_string(qname, env));
return AXIS2_FAILURE;
}
/*
* building return array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building return element
*/
element_qname = axutil_qname_create(env, "return", "http://service.mgt.user.carbon.wso2.org", NULL);
for (i = 0, sequence_broken = 0, current_node = first_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 (
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
{
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
{
is_early_node_valid = AXIS2_TRUE;
}
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));
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
current_node = axiom_node_get_next_sibling(current_node, env);
}
else
{
is_early_node_valid = AXIS2_FALSE;
sequence_broken = 1;
}
}
if (i < 0)
{
/* found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "return (@minOccurs = '0') only have %d elements", i);
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_getInternalUsersResponse_set_return(_getInternalUsersResponse, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
