lemon-0.x: comparison lemon/graph

equal deleted inserted replaced

-:ba74d8cb4203
+:fbf765cdfbaf
 ///
 /// This function counts the nodes in the graph.
 /// The complexity of the function is O(n) but for some
 /// graph structures it is specialized to run in O(1).
 ///
-/// \todo Refer how to specialize it.
+/// If the graph contains a \e nodeNum() member function and a
+/// \e NodeNumTag tag then this function calls directly the member
+/// function to query the cardinality of the node set.
 template <typename Graph>
 inline int countNodes(const Graph& g) {
 return _graph_utils_bits::CountNodesSelector<Graph>::count(g);
 }
 ///
 /// This function counts the anodes in the graph.
 /// The complexity of the function is O(an) but for some
 /// graph structures it is specialized to run in O(1).
 ///
-/// \todo Refer how to specialize it.
+/// If the graph contains an \e aNodeNum() member function and a
+/// \e NodeNumTag tag then this function calls directly the member
+/// function to query the cardinality of the A-node set.
 template <typename Graph>
 inline int countANodes(const Graph& g) {
 return _graph_utils_bits::CountANodesSelector<Graph>::count(g);
 }
 ///
 /// This function counts the bnodes in the graph.
 /// The complexity of the function is O(bn) but for some
 /// graph structures it is specialized to run in O(1).
 ///
-/// \todo Refer how to specialize it.
+/// If the graph contains a \e bNodeNum() member function and a
+/// \e NodeNumTag tag then this function calls directly the member
+/// function to query the cardinality of the B-node set.
 template <typename Graph>
 inline int countBNodes(const Graph& g) {
 return _graph_utils_bits::CountBNodesSelector<Graph>::count(g);
 }
 /// \brief Function to count the edges in the graph.
 ///
 /// This function counts the edges in the graph.
 /// The complexity of the function is O(e) but for some
 /// graph structures it is specialized to run in O(1).
+///
+/// If the graph contains a \e edgeNum() member function and a
+/// \e EdgeNumTag tag then this function calls directly the member
+/// function to query the cardinality of the edge set.
 template <typename Graph>
 inline int countEdges(const Graph& g) {
 return _graph_utils_bits::CountEdgesSelector<Graph>::count(g);
 }
 /// \brief Function to count the undirected edges in the graph.
 ///
 /// This function counts the undirected edges in the graph.
 /// The complexity of the function is O(e) but for some
 /// graph structures it is specialized to run in O(1).
+///
+/// If the graph contains a \e uEdgeNum() member function and a
+/// \e EdgeNumTag tag then this function calls directly the member
+/// function to query the cardinality of the undirected edge set.
 template <typename Graph>
 inline int countUEdges(const Graph& g) {
 return _graph_utils_bits::CountUEdgesSelector<Graph>::count(g);
 }
 const Graph& graph;
 };
 /// \brief Copy a map.
 ///
-/// This function copies the \c source map to the \c target map. It uses the
+/// This function copies the \c from map to the \c to map. It uses the
 /// given iterator to iterate on the data structure and it uses the \c ref
-/// mapping to convert the source's keys to the target's keys.
+/// mapping to convert the from's keys to the to's keys.
-template <typename Target, typename Source,
+template <typename To, typename From,
 	    typename ItemIt, typename Ref>
-void copyMap(Target& target, const Source& source,
+void copyMap(To& to, const From& from,
 	       ItemIt it, const Ref& ref) {
 for (; it != INVALID; ++it) {
-target[ref[it]] = source[it];
+to[ref[it]] = from[it];
 }
 }
-/// \brief Copy the source map to the target map.
+/// \brief Copy the from map to the to map.
 ///
-/// Copy the \c source map to the \c target map. It uses the given iterator
+/// Copy the \c from map to the \c to map. It uses the given iterator
 /// to iterate on the data structure.
-template <typename Target, typename Source, typename ItemIt>
+template <typename To, typename From, typename ItemIt>
-void copyMap(Target& target, const Source& source, ItemIt it) {
+void copyMap(To& to, const From& from, ItemIt it) {
 for (; it != INVALID; ++it) {
-target[it] = source[it];
+to[it] = from[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 void copy(const Graph& from, const RefMap& refMap) = 0;
 virtual ~MapCopyBase() {}
 };
 template <typename Graph, typename Item, typename RefMap,
-typename TargetMap, typename SourceMap>
+typename ToMap, typename FromMap>
 class MapCopy : public MapCopyBase<Graph, Item, RefMap> {
 public:
-MapCopy(TargetMap& tmap, const SourceMap& map)
+MapCopy(ToMap& tmap, const FromMap& 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;
+ToMap& _tmap;
-const SourceMap& _map;
+const FromMap& _map;
 };
 template <typename Graph, typename Item, typename RefMap, typename It>
 class ItemCopy : public MapCopyBase<Graph, Item, RefMap> {
 public:
 CrossRef& _cmap;
 };
 template <typename Graph, typename Enable = void>
 struct GraphCopySelector {
-template <typename Source, typename NodeRefMap, typename EdgeRefMap>
+template <typename From, typename NodeRefMap, typename EdgeRefMap>
-static void copy(Graph &target, const Source& source,
+static void copy(Graph &to, const From& from,
 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
-for (typename Source::NodeIt it(source); it != INVALID; ++it) {
+for (typename From::NodeIt it(from); it != INVALID; ++it) {
-nodeRefMap[it] = target.addNode();
+nodeRefMap[it] = to.addNode();
 }
-for (typename Source::EdgeIt it(source); it != INVALID; ++it) {
+for (typename From::EdgeIt it(from); it != INVALID; ++it) {
-edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
+edgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)],
-nodeRefMap[source.target(it)]);
+nodeRefMap[from.target(it)]);
 }
 }
 };
 template <typename Graph>
 struct GraphCopySelector<
 Graph,
 typename enable_if<typename Graph::BuildTag, void>::type>
 {
-template <typename Source, typename NodeRefMap, typename EdgeRefMap>
+template <typename From, typename NodeRefMap, typename EdgeRefMap>
-static void copy(Graph &target, const Source& source,
+static void copy(Graph &to, const From& from,
 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
-target.build(source, nodeRefMap, edgeRefMap);
+to.build(from, nodeRefMap, edgeRefMap);
 }
 };
 template <typename UGraph, typename Enable = void>
 struct UGraphCopySelector {
-template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
+template <typename From, typename NodeRefMap, typename UEdgeRefMap>
-static void copy(UGraph &target, const Source& source,
+static void copy(UGraph &to, const From& from,
 NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
-for (typename Source::NodeIt it(source); it != INVALID; ++it) {
+for (typename From::NodeIt it(from); it != INVALID; ++it) {
-nodeRefMap[it] = target.addNode();
+nodeRefMap[it] = to.addNode();
 }
-for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
+for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
-uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
+uEdgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)],
-nodeRefMap[source.target(it)]);
+				       nodeRefMap[from.target(it)]);
 }
 }
 };
 template <typename UGraph>
 struct UGraphCopySelector<
 UGraph,
 typename enable_if<typename UGraph::BuildTag, void>::type>
 {
-template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
+template <typename From, typename NodeRefMap, typename UEdgeRefMap>
-static void copy(UGraph &target, const Source& source,
+static void copy(UGraph &to, const From& from,
 NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
-target.build(source, nodeRefMap, uEdgeRefMap);
+to.build(from, nodeRefMap, uEdgeRefMap);
 }
 };
 template <typename BpUGraph, typename Enable = void>
 struct BpUGraphCopySelector {
-template <typename Source, typename ANodeRefMap,
+template <typename From, typename ANodeRefMap,
 typename BNodeRefMap, typename UEdgeRefMap>
-static void copy(BpUGraph &target, const Source& source,
+static void copy(BpUGraph &to, const From& from,
 ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
 UEdgeRefMap& uEdgeRefMap) {
-for (typename Source::ANodeIt it(source); it != INVALID; ++it) {
+for (typename From::ANodeIt it(from); it != INVALID; ++it) {
-aNodeRefMap[it] = target.addANode();
+aNodeRefMap[it] = to.addANode();
 }
-for (typename Source::BNodeIt it(source); it != INVALID; ++it) {
+for (typename From::BNodeIt it(from); it != INVALID; ++it) {
-bNodeRefMap[it] = target.addBNode();
+bNodeRefMap[it] = to.addBNode();
 }
-for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
+for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
-uEdgeRefMap[it] = target.addEdge(aNodeRefMap[source.aNode(it)],
+uEdgeRefMap[it] = to.addEdge(aNodeRefMap[from.aNode(it)],
-bNodeRefMap[source.bNode(it)]);
+bNodeRefMap[from.bNode(it)]);
 }
 }
 };
 template <typename BpUGraph>
 struct BpUGraphCopySelector<
 BpUGraph,
 typename enable_if<typename BpUGraph::BuildTag, void>::type>
 {
-template <typename Source, typename ANodeRefMap,
+template <typename From, typename ANodeRefMap,
 typename BNodeRefMap, typename UEdgeRefMap>
-static void copy(BpUGraph &target, const Source& source,
+static void copy(BpUGraph &to, const From& from,
 ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
 UEdgeRefMap& uEdgeRefMap) {
-target.build(source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
+to.build(from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
 }
 };
 }
 /// \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>
+template <typename To, typename From>
 class GraphCopy {
 private:
-typedef typename Source::Node Node;
+typedef typename From::Node Node;
-typedef typename Source::NodeIt NodeIt;
+typedef typename From::NodeIt NodeIt;
-typedef typename Source::Edge Edge;
+typedef typename From::Edge Edge;
-typedef typename Source::EdgeIt EdgeIt;
+typedef typename From::EdgeIt EdgeIt;
-typedef typename Target::Node TNode;
+typedef typename To::Node TNode;
-typedef typename Target::Edge TEdge;
+typedef typename To::Edge TEdge;
-typedef typename Source::template NodeMap<TNode> NodeRefMap;
+typedef typename From::template NodeMap<TNode> NodeRefMap;
-typedef typename Source::template EdgeMap<TEdge> EdgeRefMap;
+typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 public:
 /// \brief Constructor for the GraphCopy.
 ///
-/// It copies the content of the \c _source graph into the
+/// It copies the content of the \c _from graph into the
-/// \c _target graph.
+/// \c _to graph.
-GraphCopy(Target& _target, const Source& _source)
+GraphCopy(To& _to, const From& _from)
-: source(_source), target(_target) {}
+: from(_from), to(_to) {}
 /// \brief Destructor of the GraphCopy
 ///
 /// Destructor of the GraphCopy
 ~GraphCopy() {
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
 GraphCopy& nodeRef(NodeRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
 NodeRefMap, NodeRef>(map));
 return *this;
 }
 /// \brief Copies the node cross references into the given map.
 ///
 ///  Copies the node cross references (reverse references) into
 ///  the given map.
 template <typename NodeCrossRef>
 GraphCopy& nodeCrossRef(NodeCrossRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
 NodeRefMap, NodeCrossRef>(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 node type,
+/// The new map's key type is the to graph's node type,
-/// and the copied map's key type is the source graph's node
+/// and the copied map's key type is the from graph's node
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-GraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
+GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
-NodeRefMap, TargetMap, SourceMap>(tmap, map));
+NodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given node.
 ///
 /// Make a copy of the given node.
 GraphCopy& node(TNode& tnode, const Node& snode) {
-nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
 NodeRefMap, TNode>(tnode, snode));
 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,
+edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
 EdgeRefMap, EdgeRef>(map));
 return *this;
 }
 /// \brief Copies the edge cross references into the given map.
 ///
 ///  Copies the edge cross references (reverse references) into
 ///  the given map.
 template <typename EdgeCrossRef>
 GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 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,
+/// The new map's key type is the to graph's edge type,
-/// and the copied map's key type is the source graph's edge
+/// and the copied map's key type is the from graph's edge
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-GraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
+GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
-EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+EdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given edge.
 ///
 /// Make a copy of the given edge.
 GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
 EdgeRefMap, TEdge>(tedge, sedge));
 return *this;
 }
 /// \brief Executes the copies.
 ///
 /// Executes the copies.
 void run() {
-NodeRefMap nodeRefMap(source);
+NodeRefMap nodeRefMap(from);
-EdgeRefMap edgeRefMap(source);
+EdgeRefMap edgeRefMap(from);
-_graph_utils_bits::GraphCopySelector<Target>::
+_graph_utils_bits::GraphCopySelector<To>::
-copy(target, source, nodeRefMap, edgeRefMap);
+copy(to, from, nodeRefMap, edgeRefMap);
 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-nodeMapCopies[i]->copy(source, nodeRefMap);
+nodeMapCopies[i]->copy(from, nodeRefMap);
 }
 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-edgeMapCopies[i]->copy(source, edgeRefMap);
+edgeMapCopies[i]->copy(from, edgeRefMap);
 }
 }
 protected:
-const Source& source;
+const From& from;
-Target& target;
+To& to;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
 nodeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 edgeMapCopies;
 };
 /// \brief Copy a graph to another graph.
 ///\code
 /// 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
+/// from graph's nodes to the to graph's nodes and the \c ecr will
-/// contain the mapping from the target graph's edges to the source's
+/// contain the mapping from the to graph's edges to the from's
 /// edges.
 ///
 /// \see GraphCopy
-template <typename Target, typename Source>
+template <typename To, typename From>
-GraphCopy<Target, Source> copyGraph(Target& target, const Source& source) {
+GraphCopy<To, From> copyGraph(To& to, const From& from) {
-return GraphCopy<Target, Source>(target, source);
+return GraphCopy<To, From>(to, from);
 }
 /// \brief Class to copy an undirected graph.
 ///
 /// 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>
+template <typename To, typename From>
 class UGraphCopy {
 private:
-typedef typename Source::Node Node;
+typedef typename From::Node Node;
-typedef typename Source::NodeIt NodeIt;
+typedef typename From::NodeIt NodeIt;
-typedef typename Source::Edge Edge;
+typedef typename From::Edge Edge;
-typedef typename Source::EdgeIt EdgeIt;
+typedef typename From::EdgeIt EdgeIt;
-typedef typename Source::UEdge UEdge;
+typedef typename From::UEdge UEdge;
-typedef typename Source::UEdgeIt UEdgeIt;
+typedef typename From::UEdgeIt UEdgeIt;
-typedef typename Target::Node TNode;
+typedef typename To::Node TNode;
-typedef typename Target::Edge TEdge;
+typedef typename To::Edge TEdge;
-typedef typename Target::UEdge TUEdge;
+typedef typename To::UEdge TUEdge;
-typedef typename Source::template NodeMap<TNode> NodeRefMap;
+typedef typename From::template NodeMap<TNode> NodeRefMap;
-typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
+typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
 struct EdgeRefMap {
-EdgeRefMap(const Target& _target, const Source& _source,
+EdgeRefMap(const To& _to, const From& _from,
 const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref)
-: target(_target), source(_source),
+: to(_to), from(_from),
 uedge_ref(_uedge_ref), node_ref(_node_ref) {}
-typedef typename Source::Edge Key;
+typedef typename From::Edge Key;
-typedef typename Target::Edge Value;
+typedef typename To::Edge Value;
 Value operator[](const Key& key) const {
 bool forward =
-(source.direction(key) ==
+(from.direction(key) ==
-(node_ref[source.source(static_cast<const UEdge&>(key))] ==
+(node_ref[from.source(static_cast<const UEdge&>(key))] ==
-target.source(uedge_ref[static_cast<const UEdge&>(key)])));
+to.source(uedge_ref[static_cast<const UEdge&>(key)])));
-	return target.direct(uedge_ref[key], forward);
+	return to.direct(uedge_ref[key], forward);
 }
-const Target& target;
+const To& to;
-const Source& source;
+const From& from;
 const UEdgeRefMap& uedge_ref;
 const NodeRefMap& node_ref;
 };
 public:
 /// \brief Constructor for the GraphCopy.
 ///
-/// It copies the content of the \c _source graph into the
+/// It copies the content of the \c _from graph into the
-/// \c _target graph.
+/// \c _to graph.
-UGraphCopy(Target& _target, const Source& _source)
+UGraphCopy(To& _to, const From& _from)
-: source(_source), target(_target) {}
+: from(_from), to(_to) {}
 /// \brief Destructor of the GraphCopy
 ///
 /// Destructor of the GraphCopy
 ~UGraphCopy() {
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
 UGraphCopy& nodeRef(NodeRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
 NodeRefMap, NodeRef>(map));
 return *this;
 }
 /// \brief Copies the node cross references into the given map.
 ///
 ///  Copies the node cross references (reverse references) into
 ///  the given map.
 template <typename NodeCrossRef>
 UGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
 NodeRefMap, NodeCrossRef>(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 node type,
+/// The new map's key type is the to graph's node type,
-/// and the copied map's key type is the source graph's node
+/// and the copied map's key type is the from graph's node
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-UGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
+UGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
-NodeRefMap, TargetMap, SourceMap>(tmap, map));
+NodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given node.
 ///
 /// Make a copy of the given node.
 UGraphCopy& node(TNode& tnode, const Node& snode) {
-nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
 NodeRefMap, TNode>(tnode, snode));
 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,
+edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
 EdgeRefMap, EdgeRef>(map));
 return *this;
 }
 /// \brief Copies the edge cross references into the given map.
 ///
 ///  Copies the edge cross references (reverse references) into
 ///  the given map.
 template <typename EdgeCrossRef>
 UGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 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,
+/// The new map's key type is the to graph's edge type,
-/// and the copied map's key type is the source graph's edge
+/// and the copied map's key type is the from graph's edge
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-UGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
+UGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
-EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+EdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given edge.
 ///
 /// Make a copy of the given edge.
 UGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
 EdgeRefMap, TEdge>(tedge, sedge));
 return *this;
 }
 /// \brief Copies the undirected edge references into the given map.
 ///
 /// Copies the undirected edge references into the given map.
 template <typename UEdgeRef>
 UGraphCopy& uEdgeRef(UEdgeRef& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge,
 UEdgeRefMap, UEdgeRef>(map));
 return *this;
 }
 /// \brief Copies the undirected edge cross references into the given map.
 ///
 /// Copies the undirected edge cross references (reverse
 /// references) into the given map.
 template <typename UEdgeCrossRef>
 UGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
+uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
 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 undirected edge type,
+/// The new map's key type is the to graph's undirected edge type,
-/// and the copied map's key type is the source graph's undirected edge
+/// and the copied map's key type is the from graph's undirected edge
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-UGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
+UGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge,
-UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
+UEdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given undirected edge.
 ///
 /// Make a copy of the given undirected edge.
 UGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge,
 UEdgeRefMap, TUEdge>(tuedge, suedge));
 return *this;
 }
 /// \brief Executes the copies.
 ///
 /// Executes the copies.
 void run() {
-NodeRefMap nodeRefMap(source);
+NodeRefMap nodeRefMap(from);
-UEdgeRefMap uEdgeRefMap(source);
+UEdgeRefMap uEdgeRefMap(from);
-EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
+EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
-_graph_utils_bits::UGraphCopySelector<Target>::
+_graph_utils_bits::UGraphCopySelector<To>::
-copy(target, source, nodeRefMap, uEdgeRefMap);
+copy(to, from, nodeRefMap, uEdgeRefMap);
 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-nodeMapCopies[i]->copy(source, nodeRefMap);
+nodeMapCopies[i]->copy(from, nodeRefMap);
 }
 for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
-uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
+uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
 }
 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-edgeMapCopies[i]->copy(source, edgeRefMap);
+edgeMapCopies[i]->copy(from, edgeRefMap);
 }
 }
 private:
-const Source& source;
+const From& from;
-Target& target;
+To& to;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
 nodeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 edgeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* >
 uEdgeMapCopies;
 };
 /// \brief Copy an undirected graph to another graph.
 ///\code
 /// 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
+/// from graph's nodes to the to graph's nodes and the \c ecr will
-/// contain the mapping from the target graph's edges to the source's
+/// contain the mapping from the to graph's edges to the from's
 /// edges.
 ///
 /// \see UGraphCopy
-template <typename Target, typename Source>
+template <typename To, typename From>
-UGraphCopy<Target, Source>
+UGraphCopy<To, From>
-copyUGraph(Target& target, const Source& source) {
+copyUGraph(To& to, const From& from) {
-return UGraphCopy<Target, Source>(target, source);
+return UGraphCopy<To, From>(to, from);
 }
 /// \brief Class to copy a bipartite undirected graph.
 ///
 /// Class to copy a bipartite undirected graph to another graph
 /// (duplicate a graph).  The simplest way of using it is through
 /// the \c copyBpUGraph() function.
-template <typename Target, typename Source>
+template <typename To, typename From>
 class BpUGraphCopy {
 private:
-typedef typename Source::Node Node;
+typedef typename From::Node Node;
-typedef typename Source::ANode ANode;
+typedef typename From::ANode ANode;
-typedef typename Source::BNode BNode;
+typedef typename From::BNode BNode;
-typedef typename Source::NodeIt NodeIt;
+typedef typename From::NodeIt NodeIt;
-typedef typename Source::Edge Edge;
+typedef typename From::Edge Edge;
-typedef typename Source::EdgeIt EdgeIt;
+typedef typename From::EdgeIt EdgeIt;
-typedef typename Source::UEdge UEdge;
+typedef typename From::UEdge UEdge;
-typedef typename Source::UEdgeIt UEdgeIt;
+typedef typename From::UEdgeIt UEdgeIt;
-typedef typename Target::Node TNode;
+typedef typename To::Node TNode;
-typedef typename Target::Edge TEdge;
+typedef typename To::Edge TEdge;
-typedef typename Target::UEdge TUEdge;
+typedef typename To::UEdge TUEdge;
-typedef typename Source::template ANodeMap<TNode> ANodeRefMap;
+typedef typename From::template ANodeMap<TNode> ANodeRefMap;
-typedef typename Source::template BNodeMap<TNode> BNodeRefMap;
+typedef typename From::template BNodeMap<TNode> BNodeRefMap;
-typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
+typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
 struct NodeRefMap {
-NodeRefMap(const Source& _source, const ANodeRefMap& _anode_ref,
+NodeRefMap(const From& _from, const ANodeRefMap& _anode_ref,
 const BNodeRefMap& _bnode_ref)
-: source(_source), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
+: from(_from), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
-typedef typename Source::Node Key;
+typedef typename From::Node Key;
-typedef typename Target::Node Value;
+typedef typename To::Node Value;
 Value operator[](const Key& key) const {
-	return source.aNode(key) ? anode_ref[key] : bnode_ref[key];
+	return from.aNode(key) ? anode_ref[key] : bnode_ref[key];
 }
-const Source& source;
+const From& from;
 const ANodeRefMap& anode_ref;
 const BNodeRefMap& bnode_ref;
 };
 struct EdgeRefMap {
-EdgeRefMap(const Target& _target, const Source& _source,
+EdgeRefMap(const To& _to, const From& _from,
 const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref)
-: target(_target), source(_source),
+: to(_to), from(_from),
 uedge_ref(_uedge_ref), node_ref(_node_ref) {}
-typedef typename Source::Edge Key;
+typedef typename From::Edge Key;
-typedef typename Target::Edge Value;
+typedef typename To::Edge Value;
 Value operator[](const Key& key) const {
 bool forward =
-(source.direction(key) ==
+(from.direction(key) ==
-(node_ref[source.source(static_cast<const UEdge&>(key))] ==
+(node_ref[from.source(static_cast<const UEdge&>(key))] ==
-target.source(uedge_ref[static_cast<const UEdge&>(key)])));
+to.source(uedge_ref[static_cast<const UEdge&>(key)])));
-	return target.direct(uedge_ref[key], forward);
+	return to.direct(uedge_ref[key], forward);
 }
-const Target& target;
+const To& to;
-const Source& source;
+const From& from;
 const UEdgeRefMap& uedge_ref;
 const NodeRefMap& node_ref;
 };
 public:
 /// \brief Constructor for the GraphCopy.
 ///
-/// It copies the content of the \c _source graph into the
+/// It copies the content of the \c _from graph into the
-/// \c _target graph.
+/// \c _to graph.
-BpUGraphCopy(Target& _target, const Source& _source)
+BpUGraphCopy(To& _to, const From& _from)
-: source(_source), target(_target) {}
+: from(_from), to(_to) {}
 /// \brief Destructor of the GraphCopy
 ///
 /// Destructor of the GraphCopy
 ~BpUGraphCopy() {
 /// \brief Copies the A-node references into the given map.
 ///
 /// Copies the A-node references into the given map.
 template <typename ANodeRef>
 BpUGraphCopy& aNodeRef(ANodeRef& map) {
-aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, ANode,
+aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, ANode,
 ANodeRefMap, ANodeRef>(map));
 return *this;
 }
 /// \brief Copies the A-node cross references into the given map.
 ///
 /// Copies the A-node cross references (reverse references) into
 /// the given map.
 template <typename ANodeCrossRef>
 BpUGraphCopy& aNodeCrossRef(ANodeCrossRef& map) {
-aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
+aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
 ANode, ANodeRefMap, ANodeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given A-node 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,
+/// The new map's key type is the to graph's node type,
-/// and the copied map's key type is the source graph's node
+/// and the copied map's key type is the from graph's node
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-BpUGraphCopy& aNodeMap(TargetMap& tmap, const SourceMap& map) {
+BpUGraphCopy& aNodeMap(ToMap& tmap, const FromMap& map) {
-aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, ANode,
+aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, ANode,
-ANodeRefMap, TargetMap, SourceMap>(tmap, map));
+ANodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Copies the B-node references into the given map.
 ///
 /// Copies the B-node references into the given map.
 template <typename BNodeRef>
 BpUGraphCopy& bNodeRef(BNodeRef& map) {
-bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, BNode,
+bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, BNode,
 BNodeRefMap, BNodeRef>(map));
 return *this;
 }
 /// \brief Copies the B-node cross references into the given map.
 ///
 ///  Copies the B-node cross references (reverse references) into
 ///  the given map.
 template <typename BNodeCrossRef>
 BpUGraphCopy& bNodeCrossRef(BNodeCrossRef& map) {
-bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
+bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
 BNode, BNodeRefMap, BNodeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given B-node 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,
+/// The new map's key type is the to graph's node type,
-/// and the copied map's key type is the source graph's node
+/// and the copied map's key type is the from graph's node
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-BpUGraphCopy& bNodeMap(TargetMap& tmap, const SourceMap& map) {
+BpUGraphCopy& bNodeMap(ToMap& tmap, const FromMap& map) {
-bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, BNode,
+bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, BNode,
-BNodeRefMap, TargetMap, SourceMap>(tmap, map));
+BNodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
 BpUGraphCopy& nodeRef(NodeRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
 NodeRefMap, NodeRef>(map));
 return *this;
 }
 /// \brief Copies the node cross references into the given map.
 ///
 ///  Copies the node cross references (reverse references) into
 ///  the given map.
 template <typename NodeCrossRef>
 BpUGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
 NodeRefMap, NodeCrossRef>(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 node type,
+/// The new map's key type is the to graph's node type,
-/// and the copied map's key type is the source graph's node
+/// and the copied map's key type is the from graph's node
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-BpUGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
+BpUGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
-nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
-NodeRefMap, TargetMap, SourceMap>(tmap, map));
+NodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given node.
 ///
 /// Make a copy of the given node.
 BpUGraphCopy& node(TNode& tnode, const Node& snode) {
-nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
+nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
 NodeRefMap, TNode>(tnode, snode));
 return *this;
 }
 /// \brief Copies the edge references into the given map.
 ///
 /// Copies the edge references into the given map.
 template <typename EdgeRef>
 BpUGraphCopy& edgeRef(EdgeRef& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
 EdgeRefMap, EdgeRef>(map));
 return *this;
 }
 /// \brief Copies the edge cross references into the given map.
 ///
 ///  Copies the edge cross references (reverse references) into
 ///  the given map.
 template <typename EdgeCrossRef>
 BpUGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 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,
+/// The new map's key type is the to graph's edge type,
-/// and the copied map's key type is the source graph's edge
+/// and the copied map's key type is the from graph's edge
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-BpUGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
+BpUGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
-edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
-EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+EdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given edge.
 ///
 /// Make a copy of the given edge.
 BpUGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
+edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
 EdgeRefMap, TEdge>(tedge, sedge));
 return *this;
 }
 /// \brief Copies the undirected edge references into the given map.
 ///
 /// Copies the undirected edge references into the given map.
 template <typename UEdgeRef>
 BpUGraphCopy& uEdgeRef(UEdgeRef& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge,
 UEdgeRefMap, UEdgeRef>(map));
 return *this;
 }
 /// \brief Copies the undirected edge cross references into the given map.
 ///
 /// Copies the undirected edge cross references (reverse
 /// references) into the given map.
 template <typename UEdgeCrossRef>
 BpUGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
+uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
 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 undirected edge type,
+/// The new map's key type is the to graph's undirected edge type,
-/// and the copied map's key type is the source graph's undirected edge
+/// and the copied map's key type is the from graph's undirected edge
 /// type.
-template <typename TargetMap, typename SourceMap>
+template <typename ToMap, typename FromMap>
-BpUGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
+BpUGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge,
-UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
+UEdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given undirected edge.
 ///
 /// Make a copy of the given undirected edge.
 BpUGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
-uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
+uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge,
 UEdgeRefMap, TUEdge>(tuedge, suedge));
 return *this;
 }
 /// \brief Executes the copies.
 ///
 /// Executes the copies.
 void run() {
-ANodeRefMap aNodeRefMap(source);
+ANodeRefMap aNodeRefMap(from);
-BNodeRefMap bNodeRefMap(source);
+BNodeRefMap bNodeRefMap(from);
-NodeRefMap nodeRefMap(source, aNodeRefMap, bNodeRefMap);
+NodeRefMap nodeRefMap(from, aNodeRefMap, bNodeRefMap);
-UEdgeRefMap uEdgeRefMap(source);
+UEdgeRefMap uEdgeRefMap(from);
-EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
+EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
-_graph_utils_bits::BpUGraphCopySelector<Target>::
+_graph_utils_bits::BpUGraphCopySelector<To>::
-copy(target, source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
+copy(to, from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
 for (int i = 0; i < int(aNodeMapCopies.size()); ++i) {
-aNodeMapCopies[i]->copy(source, aNodeRefMap);
+aNodeMapCopies[i]->copy(from, aNodeRefMap);
 }
 for (int i = 0; i < int(bNodeMapCopies.size()); ++i) {
-bNodeMapCopies[i]->copy(source, bNodeRefMap);
+bNodeMapCopies[i]->copy(from, bNodeRefMap);
 }
 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-nodeMapCopies[i]->copy(source, nodeRefMap);
+nodeMapCopies[i]->copy(from, nodeRefMap);
 }
 for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
-uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
+uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
 }
 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-edgeMapCopies[i]->copy(source, edgeRefMap);
+edgeMapCopies[i]->copy(from, edgeRefMap);
 }
 }
 private:
-const Source& source;
+const From& from;
-Target& target;
+To& to;
-std::vector<_graph_utils_bits::MapCopyBase<Source, ANode, ANodeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, ANode, ANodeRefMap>* >
 aNodeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, BNode, BNodeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, BNode, BNodeRefMap>* >
 bNodeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
 nodeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 edgeMapCopies;
-std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* >
+std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* >
 uEdgeMapCopies;
 };
 /// \brief Copy a bipartite undirected graph to another graph.
 ///\code
 /// copyBpUGraph(trg, src).aNodeRef(anr).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
+/// from graph's nodes to the to graph's nodes and the \c ecr will
-/// contain the mapping from the target graph's edges to the source's
+/// contain the mapping from the to graph's edges to the from's
 /// edges.
 ///
 /// \see BpUGraphCopy
-template <typename Target, typename Source>
+template <typename To, typename From>
-BpUGraphCopy<Target, Source>
+BpUGraphCopy<To, From>
-copyBpUGraph(Target& target, const Source& source) {
+copyBpUGraph(To& to, const From& from) {
-return BpUGraphCopy<Target, Source>(target, source);
+return BpUGraphCopy<To, From>(to, from);
 }
 /// @}

changeset 2493	6231d9d3957b
parent 2476	059dcdda37c5
child 2510	bb523a4758f7