自学教程：C++ HK函数代码示例

static ssize_t addrs_count(backend_t *chain, request_t *request){	size_t           units; 	data_t          *buffer;	data_ctx_t      *buffer_ctx;	file_userdata   *data = ((file_userdata *)chain->userdata);		if( (buffer = hash_get_data(request, HK(buffer))) == NULL)		return -EINVAL;		buffer_ctx = hash_get_data_ctx(request, HK(buffer));		if(hash_find(request, HK(blocks)) == NULL){		if(tree_size(data->tree, &units) != 0)			return -EINVAL;	}else{		units = tree_blocks_count(data->tree);	}		data_t dt_units = DATA_PTR_OFFT(&units);		return data_transfer(		buffer,     buffer_ctx,		&dt_units,  NULL	);}

static ssize_t          mphf_configure_any(backend_t *backend, config_t *config, request_t *fork_req){ // {{{	ssize_t          ret;	uintmax_t        fork_only       = 0;	char            *mphf_type_str   = NULL;	mphf_userdata   *userdata        = (mphf_userdata *)backend->userdata;		hash_data_copy(ret, TYPE_STRINGT,  mphf_type_str,    config, HK(type));	hash_data_copy(ret, TYPE_UINTT,    fork_only,        config, HK(fork_only));	hash_data_copy(ret, TYPE_HASHKEYT, userdata->input,  config, HK(input));	hash_data_copy(ret, TYPE_HASHKEYT, userdata->output, config, HK(output));       	if(fork_only == 1 && fork_req == NULL)		return 0;	if( (userdata->mphf_proto = mphf_string_to_proto(mphf_type_str)) == NULL)		return error("backend mphf parameter mphf_type invalid or not supplied");		memset(&userdata->mphf, 0, sizeof(userdata->mphf));		userdata->mphf.config     = config;	userdata->broken          = 0;	if(fork_req == NULL){		if( (ret = userdata->mphf_proto->func_load(&userdata->mphf)) < 0)			return ret;	}else{		if( (ret = userdata->mphf_proto->func_fork(&userdata->mphf, fork_req)) < 0)			return ret;	}	return 0;} // }}}

ssize_t     action_crud_to_fast(void *userdata, request_t *request, f_hash_to_fast callback){ // {{{	ssize_t                ret;	action_t               action;	data_t                *key;	data_t                *value;		hash_data_get(ret, TYPE_ACTIONT, action, request, HK(action));	if(ret != 0)		return ret;		key   = hash_data_find(request, HK(key));	value = hash_data_find(request, HK(value));		if(key){		data_realholder(ret, key, key);		if(ret < 0)			return ret;	}	if(value){		data_realholder(ret, value, value);		if(ret < 0)			return ret;	}		fastcall_crud fargs = { { 4, action }, key, value };	ret = callback(userdata, &fargs);		return ret;} // }}}

ssize_t     action_write_to_fast(void *userdata, request_t *request, f_hash_to_fast callback){ // {{{	ssize_t                ret;	data_t                *r_buffer;	data_t                *r_size;	uintmax_t              offset            = 0;	uintmax_t              size              = ~0;		hash_data_get(ret, TYPE_UINTT, offset, request, HK(offset));		if( (r_size   = hash_data_find(request, HK(size))) != NULL){		data_get(ret, TYPE_UINTT, size, r_size);	}		if( (r_buffer = hash_data_find(request, HK(buffer))) == NULL)		return -EINVAL;		data_t                 d_slice    = DATA_SLICET(userdata, offset, size); // FIXME	fastcall_convert_to    r_convert = { { 5, ACTION_CONVERT_TO }, &d_slice, FORMAT(native) };		ret = data_query(r_buffer, &r_convert);		fastcall_write         r_write           = { { 5, ACTION_WRITE }, 0, &r_convert.transfered, sizeof(r_convert.transfered) };	if(r_size)		data_query(r_size, &r_write);		return ret;} // }}}

ssize_t     action_crud_to_hash(void *userdata, fastcall_crud *fargs, f_fast_to_hash callback){ // {{{	ssize_t                ret;		request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		hash_null,		hash_null,		hash_end	};	if(fargs->key){		r_next[1].key  = HK(key);		r_next[1].data = *fargs->key;	}	if(fargs->value){		r_next[2].key  = HK(value);		r_next[2].data = *fargs->value;	}	ret = callback(userdata, r_next);		if(fargs->key)		*fargs->key   = r_next[1].data;	if(fargs->value)		*fargs->value = r_next[2].data;	return ret;} // }}}

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 int addrs_configure(backend_t *chain, hash_t *config){	ssize_t           ret;	DT_UINT32T          elements_per_level = 0;	DT_UINT32T          read_per_calc      = READ_PER_CALC_DEFAULT;	addrs_userdata   *data = (addrs_userdata *)chain->userdata;		hash_data_copy(ret, TYPE_UINT32T, elements_per_level, config, HK(perlevel));	hash_data_copy(ret, TYPE_UINT32T, read_per_calc,      config, HK(read_size));		if(elements_per_level <= 1)		return -EINVAL; // "chain blocks-address variable 'per-level' invalid");		if(read_per_calc < 1)		read_per_calc = READ_PER_CALC_DEFAULT;		if( (data->tree = tree_alloc(chain, elements_per_level, read_per_calc)) == NULL)		return error("chain blocks-address no memory"); 		if(tree_recalc(data->tree) != 0){		tree_free(data->tree);		return error("chain blocks-address tree recalc failed");	}		return 0;}

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;} // }}}

ssize_t     action_query_to_hash(void *userdata, fastcall_query *fargs, f_fast_to_hash callback){ // {{{	request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(request),    DATA_PTR_HASHT( fargs->request                     ) },		hash_end	};	return callback(userdata, r_next);} // }}}

static int call_configure(backend_t *backend, config_t *config){ // {{{	ssize_t                ret;	call_userdata         *userdata          = (call_userdata *)backend->userdata;		hash_data_copy(ret, TYPE_HASHKEYT, userdata->hk_backend,    config, HK(input));	hash_data_copy(ret, TYPE_UINTT,    userdata->retry_request, config, HK(retry));	return 0;} // }}}

ssize_t     action_resize_to_hash(void *userdata, fastcall_resize *fargs, f_fast_to_hash callback){ // {{{	request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(size),       DATA_UINTT(      fargs->length                     ) },		hash_end	};	return callback(userdata, r_next);} // }}}

ssize_t     action_enum_to_hash(void *userdata, fastcall_enum *fargs, f_fast_to_hash callback){ // {{{	request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(data),      *fargs->dest                                          },		hash_end	};	return callback(userdata, r_next);} // }}}

static ssize_t data_list_t_convert_to(data_t *src, fastcall_convert_to *fargs){ // {{{	ssize_t                ret               = 0;	ssize_t                qret;	list_chunk_t          *chunk;	list_t                *fdata             = (list_t *)src->ptr;	data_t                 sl_output         = DATA_SLIDERT(fargs->dest, 0);		switch(fargs->format){		case FORMAT(packed):;			for(chunk = fdata->head; chunk; chunk = chunk->cnext){				// remove ref_t from top				hash_t           r_key[] = {					{ 0, DATA_HASHKEYT(HK(data)) },					hash_end				};				data_t           d_key     = DATA_PTR_HASHT(r_key);				fastcall_control r_control = {					{ 5, ACTION_CONTROL },					HK(data),					&d_key,					NULL				};				if( (ret = data_query(&chunk->data, &r_control)) < 0)					break;								data_t         d_data             = DATA_PTR_DATAT(r_control.value);								fastcall_convert_to r_convert = { { 5, ACTION_CONVERT_TO }, &sl_output, FORMAT(packed) };				ret = data_query(&d_data, &r_convert);								data_slider_t_set_offset(&sl_output, r_convert.transfered, SEEK_CUR);								if(ret < 0)					break;			}						// terminate list			data_t                 terminator         = { TYPE_LISTENDT, NULL };			data_t                 d_data             = DATA_PTR_DATAT(&terminator);						fastcall_convert_to r_convert = { { 5, ACTION_CONVERT_TO }, &sl_output, FORMAT(packed) };			qret = data_query(&d_data, &r_convert);						data_slider_t_set_offset(&sl_output, r_convert.transfered, SEEK_CUR);						if(qret < 0)				ret = qret;			break;					default:			return -ENOSYS;	}	if(fargs->header.nargs >= 5)		fargs->transfered = data_slider_t_get_offset(&sl_output);		return ret;} // }}}

static int mphf_init(backend_t *backend){ // {{{	mphf_userdata *userdata = backend->userdata = calloc(1, sizeof(mphf_userdata));	if(userdata == NULL)		return error("calloc failed");		userdata->input  = HK(key);	userdata->output = HK(offset);	return 0;} // }}}

static ssize_t try_handler(machine_t *machine, request_t *request){ // {{{	ssize_t               ret;	data_t                freeme;	request_t            *try_request;	try_userdata         *userdata          = (try_userdata *)machine->userdata;	try_threaddata       *threaddata        = thread_data_get(&userdata->thread_data);		threaddata->machine  = machine;	threaddata->request  = request;	threaddata->ret      = 0;		data_set_void(&freeme);		if(userdata->request == 0){		try_request = request;	}else{		if( (ret = get_hash(hash_data_find(request, userdata->request), &freeme, &try_request)) < 0)			return ret;	}		request_t r_next[] = {		{ userdata->return_to, DATA_MACHINET(userdata->try_end) },		hash_inline(try_request),		hash_end	};		fastcall_query r_query = { { 3, ACTION_QUERY }, r_next };	if( (ret = data_query(&userdata->machine, &r_query)) < 0){		if(userdata->request == 0){			request_t r_pass[] = {				{ HK(ret), DATA_PTR_SIZET(&ret) },				hash_inline(request),				hash_end			};			threaddata->ret = machine_pass(machine, r_pass);		}else{			request_t r_pass[] = {				{ HK(ret), DATA_PTR_SIZET(&ret) },				hash_inline(try_request),				hash_end			};						request_t r_next[] = {				{ HK(ret),               DATA_PTR_SIZET(&ret)   },				{ userdata->request_out, DATA_PTR_HASHT(r_pass) },				hash_inline(request),				hash_end			};			threaddata->ret = machine_pass(machine, r_next);		}	}		data_free(&freeme);	return threaddata->ret;} // }}}

static ssize_t murmur_configure(machine_t *machine, hash_t *config){ // {{{	ssize_t                ret;	murmur_userdata       *userdata          = (murmur_userdata *)machine->userdata;		hash_data_get(ret, TYPE_HASHKEYT, userdata->input,    config, HK(input));	hash_data_get(ret, TYPE_HASHKEYT, userdata->output,   config, HK(output));	hash_data_get(ret, TYPE_UINTT,    userdata->fatal,    config, HK(fatal));		userdata->fatal   = ( userdata->fatal == 0 ) ? 0 : 1;	return 0;} // }}}

ssize_t     action_pop_to_hash(void *userdata, fastcall_pop *fargs, f_fast_to_hash callback){ // {{{	if(fargs->data == NULL)		return -EINVAL;		request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(data),       *fargs->data                                         },		hash_end	};	return callback(userdata, r_next);} // }}}

static int tcp_configure(machine_t *machine, hash_t *config){ // {{{	ssize_t                ret;	tcp_userdata          *userdata          = (tcp_userdata *)machine->userdata;		hash_data_convert(ret, TYPE_STRINGT, userdata->tcp_addr, config, HK(addr));	hash_data_get    (ret, TYPE_UINTT,   userdata->tcp_port, config, HK(port));	hash_data_get    (ret, TYPE_HASHT,   userdata->machine,  config, HK(machine));		tcp_control_start(machine);	return 0;} // }}}

static int hashtable_configure(backend_t *backend, config_t *config){ // {{{	ssize_t                ret;	hashtable_userdata    *userdata        = (hashtable_userdata *)backend->userdata;		hash_data_copy(ret, TYPE_HASHKEYT, userdata->input,          config, HK(input));       	hash_data_copy(ret, TYPE_UINTT,    userdata->hashtable_size, config, HK(nelements));		if(userdata->hashtable_size == 0)		return error("invalid hashtable size");	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 morph_configure(machine_t *machine, config_t *config){ // {{{	ssize_t                ret;	morph_userdata      *userdata          = (morph_userdata *)machine->userdata;		hash_data_get    (ret, TYPE_UINTT, userdata->pass_first,     config, HK(pass_first));	hash_data_consume(ret, TYPE_HASHT, userdata->machine_config, config, HK(config));	if(ret != 0)		return error("HK(config) not supplied");		//userdata->running = 0; // calloc in init already set it	return 0;} // }}}

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 int lookup_configure(backend_t *backend, config_t *config){ // {{{	ssize_t                ret;	lookup_userdata       *userdata          = (lookup_userdata *)backend->userdata;		hash_data_copy(ret, TYPE_HASHKEYT,  userdata->output,        config, HK(output));	hash_data_copy(ret, TYPE_DATATYPET, userdata->output_type,   config, HK(output_type));	hash_data_copy(ret, TYPE_UINTT,     userdata->fatal,         config, HK(fatal));	hash_data_copy(ret, TYPE_UINTT,     userdata->force_query,   config, HK(force_query));	hash_data_copy(ret, TYPE_BACKENDT,  userdata->backend_index, config, HK(index));	if(ret != 0)		return error("supplied index backend not valid, or not found");		return 0;} // }}}

static ssize_t data_emitter_t_handler (data_t *data, fastcall_header *hargs) { // {{{    ssize_t                   ret            = 0;    emitter_t                *fdata          = (emitter_t *)data->ptr;    switch(hargs->action) {    case ACTION_CONVERT_FROM:        ;        hash_t                   *parameters;        fastcall_convert_from    *fargs            = (fastcall_convert_from *)hargs;        data_get(ret, TYPE_HASHT, parameters, fargs->src);        if(ret != 0)            return -EINVAL;        if(fdata == NULL) {            if( (data->ptr = fdata = calloc(1, sizeof(emitter_t))) == NULL)                return -ENOMEM;            fdata->allocated = 1;        }        hash_data_consume(ret, TYPE_MACHINET, fdata->machine, parameters, HK(machine));        hash_data_consume(ret, TYPE_HASHT,    fdata->request, parameters, HK(request));        if(fdata->machine != NULL && fdata->request != NULL)            break;        fdata->request = NULL;        ret = -EFAULT;    // fall    case ACTION_FREE:        if(fdata == NULL)            return -EFAULT;        shop_destroy(fdata->machine);        hash_free(fdata->request);        if(fdata->allocated)            free(data->ptr);        data->ptr = NULL;        break;    default:        if(fdata == NULL)            return -EFAULT;        return machine_query(fdata->machine, fdata->request);    }    return ret;} // }}}

ssize_t     action_io_to_hash(void *userdata, fastcall_io *fargs, f_fast_to_hash callback){ // {{{	ssize_t                ret;	request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(offset),     DATA_UINTT(      fargs->offset                     ) },		{ HK(buffer),     DATA_RAW(        fargs->buffer, fargs->buffer_size ) },		{ HK(size),       DATA_UINTT(      fargs->buffer_size                ) },		hash_end	};	ret = callback(userdata, r_next);	fargs->offset = DEREF_TYPE_UINTT(&r_next[1].data);	fargs->buffer_size = DEREF_TYPE_UINTT(&r_next[3].data);	return ret;} // }}}

ssize_t     action_length_to_hash(void *userdata, fastcall_length *fargs, f_fast_to_hash callback){ // {{{	ssize_t                ret;	format_t               format            = fargs->format;		request_t  r_next[] = {		{ HK(action),     DATA_PTR_ACTIONT( &fargs->header.action            ) },		{ HK(size),       DATA_UINTT(      fargs->length                     ) },		{ HK(format),     DATA_PTR_FORMATT( &format                          ) },		hash_end	};	ret = callback(userdata, r_next);	fargs->length = DEREF_TYPE_UINTT(&r_next[1].data);	return ret;} // }}}

static ssize_t data_env_t_alloc(data_t *data, fastcall_alloc *hargs){ // {{{	if( (data->ptr = malloc(sizeof(env_t))) == NULL)		return -ENOMEM;		((env_t *)data->ptr)->key = HK(input);	return 0;} // }}}

static int implode_configure(machine_t *machine, hash_t *config){ // {{{	ssize_t                ret;	implode_userdata      *userdata          = (implode_userdata *)machine->userdata;		hash_data_get(ret, TYPE_HASHKEYT, userdata->buffer,        config, HK(buffer));	return 0;} // }}}

static int null_configure(machine_t *machine, config_t *config){ // {{{	ssize_t                ret;	null_userdata         *userdata          = (null_userdata *)machine->userdata;		hash_data_get(ret, TYPE_UINTT, userdata->testparam, config, HK(test));	return 0;} // }}}

static ssize_t addrs_set(backend_t *chain, request_t *request){	ssize_t           ret;	uint32_t          r_block_vid, r_block_off, r_block_size, insert = 1;	addrs_userdata   *data = (addrs_userdata *)chain->userdata;		hash_data_copy(ret, TYPE_UINT32T, r_block_size, request, HK(block_size)); if(ret != 0) return error("no block_size supplied");	hash_data_copy(ret, TYPE_UINT32T, r_block_off,  request, HK(block_off));  if(ret != 0) insert = 0;	hash_data_copy(ret, TYPE_UINT32T, r_block_vid,  request, HK(block_vid));	if(ret != 0)		r_block_vid = tree_blocks_count(data->tree);		if(insert == 0){		return tree_resize_block(data->tree, r_block_vid, r_block_size);	}	return tree_insert(data->tree, r_block_vid, r_block_off, r_block_size);}