Spatial C++ Library
Generic MultiDimensional Containers and Spatial Operations

A Link Mode defines the relationship between a node and the links that bear the node.
It provides all necessary informations in order to get from the node to the link, and to access the key and value information contained in the link.
The important concept to understand is that the link is the type that aggregates the key, the value and the node. A tree is composed of a series of nodes all tied to their key and values through the link type.
There are multiple types of link in the library. Sometimes, the link derives from the node and the key and values are attributes. Other times, the value type is the link itself, and it contains the node as an attribute. This diversity explains why, in the tree algorithm, only the node is being used, and the key, the value or the link are only retreived on demand.
The models of LinkMode shall publicly provide the following interface:
Signature/Typedef  Description  
Legend  T  A model of Link Mode 
Require  typename T::link_type;  The link type which should be defined as Link. 
Require  typename T::key_type;  The key type in the link. 
Require  typename T::value_type;  The value type in the link. 
Require  typename T::link_ptr  A pointer to a mutable value of T::link_type . 
Require  typename T::const_link_ptr  A pointer to a contant value of T::link_type . 
Require  typename T::node_ptr  An alias to the type of Node<T>::ptr . 
Require  typename T::const_node_ptr  An alias to the type of Node<T>::const_ptr . 
Require  T::key_type& key(Node<T>&);  A function to return a T::key_type reference from a node must exists. 
Require  const T::key_type& const key(const Node<T>&);  A function to return a const T::key_type reference from a constant node must exists. 
Require  T::value_type& value(Node<T>&);  A function to return a T::value_type reference from a node must exists. 
Require  const T::value_type& value(const Node<T>&);  A function to return a const T::value_type reference from a constant node must exists. 
Require  T::link_type& link(Node<T>&);  A function to return a T::link_type from a node must exists. 
Require  const T::link_type& link(const Node<T>&);  A function to return a const T::link_type from a constant node must exists. 
Require  void swap(Node<T>&, Node<T>&);  A function to swap two instances of T::link_type must exists. 
This level of abstraction allows the same algorithms to be used for regular and intrusive containers, without loss of performance and without the use of an otherwise cumbersome syntax.