RhodeCode

  // The simple graph's can be refered as two containers, one node container

  // and one edge container. But they are not standard containers they

  // does not store values directly they are just key continars for more

  // value containers which are the node and edge maps.

  // The graph's node and edge sets can be changed as we add or erase

  // in the library. We use another solution we notify all maps about

  // This class provides an interface to the container. The \e first() and \e

  // next() member functions make possible to iterate on the keys of the

  // container. The \e id() function returns an integer id for each key.

  // The \e maxId() function gives back an upper bound of the ids.

  // about each alteration in the container. The alterations have four type

  // as \e add(), \e erase(), \e build() and \e clear(). The \e add() and

  // \e erase() signals that only one or few items added or erased to or

  // from the graph. If all items are erased from the graph or from an empty

  // graph a new graph is builded then it can be signaled with the

  // from graph we should first signal the alteration and after that erase

  // \e ObserverBase nested class. The signals can be handled with

  // \e attach() member and can be detached with detach() function. The

  // Alteration observers try to be exception safe. If an \e add() or

  // a \e clear() function throws an exception then the remaining

  // be rolled back by calling the \e erase() or \e clear()

  // functions. Thence the \e erase() and \e clear() should not throw

  // exception. Actullay, it can be throw only \ref ImmediateDetach

  // exception which detach the observer from the notifier.

  // There are some place when the alteration observing is not completly

  // as in the \ref InDegMap and we use the reverseEdge that cause

  // only erasing and adding but not the reversing it will stores bad

  // degrees. The sub graph adaptors cannot signal the alterations because

  // just a setting in the filter map can modify the graph and this cannot

  // be watched in any way.

    // \brief Exception which can be called from \e clear() and

    // \e erase().

    // From the \e clear() and \e erase() function only this

    // \e clear() and \e erase() should not throw other exceptions

    // to notify the oberver when one item is added or

    // erased.

  // The ArrayMap template class is graph map structure what

  // automatically updates the map when a key is added to or erased from

  // the map. This map uses the allocators to implement

  // the container functionality.

  // The template parameters are the Graph the current Item type and

    // The graph type of the maps.

    // The item type of the map.

    // The key type of the maps.

    // It adds a new key to the map. It called by the observer notifier

    // It adds more new keys to the map. It called by the observer notifier

    // Erase a key from the map. It called by the observer notifier

    // Erase more keys from the map. It called by the observer notifier

    // \brief Buildes the map.

    // It buildes the map. It called by the observer notifier

    // It erase all items from the map. It called by the observer notifier

//\brief Extenders for the digraph types

//\brief Extenders for the digraph types

  // \brief Extender for the Digraphs

  // The VectorMap template class is graph map structure what

  // automatically updates the map when a key is added to or erased from

  // the map. This map type uses the std::vector to store the values.

    // It adds a new key to the map. It called by the observer notifier

    // It adds more new keys to the map. It called by the observer notifier

    // Erase a key from the map. It called by the observer notifier

    // Erase more keys from the map. It called by the observer notifier

    // \brief Buildes the map.

    // It buildes the map. It called by the observer notifier

    // It erase all items from the map. It called by the observer notifier