lemon-0.x: comparison lemon/graph

equal deleted inserted replaced

-:2afbf0cc0b42
+:d4f1db41e646
 #define UGRAPH_TYPEDEFS(Graph)				\
 GRAPH_TYPEDEFS(Graph)						\
 typedef Graph:: UEdge   UEdge;			\
 typedef Graph:: UEdgeIt UEdgeIt;			\
 typedef Graph:: IncEdgeIt   IncEdgeIt;
-//     typedef Graph::template UEdgeMap<bool> BoolUEdgeMap;
-//     typedef Graph::template UEdgeMap<int> IntUEdgeMap;
-//     typedef Graph::template UEdgeMap<double> DoubleUEdgeMap;
 ///\brief Creates convenience typedefs for the bipartite undirected graph
 ///types and iterators
 ///This \c \#define creates the same convenience typedefs as defined by
 ///
 ///\warning There are no typedefs for the graph maps because of the lack of
 ///template typedefs in C++.
 #define BPUGRAPH_TYPEDEFS(Graph)            \
 UGRAPH_TYPEDEFS(Graph)                    \
+typedef Graph::ANode ANode;             \
+typedef Graph::BNode BNode;             \
 typedef Graph::ANodeIt ANodeIt;	    \
 typedef Graph::BNodeIt BNodeIt;
 /// \brief Function to count the items in the graph.
 ///
 ///
 ///\sa EdgeLookUp
 ///\se AllEdgeLookup
 ///\sa ConEdgeIt
 template <typename Graph>
-inline typename Graph::Edge findEdge(const Graph &g,
+inline typename Graph::Edge
-				       typename Graph::Node u,
+findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
-				       typename Graph::Node v,
+typename Graph::Edge prev = INVALID) {
-				       typename Graph::Edge prev = INVALID) {
 return _graph_utils_bits::FindEdgeSelector<Graph>::find(g, u, v, prev);
 }
 /// \brief Iterator for iterating on edges connected the same nodes.
 ///
 ///\endcode
 ///
 ///\sa ConEdgeIt
 template <typename Graph>
-inline typename Graph::UEdge findUEdge(const Graph &g,
+inline typename Graph::UEdge
-typename Graph::Node u,
+findUEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
-typename Graph::Node v,
+typename Graph::UEdge p = INVALID) {
-typename Graph::UEdge p = INVALID) {
 return _graph_utils_bits::FindUEdgeSelector<Graph>::find(g, u, v, p);
 }
 /// \brief Iterator for iterating on uedges connected the same nodes.
 ///
 for (; it != INVALID; ++it) {
 target[it] = source[it];
 }
 }
+namespace _graph_utils_bits {
+template <typename Graph, typename Item, typename RefMap>
+class MapCopyBase {
+public:
+virtual void copy(const Graph& source, const RefMap& refMap) = 0;
+virtual ~MapCopyBase() {}
+};
+template <typename Graph, typename Item, typename RefMap,
+typename TargetMap, typename SourceMap>
+class MapCopy : public MapCopyBase<Graph, Item, RefMap> {
+public:
+MapCopy(TargetMap& tmap, const SourceMap& map)
+: _tmap(tmap), _map(map) {}
+virtual void copy(const Graph& graph, const RefMap& refMap) {
+typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;
+for (ItemIt it(graph); it != INVALID; ++it) {
+_tmap.set(refMap[it], _map[it]);
+}
+}
+private:
+TargetMap& _tmap;
+const SourceMap& _map;
+};
+template <typename Graph, typename Item, typename RefMap, typename Ref>
+class RefCopy : public MapCopyBase<Graph, Item, RefMap> {
+public:
+RefCopy(Ref& map) : _map(map) {}
+virtual void copy(const Graph& graph, const RefMap& refMap) {
+typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;
+for (ItemIt it(graph); it != INVALID; ++it) {
+_map.set(it, refMap[it]);
+}
+}
+private:
+Ref& _map;
+};
+template <typename Graph, typename Item, typename RefMap,
+typename CrossRef>
+class CrossRefCopy : public MapCopyBase<Graph, Item, RefMap> {
+public:
+CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
+virtual void copy(const Graph& graph, const RefMap& refMap) {
+typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;
+for (ItemIt it(graph); it != INVALID; ++it) {
+_cmap.set(refMap[it], it);
+}
+}
+private:
+CrossRef& _cmap;
+};
+}
 /// \brief Class to copy a graph.
 ///
 /// Class to copy a graph to another graph (duplicate a graph). The
 /// simplest way of using it is through the \c copyGraph() function.
 template <typename Target, typename Source>
 class GraphCopy {
-public:
+private:
 typedef typename Source::Node Node;
 typedef typename Source::NodeIt NodeIt;
 typedef typename Source::Edge Edge;
 typedef typename Source::EdgeIt EdgeIt;
-typedef typename Source::template NodeMap<typename Target::Node>NodeRefMap;
+typedef typename Target::Node TNode;
-typedef typename Source::template EdgeMap<typename Target::Edge>EdgeRefMap;
+typedef typename Target::Edge TEdge;
+typedef typename Source::template NodeMap<TNode> NodeRefMap;
+typedef typename Source::template EdgeMap<TEdge> EdgeRefMap;
+public:
 /// \brief Constructor for the GraphCopy.
 ///
 /// It copies the content of the \c _source graph into the
-/// \c _target graph. It creates also two references, one beetween
+/// \c _target graph.
-/// the two nodeset and one beetween the two edgesets.
 GraphCopy(Target& _target, const Source& _source)
-: source(_source), target(_target),
+: source(_source), target(_target) {}
-	nodeRefMap(_source), edgeRefMap(_source) {
-for (NodeIt it(source); it != INVALID; ++it) {
+/// \brief Destructor of the GraphCopy
-	nodeRefMap[it] = target.addNode();
+///
-}
+/// Destructor of the GraphCopy
-for (EdgeIt it(source); it != INVALID; ++it) {
+~GraphCopy() {
-	edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
+for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
-					nodeRefMap[source.target(it)]);
+delete nodeMapCopies[i];
 }
+for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
+delete edgeMapCopies[i];
+}
 }
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
-const GraphCopy& nodeRef(NodeRef& map) const {
+GraphCopy& nodeRef(NodeRef& map) {
-for (NodeIt it(source); it != INVALID; ++it) {
+nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
-	map.set(it, nodeRefMap[it]);
+NodeRefMap, NodeRef>(map));
-}
 return *this;
 }
 /// \brief Reverse and copies the node references into the given map.
 ///
 /// Reverse and copies the node references into the given map.
-template <typename NodeRef>
+template <typename NodeCrossRef>
-const GraphCopy& nodeCrossRef(NodeRef& map) const {
+GraphCopy& nodeCrossRef(NodeCrossRef& map) {
-for (NodeIt it(source); it != INVALID; ++it) {
+nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
-	map.set(nodeRefMap[it], it);
+NodeRefMap, NodeCrossRef>(map));
-}
-return *this;
-}
-/// \brief Copies the edge references into the given map.
-///
-/// Copies the edge references into the given map.
-template <typename EdgeRef>
-const GraphCopy& edgeRef(EdgeRef& map) const {
-for (EdgeIt it(source); it != INVALID; ++it) {
-	map.set(it, edgeRefMap[it]);
-}
-return *this;
-}
-/// \brief Reverse and copies the edge references into the given map.
-///
-/// Reverse and copies the edge references into the given map.
-template <typename EdgeRef>
-const GraphCopy& edgeCrossRef(EdgeRef& map) const {
-for (EdgeIt it(source); it != INVALID; ++it) {
-	map.set(edgeRefMap[it], it);
-}
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the target graph's node type,
 /// and the copied map's key type is the source graph's node
 /// type.
 template <typename TargetMap, typename SourceMap>
-const GraphCopy& nodeMap(TargetMap& tMap, const SourceMap& sMap) const {
+GraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
-copyMap(tMap, sMap, NodeIt(source), nodeRefMap);
+nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
+NodeRefMap, TargetMap, SourceMap>(tmap, map));
+return *this;
+}
+/// \brief Copies the edge references into the given map.
+///
+/// Copies the edge references into the given map.
+template <typename EdgeRef>
+GraphCopy& edgeRef(EdgeRef& map) {
+edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
+EdgeRefMap, EdgeRef>(map));
+return *this;
+}
+/// \brief Reverse and copies the edge references into the given map.
+///
+/// Reverse and copies the edge references into the given map.
+template <typename EdgeCrossRef>
+GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
+edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+EdgeRefMap, EdgeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the target graph's edge type,
 /// and the copied map's key type is the source graph's edge
 /// type.
 template <typename TargetMap, typename SourceMap>
-const GraphCopy& edgeMap(TargetMap& tMap, const SourceMap& sMap) const {
+GraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
-copyMap(tMap, sMap, EdgeIt(source), edgeRefMap);
+edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
+EdgeRefMap, TargetMap, SourceMap>(tmap, map));
 return *this;
 }
-/// \brief Gives back the stored node references.
+/// \brief Executes the copies.
 ///
-/// Gives back the stored node references.
+/// Executes the copies.
-const NodeRefMap& nodeRef() const {
+void run() {
-return nodeRefMap;
+NodeRefMap nodeRefMap(source);
-}
+for (NodeIt it(source); it != INVALID; ++it) {
+	nodeRefMap[it] = target.addNode();
-/// \brief Gives back the stored edge references.
+}
-///
+for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
-/// Gives back the stored edge references.
+nodeMapCopies[i]->copy(source, nodeRefMap);
-const EdgeRefMap& edgeRef() const {
+}
-return edgeRefMap;
+EdgeRefMap edgeRefMap(source);
-}
+for (EdgeIt it(source); it != INVALID; ++it) {
+	edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
-void run() const {}
+					nodeRefMap[source.target(it)]);
+}
+for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
+edgeMapCopies[i]->copy(source, edgeRefMap);
+}
+}
 private:
 const Source& source;
 Target& target;
-NodeRefMap nodeRefMap;
+std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
-EdgeRefMap edgeRefMap;
+nodeMapCopies;
+std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
+edgeMapCopies;
 };
 /// \brief Copy a graph to another graph.
 ///
 /// Copy a graph to another graph.
 /// The usage of the function:
 ///
 ///\code
-/// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
+/// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr).run();
 ///\endcode
 ///
 /// After the copy the \c nr map will contain the mapping from the
 /// source graph's nodes to the target graph's nodes and the \c ecr will
 /// contain the mapping from the target graph's edges to the source's
 ///
 /// Class to copy an undirected graph to another graph (duplicate a graph).
 /// The simplest way of using it is through the \c copyUGraph() function.
 template <typename Target, typename Source>
 class UGraphCopy {
-public:
+private:
 typedef typename Source::Node Node;
 typedef typename Source::NodeIt NodeIt;
 typedef typename Source::Edge Edge;
 typedef typename Source::EdgeIt EdgeIt;
 typedef typename Source::UEdge UEdge;
 typedef typename Source::UEdgeIt UEdgeIt;
-typedef typename Source::
+typedef typename Target::Node TNode;
-template NodeMap<typename Target::Node> NodeRefMap;
+typedef typename Target::Edge TEdge;
+typedef typename Target::UEdge TUEdge;
-typedef typename Source::
-template UEdgeMap<typename Target::UEdge> UEdgeRefMap;
+typedef typename Source::template NodeMap<TNode> NodeRefMap;
+typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
-private:
 struct EdgeRefMap {
-EdgeRefMap(UGraphCopy& _gc) : gc(_gc) {}
+EdgeRefMap(const Target& _target, const Source& _source,
+const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref)
+: target(_target), source(_source),
+uedge_ref(_uedge_ref), node_ref(_node_ref) {}
 typedef typename Source::Edge Key;
 typedef typename Target::Edge Value;
-Value operator[](const Key& key) {
+Value operator[](const Key& key) const {
-	return gc.target.direct(gc.uEdgeRef[key],
+bool forward = (source.direction(key) ==
-				gc.target.direction(key));
+(node_ref[source.source((UEdge)key)] ==
+target.source(uedge_ref[(UEdge)key])));
+	return target.direct(uedge_ref[key], forward);
 }
-UGraphCopy& gc;
+const Target& target;
+const Source& source;
+const UEdgeRefMap& uedge_ref;
+const NodeRefMap& node_ref;
 };
-public:
+public:
-/// \brief Constructor for the UGraphCopy.
+/// \brief Constructor for the GraphCopy.
 ///
 /// It copies the content of the \c _source graph into the
-/// \c _target graph. It creates also two references, one beetween
+/// \c _target graph.
-/// the two nodeset and one beetween the two edgesets.
 UGraphCopy(Target& _target, const Source& _source)
-: source(_source), target(_target),
+: source(_source), target(_target) {}
-	nodeRefMap(_source), edgeRefMap(*this), uEdgeRefMap(_source) {
-for (NodeIt it(source); it != INVALID; ++it) {
+/// \brief Destructor of the GraphCopy
-	nodeRefMap[it] = target.addNode();
+///
-}
+/// Destructor of the GraphCopy
-for (UEdgeIt it(source); it != INVALID; ++it) {
+~UGraphCopy() {
-	uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
+for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
-					nodeRefMap[source.target(it)]);
+delete nodeMapCopies[i];
 }
+for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
+delete edgeMapCopies[i];
+}
+for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
+delete uEdgeMapCopies[i];
+}
 }
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
-const UGraphCopy& nodeRef(NodeRef& map) const {
+UGraphCopy& nodeRef(NodeRef& map) {
-for (NodeIt it(source); it != INVALID; ++it) {
+nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
-	map.set(it, nodeRefMap[it]);
+NodeRefMap, NodeRef>(map));
-}
 return *this;
 }
 /// \brief Reverse and copies the node references into the given map.
 ///
 /// Reverse and copies the node references into the given map.
-template <typename NodeRef>
+template <typename NodeCrossRef>
-const UGraphCopy& nodeCrossRef(NodeRef& map) const {
+UGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-for (NodeIt it(source); it != INVALID; ++it) {
+nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
-	map.set(nodeRefMap[it], it);
+NodeRefMap, NodeCrossRef>(map));
-}
-return *this;
-}
-/// \brief Copies the edge references into the given map.
-///
-/// Copies the edge references into the given map.
-template <typename EdgeRef>
-const UGraphCopy& edgeRef(EdgeRef& map) const {
-for (EdgeIt it(source); it != INVALID; ++it) {
-	map.set(edgeRefMap[it], it);
-}
-return *this;
-}
-/// \brief Reverse and copies the undirected edge references into the
-/// given map.
-///
-/// Reverse and copies the undirected edge references into the given map.
-template <typename EdgeRef>
-const UGraphCopy& edgeCrossRef(EdgeRef& map) const {
-for (EdgeIt it(source); it != INVALID; ++it) {
-	map.set(it, edgeRefMap[it]);
-}
-return *this;
-}
-/// \brief Copies the undirected edge references into the given map.
-///
-/// Copies the undirected edge references into the given map.
-template <typename EdgeRef>
-const UGraphCopy& uEdgeRef(EdgeRef& map) const {
-for (UEdgeIt it(source); it != INVALID; ++it) {
-	map.set(it, uEdgeRefMap[it]);
-}
-return *this;
-}
-/// \brief Reverse and copies the undirected edge references into the
-/// given map.
-///
-/// Reverse and copies the undirected edge references into the given map.
-template <typename EdgeRef>
-const UGraphCopy& uEdgeCrossRef(EdgeRef& map) const {
-for (UEdgeIt it(source); it != INVALID; ++it) {
-	map.set(uEdgeRefMap[it], it);
-}
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the target graph's node type,
 /// and the copied map's key type is the source graph's node
 /// type.
 template <typename TargetMap, typename SourceMap>
-const UGraphCopy& nodeMap(TargetMap& tMap,
+UGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
-				  const SourceMap& sMap) const {
+nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
-copyMap(tMap, sMap, NodeIt(source), nodeRefMap);
+NodeRefMap, TargetMap, SourceMap>(tmap, map));
+return *this;
+}
+/// \brief Copies the edge references into the given map.
+///
+/// Copies the edge references into the given map.
+template <typename EdgeRef>
+UGraphCopy& edgeRef(EdgeRef& map) {
+edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
+EdgeRefMap, EdgeRef>(map));
+return *this;
+}
+/// \brief Reverse and copies the edge references into the given map.
+///
+/// Reverse and copies the edge references into the given map.
+template <typename EdgeCrossRef>
+UGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
+edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+EdgeRefMap, EdgeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the target graph's edge type,
 /// and the copied map's key type is the source graph's edge
 /// type.
 template <typename TargetMap, typename SourceMap>
-const UGraphCopy& edgeMap(TargetMap& tMap,
+UGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
-				  const SourceMap& sMap) const {
+edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
-copyMap(tMap, sMap, EdgeIt(source), edgeRefMap);
+EdgeRefMap, TargetMap, SourceMap>(tmap, map));
 return *this;
 }
+/// \brief Copies the uEdge references into the given map.
+///
+/// Copies the uEdge references into the given map.
+template <typename UEdgeRef>
+UGraphCopy& uEdgeRef(UEdgeRef& map) {
+uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge,
+UEdgeRefMap, UEdgeRef>(map));
+return *this;
+}
+/// \brief Reverse and copies the uEdge references into the given map.
+///
+/// Reverse and copies the uEdge references into the given map.
+template <typename UEdgeCrossRef>
+UGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
+uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
+UEdge, UEdgeRefMap, UEdgeCrossRef>(map));
+return *this;
+}
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
-/// The new map's key type is the target graph's edge type,
+/// The new map's key type is the target graph's uEdge type,
-/// and the copied map's key type is the source graph's edge
+/// and the copied map's key type is the source graph's uEdge
 /// type.
 template <typename TargetMap, typename SourceMap>
-const UGraphCopy& uEdgeMap(TargetMap& tMap,
+UGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
-				  const SourceMap& sMap) const {
+uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge,
-copyMap(tMap, sMap, UEdgeIt(source), uEdgeRefMap);
+UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
 return *this;
 }
-/// \brief Gives back the stored node references.
+/// \brief Executes the copies.
 ///
-/// Gives back the stored node references.
+/// Executes the copies.
-const NodeRefMap& nodeRef() const {
+void run() {
-return nodeRefMap;
+NodeRefMap nodeRefMap(source);
-}
+for (NodeIt it(source); it != INVALID; ++it) {
+	nodeRefMap[it] = target.addNode();
-/// \brief Gives back the stored edge references.
+}
-///
+for (int i = 0; i < (int)nodeMapCopies.size(); ++i) {
-/// Gives back the stored edge references.
+nodeMapCopies[i]->copy(source, nodeRefMap);
-const EdgeRefMap& edgeRef() const {
+}
-return edgeRefMap;
+UEdgeRefMap uEdgeRefMap(source);
-}
+EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
+for (UEdgeIt it(source); it != INVALID; ++it) {
-/// \brief Gives back the stored uedge references.
+	uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
-///
+nodeRefMap[source.target(it)]);
-/// Gives back the stored uedge references.
+}
-const UEdgeRefMap& uEdgeRef() const {
+for (int i = 0; i < (int)uEdgeMapCopies.size(); ++i) {
-return uEdgeRefMap;
+uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
 }
+for (int i = 0; i < (int)edgeMapCopies.size(); ++i) {
-void run() const {}
+edgeMapCopies[i]->copy(source, edgeRefMap);
+}
+}
 private:
 const Source& source;
 Target& target;
-NodeRefMap nodeRefMap;
+std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
-EdgeRefMap edgeRefMap;
+nodeMapCopies;
-UEdgeRefMap uEdgeRefMap;
+std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
+edgeMapCopies;
+std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* >
+uEdgeMapCopies;
 };
 /// \brief Copy a graph to another graph.
 ///
 /// Copy a graph to another graph.
 /// The usage of the function:
 ///
 ///\code
-/// copyUGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
+/// copyUGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr).run();
 ///\endcode
 ///
 /// After the copy the \c nr map will contain the mapping from the
 /// source graph's nodes to the target graph's nodes and the \c ecr will
 /// contain the mapping from the target graph's edges to the source's
 typedef _Item Key;
 /// \brief Constructor.
 ///
 /// Constructor for creating id map.
-IdMap(const Graph& _graph) : graph(&_graph) {}
+explicit IdMap(const Graph& _graph) : graph(&_graph) {}
 /// \brief Gives back the \e id of the item.
 ///
 /// Gives back the immutable and unique \e id of the map.
 int operator[](const Item& item) const { return graph->id(item);}
 public:
 /// \brief Constructor.
 ///
 /// Constructor for creating an id-to-item map.
-InverseMap(const Graph& _graph) : graph(&_graph) {}
+explicit InverseMap(const Graph& _graph) : graph(&_graph) {}
 /// \brief Constructor.
 ///
 /// Constructor for creating an id-to-item map.
-InverseMap(const IdMap& idMap) : graph(idMap.graph) {}
+explicit InverseMap(const IdMap& idMap) : graph(idMap.graph) {}
 /// \brief Gives back the given item from its id.
 ///
 /// Gives back the given item from its id.
 ///
 /// \brief Constructor.
 ///
 /// Construct a new InvertableMap for the graph.
 ///
-InvertableMap(const Graph& graph) : Map(graph) {}
+explicit InvertableMap(const Graph& graph) : Map(graph) {}
 /// \brief Forward iterator for values.
 ///
 /// This iterator is an stl compatible forward
 /// iterator on the values of the map. The values can
 class InverseMap {
 public:
 /// \brief Constructor of the InverseMap.
 ///
 /// Constructor of the InverseMap.
-InverseMap(const InvertableMap& _inverted) : inverted(_inverted) {}
+explicit InverseMap(const InvertableMap& _inverted)
+: inverted(_inverted) {}
 /// The value type of the InverseMap.
 typedef typename InvertableMap::Key Value;
 /// The key type of the InverseMap.
 typedef typename InvertableMap::Value Key;
 typedef typename _Map::Value Value;
 /// \brief Constructor.
 ///
 /// Constructor for descriptor map.
-DescriptorMap(const Graph& _graph) : Map(_graph) {
+explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
 Item it;
 const typename Map::Notifier* notifier = Map::getNotifier();
 for (notifier->first(it); it != INVALID; notifier->next(it)) {
 	Map::set(it, invMap.size());
 	invMap.push_back(it);
 }
 }
 protected:
 /// \brief Add a new key to the map.
 ///
 class InverseMap {
 public:
 /// \brief Constructor of the InverseMap.
 ///
 /// Constructor of the InverseMap.
-InverseMap(const DescriptorMap& _inverted)
+explicit InverseMap(const DescriptorMap& _inverted)
 	: inverted(_inverted) {}
 /// The value type of the InverseMap.
 typedef typename DescriptorMap::Key Value;
 /// \brief Constructor
 ///
 /// Constructor
 /// \param _graph The graph that the map belongs to.
-SourceMap(const Graph& _graph) : graph(_graph) {}
+explicit SourceMap(const Graph& _graph) : graph(_graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param edge The edge
 /// \brief Constructor
 ///
 /// Constructor
 /// \param _graph The graph that the map belongs to.
-TargetMap(const Graph& _graph) : graph(_graph) {}
+explicit TargetMap(const Graph& _graph) : graph(_graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param e The edge
 /// \brief Constructor
 ///
 /// Constructor
 /// \param _graph The graph that the map belongs to.
-ForwardMap(const Graph& _graph) : graph(_graph) {}
+explicit ForwardMap(const Graph& _graph) : graph(_graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param key An undirected edge
 /// \brief Constructor
 ///
 /// Constructor
 /// \param _graph The graph that the map belongs to.
-BackwardMap(const Graph& _graph) : graph(_graph) {}
+explicit BackwardMap(const Graph& _graph) : graph(_graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param key An undirected edge
 typedef typename NodeMap::Value Value;
 /// \brief Constructor
 ///
 /// Contructor of the map
-PotentialDifferenceMap(const Graph& _graph, const NodeMap& _potential)
+explicit PotentialDifferenceMap(const Graph& _graph,
+const NodeMap& _potential)
 : graph(_graph), potential(_potential) {}
 /// \brief Const subscription operator
 ///
 /// Const subscription operator
 public:
 /// \brief Constructor.
 ///
 /// Constructor for creating in-degree map.
-InDegMap(const Graph& _graph) : graph(_graph), deg(_graph) {
+explicit InDegMap(const Graph& _graph) : graph(_graph), deg(_graph) {
 Parent::attach(graph.getNotifier(typename _Graph::Edge()));
 for(typename _Graph::NodeIt it(graph); it != INVALID; ++it) {
 	deg[it] = countInEdges(graph, it);
 }
 public:
 /// \brief Constructor.
 ///
 /// Constructor for creating out-degree map.
-OutDegMap(const Graph& _graph) : graph(_graph), deg(_graph) {
+explicit OutDegMap(const Graph& _graph) : graph(_graph), deg(_graph) {
 Parent::attach(graph.getNotifier(typename _Graph::Edge()));
 for(typename _Graph::NodeIt it(graph); it != INVALID; ++it) {
 	deg[it] = countOutEdges(graph, it);
 }

changeset 2286	1ef281b2b10e
parent 2235	48801095a410
child 2287	16954ac69517