// -*- c++ -*-

 #ifndef LEMON_MAPPABLE_GRAPH_EXTENDER_H

 #define LEMON_MAPPABLE_GRAPH_EXTENDER_H

 namespace lemon {

   template <typename Base, template <class,class,class,class,class,class> class DynMap> 

   class MappableGraphExtender : public Base {

   public:

     typedef MappableGraphExtender Graph;

     typedef Base Parent;

     typedef typename Parent::Node Node;

     typedef typename Parent::NodeIt NodeIt;

     typedef typename Parent::NodeObserverRegistry NodeObserverRegistry;

     typedef typename Parent::Edge Edge;

     typedef typename Parent::EdgeIt EdgeIt;

     typedef typename Parent::EdgeObserverRegistry EdgeObserverRegistry;

   public:

     class NodeIdMap {

     private:

       const Graph* graph;

     public:

       NodeIdMap(const Graph& g) : graph(&g) {}

       int operator[](const Node& node) { return graph->id(node); }

       int maxId() const {return graph->maxNodeId(); }

     };

     //    template <typename Value>

     //    friend class DynMap<NodeObserverRegistry, Graph, Node, NodeIt,

     //		NodeIdMap, Value>;

     class EdgeIdMap {

     private:

       const Graph* graph;

     public:

       EdgeIdMap(const Graph& g) : graph(&g) {}

       int operator[](const Edge& edge) const { return graph->id(edge); }

       int maxId() const {return graph->maxEdgeId(); }

     };

     //    template <typename Value>

     //    friend class DynMap<EdgeObserverRegistry, Graph, Edge, EdgeIt,

     //		EdgeIdMap, Value>;

   public:

     template <typename Value>

     class NodeMap 

       : public DynMap<NodeObserverRegistry, Graph, Node, NodeIt,

 		      NodeIdMap, Value> {

     public:

       typedef DynMap<NodeObserverRegistry, Graph, Node, NodeIt,

 		     NodeIdMap, Value> Parent;

       NodeMap(const Graph& g) 

 	: Parent(g, g.Graph::Parent::getNodeObserverRegistry()) {}

       NodeMap(const Graph& g, const Value& v) 

 	: Parent(g, g.Graph::Parent::getNodeObserverRegistry(), v) {}

     };

     template <typename Value>

     class EdgeMap 

       : public DynMap<EdgeObserverRegistry, Graph, Edge, EdgeIt,

 		      EdgeIdMap, Value> {

     public:

       typedef DynMap<EdgeObserverRegistry, Graph, Edge, EdgeIt,

 		     EdgeIdMap, Value> Parent;

       EdgeMap(const Graph& g) 

 	: Parent(g, g.Graph::Parent::getEdgeObserverRegistry()) {}

       EdgeMap(const Graph& g, const Value& v) 

 	: Parent(g, g.Graph::Parent::getEdgeObserverRegistry(), v) {}

     };

   };

 }

 #endif