static ssize_t data_triplet_format_t_from_config(data_t *data, config_t *config) { // {{{
ssize_t ret;
data_t storage;
data_t slave;
hash_holder_consume(ret, storage, config, HK(data));
if(ret < 0)
goto error1;
hash_holder_consume(ret, slave, config, HK(slave));
if(ret < 0)
goto error2;
if( (ret = data_triplet_format_t(data, storage, slave)) < 0)
goto error3;
return 0;
error3:
data_free(&slave);
error2:
data_free(&storage);
error1:
return ret;
} // }}}
static ssize_t chm_imp_configure (mphf_t *mphf, request_t *config){ // {{{
ssize_t ret;
chm_imp_t *data = (chm_imp_t *)&mphf->data;
data->nelements_min = CAPACITY_MIN_DEFAULT;
data->nelements_step = CAPACITY_STEP_DEFAULT;
data->nelements_mul = CAPACITY_MUL_DEFAULT;
data->readonly = 0;
hash_data_get(ret, TYPE_UINTT, data->nelements_min, config, HK(nelements_min));
hash_data_get(ret, TYPE_UINTT, data->nelements_step, config, HK(nelements_step));
hash_data_get(ret, TYPE_UINTT, data->nelements_mul, config, HK(nelements_mul));
hash_data_get(ret, TYPE_UINTT, data->bt_value, config, HK(value_size));
hash_data_get(ret, TYPE_UINTT, data->readonly, config, HK(readonly)); // run in read-only mode
if(data->bt_value > sizeof(uintmax_t))
return error("value_size is too big");
hash_holder_consume(ret, data->be_v, config, HK(data_v)); if(ret != 0) data->readonly = 1;
hash_holder_consume(ret, data->be_e, config, HK(data_e)); if(ret != 0) data->readonly = 1;
hash_holder_consume(ret, data->be_g, config, HK(data_g));
if(ret != 0)
return error("data chm_imp parameter data_g invalid");
return 0;
} // }}}
static ssize_t allocator_new(allocator_fixed_t **pfdata, hash_t *config){ // {{{
ssize_t ret;
data_t *sample;
allocator_fixed_t *fdata;
if((fdata = calloc(1, sizeof(allocator_fixed_t))) == NULL)
return error("calloc failed");
pthread_rwlock_init(&fdata->rwlock, NULL);
// get removed items tracker
hash_holder_consume(ret, fdata->removed_items, config, HK(removed_items));
hash_holder_consume(ret, fdata->storage, config, HK(storage));
if(ret != 0){
ret = error("invalid storage supplied");
goto error;
}
hash_data_get(ret, TYPE_UINTT, fdata->item_size, config, HK(item_size));
if(ret != 0){
if( (sample = hash_data_find(config, HK(item_sample))) == NULL){
ret = error("no item_size nor item_sample supplied");
goto error;
}
fastcall_length r_len = { { 4, ACTION_LENGTH }, 0, FORMAT(binary) };
if( data_query(sample, &r_len) != 0 ){
ret = error("bad item_sample");
goto error;
}
fdata->item_size = r_len.length;
}
if(fdata->item_size == 0){
ret = error("bad item size");
goto error;
}
// get last id
fastcall_length r_len = { { 4, ACTION_LENGTH }, 0, FORMAT(clean) };
if( data_query(&fdata->storage, &r_len) != 0){
ret = error("bad underlying storage");
goto error;
}
fdata->last_id = r_len.length / fdata->item_size;
*pfdata = fdata;
return 0;
error:
allocator_destroy(fdata);
return ret;
} // }}}
static ssize_t data_length_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
length_t *fdata;
if(dst->ptr != NULL)
return -EINVAL;
switch(fargs->format){
case FORMAT(hash):;
hash_t *config;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return ret;
if( (fdata = malloc(sizeof(length_t))) == NULL)
return -ENOMEM;
hash_holder_consume(ret, fdata->data, config, HK(data));
if(ret != 0){
free(fdata);
return -EINVAL;
}
fdata->format = FORMAT(clean);
hash_data_get(ret, TYPE_FORMATT, fdata->format, config, HK(format));
dst->ptr = fdata;
return 0;
default:
break;
}
return -ENOSYS;
} // }}}
static int try_configure(machine_t *machine, config_t *config){ // {{{
ssize_t ret;
try_userdata *userdata = (try_userdata *)machine->userdata;
hash_data_get(ret, TYPE_HASHKEYT, userdata->request, config, HK(request));
if(ret == 0){
userdata->request_out = userdata->request;
}
hash_data_get(ret, TYPE_HASHKEYT, userdata->request_out, config, HK(request_out));
hash_data_get(ret, TYPE_HASHKEYT, userdata->return_to, config, HK(return_to));
hash_holder_consume(ret, userdata->machine, config, HK(shop));
if(ret != 0)
return error("shop parameter not supplied");
return 0;
} // }}}
static ssize_t data_pcre_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
pcre_t *fdata;
if(fargs->src == NULL)
return -EINVAL;
switch( fargs->format ){
case FORMAT(hash):;
hash_t *config;
data_t data;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
if( (ret = pcre_t_new((pcre_t **)&dst->ptr, config)) < 0)
return ret;
fdata = (pcre_t *)dst->ptr;
hash_holder_consume(ret, data, config, HDK(data));
if(ret == 0){
fdata->freeit = data;
fdata->data = &fdata->freeit;
}
return 0;
case FORMAT(config):;
case FORMAT(human):;
request_t r_config[] = {
{ HDK(regexp), *fargs->src },
hash_end
};
return pcre_t_new((pcre_t **)&dst->ptr, r_config);
default:
break;
};
return -ENOSYS;
} // }}}
static ssize_t data_ref_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
if(dst->ptr != NULL)
return data_ref_t_handler(dst, (fastcall_header *)fargs); // already inited - pass to underlying data
switch(fargs->format){
case FORMAT(hash):;
hash_t *config;
data_t data;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
hash_holder_consume(ret, data, config, HK(data));
return ( (dst->ptr = ref_t_alloc(&data)) == NULL ) ? -EFAULT : 0;
default:
break;
}
return -ENOSYS;
} // }}}
