class RefTrieNode

RefTrieNode definition. More...

Definition#include <ref_trie.hh>
Template formRefTrieNode<class A, class Payload>
List of all Methods
Annotated List
Files
Globals
Hierarchy
Index

Public Types

Public Methods

Public Static Methods


Detailed Description

RefTrieNode's are the elements of a RefTrie. Each node is associated to a Key and possibly a Payload. Nodes with a Payload ("full") can have 0, 1 or 2 children. Nodes without a Payload ("empty") can only be internal nodes, and MUST have 2 children (or they have no reason to exist).

Children have a Key which is strictly contained in their parent's Key -- more precisely, they are in either the left or the right half of the parent's Key. The branch to which a child is attached (left or right) is defined accordingly.

typedef IPNet<A> Key

Key

typedef MiniTraits<Payload>::NonConst PPayload

PPayload

 RefTrieNode ()

RefTrieNode

Constructors

 RefTrieNode (const Key& key, const Payload& p, RefTrieNode* up = 0)

RefTrieNode

 RefTrieNode (const Key& key, RefTrieNode* up = 0)

RefTrieNode

 ~RefTrieNode ()

~RefTrieNode

RefTrieNodeinsert (RefTrieNode **root, const Key& key, const Payload& p, bool& replaced)

insert

[static]

add a node to a subtree

Returns: a pointer to the node.

RefTrieNodeerase ()

erase

erase current node, replumb. Returns the new root.

RefTrieNodefind (const Key& key)

find

main search routine. Given a key, returns a node.

const RefTrieNodeconst_find (const Key& key)

const_find

[const]

RefTrieNodefind_subtree (const Key &key)

find_subtree

aux search routine. Given a key, returns a subtree contained in the key, irrespective of the presence of a payload in the node.

RefTrieNode*  lower_bound (const Key &key)

lower_bound

Given a key, find the node with that key and a payload. If the next doesn't exist or does not have a payload, find the next node in the iterator sequence. XXX check the description.

RefTrieNode*  get_left ()

get_left

RefTrieNode*  get_right ()

get_right

RefTrieNode*  get_parent ()

get_parent

bool  has_payload ()

has_payload

[const]

bool  has_active_payload ()

has_active_payload

[const]

const Payload & const_p ()

const_p

[const]

Payload & p ()

p

void  set_payload (const Payload& p)

set_payload

uint32_t  references ()

references

[const]

void  incr_refcount ()

incr_refcount

void  decr_refcount ()

decr_refcount

bool  deleted ()

deleted

[const]

const Key & k ()

k

[const]

void  print (int indent, const char *msg)

print

[const]

string  str ()

str

[const]

void  delete_subtree ()

delete_subtree

helper function to delete an entire subtree (including the root).

void  validate (const RefTrieNode *parent)

validate

[const]

debugging, validates a node by checking pointers and Key invariants.

bool  is_left ()

is_left

[const]

Returns: the leftmost node under this node

RefTrieNodeleftmost ()

leftmost

void  find_bounds (const A& a, A &lo, A &hi)

find_bounds

[const]

Algorithm:


		n = find(a);
 		if we have no route (hence no default), provide a fake 0/0;
		set lo and hi to the boundaries of the current node.

 if n.is_a_leaf() we are done (results are the extremes of the entry)
 Otherwise: we are in an intermediate node, and a can be in positions
 1..5 if the node has 2 children, or 1'..3' if it has 1 child.

	n:		|---------------.----------------|
  a:                1    2        3      4     5
                       |--X--|         |--Y--|

  a:                1'    2'        3'
                       |--X--|

 Behaviour is the following:
  case 1 and 1':	lo already set, hi = (lowest address in X)-1
  case 2 and 2': set n = X and repeat
  case 3: lo = (highest addr in X)+1, hi = (lowest addr in Y)-1
  case 3': lo = (highest addr in X)+1, hi is already set
  case 4: set n = Y and repeat
  case 5:	lo = (highest addr in Y)+1, hi is already set

Returns: the boundaries ("lo" and "hi") of the largest range that contains 'a' and maps to the same route entry.

A  low ()

low

[const]

Returns: the lowest address in a subtree which has a route. Search starting from left or right until a full node is found.

A  high ()

high

[const]

Returns: the highest address in a subtree which has a route. Search starting from right or left until a full node is found.


Generated by: pavlin on possum.icir.org on Thu Nov 6 23:46:46 2003, using kdoc 2.0a54+XORP.