GNUNET_memcpy (val->path_info,
put_ctx->path_info,
put_ctx->path_info_len * sizeof (struct GNUNET_PeerIdentity));
- GNUNET_CONTAINER_heap_update_cost (put_ctx->heap,
- val->hn,
+ GNUNET_CONTAINER_heap_update_cost (val->hn,
val->discard_time.abs_value_us);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Got same value for key %s and type %d (size %u vs %u)\n",
* The plugin.
*/
struct Plugin *plugin;
-
+
/**
* Requested value hash.
*/
* priority should be added to the existing priority, ignoring the
* priority in value.
*
- * @param cls our "struct Plugin*"
+ * @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
PluginUpdateCont cont,
void *cont_cls)
{
- struct Plugin *plugin = cls;
struct Value *value;
value = (struct Value*) (long) uid;
if (value->expiration.abs_value_us != expire.abs_value_us)
{
value->expiration = expire;
- GNUNET_CONTAINER_heap_update_cost (plugin->by_expiration,
- value->expire_heap,
+ GNUNET_CONTAINER_heap_update_cost (value->expire_heap,
expire.abs_value_us);
}
if ( (delta < 0) && (value->priority < - delta) )
return NULL;
/* Mark this connection as freshly used */
if (NULL == state_key)
- GNUNET_CONTAINER_heap_update_cost (connections_heap,
- state->specifics.tcp_udp.heap_node,
- GNUNET_TIME_absolute_get ().abs_value_us);
+ GNUNET_CONTAINER_heap_update_cost (state->specifics.tcp_udp.heap_node,
+ GNUNET_TIME_absolute_get ().abs_value_us);
return state;
}
* @return cost of the node
*/
GNUNET_CONTAINER_HeapCostType
-GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode
- *node);
+GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode *node);
+
/**
* @ingroup heap
* @ingroup heap
* Updates the cost of any node in the tree
*
- * @param heap heap to modify
* @param node node for which the cost is to be changed
* @param new_cost new cost for the node
*/
void
-GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_Heap *heap,
- struct GNUNET_CONTAINER_HeapNode *node,
+GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node,
GNUNET_CONTAINER_HeapCostType new_cost);
if (sizeof(struct IPv4UdpAddress) == addrlen)
{
struct sockaddr_in s4;
-
+
v4 = (const struct IPv4UdpAddress *) addr;
if (GNUNET_OK != check_port (plugin,
ntohs (v4->u4_port)))
#endif
s4.sin_port = v4->u4_port;
s4.sin_addr.s_addr = v4->ipv4_addr;
-
+
if (GNUNET_OK !=
GNUNET_NAT_test_address (plugin->nat,
&s4,
msg))
{
/* keep this 'rc' from expiring */
- GNUNET_CONTAINER_heap_update_cost (plugin->defrag_ctxs,
- d_ctx->hnode,
+ GNUNET_CONTAINER_heap_update_cost (d_ctx->hnode,
(GNUNET_CONTAINER_HeapCostType) now.abs_value_us);
}
if (GNUNET_CONTAINER_heap_get_size (plugin->defrag_ctxs) >
{
struct Plugin *plugin = cls;
const struct GNUNET_SCHEDULER_TaskContext *tc;
-
+
plugin->select_task_v4 = NULL;
if (NULL == plugin->sockv4)
return;
/**
* Updates the cost of any node in the tree
*
- * @param heap heap to modify
* @param node node for which the cost is to be changed
* @param new_cost new cost for the node
*/
void
-GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_Heap *heap,
- struct GNUNET_CONTAINER_HeapNode *node,
+GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node,
GNUNET_CONTAINER_HeapCostType new_cost)
{
-#if EXTRA_CHECKS
- GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
- (heap->size == heap->root->tree_size + 1));
- CHECK (heap->root);
-#endif
+ struct GNUNET_CONTAINER_Heap *heap = node->heap;
+
remove_node (node);
-#if EXTRA_CHECKS
- CHECK (heap->root);
- GNUNET_assert (((heap->size == 1) && (heap->root == NULL)) ||
- (heap->size == heap->root->tree_size + 2));
-#endif
node->cost = new_cost;
- if (heap->root == NULL)
+ if (NULL == heap->root)
heap->root = node;
else
- insert_node (heap, heap->root, node);
-#if EXTRA_CHECKS
- CHECK (heap->root);
- GNUNET_assert (((heap->size == 0) && (heap->root == NULL)) ||
- (heap->size == heap->root->tree_size + 1));
-#endif
+ insert_node (heap,
+ heap->root,
+ node);
}
#include "gnunet_util_lib.h"
static int
-iterator_callback (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
+iterator_callback (void *cls,
+ struct GNUNET_CONTAINER_HeapNode *node,
void *element, GNUNET_CONTAINER_HeapCostType cost)
{
return GNUNET_OK;
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_CONTAINER_heap_update_cost (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_CONTAINER_heap_update_cost (n4, 50);
GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap));
GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
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_update_cost (n6, 200);
GNUNET_CONTAINER_heap_remove_node (n3);
r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */
GNUNET_assert (NULL != r);
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);
+ GNUNET_CONTAINER_heap_update_cost (n1, 15);
r = GNUNET_CONTAINER_heap_remove_node (n1);
GNUNET_assert (NULL != r);
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_CONTAINER_heap_update_cost (n1, 15);
GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
}
else
{
- GNUNET_CONTAINER_heap_update_cost (channel_heap,
- ts->heap_node,
+ GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
}
if (NULL == ts->channel)
default:
GNUNET_assert (0);
}
- GNUNET_CONTAINER_heap_update_cost (channel_heap,
- ts->heap_node,
+ GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
default:
GNUNET_assert (0);
}
- GNUNET_CONTAINER_heap_update_cost (channel_heap,
- ts->heap_node,
+ GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
break;
}
- GNUNET_CONTAINER_heap_update_cost (channel_heap,
- ts->heap_node,
+ GNUNET_CONTAINER_heap_update_cost (ts->heap_node,
GNUNET_TIME_absolute_get ().abs_value_us);
GNUNET_CADET_receive_done (channel);
return GNUNET_OK;