AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_add_handler_at(
axis2_phase_t * phase,
const axutil_env_t * env,
const int idx,
axis2_handler_t * handler)
{
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
"axis2_handler_t *%s added to the index %d of the phase %s", axutil_string_get_buffer(
axis2_handler_get_name(handler, env), env), idx, phase->name);
return axutil_array_list_add_at(phase->handlers, env, idx, handler);
}
axis2_status_t AXIS2_CALL
adb_listExternalUsersResponse_deserialize_obj(
adb_listExternalUsersResponse_t* _listExternalUsersResponse,
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, _listExternalUsersResponse, 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 listExternalUsersResponse : "
"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, _listExternalUsersResponse-> 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 listExternalUsersResponse : "
"Expected %s but returned %s",
axutil_qname_to_string(_listExternalUsersResponse-> 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_listExternalUsersResponse_set_return(_listExternalUsersResponse, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_deserialize_obj(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
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;
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, _CanonicalizationMethodType, 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 CanonicalizationMethodType : "
"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 extraElement array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building extraElement element
*/
/* 'any' arrays are not handling correctly when there are other elements mixed with the 'any' element. */
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;
}
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("extraElement", axiom_element_get_localname(current_element, env))))
{
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);
axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node);
}
if(AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for extraElement ");
if(element_qname)
{
axutil_qname_free(element_qname, env);
}
if(arr_list)
{
axutil_array_list_free(arr_list, env);
}
return AXIS2_FAILURE;
}
i ++;
}
if(0 == axutil_array_list_size(arr_list,env))
{
axutil_array_list_free(arr_list, env);
}
else
{
status = adb_CanonicalizationMethodType_set_extraElement(_CanonicalizationMethodType, env,
arr_list);
}
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, "Algorithm"))
{
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 "Algorithm", this happnes when name is in default namespace */
attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "Algorithm");
}
if(attrib_text != NULL)
{
adb_CanonicalizationMethodType_set_Algorithm(_CanonicalizationMethodType,
env, axutil_uri_parse_string(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 Algorithm missing");
return AXIS2_FAILURE;
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_OperationMetaDataWrapper_deserialize_obj(
adb_OperationMetaDataWrapper_t* _OperationMetaDataWrapper,
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;
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, _OperationMetaDataWrapper, 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 OperationMetaDataWrapper : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building controlOperations array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building controlOperations element
*/
element_qname = axutil_qname_create(env, "controlOperations", "http://mgt.operation.carbon.wso2.org/xsd", 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 (adb_OperationMetaData_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_OperationMetaData");
status = adb_OperationMetaData_deserialize((adb_OperationMetaData_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 controlOperations ");
}
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 controlOperations ");
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, "controlOperations (@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_OperationMetaDataWrapper_set_controlOperations(_OperationMetaDataWrapper, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
/*
* building publishedOperations array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building publishedOperations element
*/
element_qname = axutil_qname_create(env, "publishedOperations", "http://mgt.operation.carbon.wso2.org/xsd", NULL);
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
{
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
{
current_node =axiom_node_get_next_sibling(current_node, env);
is_early_node_valid = AXIS2_FALSE;
continue;
}
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
qname = axiom_element_get_qname(current_element, env, current_node);
if (adb_OperationMetaData_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_OperationMetaData");
status = adb_OperationMetaData_deserialize((adb_OperationMetaData_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 publishedOperations ");
}
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 publishedOperations ");
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, "publishedOperations (@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_OperationMetaDataWrapper_set_publishedOperations(_OperationMetaDataWrapper, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
axis2_PortFolio_deserialize(
axis2_PortFolio_t* PortFolio,
const axutil_env_t *env,
axiom_node_t* parent)
{
axis2_status_t status = AXIS2_SUCCESS;
axiom_namespace_t *ns1 = NULL;
int i = 0;
int element_found = 0;
axutil_array_list_t *arr_list = NULL;
int sequence_broken = 0;
axiom_node_t *tmp_node = NULL;
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;
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 PortFolio"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
first_node = parent;
/**
* building portFolioItem array
*/
arr_list = axutil_array_list_create( env, 10);
/**
* building portFolioItem element
*/
element_qname = axutil_qname_create( env, "portFolioItem", "","");
for ( i = 0, sequence_broken = 0, tmp_node = current_node = first_node; current_node != NULL; current_node = axiom_node_get_next_sibling( current_node, env))
{
current_element = 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) )
{
if( sequence_broken)
{
/** found element out of order */
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "elements found out of order for arrayportFolioItem missing"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
tmp_node = current_node; /** always update the current node */
element_found = 1;
element = (void*)axis2_PortFolioItem_create( env);
status = axis2_PortFolioItem_deserialize( ( axis2_PortFolioItem_t*)element, env,
axiom_node_get_first_child(current_node, env)==NULL?current_node:axiom_node_get_first_child(current_node, env));
if( AXIS2_FAILURE == status)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element portFolioItem "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
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 portFolioItem "
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
i ++;
}
else
{
sequence_broken = 1;
}
}
current_node = tmp_node;
status = axis2_PortFolio_set_portFolioItem( PortFolio, env,
arr_list);
return status;
}
axis2_status_t AXIS2_CALL
adb_getReservationStatusesResponse_deserialize(
adb_getReservationStatusesResponse_t* _getReservationStatusesResponse,
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, _getReservationStatusesResponse, 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 getReservationStatusesResponse : "
"NULL elemenet can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building reservationStatuses array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building reservationStatuses element
*/
element_qname = axutil_qname_create(env, "reservationStatuses", 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("reservationStatuses", axiom_element_get_localname(current_element, env)))
{
is_early_node_valid = AXIS2_TRUE;
element = (void*)adb_ReservationStatus_create(env);
status = adb_ReservationStatus_deserialize((adb_ReservationStatus_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 reservationStatuses ");
}
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 reservationStatuses ");
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, "reservationStatuses (@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_getReservationStatusesResponse_set_reservationStatuses(_getReservationStatusesResponse, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
axis2_status_t AXIS2_CALL
adb_supportedContentFormats_type0_deserialize_obj(
adb_supportedContentFormats_type0_t* _supportedContentFormats_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, _supportedContentFormats_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 supportedContentFormats_type0 : "
"NULL element can not be passed to deserialize");
return AXIS2_FAILURE;
}
first_node = axiom_node_get_first_child(parent, env);
/*
* building contentFormat array
*/
arr_list = axutil_array_list_create(env, 10);
/*
* building contentFormat element
*/
element_qname = axutil_qname_create(env, "contentFormat", "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 contentFormat");
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 contentFormat ");
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, "contentFormat (@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_supportedContentFormats_type0_set_contentFormat(_supportedContentFormats_type0, env,
arr_list);
}
if(element_qname)
{
axutil_qname_free(element_qname, env);
element_qname = NULL;
}
return status;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_insert_before_and_after(
axis2_phase_t * phase,
const axutil_env_t * env,
axis2_handler_t * handler)
{
int before = -1;
int after = -1;
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
const axis2_char_t *before_handler_name = NULL, *after_handler_name = NULL, *after_name = NULL,
*before_name = NULL, *handler_name = NULL;
int i = 0;
int size = 0;
const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env);
const axis2_char_t *handler_desc_name = NULL;
handler_desc = axis2_handler_get_handler_desc(handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the handler %s within phase %s", name, phase->name);
return AXIS2_FAILURE;
}
handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
rules = axis2_handler_desc_get_rules(handler_desc, env);
if(!rules)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler rules are not set in the handler description %s within "
"phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
before_name = axis2_phase_rule_get_before(rules, env);
if(!before_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Rule `before` is not set in the handler rules for handler desc "
" %s within phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
after_name = axis2_phase_rule_get_after(rules, env);
if(!after_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Rule `after` is not set in the handler rules for handler desc "
"%s within phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
if(phase->first_handler)
{
const axis2_char_t *first_handler_name = axutil_string_get_buffer(axis2_handler_get_name(
phase->first_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(phase->first_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the first handler %s "
"within phase %s", first_handler_name, phase->name);
return AXIS2_FAILURE;
}
before_handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc,
env), env);
if(!before_handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description for the "
"first handler %s within phase %s", first_handler_name, phase->name);
return AXIS2_FAILURE;
}
}
if(phase->last_handler)
{
const axis2_char_t *last_handler_name = axutil_string_get_buffer(axis2_handler_get_name(
phase->last_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(phase->last_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the last handler %s "
"within phase %s", last_handler_name, phase->name);
return AXIS2_FAILURE;
}
after_handler_name = axutil_string_get_buffer(
axis2_handler_desc_get_name(handler_desc, env), env);
if(!after_handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description for the "
"last handler %s within phase %s", last_handler_name, phase->name);
return AXIS2_FAILURE;
}
}
if(before_handler_name && after_handler_name)
{
if(!axutil_strcmp(before_handler_name, before_name) && !axutil_strcmp(after_handler_name,
after_name))
{
return axis2_phase_add_unique(env, phase->handlers, handler);
}
}
if(after_handler_name)
{
if(!axutil_strcmp(after_handler_name, after_name))
after = 0;
}
size = axutil_array_list_size(phase->handlers, env);
if(after_handler_name)
{
if(!axutil_strcmp(before_handler_name, before_name))
before = size;
}
for(i = 0; i < size; i++)
{
axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers,
env, i);
if(temp_handler)
{
const axis2_char_t *temp_handler_name = axutil_string_get_buffer(
axis2_handler_get_name(temp_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(temp_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler Description is not set for the Handler %s "
"within phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
if(!handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler Description for "
"handler %s within phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
if(!axutil_strcmp(handler_name, after_name))
after = i;
if(!axutil_strcmp(handler_name, before_name))
before = i;
}
if((after >= 0) && (before >= 0))
{
/*both the before and after indexes have been found */
if(after > before)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Both the before and after indexes have been found and "
"`after` comes before `before` which is wrong within "
"phase %s", phase->name);
return AXIS2_FAILURE;
}
else
{
if(after + 1 < size)
{
return axutil_array_list_add_at(phase->handlers, env, after + 1, handler);
}
else
{
return axis2_phase_add_unique(env, phase->handlers, handler);
}
}
}
}
return axis2_phase_add_unique(env, phase->handlers, handler);
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_insert_after(
axis2_phase_t * phase,
const axutil_env_t * env,
axis2_handler_t * handler)
{
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
const axis2_char_t *handler_name = NULL;
const axis2_char_t *after = NULL;
int i = 0;
int size = 0;
const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env);
const axis2_char_t *handler_desc_name = NULL;
handler_desc = axis2_handler_get_handler_desc(handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the handler %s within phase %s", name, phase->name);
return AXIS2_FAILURE;
}
handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
rules = axis2_handler_desc_get_rules(handler_desc, env);
if(!rules)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler rules are not set in the handler description %s within "
"phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
after = axis2_phase_rule_get_after(rules, env);
if(!after)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Rule `after` is not set in the handler rules for handler desc "
"%s within phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
if(phase->first_handler)
{
const axis2_char_t *first_handler_name = axutil_string_get_buffer(axis2_handler_get_name(
phase->first_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(phase->first_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the first handler %s "
"within phase %s", first_handler_name, phase->name);
return AXIS2_FAILURE;
}
handler_name
= axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), env);
if(!handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description for "
"handler %s within phase %s", name, phase->name);
return AXIS2_FAILURE;
}
if(!axutil_strcmp(after, handler_name))
{
return axutil_array_list_add_at(phase->handlers, env, 0, handler);
}
}
size = axutil_array_list_size(phase->handlers, env);
for(i = 0; i < size; i++)
{
axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers,
env, i);
if(temp_handler)
{
const axis2_char_t *temp_handler_name = axutil_string_get_buffer(
axis2_handler_get_name(temp_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(temp_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the handler %s within"
" phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
if(!handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description %s "
"within phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
if(!axutil_strcmp(after, handler_name))
{
if(i == (size - 1))
{
return axis2_phase_add_unique(env, phase->handlers, handler);
}
else
return axutil_array_list_add_at(phase->handlers, env, i + 1, handler);
}
}
}
if(size > 0)
return axutil_array_list_add_at(phase->handlers, env, 0, handler);
else
{
return axis2_phase_add_unique(env, phase->handlers, handler);
}
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_phase_insert_before(
axis2_phase_t * phase,
const axutil_env_t * env,
axis2_handler_t * handler)
{
axis2_phase_rule_t *rules = NULL;
axis2_handler_desc_t *handler_desc = NULL;
const axis2_char_t *handler_name = NULL, *before = NULL;
int i = 0;
int size = 0;
const axis2_char_t *name = axutil_string_get_buffer(axis2_handler_get_name(handler, env), env);
const axis2_char_t *handler_desc_name = NULL;
handler_desc = axis2_handler_get_handler_desc(handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the handler %s within phase %s", name, phase->name);
return AXIS2_FAILURE;
}
handler_desc_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
rules = axis2_handler_desc_get_rules(handler_desc, env);
if(!rules)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler rules are not set in the handler description %s within "
"phase %s", handler_desc_name, phase->name);
return AXIS2_FAILURE;
}
before = axis2_phase_rule_get_before(rules, env);
if(!before)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Rule `before` is not set in the handler rules for handler %s "
"within phase %s", name, phase->name);
return AXIS2_FAILURE;
}
if(phase->last_handler)
{
const axis2_char_t *last_handler_name = axutil_string_get_buffer(axis2_handler_get_name(
phase->last_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(phase->last_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler description is not set in the last handler %s of "
"phase %s", last_handler_name, phase->name);
return AXIS2_FAILURE;
}
handler_name
= axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env), env);
if(!handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description for "
"last handler %s within phase %s", last_handler_name, phase->name);
return AXIS2_FAILURE;
}
if(!axutil_strcmp(before, handler_name))
{
/*return axutil_array_list_add(phase->handlers, env, handler); */
return axis2_phase_add_unique(env, phase->handlers, handler);
}
}
size = axutil_array_list_size(phase->handlers, env);
for(i = 0; i < size; i++)
{
axis2_handler_t *temp_handler = (axis2_handler_t *)axutil_array_list_get(phase->handlers,
env, i);
if(temp_handler)
{
const axis2_char_t *temp_handler_name = axutil_string_get_buffer(
axis2_handler_get_name(temp_handler, env), env);
handler_desc = axis2_handler_get_handler_desc(temp_handler, env);
if(!handler_desc)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler Description is not set for the Handler %s "
"within phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
handler_name = axutil_string_get_buffer(axis2_handler_desc_get_name(handler_desc, env),
env);
if(!handler_name)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Handler name is not set in the handler description for "
"handler %s within phase %s", temp_handler_name, phase->name);
return AXIS2_FAILURE;
}
if(!axutil_strcmp(before, handler_name))
{
return axutil_array_list_add_at(phase->handlers, env, i, handler);
}
}
}
/* add as the last handler */
/* return axutil_array_list_add(phase->handlers, env, handler); */
return axis2_phase_add_unique(env, phase->handlers, handler);
}
