container_heap.c File Reference

Implementation of a heap. More...

#include "gnunet_common.h"
#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for container_heap.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_CONTAINER_HeapNode
	Node in the heap. More...
struct	GNUNET_CONTAINER_Heap
	Handle to a node in a heap. More...

Macros
#define	LOG(kind, ...)
#define	EXTRA_CHECKS   0
#define	CHECK(n)   do {} while (0)

Functions
struct GNUNET_CONTAINER_Heap *	GNUNET_CONTAINER_heap_create (enum GNUNET_CONTAINER_HeapOrder order)
	Create a new heap. More...
void	GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
	Destroys the heap. More...
void *	GNUNET_CONTAINER_heap_peek (const struct GNUNET_CONTAINER_Heap *heap)
	Get element stored at the root of heap. More...
enum GNUNET_GenericReturnValue	GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap *heap, void **element, GNUNET_CONTAINER_HeapCostType *cost)
	Get element and cost stored at the root of heap. More...
unsigned int	GNUNET_CONTAINER_heap_get_size (const struct GNUNET_CONTAINER_Heap *heap)
	Get the current size of the heap. More...
GNUNET_CONTAINER_HeapCostType	GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode *node)
	Get the current cost of the node. More...
static int	node_iterator (const struct GNUNET_CONTAINER_Heap *heap, struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
	Iterate over the children of the given node. More...
void	GNUNET_CONTAINER_heap_iterate (const struct GNUNET_CONTAINER_Heap *heap, GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
	Iterate over all entries in the heap. More...
void *	GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
	Perform a random walk of the tree. More...
static void	insert_node (struct GNUNET_CONTAINER_Heap *heap, struct GNUNET_CONTAINER_HeapNode *pos, struct GNUNET_CONTAINER_HeapNode *node)
	Insert the given node 'node' into the subtree starting at 'pos' (while keeping the tree somewhat balanced). More...
struct GNUNET_CONTAINER_HeapNode *	GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
	Inserts a new element into the heap. More...
void *	GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
	Remove root of the heap. More...
static void	remove_node (struct GNUNET_CONTAINER_HeapNode *node)
	Remove the given node 'node' from the tree and update the 'tree_size' fields accordingly. More...
void *	GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node)
	Removes a node from the heap. More...
void	GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
	Updates the cost of any node in the tree. More...

Detailed Description

Implementation of a heap.

Author

Nathan Evans

Christian Grothoff

Definition in file container_heap.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)

Value:

                                        GNUNET_log_from (kind, "util-container-heap", \
                                        __VA_ARGS__)

Definition at line 33 of file container_heap.c.

EXTRA_CHECKS

#define EXTRA_CHECKS   0

Definition at line 36 of file container_heap.c.

CHECK

#define CHECK

(

n

)

do {} while (0)

Definition at line 130 of file container_heap.c.

Function Documentation

node_iterator()

static int node_iterator ( const struct GNUNET_CONTAINER_Heap *  heap, struct GNUNET_CONTAINER_HeapNode *  node, GNUNET_CONTAINER_HeapIterator  iterator, void *  iterator_cls  )

static

Iterate over the children of the given node.

Parameters

heap	argument to give to iterator
node	node to iterate over
iterator	function to call on each node
iterator_cls	closure for iterator

Returns

GNUNET_YES to continue to iterate

Definition at line 211 of file container_heap.c.

{
  if (node == NULL)
    return GNUNET_YES;
  if (GNUNET_YES !=
      node_iterator (heap, node->left_child, iterator, iterator_cls))
    return GNUNET_NO;
  if (GNUNET_YES !=
      node_iterator (heap, node->right_child, iterator, iterator_cls))
    return GNUNET_NO;
  return iterator (iterator_cls, node, node->element, node->cost);
}

References GNUNET_CONTAINER_HeapNode::cost, GNUNET_CONTAINER_HeapNode::element, GNUNET_NO, GNUNET_YES, iterator(), GNUNET_CONTAINER_HeapNode::left_child, and GNUNET_CONTAINER_HeapNode::right_child.

Referenced by GNUNET_CONTAINER_heap_iterate().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_node()

static void insert_node ( struct GNUNET_CONTAINER_Heap *  heap, struct GNUNET_CONTAINER_HeapNode *  pos, struct GNUNET_CONTAINER_HeapNode *  node  )

static

Insert the given node 'node' into the subtree starting at 'pos' (while keeping the tree somewhat balanced).

Parameters

heap	heap to modify
pos	existing tree
node	node to insert (which may be a subtree itself)

Definition at line 265 of file container_heap.c.

{
  struct GNUNET_CONTAINER_HeapNode *parent;
 
  GNUNET_assert (node->parent == NULL);
  while ((heap->order == GNUNET_CONTAINER_HEAP_ORDER_MAX) ? (pos->cost >=
                                                             node->cost)
         : (pos->cost <= node->cost))
  {
    /* node is descendent of pos */
    pos->tree_size += (1 + node->tree_size);
    if (pos->left_child == NULL)
    {
      pos->left_child = node;
      node->parent = pos;
      return;
    }
    if (pos->right_child == NULL)
    {
      pos->right_child = node;
      node->parent = pos;
      return;
    }
    /* keep it balanced by descending into smaller subtree */
    if (pos->left_child->tree_size < pos->right_child->tree_size)
      pos = pos->left_child;
    else
      pos = pos->right_child;
  }
  /* make 'node' parent of 'pos' */
  parent = pos->parent;
  pos->parent = NULL;
  node->parent = parent;
  if (NULL == parent)
  {
    heap->root = node;
  }
  else
  {
    if (parent->left_child == pos)
      parent->left_child = node;
    else
      parent->right_child = node;
  }
  /* insert 'pos' below 'node' */
  insert_node (heap, node, pos);
  CHECK (pos);
}

References CHECK, GNUNET_CONTAINER_HeapNode::cost, GNUNET_assert, GNUNET_CONTAINER_HEAP_ORDER_MAX, GNUNET_CONTAINER_HeapNode::heap, GNUNET_CONTAINER_HeapNode::left_child, GNUNET_CONTAINER_Heap::order, GNUNET_CONTAINER_HeapNode::parent, GNUNET_CONTAINER_HeapNode::right_child, GNUNET_CONTAINER_Heap::root, and GNUNET_CONTAINER_HeapNode::tree_size.

Referenced by GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_heap_update_cost(), and remove_node().

Here is the caller graph for this function:

remove_node()

static void remove_node ( struct GNUNET_CONTAINER_HeapNode *  node )

static

Remove the given node 'node' from the tree and update the 'tree_size' fields accordingly.

Preserves the children of 'node' and does NOT change the overall 'size' field of the tree.

Definition at line 391 of file container_heap.c.

{
  struct GNUNET_CONTAINER_HeapNode *ancestor;
  struct GNUNET_CONTAINER_Heap *heap = node->heap;
 
  /* update 'size' of the ancestors */
  ancestor = node;
  while (NULL != (ancestor = ancestor->parent))
    ancestor->tree_size--;
 
  /* update 'size' of node itself */
  if (node->left_child != NULL)
    node->tree_size -= (1 + node->left_child->tree_size);
  if (node->right_child != NULL)
    node->tree_size -= (1 + node->right_child->tree_size);
 
  /* unlink 'node' itself and insert children in its place */
  if (node->parent == NULL)
  {
    if (node->left_child != NULL)
    {
      heap->root = node->left_child;
      node->left_child->parent = NULL;
      if (node->right_child != NULL)
      {
        node->right_child->parent = NULL;
        insert_node (heap, heap->root, node->right_child);
      }
    }
    else
    {
      heap->root = node->right_child;
      if (node->right_child != NULL)
        node->right_child->parent = NULL;
    }
  }
  else
  {
    if (node->parent->left_child == node)
      node->parent->left_child = NULL;
    else
      node->parent->right_child = NULL;
    if (node->left_child != NULL)
    {
      node->left_child->parent = NULL;
      node->parent->tree_size -= (1 + node->left_child->tree_size);
      insert_node (heap, node->parent, node->left_child);
    }
    if (node->right_child != NULL)
    {
      node->right_child->parent = NULL;
      node->parent->tree_size -= (1 + node->right_child->tree_size);
      insert_node (heap, node->parent, node->right_child);
    }
  }
  node->parent = NULL;
  node->left_child = NULL;
  node->right_child = NULL;
  GNUNET_assert (node->tree_size == 0);
  CHECK (heap->root);
}

References CHECK, GNUNET_assert, GNUNET_CONTAINER_HeapNode::heap, insert_node(), GNUNET_CONTAINER_HeapNode::left_child, GNUNET_CONTAINER_HeapNode::parent, GNUNET_CONTAINER_HeapNode::right_child, GNUNET_CONTAINER_Heap::root, and GNUNET_CONTAINER_HeapNode::tree_size.

Referenced by GNUNET_CONTAINER_heap_remove_node(), and GNUNET_CONTAINER_heap_update_cost().

Here is the call graph for this function:

Here is the caller graph for this function: