Index: src/hugo/map_defines.h
===================================================================
--- src/hugo/map_defines.h	(revision 877)
+++ src/hugo/map_defines.h	(revision 891)
@@ -39,19 +39,22 @@
 template <typename Value> \
 class NodeMap : public DynMap<NodeMapRegistry, Value> { \
-typedef DynMap<NodeMapRegistry, Value> MapImpl; \
-public: \
+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));\
-  return *this; \
-} \
-template <typename CMap> NodeMap& operator=(const CMap& copy) { \
-  MapImpl::operator=(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; \
 } \
@@ -67,19 +70,23 @@
 template <typename Value> \
 class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \
-typedef DynMap<EdgeMapRegistry, Value> MapImpl; \
-public: \
+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));\
-  return *this; \
-} \
-template <typename CMap> EdgeMap& operator=(const CMap& copy) { \
-  MapImpl::operator=(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; \
 } \
@@ -109,30 +116,27 @@
 template <typename Value> \
 class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \
-  typedef SymMap<DynMap, SymEdgeMapRegistry, Value> MapImpl; \
- public: \
-\
-  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; \
-  } \
-};
-
+public: \
+typedef SymMap<DynMap, SymEdgeMapRegistry, Value> Parent; \
+\
+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.
@@ -140,33 +144,28 @@
 #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() {} \
-\
-   NodeMap(const To& to) \
-     : MapImpl(static_cast<const From&>(from)) { } \
-\
-   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; \
-   } \
+class NodeMap : public From::template NodeMap<Value> { \
+\
+public: \
+typedef typename From::template NodeMap<Value> Parent; \
+\
+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; \
+} \
 };
 
@@ -175,33 +174,28 @@
 #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() {} \
-\
-   EdgeMap(const To& to) \
-     : MapImpl(static_cast<const From&>(from)) { } \
-\
-   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; \
-   } \
+class EdgeMap : public From::template EdgeMap<Value> { \
+\
+public: \
+typedef typename From::template EdgeMap<Value> Parent; \
+\
+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; \
+} \
 };
 
