int
binheap_walk(binheap_t *bh, binheap_walk_callback_t cb, void *priv)
{
int cnt = 0;
int i;
for (i = 0; i < list_count(bh->trees); i++) {
binomial_tree_node_t *curtree = list_pick_value(bh->trees, i);
if (!binomial_tree_walk(curtree, &cnt, cb, priv))
break;
}
return cnt;
}
int
binheap_delete(binheap_t *bh, void *key, size_t klen, void **value)
{
binomial_tree_node_t *tree = NULL;
int i;
for (i = 0; i < list_count(bh->trees); i++) {
binomial_tree_node_t *cur_tree = list_pick_value(bh->trees, i);
if (HAS_PRECEDENCE(bh, cur_tree->key, cur_tree->klen, key, klen)) {
if (tree) {
if (HAS_PRECEDENCE(bh, tree->key, tree->klen, cur_tree->key, cur_tree->klen)) {
tree = cur_tree;
}
} else {
tree = cur_tree;
}
}
}
binomial_tree_node_t *to_delete = tree;
while(to_delete && bh->cbs->cmp(to_delete->key, to_delete->klen, key, klen) != 0)
{
binomial_tree_node_t *next_tree = NULL;
for (i = 0; i < to_delete->num_children; i++) {
binomial_tree_node_t *child = to_delete->children[i];
if (HAS_PRECEDENCE(bh, child->key, child->klen, key, klen)) {
if (next_tree) {
if (HAS_PRECEDENCE(bh, next_tree->key, next_tree->klen, child->key, child->klen)) {
next_tree = child;
}
} else {
next_tree = child;
}
}
}
if (next_tree) {
to_delete = next_tree;
} else {
to_delete = NULL;
}
}
if (to_delete) {
if (value)
*value = to_delete->value;
binomial_tree_node_destroy(to_delete, 0);
return 0;
}
return -1;
}
static inline shc_multi_ctx_t *
shc_multi_context_create(shardcache_client_t *c,
shardcache_hdr_t cmd,
char *peer,
char *secret,
linked_list_t *items,
uint32_t *total_count,
int (*cb)(shc_multi_ctx_t *, int ),
void *priv)
{
shc_multi_ctx_t *ctx = calloc(1, sizeof(shc_multi_ctx_t));
ctx->client = c;
ctx->commands = fbuf_create(0);
ctx->num_requests = list_count(items);
ctx->items = calloc(1, sizeof(shc_multi_item_t *) * (ctx->num_requests+1));
ctx->reader = async_read_context_create(secret, shc_multi_collect_data, ctx);
ctx->cmd = cmd;
ctx->peer = peer;
ctx->total_count = total_count;
ctx->cb = cb;
ctx->priv = priv;
int n;
for (n = 0; n < ctx->num_requests; n++) {
shc_multi_item_t *item = list_pick_value(items, n);
ctx->items[n] = item;
shardcache_record_t record[3] = {
{
.v = item->key,
.l = item->klen
},
{
.v = NULL,
.l = 0
},
{
.v = NULL,
.l = 0
}
};
static binomial_tree_node_t *
__binheap_maxmin(binheap_t *bh, uint32_t *index, int maxmin)
{
int i;
binomial_tree_node_t *node = NULL;
for (i = 0; i < list_count(bh->trees); i ++) {
binomial_tree_node_t *curtree = list_pick_value(bh->trees, i);
if (!node) {
node = curtree;
if (index)
*index = i;
continue;
}
int is_bigger = (bh->cbs->cmp(curtree->key, curtree->klen, node->key, node->klen) >= 0);
if ((maxmin == 0 && is_bigger) || (maxmin != 0 && !is_bigger))
{
node = curtree;
if (index)
*index = i;
}
}
return node;
}
tagged_value_t *
list_pick_tagged_value(linked_list_t *list, size_t pos)
{
return (tagged_value_t *)list_pick_value(list, pos);
}
