/**
* Update the priority for a particular key in the datastore. If
* the expiration time in value is different than the time found in
* the datastore, the higher value should be kept. For the
* anonymity level, the lower value is to be used. The specified
* priority should be added to the existing priority, ignoring the
* priority in value.
*
* @param cls our "struct Plugin*"
* @param uid unique identifier of the datum
* @param delta by how much should the priority
* change? If priority + delta < 0 the
* priority should be set to 0 (never go
* negative).
* @param expire new expiration time should be the
* MAX of any existing expiration time and
* this value
* @param msg set to error message
* @return GNUNET_OK on success
*/
static int
heap_plugin_update (void *cls,
uint64_t uid,
int delta,
struct GNUNET_TIME_Absolute expire, char **msg)
{
struct Plugin *plugin = cls;
struct Value *value;
value = (struct Value*) (long) uid;
GNUNET_assert (NULL != value);
if (value->expiration.abs_value != expire.abs_value)
{
value->expiration = expire;
GNUNET_CONTAINER_heap_update_cost (plugin->by_expiration,
value->expire_heap,
expire.abs_value);
}
if ( (delta < 0) && (value->priority < - delta) )
value->priority = 0;
else
value->priority += delta;
return GNUNET_OK;
}
static int
check ()
{
struct GNUNET_CONTAINER_Heap *myHeap;
struct GNUNET_CONTAINER_HeapNode *n1;
struct GNUNET_CONTAINER_HeapNode *n2;
struct GNUNET_CONTAINER_HeapNode *n3;
struct GNUNET_CONTAINER_HeapNode *n4;
struct GNUNET_CONTAINER_HeapNode *n5;
struct GNUNET_CONTAINER_HeapNode *n6;
struct GNUNET_CONTAINER_HeapNode *n7;
struct GNUNET_CONTAINER_HeapNode *n8;
const char *r;
myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
// GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch
n1 = GNUNET_CONTAINER_heap_remove_root (myHeap);
GNUNET_assert (NULL == n1);
// GNUNET_CONTAINER_heap_peek heap empty, taking if-branch
n1 = GNUNET_CONTAINER_heap_peek (myHeap);
GNUNET_assert (NULL == n1);
// GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch
n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_assert (NULL == n1);
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "11", 11);
GNUNET_assert (NULL != n1);
// GNUNET_CONTAINER_heap_peek not empty, taking if-branch
n2 = NULL;
n2 = GNUNET_CONTAINER_heap_peek (myHeap);
GNUNET_assert (NULL != n2);
// GNUNET_CONTAINER_heap_walk_get_next: 1 element
n1 = NULL;
n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_assert (NULL != n1);
GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78);
GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_assert (0 == strcmp ("78", GNUNET_CONTAINER_heap_remove_node (n2)));
GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "15", 5);
GNUNET_CONTAINER_heap_update_cost (myHeap, n3, 15);
GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
n4 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
GNUNET_CONTAINER_heap_update_cost (myHeap, n4, 50);
GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100);
n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30);
GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_remove_node (n5);
r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("11", r));
GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200);
GNUNET_CONTAINER_heap_remove_node (n3);
r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("50", r));
r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n6 */
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("30/200", r));
GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_destroy (myHeap);
// My additions to a complete testcase
// Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN
// Testing remove_node
myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
r = GNUNET_CONTAINER_heap_remove_node (n1);
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("10", r));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
r = GNUNET_CONTAINER_heap_remove_node (n2);
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("20", r));
r = GNUNET_CONTAINER_heap_remove_node (n1);
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("10", r));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
GNUNET_CONTAINER_heap_remove_node (n2);
GNUNET_CONTAINER_heap_remove_node (n1);
r = GNUNET_CONTAINER_heap_remove_root (myHeap);
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("30", r));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
GNUNET_CONTAINER_heap_remove_node (n2);
GNUNET_CONTAINER_heap_remove_node (n1);
r = GNUNET_CONTAINER_heap_remove_node (n3);
GNUNET_assert (NULL != r);
GNUNET_assert (0 == strcmp ("30", r));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
GNUNET_assert (0 ==
nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap)));
GNUNET_assert (0 ==
nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40);
n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60);
// Inserting nodes deeper in the tree with lower costs
n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
// Cleaning up...
GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
// Testing heap_walk_get_next
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);;
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
// End Testing remove_node
// Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX
GNUNET_CONTAINER_heap_destroy (myHeap);
myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
GNUNET_CONTAINER_heap_remove_node (n2);
GNUNET_CONTAINER_heap_remove_node (n1);
GNUNET_assert (0 ==
nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
GNUNET_CONTAINER_heap_remove_node (n2);
GNUNET_CONTAINER_heap_remove_node (n1);
GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40);
n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50);
n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60);
// Inserting nodes deeper in the tree with lower costs
n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
// Cleaning up...
GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
// Testing heap_walk_get_next
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);;
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_CONTAINER_heap_walk_get_next (myHeap);
GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
// End Testing remove_node
GNUNET_CONTAINER_heap_destroy (myHeap);
return 0;
}
