void
test_array_list(
const axutil_env_t * env)
{
axutil_array_list_t *al;
a *entry = NULL;
int size;
al = axutil_array_list_create(env, 1);
printf("list size %d\n", axutil_array_list_size(al, env));
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value1");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value2");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value3");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value4");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value5");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value6");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value7");
axutil_array_list_set(al, env, 3, (void *) entry);
axutil_array_list_remove(al, env, 2);
entry = (a *) axutil_array_list_get(al, env, 0);
printf("entry->value:%s\n", entry->value);
entry = (a *) axutil_array_list_get(al, env, 2);
printf("entry->value:%s\n", entry->value);
size = axutil_array_list_size(al, env);
printf("list size %d\n", axutil_array_list_size(al, env));
}
/**
* Set return to nill at i
*/
axis2_status_t AXIS2_CALL
adb_listExternalUsersResponse_set_return_nil_at(
adb_listExternalUsersResponse_t* _listExternalUsersResponse,
const axutil_env_t *env, int i)
{
void *element = NULL;
int size = 0;
int j;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
int k = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, AXIS2_FAILURE);
if(_listExternalUsersResponse->property_return == NULL ||
_listExternalUsersResponse->is_valid_return == AXIS2_FALSE)
{
non_nil_exists = AXIS2_FALSE;
}
else
{
size = axutil_array_list_size(_listExternalUsersResponse->property_return, env);
for(j = 0, k = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_listExternalUsersResponse->property_return, env, i))
{
k ++;
non_nil_exists = AXIS2_TRUE;
if( k >= 0)
{
break;
}
}
}
}
if( k < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of return is beinng set to be smaller than the specificed number of minOccurs(0)");
return AXIS2_FAILURE;
}
if(_listExternalUsersResponse->property_return == NULL)
{
_listExternalUsersResponse->is_valid_return = AXIS2_FALSE;
return AXIS2_SUCCESS;
}
/* check whether there already exist an element */
element = axutil_array_list_get(_listExternalUsersResponse->property_return, env, i);
if(NULL != element)
{
/* This is an unknown type or a primitive. Please free this manually*/
}
if(!non_nil_exists)
{
_listExternalUsersResponse->is_valid_return = AXIS2_FALSE;
axutil_array_list_set(_listExternalUsersResponse->property_return , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_listExternalUsersResponse->property_return , env, i, NULL);
return AXIS2_SUCCESS;
}
/**
* Set the ith element of return.
*/
axis2_status_t AXIS2_CALL
adb_listExternalUsersResponse_set_return_at(
adb_listExternalUsersResponse_t* _listExternalUsersResponse,
const axutil_env_t *env, int i,
const axis2_char_t* arg_return)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, AXIS2_FAILURE);
if( _listExternalUsersResponse->is_valid_return &&
_listExternalUsersResponse->property_return &&
arg_return == (axis2_char_t*)axutil_array_list_get(_listExternalUsersResponse->property_return, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_return)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_listExternalUsersResponse->property_return != NULL)
{
size = axutil_array_list_size(_listExternalUsersResponse->property_return, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_listExternalUsersResponse->property_return, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 0)
{
break;
}
}
}
}
}
if(_listExternalUsersResponse->property_return == NULL)
{
_listExternalUsersResponse->property_return = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_listExternalUsersResponse->property_return, env, i);
if(NULL != element)
{
/* This is an unknown type or a primitive. Please free this manually*/
}
if(!non_nil_exists)
{
_listExternalUsersResponse->is_valid_return = AXIS2_FALSE;
axutil_array_list_set(_listExternalUsersResponse->property_return , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_listExternalUsersResponse->property_return , env, i, axutil_strdup(env, arg_return));
_listExternalUsersResponse->is_valid_return = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Set the ith element of extraElement.
*/
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_set_extraElement_at(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
const axutil_env_t *env, int i,
axiom_node_t* arg_extraElement)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE);
if( _CanonicalizationMethodType->is_valid_extraElement &&
_CanonicalizationMethodType->property_extraElement &&
arg_extraElement == (axiom_node_t*)axutil_array_list_get(_CanonicalizationMethodType->property_extraElement, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_extraElement)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_CanonicalizationMethodType->property_extraElement != NULL)
{
size = axutil_array_list_size(_CanonicalizationMethodType->property_extraElement, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_CanonicalizationMethodType->property_extraElement, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 0)
{
break;
}
}
}
}
}
if(_CanonicalizationMethodType->property_extraElement == NULL)
{
_CanonicalizationMethodType->property_extraElement = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_CanonicalizationMethodType->property_extraElement, env, i);
if(NULL != element)
{
axiom_node_free_tree ((axiom_node_t*)element, env);
}
if(!non_nil_exists)
{
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_FALSE;
axutil_array_list_set(_CanonicalizationMethodType->property_extraElement , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_CanonicalizationMethodType->property_extraElement , env, i, arg_extraElement);
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Set extraElement to nill at i
*/
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_set_extraElement_nil_at(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
const axutil_env_t *env, int i)
{
void *element = NULL;
int size = 0;
int j;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
int k = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE);
if(_CanonicalizationMethodType->property_extraElement == NULL ||
_CanonicalizationMethodType->is_valid_extraElement == AXIS2_FALSE)
{
non_nil_exists = AXIS2_FALSE;
}
else
{
size = axutil_array_list_size(_CanonicalizationMethodType->property_extraElement, env);
for(j = 0, k = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_CanonicalizationMethodType->property_extraElement, env, i))
{
k ++;
non_nil_exists = AXIS2_TRUE;
if( k >= 0)
{
break;
}
}
}
}
if( k < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of extraElement is beinng set to be smaller than the specificed number of minOccurs(0)");
return AXIS2_FAILURE;
}
if(_CanonicalizationMethodType->property_extraElement == NULL)
{
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_FALSE;
return AXIS2_SUCCESS;
}
/* check whether there already exist an element */
element = axutil_array_list_get(_CanonicalizationMethodType->property_extraElement, env, i);
if(NULL != element)
{
axiom_node_free_tree ((axiom_node_t*)element, env);
}
if(!non_nil_exists)
{
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_FALSE;
axutil_array_list_set(_CanonicalizationMethodType->property_extraElement , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_CanonicalizationMethodType->property_extraElement , env, i, NULL);
return AXIS2_SUCCESS;
}
/**
* Set the ith element of controlOperations.
*/
axis2_status_t AXIS2_CALL
adb_OperationMetaDataWrapper_set_controlOperations_at(
adb_OperationMetaDataWrapper_t* _OperationMetaDataWrapper,
const axutil_env_t *env, int i,
adb_OperationMetaData_t* arg_controlOperations)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _OperationMetaDataWrapper, AXIS2_FAILURE);
if( _OperationMetaDataWrapper->is_valid_controlOperations &&
_OperationMetaDataWrapper->property_controlOperations &&
arg_controlOperations == (adb_OperationMetaData_t*)axutil_array_list_get(_OperationMetaDataWrapper->property_controlOperations, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_controlOperations)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_OperationMetaDataWrapper->property_controlOperations != NULL)
{
size = axutil_array_list_size(_OperationMetaDataWrapper->property_controlOperations, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_OperationMetaDataWrapper->property_controlOperations, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 0)
{
break;
}
}
}
}
}
if(_OperationMetaDataWrapper->property_controlOperations == NULL)
{
_OperationMetaDataWrapper->property_controlOperations = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_OperationMetaDataWrapper->property_controlOperations, env, i);
if(NULL != element)
{
adb_OperationMetaData_free((adb_OperationMetaData_t*)element, env);
}
if(!non_nil_exists)
{
_OperationMetaDataWrapper->is_valid_controlOperations = AXIS2_FALSE;
axutil_array_list_set(_OperationMetaDataWrapper->property_controlOperations , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_OperationMetaDataWrapper->property_controlOperations , env, i, arg_controlOperations);
_OperationMetaDataWrapper->is_valid_controlOperations = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Set Transform to nill at i
*/
axis2_status_t AXIS2_CALL
adb_TransformsType_set_Transform_nil_at(
adb_TransformsType_t* _TransformsType,
const axutil_env_t *env, int i)
{
void *element = NULL;
int size = 0;
int j;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
int k = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _TransformsType, AXIS2_FAILURE);
if(_TransformsType->property_Transform == NULL ||
_TransformsType->is_valid_Transform == AXIS2_FALSE)
{
non_nil_exists = AXIS2_FALSE;
}
else
{
size = axutil_array_list_size(_TransformsType->property_Transform, env);
for(j = 0, k = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_TransformsType->property_Transform, env, i))
{
k ++;
non_nil_exists = AXIS2_TRUE;
if( k >= 1)
{
break;
}
}
}
}
if(!non_nil_exists)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of Transform is being set to NULL, but it is not a nullable or minOccurs=0 element");
return AXIS2_FAILURE;
}
if( k < 1)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of Transform is beinng set to be smaller than the specificed number of minOccurs(1)");
return AXIS2_FAILURE;
}
if(_TransformsType->property_Transform == NULL)
{
_TransformsType->is_valid_Transform = AXIS2_FALSE;
return AXIS2_SUCCESS;
}
/* check whether there already exist an element */
element = axutil_array_list_get(_TransformsType->property_Transform, env, i);
if(NULL != element)
{
adb_TransformType_free((adb_TransformType_t*)element, env);
}
axutil_array_list_set(_TransformsType->property_Transform , env, i, NULL);
return AXIS2_SUCCESS;
}
/**
* Set the ith element of return.
*/
axis2_status_t AXIS2_CALL
adb_listModulesForServiceGroupResponse_set_return_at(
adb_listModulesForServiceGroupResponse_t* _listModulesForServiceGroupResponse,
const axutil_env_t *env, int i,
adb_ModuleMetaData_t* arg_return)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _listModulesForServiceGroupResponse, AXIS2_FAILURE);
if( _listModulesForServiceGroupResponse->is_valid_return &&
_listModulesForServiceGroupResponse->property_return &&
arg_return == (adb_ModuleMetaData_t*)axutil_array_list_get(_listModulesForServiceGroupResponse->property_return, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_return)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_listModulesForServiceGroupResponse->property_return != NULL)
{
size = axutil_array_list_size(_listModulesForServiceGroupResponse->property_return, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_listModulesForServiceGroupResponse->property_return, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 0)
{
break;
}
}
}
}
}
if(_listModulesForServiceGroupResponse->property_return == NULL)
{
_listModulesForServiceGroupResponse->property_return = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_listModulesForServiceGroupResponse->property_return, env, i);
if(NULL != element)
{
adb_ModuleMetaData_free((adb_ModuleMetaData_t*)element, env);
}
if(!non_nil_exists)
{
_listModulesForServiceGroupResponse->is_valid_return = AXIS2_FALSE;
axutil_array_list_set(_listModulesForServiceGroupResponse->property_return , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_listModulesForServiceGroupResponse->property_return , env, i, arg_return);
_listModulesForServiceGroupResponse->is_valid_return = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Set the ith element of reservationStatuses.
*/
axis2_status_t AXIS2_CALL
adb_getReservationStatusesResponse_set_reservationStatuses_at(
adb_getReservationStatusesResponse_t* _getReservationStatusesResponse,
const axutil_env_t *env, int i,
adb_ReservationStatus_t* arg_reservationStatuses)
{
void *element = NULL;
int size = 0;
int j;
int k;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _getReservationStatusesResponse, AXIS2_FAILURE);
if( _getReservationStatusesResponse->is_valid_reservationStatuses &&
_getReservationStatusesResponse->property_reservationStatuses &&
arg_reservationStatuses == (adb_ReservationStatus_t*)axutil_array_list_get(_getReservationStatusesResponse->property_reservationStatuses, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL == arg_reservationStatuses)
{
if(_getReservationStatusesResponse->property_reservationStatuses != NULL)
{
size = axutil_array_list_size(_getReservationStatusesResponse->property_reservationStatuses, env);
for(j = 0, k = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_getReservationStatusesResponse->property_reservationStatuses, env, i))
{
k ++;
non_nil_exists = AXIS2_TRUE;
if(k >= 0)
{
break;
}
}
}
}
}
else
{
non_nil_exists = AXIS2_TRUE;
}
if( k < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of reservationStatuses is beinng set to be smaller than the specificed number of minOccurs(0)");
return AXIS2_FAILURE;
}
if(_getReservationStatusesResponse->property_reservationStatuses == NULL)
{
_getReservationStatusesResponse->property_reservationStatuses = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_getReservationStatusesResponse->property_reservationStatuses, env, i);
if(NULL != element)
{
adb_ReservationStatus_free((adb_ReservationStatus_t*)element, env);
}
if(!non_nil_exists)
{
_getReservationStatusesResponse->is_valid_reservationStatuses = AXIS2_FALSE;
axutil_array_list_set(_getReservationStatusesResponse->property_reservationStatuses , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_getReservationStatusesResponse->property_reservationStatuses , env, i, arg_reservationStatuses);
_getReservationStatusesResponse->is_valid_reservationStatuses = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Set the ith element of protocol.
*/
axis2_status_t AXIS2_CALL
adb_additionalTransferProtocols_type0_set_protocol_at(
adb_additionalTransferProtocols_type0_t* _additionalTransferProtocols_type0,
const axutil_env_t *env, int i,
const axis2_char_t* arg_protocol)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _additionalTransferProtocols_type0, AXIS2_FAILURE);
if( _additionalTransferProtocols_type0->is_valid_protocol &&
_additionalTransferProtocols_type0->property_protocol &&
arg_protocol == (axis2_char_t*)axutil_array_list_get(_additionalTransferProtocols_type0->property_protocol, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_protocol)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_additionalTransferProtocols_type0->property_protocol != NULL)
{
size = axutil_array_list_size(_additionalTransferProtocols_type0->property_protocol, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_additionalTransferProtocols_type0->property_protocol, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 1)
{
break;
}
}
}
if( non_nil_count < 1)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of protocol is beinng set to be smaller than the specificed number of minOccurs(1)");
return AXIS2_FAILURE;
}
}
}
if(!non_nil_exists)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "All the elements in the array of protocol is being set to NULL, but it is not a nullable or minOccurs=0 element");
return AXIS2_FAILURE;
}
if(_additionalTransferProtocols_type0->property_protocol == NULL)
{
_additionalTransferProtocols_type0->property_protocol = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_additionalTransferProtocols_type0->property_protocol, env, i);
if(NULL != element)
{
/* This is an unknown type or a primitive. Please free this manually*/
}
axutil_array_list_set(_additionalTransferProtocols_type0->property_protocol , env, i, axutil_strdup(env, arg_protocol));
_additionalTransferProtocols_type0->is_valid_protocol = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
axis2_status_t static
remote_registry_rest_client_set_cache(
remote_registry_rest_client_t *rest_client,
const axutil_env_t *env,
const axis2_char_t *url,
axis2_char_t *buffer,
int buffer_len,
axis2_char_t* new_etag)
{
axis2_char_t *prev_cache = NULL;
axis2_char_t *prev_cache_etag = NULL;
int cache_replacing = 0;
axis2_char_t *early_url = NULL;
axis2_char_t *url_dup = NULL;
axis2_char_t *buffer_dup = NULL;
/* updating the env for all the hashes */
axutil_hash_set_env(rest_client->cached_entries, env);
axutil_hash_set_env(rest_client->cached_entries_len, env);
axutil_hash_set_env(rest_client->etags, env);
axutil_hash_set_env(rest_client->reverse_cached_order, env);
/* check wether there were any old entries, if so free them */
prev_cache = axutil_hash_get(rest_client->cached_entries, url, AXIS2_HASH_KEY_STRING);
/* freeing the old entries */
if(prev_cache)
{
int prev_cache_index;
/* set a flag to identify that we replace already existed one */
cache_replacing = 1;
AXIS2_FREE(env->allocator, prev_cache);
/* now we are going to check the place of it in the cached index */
prev_cache_index = (int)axutil_hash_get(rest_client->reverse_cached_order, url, AXIS2_HASH_KEY_STRING);
/* the value of the url and early_url is same, but different pointers */
early_url = axutil_array_list_get(rest_client->cached_order, env, prev_cache_index);
AXIS2_FREE(env->allocator, early_url);
/* the reverse cache order will be cleard at the time it is overwritten */
/* checking the next to clear (because of out of LIMIT) */
early_url = axutil_array_list_get(rest_client->cached_order, env, rest_client->cached_order_index);
if(early_url)
{
/* so actually we need to erase the existing one, rather we promot it to the prev_cache_index
so non of the cache will be erased other than the one that got replaced */
axutil_array_list_set(rest_client->cached_order, env, prev_cache_index, early_url);
early_url = axutil_strdup(env, early_url);
axutil_hash_set(rest_client->reverse_cached_order, early_url, AXIS2_HASH_KEY_STRING, (void*)prev_cache_index);
}
/* and we are going to put our current url to the rest_client->cached_order_index */
url_dup = axutil_strdup(env, url);
axutil_array_list_set(rest_client->cached_order, env, rest_client->cached_order_index, url_dup);
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->reverse_cached_order, url_dup, AXIS2_HASH_KEY_STRING, (void*)rest_client->cached_order_index);
}
if(!cache_replacing)
{
int prev_cache_len;
/* now we have to consider the limit of the cache for non-replacing case */
early_url = axutil_array_list_get(rest_client->cached_order, env, rest_client->cached_order_index);
if(early_url)
{
/* we have to remove this url for fit within the cache url */
prev_cache = axutil_hash_get(rest_client->cached_entries, early_url, AXIS2_HASH_KEY_STRING);
if(prev_cache)
{
AXIS2_FREE(env->allocator, prev_cache);
axutil_hash_set(rest_client->cached_entries, early_url, AXIS2_HASH_KEY_STRING, NULL);
}
prev_cache_etag = axutil_hash_get(rest_client->etags, early_url, AXIS2_HASH_KEY_STRING);
if(prev_cache_etag)
{
AXIS2_FREE(env->allocator, prev_cache_etag);
axutil_hash_set(rest_client->etags, early_url, AXIS2_HASH_KEY_STRING, NULL);
}
prev_cache_len = (int)axutil_hash_get(rest_client->cached_entries_len, early_url, AXIS2_HASH_KEY_STRING);
if(prev_cache_len)
{
axutil_hash_set(rest_client->cached_entries_len, early_url, AXIS2_HASH_KEY_STRING, NULL);
}
/* as the last we remove it from the order as well */
axutil_hash_set(rest_client->reverse_cached_order, early_url, AXIS2_HASH_KEY_STRING, NULL);
AXIS2_FREE(env->allocator, early_url);
/* and we put our values in there */
url_dup = axutil_strdup(env, url);
axutil_array_list_set(rest_client->cached_order, env, rest_client->cached_order_index, url_dup);
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->reverse_cached_order, url_dup, AXIS2_HASH_KEY_STRING, (void*)rest_client->cached_order_index);
}
else {
/* if no replacing is hapenning we can add the url to cached_order */
url_dup = axutil_strdup(env, url);
axutil_array_list_add(rest_client->cached_order, env, url_dup);
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->reverse_cached_order, url_dup, AXIS2_HASH_KEY_STRING, (void*)rest_client->cached_order_index);
}
}
if(buffer)
{
buffer_dup = (axis2_char_t*)AXIS2_MALLOC(env->allocator, buffer_len + sizeof(axis2_char_t));
memcpy(buffer_dup, buffer, buffer_len + sizeof(axis2_char_t));
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->cached_entries, url_dup, AXIS2_HASH_KEY_STRING, buffer_dup);
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->cached_entries_len, url_dup, AXIS2_HASH_KEY_STRING, (void*)buffer_len);
}
else
{
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->cached_entries, url_dup, AXIS2_HASH_KEY_STRING, NULL);
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->cached_entries_len, url_dup, AXIS2_HASH_KEY_STRING, (void*)0);
}
url_dup = axutil_strdup(env, url);
axutil_hash_set(rest_client->etags, url_dup, AXIS2_HASH_KEY_STRING, new_etag);
/* we need to increment the cached_order_index in cyclic manner .. */
rest_client->cached_order_index ++;
if(rest_client->cached_order_index >= remote_registry_conf_get_cache_entries_limit(rest_client->conf, env))
{
rest_client->cached_order_index = 0;
}
return AXIS2_SUCCESS;
}
/**
* Set protectionFormat to nill at i
*/
axis2_status_t AXIS2_CALL
adb_supportedContentProtectionFormats_type0_set_protectionFormat_nil_at(
adb_supportedContentProtectionFormats_type0_t* _supportedContentProtectionFormats_type0,
const axutil_env_t *env, int i)
{
void *element = NULL;
int size = 0;
int j;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
int k = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _supportedContentProtectionFormats_type0, AXIS2_FAILURE);
if(_supportedContentProtectionFormats_type0->property_protectionFormat == NULL ||
_supportedContentProtectionFormats_type0->is_valid_protectionFormat == AXIS2_FALSE)
{
non_nil_exists = AXIS2_FALSE;
}
else
{
size = axutil_array_list_size(_supportedContentProtectionFormats_type0->property_protectionFormat, env);
for(j = 0, k = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_supportedContentProtectionFormats_type0->property_protectionFormat, env, i))
{
k ++;
non_nil_exists = AXIS2_TRUE;
if( k >= 0)
{
break;
}
}
}
}
if( k < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of protectionFormat is beinng set to be smaller than the specificed number of minOccurs(0)");
return AXIS2_FAILURE;
}
if(_supportedContentProtectionFormats_type0->property_protectionFormat == NULL)
{
_supportedContentProtectionFormats_type0->is_valid_protectionFormat = AXIS2_FALSE;
return AXIS2_SUCCESS;
}
/* check whether there already exist an element */
element = axutil_array_list_get(_supportedContentProtectionFormats_type0->property_protectionFormat, env, i);
if(NULL != element)
{
adb_protectionFormat_type1_free((adb_protectionFormat_type1_t*)element, env);
}
if(!non_nil_exists)
{
_supportedContentProtectionFormats_type0->is_valid_protectionFormat = AXIS2_FALSE;
axutil_array_list_set(_supportedContentProtectionFormats_type0->property_protectionFormat , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_supportedContentProtectionFormats_type0->property_protectionFormat , env, i, NULL);
return AXIS2_SUCCESS;
}
/**
* Set the ith element of protectionFormat.
*/
axis2_status_t AXIS2_CALL
adb_supportedContentProtectionFormats_type0_set_protectionFormat_at(
adb_supportedContentProtectionFormats_type0_t* _supportedContentProtectionFormats_type0,
const axutil_env_t *env, int i,
adb_protectionFormat_type1_t* arg_protectionFormat)
{
void *element = NULL;
int size = 0;
int j;
int non_nil_count;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _supportedContentProtectionFormats_type0, AXIS2_FAILURE);
if( _supportedContentProtectionFormats_type0->is_valid_protectionFormat &&
_supportedContentProtectionFormats_type0->property_protectionFormat &&
arg_protectionFormat == (adb_protectionFormat_type1_t*)axutil_array_list_get(_supportedContentProtectionFormats_type0->property_protectionFormat, env, i))
{
return AXIS2_SUCCESS;
}
if(NULL != arg_protectionFormat)
{
non_nil_exists = AXIS2_TRUE;
}
else {
if(_supportedContentProtectionFormats_type0->property_protectionFormat != NULL)
{
size = axutil_array_list_size(_supportedContentProtectionFormats_type0->property_protectionFormat, env);
for(j = 0, non_nil_count = 0; j < size; j ++ )
{
if(i == j) continue;
if(NULL != axutil_array_list_get(_supportedContentProtectionFormats_type0->property_protectionFormat, env, i))
{
non_nil_count ++;
non_nil_exists = AXIS2_TRUE;
if(non_nil_count >= 0)
{
break;
}
}
}
}
}
if(_supportedContentProtectionFormats_type0->property_protectionFormat == NULL)
{
_supportedContentProtectionFormats_type0->property_protectionFormat = axutil_array_list_create(env, 10);
}
/* check whether there already exist an element */
element = axutil_array_list_get(_supportedContentProtectionFormats_type0->property_protectionFormat, env, i);
if(NULL != element)
{
adb_protectionFormat_type1_free((adb_protectionFormat_type1_t*)element, env);
}
if(!non_nil_exists)
{
_supportedContentProtectionFormats_type0->is_valid_protectionFormat = AXIS2_FALSE;
axutil_array_list_set(_supportedContentProtectionFormats_type0->property_protectionFormat , env, i, NULL);
return AXIS2_SUCCESS;
}
axutil_array_list_set(_supportedContentProtectionFormats_type0->property_protectionFormat , env, i, arg_protectionFormat);
_supportedContentProtectionFormats_type0->is_valid_protectionFormat = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
