diff -r 3a48bc350e0f -r 74589d20dbc3 src/hugo/map_defines.h
--- a/src/hugo/map_defines.h	Mon Sep 20 17:53:33 2004 +0000
+++ b/src/hugo/map_defines.h	Mon Sep 20 22:57:48 2004 +0000
@@ -38,21 +38,24 @@
 #define CREATE_NODE_MAP(DynMap) \
 template <typename Value> \
 class NodeMap : public DynMap<NodeMapRegistry, Value> { \
-typedef DynMap<NodeMapRegistry, Value> MapImpl; \
 public: \
+typedef DynMap<NodeMapRegistry, Value> Parent; \
 NodeMap() {} \
-NodeMap(const typename MapImpl::Graph& g) \
-  : MapImpl(g, g.node_maps) {} \
-NodeMap(const typename MapImpl::Graph& g, const Value& v) \
-  : MapImpl(g, g.node_maps, v) {} \
-NodeMap(const NodeMap& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {} \
-template <typename CMap> NodeMap(const CMap& copy) : MapImpl(copy) {} \
+NodeMap(const typename Parent::Graph& g) \
+  : Parent(g, g.node_maps) {} \
+NodeMap(const typename Parent::Graph& g, const Value& v) \
+  : Parent(g, g.node_maps, v) {} \
+NodeMap(const NodeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
+template <typename TT> \
+NodeMap(const NodeMap<TT>& copy) \
+  : Parent(static_cast<const typename NodeMap<TT>::Parent&>(copy)) {} \
 NodeMap& operator=(const NodeMap& copy) { \
-  MapImpl::operator=(static_cast<const MapImpl&>(copy));\
+  Parent::operator=(static_cast<const Parent&>(copy));\
   return *this; \
 } \
-template <typename CMap> NodeMap& operator=(const CMap& copy) { \
-  MapImpl::operator=(copy);\
+template <typename TT> \
+NodeMap& operator=(const NodeMap<TT>& copy) { \
+  Parent::operator=(static_cast<const typename NodeMap<TT>::Parent&>(copy));\
   return *this; \
 } \
 };
@@ -66,21 +69,25 @@
 #define CREATE_EDGE_MAP(DynMap) \
 template <typename Value> \
 class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \
-typedef DynMap<EdgeMapRegistry, Value> MapImpl; \
 public: \
+typedef DynMap<EdgeMapRegistry, Value> Parent; \
+\
 EdgeMap() {} \
-EdgeMap(const typename MapImpl::Graph& g) \
-  : MapImpl(g, g.edge_maps) {} \
-EdgeMap(const typename MapImpl::Graph& g, const Value& v) \
-  : MapImpl(g, g.edge_maps, v) {} \
-EdgeMap(const EdgeMap& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {} \
-template <typename CMap> EdgeMap(const CMap& copy) : MapImpl(copy) {} \
+EdgeMap(const typename Parent::Graph& g) \
+  : Parent(g, g.edge_maps) {} \
+EdgeMap(const typename Parent::Graph& g, const Value& v) \
+  : Parent(g, g.edge_maps, v) {} \
+EdgeMap(const EdgeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
+template <typename TT> \
+EdgeMap(const EdgeMap<TT>& copy) \
+  : Parent(static_cast<const typename EdgeMap<TT>::Parent&>(copy)) {} \
 EdgeMap& operator=(const EdgeMap& copy) { \
-  MapImpl::operator=(static_cast<const MapImpl&>(copy));\
+  Parent::operator=(static_cast<const Parent&>(copy));\
   return *this; \
 } \
-template <typename CMap> EdgeMap& operator=(const CMap& copy) { \
-  MapImpl::operator=(copy);\
+template <typename TT> \
+EdgeMap& operator=(const EdgeMap<TT>& copy) { \
+  Parent::operator=(static_cast<const typename EdgeMap<TT>::Parent&>(copy));\
   return *this; \
 } \
 };
@@ -108,101 +115,88 @@
 #define CREATE_SYM_EDGE_MAP(DynMap) \
 template <typename Value> \
 class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \
-  typedef SymMap<DynMap, SymEdgeMapRegistry, Value> MapImpl; \
- public: \
+public: \
+typedef SymMap<DynMap, SymEdgeMapRegistry, Value> Parent; \
 \
-  SymEdgeMap() {} \
-\
-  SymEdgeMap(const typename MapImpl::Graph& g) \
-    : MapImpl(g, g.sym_edge_maps) {} \
-\
-  SymEdgeMap(const typename MapImpl::Graph& g, const Value& v) \
-    : MapImpl(g, g.sym_edge_maps, v) {} \
-\
-  SymEdgeMap(const SymEdgeMap& copy) \
-    : MapImpl(static_cast<const MapImpl&>(copy)) {} \
-\
-  template <typename CMap> SymEdgeMap(const CMap& copy) : MapImpl(copy) {} \
-  SymEdgeMap& operator=(const SymEdgeMap& copy) { \
-    MapImpl::operator=(static_cast<const MapImpl&>(copy));\
-    return *this; \
-  } \
-\
-  template <typename CMap> SymEdgeMap& operator=(const CMap& copy) { \
-    MapImpl::operator=(copy);\
-    return *this; \
-  } \
+SymEdgeMap() {} \
+SymEdgeMap(const typename Parent::Graph& g) \
+  : Parent(g, g.sym_edge_maps) {} \
+SymEdgeMap(const typename Parent::Graph& g, const Value& v) \
+  : Parent(g, g.sym_edge_maps, v) {} \
+SymEdgeMap(const SymEdgeMap& copy) \
+  : Parent(static_cast<const Parent&>(copy)) {} \
+template <typename TT> \
+SymEdgeMap(const NodeMap<TT>& copy) \
+  : Parent(static_cast<const typename SymEdgeMap<TT>::Parent&>(copy)) {} \
+SymEdgeMap& operator=(const SymEdgeMap& copy) { \
+  Parent::operator=(static_cast<const Parent&>(copy));\
+  return *this; \
+} \
+template <typename TT> \
+SymEdgeMap& operator=(const SymEdgeMap<TT>& copy) { \
+  Parent::operator=(static_cast<const typename SymEdgeMap<TT>::Parent&>(copy));\
+  return *this; \
+} \
 };
 
-
 /** This is a macro to import an node map into a graph class.
  */
 #define IMPORT_NODE_MAP(From, from, To, to) \
 template <typename Value> \
-class NodeMap \
-  : public From::template NodeMap<Value> { \
-  typedef typename From::template NodeMap<Value> MapImpl; \
- public: \
-   NodeMap() : MapImpl() {} \
+class NodeMap : public From::template NodeMap<Value> { \
 \
-   NodeMap(const To& to) \
-     : MapImpl(static_cast<const From&>(from)) { } \
+public: \
+typedef typename From::template NodeMap<Value> Parent; \
 \
-   NodeMap(const To& to, const Value& value) \
-     : MapImpl(static_cast<const From&>(from), value) { } \
-\
-   NodeMap(const NodeMap& copy) \
-     : MapImpl(static_cast<const MapImpl&>(copy)) {} \
-\
-   template<typename CMap> \
-   NodeMap(const CMap& copy) \
-     : MapImpl(copy) {} \
-\
-   NodeMap& operator=(const NodeMap& copy) { \
-     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
-     return *this; \
-   } \
-\
-   template <typename CMap> \
-   NodeMap& operator=(const CMap& copy) { \
-     MapImpl::operator=(copy); \
-     return *this; \
-   } \
+NodeMap() : Parent() {} \
+NodeMap(const To& to) \
+  : Parent(static_cast<const From&>(from)) { } \
+NodeMap(const To& to, const Value& value) \
+  : Parent(static_cast<const From&>(from), value) { } \
+NodeMap(const NodeMap& copy) \
+  : Parent(static_cast<const Parent&>(copy)) {} \
+template <typename TT> \
+NodeMap(const NodeMap<TT>& copy) \
+  : Parent(static_cast<const typename NodeMap<TT>::Parent&>(copy)) {} \
+NodeMap& operator=(const NodeMap& copy) { \
+  Parent::operator=(static_cast<const Parent&>(copy)); \
+  return *this; \
+} \
+template <typename TT> \
+NodeMap& operator=(const NodeMap<TT>& copy) { \
+  Parent::operator=(static_cast<const typename NodeMap<TT>::Parent&>(copy));\
+  return *this; \
+} \
 };
 
 /** This is a macro to import an edge map into a graph class.
  */
 #define IMPORT_EDGE_MAP(From, from, To, to) \
 template <typename Value> \
-class EdgeMap \
-  : public From::template EdgeMap<Value> { \
-  typedef typename From::template EdgeMap<Value> MapImpl; \
- public: \
-   EdgeMap() : MapImpl() {} \
+class EdgeMap : public From::template EdgeMap<Value> { \
 \
-   EdgeMap(const To& to) \
-     : MapImpl(static_cast<const From&>(from)) { } \
+public: \
+typedef typename From::template EdgeMap<Value> Parent; \
 \
-   EdgeMap(const To& to, const Value& value) \
-     : MapImpl(static_cast<const From&>(from), value) { } \
-\
-   EdgeMap(const EdgeMap& copy) \
-     : MapImpl(static_cast<const MapImpl&>(copy)) {} \
-\
-   template<typename CMap> \
-   EdgeMap(const CMap& copy) \
-     : MapImpl(copy) {} \
-\
-   EdgeMap& operator=(const EdgeMap& copy) { \
-     MapImpl::operator=(static_cast<const MapImpl&>(copy)); \
-     return *this; \
-   } \
-\
-   template <typename CMap> \
-   EdgeMap& operator=(const CMap& copy) { \
-     MapImpl::operator=(copy); \
-     return *this; \
-   } \
+EdgeMap() : Parent() {} \
+EdgeMap(const To& to) \
+  : Parent(static_cast<const From&>(from)) { } \
+EdgeMap(const To& to, const Value& value) \
+  : Parent(static_cast<const From&>(from), value) { } \
+EdgeMap(const EdgeMap& copy) \
+  : Parent(static_cast<const Parent&>(copy)) {} \
+template <typename TT> \
+EdgeMap(const EdgeMap<TT>& copy) \
+  : Parent(static_cast<const typename EdgeMap<TT>::Parent&>(copy)) {} \
+EdgeMap& operator=(const EdgeMap& copy) { \
+  Parent::operator=(static_cast<const Parent&>(copy)); \
+  return *this; \
+} \
+template <typename TT> \
+EdgeMap& operator=(const EdgeMap<TT>& copy) { \
+  Parent::operator=(static_cast<const typename EdgeMap<TT>::Parent&>(copy));\
+  return *this; \
+} \
 };
 
 #define KEEP_EDGE_MAP(From, To) \