1.1 --- a/doc/Makefile.am Mon Oct 01 19:23:16 2007 +0000
1.2 +++ b/doc/Makefile.am Tue Oct 02 12:34:43 2007 +0000
1.3 @@ -10,6 +10,7 @@
1.4 doc/algorithms.dox \
1.5 doc/coding_style.dox \
1.6 doc/developers_interface.dox \
1.7 + doc/developres.dox \
1.8 doc/dirs.dox \
1.9 doc/getstart.dox \
1.10 doc/graph-adaptors.dox \
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
2.2 +++ b/doc/developers.dox Tue Oct 02 12:34:43 2007 +0000
2.3 @@ -0,0 +1,41 @@
2.4 +/* -*- C++ -*-
2.5 + *
2.6 + * This file is a part of LEMON, a generic C++ optimization library
2.7 + *
2.8 + * Copyright (C) 2003-2007
2.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
2.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
2.11 + *
2.12 + * Permission to use, modify and distribute this software is granted
2.13 + * provided that this copyright notice appears in all copies. For
2.14 + * precise terms see the accompanying LICENSE file.
2.15 + *
2.16 + * This software is provided "AS IS" with no warranty of any kind,
2.17 + * express or implied, and with no claim as to its suitability for any
2.18 + * purpose.
2.19 + *
2.20 + */
2.21 +
2.22 +namespace lemon {
2.23 +/*!
2.24 +
2.25 +
2.26 +\page developers LEMON Developers
2.27 +
2.28 +\li Mihaly Barasz
2.29 +\li Johanna Becker
2.30 +\li Attila Bernath
2.31 +\li Balazs Dezso
2.32 +\li Peter Hegyi
2.33 +\li Alpar Juttner
2.34 +\li Peter Kovacs
2.35 +\li Akos Ladanyi
2.36 +\li Marton Makai
2.37 +\li Balazs Attila Mihaly
2.38 +\li Janos Nagy
2.39 +\li Jacint Szabo
2.40 +\li Zsuzsanna Vaik
2.41 +
2.42 +*/
2.43 +}
2.44 +
3.1 --- a/lemon/concepts/bpugraph.h Mon Oct 01 19:23:16 2007 +0000
3.2 +++ b/lemon/concepts/bpugraph.h Tue Oct 02 12:34:43 2007 +0000
3.3 @@ -33,8 +33,7 @@
3.4 namespace lemon {
3.5 namespace concepts {
3.6
3.7 - /// \addtogroup graph_concepts
3.8 - /// @{
3.9 + /// \ingroup graph_concepts
3.10 ///
3.11 /// \brief Class describing the concept of Bipartite Undirected Graphs.
3.12 ///
3.13 @@ -998,9 +997,6 @@
3.14
3.15 };
3.16
3.17 -
3.18 - /// @}
3.19 -
3.20 }
3.21
3.22 }
4.1 --- a/lemon/concepts/graph.h Mon Oct 01 19:23:16 2007 +0000
4.2 +++ b/lemon/concepts/graph.h Tue Oct 02 12:34:43 2007 +0000
4.3 @@ -32,8 +32,7 @@
4.4 namespace lemon {
4.5 namespace concepts {
4.6
4.7 - /// \addtogroup graph_concepts
4.8 - /// @{
4.9 + /// \ingroup graph_concepts
4.10 ///
4.11 /// \brief Class describing the concept of Directed Graphs.
4.12 ///
4.13 @@ -446,7 +445,6 @@
4.14
4.15 };
4.16
4.17 - // @}
4.18 } //namespace concepts
4.19 } //namespace lemon
4.20
5.1 --- a/lemon/concepts/graph_components.h Mon Oct 01 19:23:16 2007 +0000
5.2 +++ b/lemon/concepts/graph_components.h Tue Oct 02 12:34:43 2007 +0000
5.3 @@ -1482,15 +1482,12 @@
5.4 ///
5.5 template <typename _Value>
5.6 class NodeMap : public GraphMap<Graph, Node, _Value> {
5.7 - private:
5.8 - NodeMap();
5.9 public:
5.10 typedef GraphMap<MappableGraphComponent, Node, _Value> Parent;
5.11
5.12 /// \brief Construct a new map.
5.13 ///
5.14 /// Construct a new map for the graph.
5.15 - /// \todo call the right parent class constructor
5.16 explicit NodeMap(const MappableGraphComponent& graph)
5.17 : Parent(graph) {}
5.18
5.19 @@ -1522,15 +1519,12 @@
5.20 ///
5.21 template <typename _Value>
5.22 class EdgeMap : public GraphMap<Graph, Edge, _Value> {
5.23 - private:
5.24 - EdgeMap();
5.25 public:
5.26 typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
5.27
5.28 /// \brief Construct a new map.
5.29 ///
5.30 /// Construct a new map for the graph.
5.31 - /// \todo call the right parent class constructor
5.32 explicit EdgeMap(const MappableGraphComponent& graph)
5.33 : Parent(graph) {}
5.34
5.35 @@ -1627,7 +1621,6 @@
5.36 /// \brief Construct a new map.
5.37 ///
5.38 /// Construct a new map for the graph.
5.39 - /// \todo call the right parent class constructor
5.40 explicit UEdgeMap(const MappableUGraphComponent& graph)
5.41 : Parent(graph) {}
5.42
5.43 @@ -1712,7 +1705,6 @@
5.44 /// \brief Construct a new map.
5.45 ///
5.46 /// Construct a new map for the graph.
5.47 - /// \todo call the right parent class constructor
5.48 explicit ANodeMap(const MappableBpUGraphComponent& graph)
5.49 : Parent(graph) {}
5.50
5.51 @@ -1750,7 +1742,6 @@
5.52 /// \brief Construct a new map.
5.53 ///
5.54 /// Construct a new map for the graph.
5.55 - /// \todo call the right parent class constructor
5.56 explicit BNodeMap(const MappableBpUGraphComponent& graph)
5.57 : Parent(graph) {}
5.58
6.1 --- a/lemon/concepts/ugraph.h Mon Oct 01 19:23:16 2007 +0000
6.2 +++ b/lemon/concepts/ugraph.h Tue Oct 02 12:34:43 2007 +0000
6.3 @@ -30,8 +30,7 @@
6.4 namespace lemon {
6.5 namespace concepts {
6.6
6.7 - /// \addtogroup graph_concepts
6.8 - /// @{
6.9 + /// \ingroup graph_concepts
6.10 ///
6.11 /// \brief Class describing the concept of Undirected Graphs.
6.12 ///
6.13 @@ -696,8 +695,6 @@
6.14
6.15 };
6.16
6.17 - /// @}
6.18 -
6.19 }
6.20
6.21 }
7.1 --- a/lemon/graph_utils.h Mon Oct 01 19:23:16 2007 +0000
7.2 +++ b/lemon/graph_utils.h Tue Oct 02 12:34:43 2007 +0000
7.3 @@ -146,8 +146,9 @@
7.4 /// The complexity of the function is O(n) but for some
7.5 /// graph structures it is specialized to run in O(1).
7.6 ///
7.7 - /// \todo Refer how to specialize it.
7.8 -
7.9 + /// If the graph contains a \e nodeNum() member function and a
7.10 + /// \e NodeNumTag tag then this function calls directly the member
7.11 + /// function to query the cardinality of the node set.
7.12 template <typename Graph>
7.13 inline int countNodes(const Graph& g) {
7.14 return _graph_utils_bits::CountNodesSelector<Graph>::count(g);
7.15 @@ -179,8 +180,9 @@
7.16 /// The complexity of the function is O(an) but for some
7.17 /// graph structures it is specialized to run in O(1).
7.18 ///
7.19 - /// \todo Refer how to specialize it.
7.20 -
7.21 + /// If the graph contains an \e aNodeNum() member function and a
7.22 + /// \e NodeNumTag tag then this function calls directly the member
7.23 + /// function to query the cardinality of the A-node set.
7.24 template <typename Graph>
7.25 inline int countANodes(const Graph& g) {
7.26 return _graph_utils_bits::CountANodesSelector<Graph>::count(g);
7.27 @@ -212,8 +214,9 @@
7.28 /// The complexity of the function is O(bn) but for some
7.29 /// graph structures it is specialized to run in O(1).
7.30 ///
7.31 - /// \todo Refer how to specialize it.
7.32 -
7.33 + /// If the graph contains a \e bNodeNum() member function and a
7.34 + /// \e NodeNumTag tag then this function calls directly the member
7.35 + /// function to query the cardinality of the B-node set.
7.36 template <typename Graph>
7.37 inline int countBNodes(const Graph& g) {
7.38 return _graph_utils_bits::CountBNodesSelector<Graph>::count(g);
7.39 @@ -247,7 +250,10 @@
7.40 /// This function counts the edges in the graph.
7.41 /// The complexity of the function is O(e) but for some
7.42 /// graph structures it is specialized to run in O(1).
7.43 -
7.44 + ///
7.45 + /// If the graph contains a \e edgeNum() member function and a
7.46 + /// \e EdgeNumTag tag then this function calls directly the member
7.47 + /// function to query the cardinality of the edge set.
7.48 template <typename Graph>
7.49 inline int countEdges(const Graph& g) {
7.50 return _graph_utils_bits::CountEdgesSelector<Graph>::count(g);
7.51 @@ -279,7 +285,10 @@
7.52 /// This function counts the undirected edges in the graph.
7.53 /// The complexity of the function is O(e) but for some
7.54 /// graph structures it is specialized to run in O(1).
7.55 -
7.56 + ///
7.57 + /// If the graph contains a \e uEdgeNum() member function and a
7.58 + /// \e EdgeNumTag tag then this function calls directly the member
7.59 + /// function to query the cardinality of the undirected edge set.
7.60 template <typename Graph>
7.61 inline int countUEdges(const Graph& g) {
7.62 return _graph_utils_bits::CountUEdgesSelector<Graph>::count(g);
7.63 @@ -559,26 +568,26 @@
7.64
7.65 /// \brief Copy a map.
7.66 ///
7.67 - /// This function copies the \c source map to the \c target map. It uses the
7.68 + /// This function copies the \c from map to the \c to map. It uses the
7.69 /// given iterator to iterate on the data structure and it uses the \c ref
7.70 - /// mapping to convert the source's keys to the target's keys.
7.71 - template <typename Target, typename Source,
7.72 + /// mapping to convert the from's keys to the to's keys.
7.73 + template <typename To, typename From,
7.74 typename ItemIt, typename Ref>
7.75 - void copyMap(Target& target, const Source& source,
7.76 + void copyMap(To& to, const From& from,
7.77 ItemIt it, const Ref& ref) {
7.78 for (; it != INVALID; ++it) {
7.79 - target[ref[it]] = source[it];
7.80 + to[ref[it]] = from[it];
7.81 }
7.82 }
7.83
7.84 - /// \brief Copy the source map to the target map.
7.85 + /// \brief Copy the from map to the to map.
7.86 ///
7.87 - /// Copy the \c source map to the \c target map. It uses the given iterator
7.88 + /// Copy the \c from map to the \c to map. It uses the given iterator
7.89 /// to iterate on the data structure.
7.90 - template <typename Target, typename Source, typename ItemIt>
7.91 - void copyMap(Target& target, const Source& source, ItemIt it) {
7.92 + template <typename To, typename From, typename ItemIt>
7.93 + void copyMap(To& to, const From& from, ItemIt it) {
7.94 for (; it != INVALID; ++it) {
7.95 - target[it] = source[it];
7.96 + to[it] = from[it];
7.97 }
7.98 }
7.99
7.100 @@ -587,17 +596,17 @@
7.101 template <typename Graph, typename Item, typename RefMap>
7.102 class MapCopyBase {
7.103 public:
7.104 - virtual void copy(const Graph& source, const RefMap& refMap) = 0;
7.105 + virtual void copy(const Graph& from, const RefMap& refMap) = 0;
7.106
7.107 virtual ~MapCopyBase() {}
7.108 };
7.109
7.110 template <typename Graph, typename Item, typename RefMap,
7.111 - typename TargetMap, typename SourceMap>
7.112 + typename ToMap, typename FromMap>
7.113 class MapCopy : public MapCopyBase<Graph, Item, RefMap> {
7.114 public:
7.115
7.116 - MapCopy(TargetMap& tmap, const SourceMap& map)
7.117 + MapCopy(ToMap& tmap, const FromMap& map)
7.118 : _tmap(tmap), _map(map) {}
7.119
7.120 virtual void copy(const Graph& graph, const RefMap& refMap) {
7.121 @@ -608,8 +617,8 @@
7.122 }
7.123
7.124 private:
7.125 - TargetMap& _tmap;
7.126 - const SourceMap& _map;
7.127 + ToMap& _tmap;
7.128 + const FromMap& _map;
7.129 };
7.130
7.131 template <typename Graph, typename Item, typename RefMap, typename It>
7.132 @@ -664,15 +673,15 @@
7.133
7.134 template <typename Graph, typename Enable = void>
7.135 struct GraphCopySelector {
7.136 - template <typename Source, typename NodeRefMap, typename EdgeRefMap>
7.137 - static void copy(Graph &target, const Source& source,
7.138 + template <typename From, typename NodeRefMap, typename EdgeRefMap>
7.139 + static void copy(Graph &to, const From& from,
7.140 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
7.141 - for (typename Source::NodeIt it(source); it != INVALID; ++it) {
7.142 - nodeRefMap[it] = target.addNode();
7.143 + for (typename From::NodeIt it(from); it != INVALID; ++it) {
7.144 + nodeRefMap[it] = to.addNode();
7.145 }
7.146 - for (typename Source::EdgeIt it(source); it != INVALID; ++it) {
7.147 - edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
7.148 - nodeRefMap[source.target(it)]);
7.149 + for (typename From::EdgeIt it(from); it != INVALID; ++it) {
7.150 + edgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)],
7.151 + nodeRefMap[from.target(it)]);
7.152 }
7.153 }
7.154 };
7.155 @@ -682,24 +691,24 @@
7.156 Graph,
7.157 typename enable_if<typename Graph::BuildTag, void>::type>
7.158 {
7.159 - template <typename Source, typename NodeRefMap, typename EdgeRefMap>
7.160 - static void copy(Graph &target, const Source& source,
7.161 + template <typename From, typename NodeRefMap, typename EdgeRefMap>
7.162 + static void copy(Graph &to, const From& from,
7.163 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
7.164 - target.build(source, nodeRefMap, edgeRefMap);
7.165 + to.build(from, nodeRefMap, edgeRefMap);
7.166 }
7.167 };
7.168
7.169 template <typename UGraph, typename Enable = void>
7.170 struct UGraphCopySelector {
7.171 - template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
7.172 - static void copy(UGraph &target, const Source& source,
7.173 + template <typename From, typename NodeRefMap, typename UEdgeRefMap>
7.174 + static void copy(UGraph &to, const From& from,
7.175 NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
7.176 - for (typename Source::NodeIt it(source); it != INVALID; ++it) {
7.177 - nodeRefMap[it] = target.addNode();
7.178 + for (typename From::NodeIt it(from); it != INVALID; ++it) {
7.179 + nodeRefMap[it] = to.addNode();
7.180 }
7.181 - for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
7.182 - uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)],
7.183 - nodeRefMap[source.target(it)]);
7.184 + for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
7.185 + uEdgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)],
7.186 + nodeRefMap[from.target(it)]);
7.187 }
7.188 }
7.189 };
7.190 @@ -709,29 +718,29 @@
7.191 UGraph,
7.192 typename enable_if<typename UGraph::BuildTag, void>::type>
7.193 {
7.194 - template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
7.195 - static void copy(UGraph &target, const Source& source,
7.196 + template <typename From, typename NodeRefMap, typename UEdgeRefMap>
7.197 + static void copy(UGraph &to, const From& from,
7.198 NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
7.199 - target.build(source, nodeRefMap, uEdgeRefMap);
7.200 + to.build(from, nodeRefMap, uEdgeRefMap);
7.201 }
7.202 };
7.203
7.204 template <typename BpUGraph, typename Enable = void>
7.205 struct BpUGraphCopySelector {
7.206 - template <typename Source, typename ANodeRefMap,
7.207 + template <typename From, typename ANodeRefMap,
7.208 typename BNodeRefMap, typename UEdgeRefMap>
7.209 - static void copy(BpUGraph &target, const Source& source,
7.210 + static void copy(BpUGraph &to, const From& from,
7.211 ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
7.212 UEdgeRefMap& uEdgeRefMap) {
7.213 - for (typename Source::ANodeIt it(source); it != INVALID; ++it) {
7.214 - aNodeRefMap[it] = target.addANode();
7.215 + for (typename From::ANodeIt it(from); it != INVALID; ++it) {
7.216 + aNodeRefMap[it] = to.addANode();
7.217 }
7.218 - for (typename Source::BNodeIt it(source); it != INVALID; ++it) {
7.219 - bNodeRefMap[it] = target.addBNode();
7.220 + for (typename From::BNodeIt it(from); it != INVALID; ++it) {
7.221 + bNodeRefMap[it] = to.addBNode();
7.222 }
7.223 - for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
7.224 - uEdgeRefMap[it] = target.addEdge(aNodeRefMap[source.aNode(it)],
7.225 - bNodeRefMap[source.bNode(it)]);
7.226 + for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
7.227 + uEdgeRefMap[it] = to.addEdge(aNodeRefMap[from.aNode(it)],
7.228 + bNodeRefMap[from.bNode(it)]);
7.229 }
7.230 }
7.231 };
7.232 @@ -741,12 +750,12 @@
7.233 BpUGraph,
7.234 typename enable_if<typename BpUGraph::BuildTag, void>::type>
7.235 {
7.236 - template <typename Source, typename ANodeRefMap,
7.237 + template <typename From, typename ANodeRefMap,
7.238 typename BNodeRefMap, typename UEdgeRefMap>
7.239 - static void copy(BpUGraph &target, const Source& source,
7.240 + static void copy(BpUGraph &to, const From& from,
7.241 ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
7.242 UEdgeRefMap& uEdgeRefMap) {
7.243 - target.build(source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
7.244 + to.build(from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
7.245 }
7.246 };
7.247
7.248 @@ -757,20 +766,20 @@
7.249 ///
7.250 /// Class to copy a graph to another graph (duplicate a graph). The
7.251 /// simplest way of using it is through the \c copyGraph() function.
7.252 - template <typename Target, typename Source>
7.253 + template <typename To, typename From>
7.254 class GraphCopy {
7.255 private:
7.256
7.257 - typedef typename Source::Node Node;
7.258 - typedef typename Source::NodeIt NodeIt;
7.259 - typedef typename Source::Edge Edge;
7.260 - typedef typename Source::EdgeIt EdgeIt;
7.261 + typedef typename From::Node Node;
7.262 + typedef typename From::NodeIt NodeIt;
7.263 + typedef typename From::Edge Edge;
7.264 + typedef typename From::EdgeIt EdgeIt;
7.265
7.266 - typedef typename Target::Node TNode;
7.267 - typedef typename Target::Edge TEdge;
7.268 + typedef typename To::Node TNode;
7.269 + typedef typename To::Edge TEdge;
7.270
7.271 - typedef typename Source::template NodeMap<TNode> NodeRefMap;
7.272 - typedef typename Source::template EdgeMap<TEdge> EdgeRefMap;
7.273 + typedef typename From::template NodeMap<TNode> NodeRefMap;
7.274 + typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
7.275
7.276
7.277 public:
7.278 @@ -778,10 +787,10 @@
7.279
7.280 /// \brief Constructor for the GraphCopy.
7.281 ///
7.282 - /// It copies the content of the \c _source graph into the
7.283 - /// \c _target graph.
7.284 - GraphCopy(Target& _target, const Source& _source)
7.285 - : source(_source), target(_target) {}
7.286 + /// It copies the content of the \c _from graph into the
7.287 + /// \c _to graph.
7.288 + GraphCopy(To& _to, const From& _from)
7.289 + : from(_from), to(_to) {}
7.290
7.291 /// \brief Destructor of the GraphCopy
7.292 ///
7.293 @@ -801,7 +810,7 @@
7.294 /// Copies the node references into the given map.
7.295 template <typename NodeRef>
7.296 GraphCopy& nodeRef(NodeRef& map) {
7.297 - nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
7.298 + nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
7.299 NodeRefMap, NodeRef>(map));
7.300 return *this;
7.301 }
7.302 @@ -812,7 +821,7 @@
7.303 /// the given map.
7.304 template <typename NodeCrossRef>
7.305 GraphCopy& nodeCrossRef(NodeCrossRef& map) {
7.306 - nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
7.307 + nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
7.308 NodeRefMap, NodeCrossRef>(map));
7.309 return *this;
7.310 }
7.311 @@ -820,13 +829,13 @@
7.312 /// \brief Make copy of the given map.
7.313 ///
7.314 /// Makes copy of the given map for the newly created graph.
7.315 - /// The new map's key type is the target graph's node type,
7.316 - /// and the copied map's key type is the source graph's node
7.317 + /// The new map's key type is the to graph's node type,
7.318 + /// and the copied map's key type is the from graph's node
7.319 /// type.
7.320 - template <typename TargetMap, typename SourceMap>
7.321 - GraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
7.322 - nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
7.323 - NodeRefMap, TargetMap, SourceMap>(tmap, map));
7.324 + template <typename ToMap, typename FromMap>
7.325 + GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
7.326 + nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
7.327 + NodeRefMap, ToMap, FromMap>(tmap, map));
7.328 return *this;
7.329 }
7.330
7.331 @@ -834,7 +843,7 @@
7.332 ///
7.333 /// Make a copy of the given node.
7.334 GraphCopy& node(TNode& tnode, const Node& snode) {
7.335 - nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
7.336 + nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
7.337 NodeRefMap, TNode>(tnode, snode));
7.338 return *this;
7.339 }
7.340 @@ -844,7 +853,7 @@
7.341 /// Copies the edge references into the given map.
7.342 template <typename EdgeRef>
7.343 GraphCopy& edgeRef(EdgeRef& map) {
7.344 - edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
7.345 + edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
7.346 EdgeRefMap, EdgeRef>(map));
7.347 return *this;
7.348 }
7.349 @@ -855,7 +864,7 @@
7.350 /// the given map.
7.351 template <typename EdgeCrossRef>
7.352 GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
7.353 - edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
7.354 + edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
7.355 EdgeRefMap, EdgeCrossRef>(map));
7.356 return *this;
7.357 }
7.358 @@ -863,13 +872,13 @@
7.359 /// \brief Make copy of the given map.
7.360 ///
7.361 /// Makes copy of the given map for the newly created graph.
7.362 - /// The new map's key type is the target graph's edge type,
7.363 - /// and the copied map's key type is the source graph's edge
7.364 + /// The new map's key type is the to graph's edge type,
7.365 + /// and the copied map's key type is the from graph's edge
7.366 /// type.
7.367 - template <typename TargetMap, typename SourceMap>
7.368 - GraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
7.369 - edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
7.370 - EdgeRefMap, TargetMap, SourceMap>(tmap, map));
7.371 + template <typename ToMap, typename FromMap>
7.372 + GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
7.373 + edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
7.374 + EdgeRefMap, ToMap, FromMap>(tmap, map));
7.375 return *this;
7.376 }
7.377
7.378 @@ -877,7 +886,7 @@
7.379 ///
7.380 /// Make a copy of the given edge.
7.381 GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
7.382 - edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
7.383 + edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
7.384 EdgeRefMap, TEdge>(tedge, sedge));
7.385 return *this;
7.386 }
7.387 @@ -886,28 +895,28 @@
7.388 ///
7.389 /// Executes the copies.
7.390 void run() {
7.391 - NodeRefMap nodeRefMap(source);
7.392 - EdgeRefMap edgeRefMap(source);
7.393 - _graph_utils_bits::GraphCopySelector<Target>::
7.394 - copy(target, source, nodeRefMap, edgeRefMap);
7.395 + NodeRefMap nodeRefMap(from);
7.396 + EdgeRefMap edgeRefMap(from);
7.397 + _graph_utils_bits::GraphCopySelector<To>::
7.398 + copy(to, from, nodeRefMap, edgeRefMap);
7.399 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
7.400 - nodeMapCopies[i]->copy(source, nodeRefMap);
7.401 + nodeMapCopies[i]->copy(from, nodeRefMap);
7.402 }
7.403 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
7.404 - edgeMapCopies[i]->copy(source, edgeRefMap);
7.405 + edgeMapCopies[i]->copy(from, edgeRefMap);
7.406 }
7.407 }
7.408
7.409 protected:
7.410
7.411
7.412 - const Source& source;
7.413 - Target& target;
7.414 + const From& from;
7.415 + To& to;
7.416
7.417 - std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
7.418 + std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
7.419 nodeMapCopies;
7.420
7.421 - std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
7.422 + std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
7.423 edgeMapCopies;
7.424
7.425 };
7.426 @@ -922,57 +931,57 @@
7.427 ///\endcode
7.428 ///
7.429 /// After the copy the \c nr map will contain the mapping from the
7.430 - /// source graph's nodes to the target graph's nodes and the \c ecr will
7.431 - /// contain the mapping from the target graph's edges to the source's
7.432 + /// from graph's nodes to the to graph's nodes and the \c ecr will
7.433 + /// contain the mapping from the to graph's edges to the from's
7.434 /// edges.
7.435 ///
7.436 /// \see GraphCopy
7.437 - template <typename Target, typename Source>
7.438 - GraphCopy<Target, Source> copyGraph(Target& target, const Source& source) {
7.439 - return GraphCopy<Target, Source>(target, source);
7.440 + template <typename To, typename From>
7.441 + GraphCopy<To, From> copyGraph(To& to, const From& from) {
7.442 + return GraphCopy<To, From>(to, from);
7.443 }
7.444
7.445 /// \brief Class to copy an undirected graph.
7.446 ///
7.447 /// Class to copy an undirected graph to another graph (duplicate a graph).
7.448 /// The simplest way of using it is through the \c copyUGraph() function.
7.449 - template <typename Target, typename Source>
7.450 + template <typename To, typename From>
7.451 class UGraphCopy {
7.452 private:
7.453
7.454 - typedef typename Source::Node Node;
7.455 - typedef typename Source::NodeIt NodeIt;
7.456 - typedef typename Source::Edge Edge;
7.457 - typedef typename Source::EdgeIt EdgeIt;
7.458 - typedef typename Source::UEdge UEdge;
7.459 - typedef typename Source::UEdgeIt UEdgeIt;
7.460 + typedef typename From::Node Node;
7.461 + typedef typename From::NodeIt NodeIt;
7.462 + typedef typename From::Edge Edge;
7.463 + typedef typename From::EdgeIt EdgeIt;
7.464 + typedef typename From::UEdge UEdge;
7.465 + typedef typename From::UEdgeIt UEdgeIt;
7.466
7.467 - typedef typename Target::Node TNode;
7.468 - typedef typename Target::Edge TEdge;
7.469 - typedef typename Target::UEdge TUEdge;
7.470 + typedef typename To::Node TNode;
7.471 + typedef typename To::Edge TEdge;
7.472 + typedef typename To::UEdge TUEdge;
7.473
7.474 - typedef typename Source::template NodeMap<TNode> NodeRefMap;
7.475 - typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
7.476 + typedef typename From::template NodeMap<TNode> NodeRefMap;
7.477 + typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
7.478
7.479 struct EdgeRefMap {
7.480 - EdgeRefMap(const Target& _target, const Source& _source,
7.481 + EdgeRefMap(const To& _to, const From& _from,
7.482 const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref)
7.483 - : target(_target), source(_source),
7.484 + : to(_to), from(_from),
7.485 uedge_ref(_uedge_ref), node_ref(_node_ref) {}
7.486
7.487 - typedef typename Source::Edge Key;
7.488 - typedef typename Target::Edge Value;
7.489 + typedef typename From::Edge Key;
7.490 + typedef typename To::Edge Value;
7.491
7.492 Value operator[](const Key& key) const {
7.493 bool forward =
7.494 - (source.direction(key) ==
7.495 - (node_ref[source.source(static_cast<const UEdge&>(key))] ==
7.496 - target.source(uedge_ref[static_cast<const UEdge&>(key)])));
7.497 - return target.direct(uedge_ref[key], forward);
7.498 + (from.direction(key) ==
7.499 + (node_ref[from.source(static_cast<const UEdge&>(key))] ==
7.500 + to.source(uedge_ref[static_cast<const UEdge&>(key)])));
7.501 + return to.direct(uedge_ref[key], forward);
7.502 }
7.503
7.504 - const Target& target;
7.505 - const Source& source;
7.506 + const To& to;
7.507 + const From& from;
7.508 const UEdgeRefMap& uedge_ref;
7.509 const NodeRefMap& node_ref;
7.510 };
7.511 @@ -983,10 +992,10 @@
7.512
7.513 /// \brief Constructor for the GraphCopy.
7.514 ///
7.515 - /// It copies the content of the \c _source graph into the
7.516 - /// \c _target graph.
7.517 - UGraphCopy(Target& _target, const Source& _source)
7.518 - : source(_source), target(_target) {}
7.519 + /// It copies the content of the \c _from graph into the
7.520 + /// \c _to graph.
7.521 + UGraphCopy(To& _to, const From& _from)
7.522 + : from(_from), to(_to) {}
7.523
7.524 /// \brief Destructor of the GraphCopy
7.525 ///
7.526 @@ -1009,7 +1018,7 @@
7.527 /// Copies the node references into the given map.
7.528 template <typename NodeRef>
7.529 UGraphCopy& nodeRef(NodeRef& map) {
7.530 - nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
7.531 + nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
7.532 NodeRefMap, NodeRef>(map));
7.533 return *this;
7.534 }
7.535 @@ -1020,7 +1029,7 @@
7.536 /// the given map.
7.537 template <typename NodeCrossRef>
7.538 UGraphCopy& nodeCrossRef(NodeCrossRef& map) {
7.539 - nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
7.540 + nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
7.541 NodeRefMap, NodeCrossRef>(map));
7.542 return *this;
7.543 }
7.544 @@ -1028,13 +1037,13 @@
7.545 /// \brief Make copy of the given map.
7.546 ///
7.547 /// Makes copy of the given map for the newly created graph.
7.548 - /// The new map's key type is the target graph's node type,
7.549 - /// and the copied map's key type is the source graph's node
7.550 + /// The new map's key type is the to graph's node type,
7.551 + /// and the copied map's key type is the from graph's node
7.552 /// type.
7.553 - template <typename TargetMap, typename SourceMap>
7.554 - UGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
7.555 - nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
7.556 - NodeRefMap, TargetMap, SourceMap>(tmap, map));
7.557 + template <typename ToMap, typename FromMap>
7.558 + UGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
7.559 + nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
7.560 + NodeRefMap, ToMap, FromMap>(tmap, map));
7.561 return *this;
7.562 }
7.563
7.564 @@ -1042,7 +1051,7 @@
7.565 ///
7.566 /// Make a copy of the given node.
7.567 UGraphCopy& node(TNode& tnode, const Node& snode) {
7.568 - nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
7.569 + nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
7.570 NodeRefMap, TNode>(tnode, snode));
7.571 return *this;
7.572 }
7.573 @@ -1052,7 +1061,7 @@
7.574 /// Copies the edge references into the given map.
7.575 template <typename EdgeRef>
7.576 UGraphCopy& edgeRef(EdgeRef& map) {
7.577 - edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
7.578 + edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
7.579 EdgeRefMap, EdgeRef>(map));
7.580 return *this;
7.581 }
7.582 @@ -1063,7 +1072,7 @@
7.583 /// the given map.
7.584 template <typename EdgeCrossRef>
7.585 UGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
7.586 - edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
7.587 + edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
7.588 EdgeRefMap, EdgeCrossRef>(map));
7.589 return *this;
7.590 }
7.591 @@ -1071,13 +1080,13 @@
7.592 /// \brief Make copy of the given map.
7.593 ///
7.594 /// Makes copy of the given map for the newly created graph.
7.595 - /// The new map's key type is the target graph's edge type,
7.596 - /// and the copied map's key type is the source graph's edge
7.597 + /// The new map's key type is the to graph's edge type,
7.598 + /// and the copied map's key type is the from graph's edge
7.599 /// type.
7.600 - template <typename TargetMap, typename SourceMap>
7.601 - UGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
7.602 - edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
7.603 - EdgeRefMap, TargetMap, SourceMap>(tmap, map));
7.604 + template <typename ToMap, typename FromMap>
7.605 + UGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
7.606 + edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
7.607 + EdgeRefMap, ToMap, FromMap>(tmap, map));
7.608 return *this;
7.609 }
7.610
7.611 @@ -1085,7 +1094,7 @@
7.612 ///
7.613 /// Make a copy of the given edge.
7.614 UGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
7.615 - edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
7.616 + edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
7.617 EdgeRefMap, TEdge>(tedge, sedge));
7.618 return *this;
7.619 }
7.620 @@ -1095,7 +1104,7 @@
7.621 /// Copies the undirected edge references into the given map.
7.622 template <typename UEdgeRef>
7.623 UGraphCopy& uEdgeRef(UEdgeRef& map) {
7.624 - uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge,
7.625 + uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge,
7.626 UEdgeRefMap, UEdgeRef>(map));
7.627 return *this;
7.628 }
7.629 @@ -1106,7 +1115,7 @@
7.630 /// references) into the given map.
7.631 template <typename UEdgeCrossRef>
7.632 UGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
7.633 - uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
7.634 + uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
7.635 UEdge, UEdgeRefMap, UEdgeCrossRef>(map));
7.636 return *this;
7.637 }
7.638 @@ -1114,13 +1123,13 @@
7.639 /// \brief Make copy of the given map.
7.640 ///
7.641 /// Makes copy of the given map for the newly created graph.
7.642 - /// The new map's key type is the target graph's undirected edge type,
7.643 - /// and the copied map's key type is the source graph's undirected edge
7.644 + /// The new map's key type is the to graph's undirected edge type,
7.645 + /// and the copied map's key type is the from graph's undirected edge
7.646 /// type.
7.647 - template <typename TargetMap, typename SourceMap>
7.648 - UGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
7.649 - uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge,
7.650 - UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
7.651 + template <typename ToMap, typename FromMap>
7.652 + UGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
7.653 + uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge,
7.654 + UEdgeRefMap, ToMap, FromMap>(tmap, map));
7.655 return *this;
7.656 }
7.657
7.658 @@ -1128,7 +1137,7 @@
7.659 ///
7.660 /// Make a copy of the given undirected edge.
7.661 UGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
7.662 - uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
7.663 + uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge,
7.664 UEdgeRefMap, TUEdge>(tuedge, suedge));
7.665 return *this;
7.666 }
7.667 @@ -1137,34 +1146,34 @@
7.668 ///
7.669 /// Executes the copies.
7.670 void run() {
7.671 - NodeRefMap nodeRefMap(source);
7.672 - UEdgeRefMap uEdgeRefMap(source);
7.673 - EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
7.674 - _graph_utils_bits::UGraphCopySelector<Target>::
7.675 - copy(target, source, nodeRefMap, uEdgeRefMap);
7.676 + NodeRefMap nodeRefMap(from);
7.677 + UEdgeRefMap uEdgeRefMap(from);
7.678 + EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
7.679 + _graph_utils_bits::UGraphCopySelector<To>::
7.680 + copy(to, from, nodeRefMap, uEdgeRefMap);
7.681 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
7.682 - nodeMapCopies[i]->copy(source, nodeRefMap);
7.683 + nodeMapCopies[i]->copy(from, nodeRefMap);
7.684 }
7.685 for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
7.686 - uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
7.687 + uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
7.688 }
7.689 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
7.690 - edgeMapCopies[i]->copy(source, edgeRefMap);
7.691 + edgeMapCopies[i]->copy(from, edgeRefMap);
7.692 }
7.693 }
7.694
7.695 private:
7.696
7.697 - const Source& source;
7.698 - Target& target;
7.699 + const From& from;
7.700 + To& to;
7.701
7.702 - std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
7.703 + std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
7.704 nodeMapCopies;
7.705
7.706 - std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
7.707 + std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
7.708 edgeMapCopies;
7.709
7.710 - std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* >
7.711 + std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* >
7.712 uEdgeMapCopies;
7.713
7.714 };
7.715 @@ -1179,15 +1188,15 @@
7.716 ///\endcode
7.717 ///
7.718 /// After the copy the \c nr map will contain the mapping from the
7.719 - /// source graph's nodes to the target graph's nodes and the \c ecr will
7.720 - /// contain the mapping from the target graph's edges to the source's
7.721 + /// from graph's nodes to the to graph's nodes and the \c ecr will
7.722 + /// contain the mapping from the to graph's edges to the from's
7.723 /// edges.
7.724 ///
7.725 /// \see UGraphCopy
7.726 - template <typename Target, typename Source>
7.727 - UGraphCopy<Target, Source>
7.728 - copyUGraph(Target& target, const Source& source) {
7.729 - return UGraphCopy<Target, Source>(target, source);
7.730 + template <typename To, typename From>
7.731 + UGraphCopy<To, From>
7.732 + copyUGraph(To& to, const From& from) {
7.733 + return UGraphCopy<To, From>(to, from);
7.734 }
7.735
7.736 /// \brief Class to copy a bipartite undirected graph.
7.737 @@ -1195,63 +1204,63 @@
7.738 /// Class to copy a bipartite undirected graph to another graph
7.739 /// (duplicate a graph). The simplest way of using it is through
7.740 /// the \c copyBpUGraph() function.
7.741 - template <typename Target, typename Source>
7.742 + template <typename To, typename From>
7.743 class BpUGraphCopy {
7.744 private:
7.745
7.746 - typedef typename Source::Node Node;
7.747 - typedef typename Source::ANode ANode;
7.748 - typedef typename Source::BNode BNode;
7.749 - typedef typename Source::NodeIt NodeIt;
7.750 - typedef typename Source::Edge Edge;
7.751 - typedef typename Source::EdgeIt EdgeIt;
7.752 - typedef typename Source::UEdge UEdge;
7.753 - typedef typename Source::UEdgeIt UEdgeIt;
7.754 + typedef typename From::Node Node;
7.755 + typedef typename From::ANode ANode;
7.756 + typedef typename From::BNode BNode;
7.757 + typedef typename From::NodeIt NodeIt;
7.758 + typedef typename From::Edge Edge;
7.759 + typedef typename From::EdgeIt EdgeIt;
7.760 + typedef typename From::UEdge UEdge;
7.761 + typedef typename From::UEdgeIt UEdgeIt;
7.762
7.763 - typedef typename Target::Node TNode;
7.764 - typedef typename Target::Edge TEdge;
7.765 - typedef typename Target::UEdge TUEdge;
7.766 + typedef typename To::Node TNode;
7.767 + typedef typename To::Edge TEdge;
7.768 + typedef typename To::UEdge TUEdge;
7.769
7.770 - typedef typename Source::template ANodeMap<TNode> ANodeRefMap;
7.771 - typedef typename Source::template BNodeMap<TNode> BNodeRefMap;
7.772 - typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
7.773 + typedef typename From::template ANodeMap<TNode> ANodeRefMap;
7.774 + typedef typename From::template BNodeMap<TNode> BNodeRefMap;
7.775 + typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
7.776
7.777 struct NodeRefMap {
7.778 - NodeRefMap(const Source& _source, const ANodeRefMap& _anode_ref,
7.779 + NodeRefMap(const From& _from, const ANodeRefMap& _anode_ref,
7.780 const BNodeRefMap& _bnode_ref)
7.781 - : source(_source), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
7.782 + : from(_from), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
7.783
7.784 - typedef typename Source::Node Key;
7.785 - typedef typename Target::Node Value;
7.786 + typedef typename From::Node Key;
7.787 + typedef typename To::Node Value;
7.788
7.789 Value operator[](const Key& key) const {
7.790 - return source.aNode(key) ? anode_ref[key] : bnode_ref[key];
7.791 + return from.aNode(key) ? anode_ref[key] : bnode_ref[key];
7.792 }
7.793
7.794 - const Source& source;
7.795 + const From& from;
7.796 const ANodeRefMap& anode_ref;
7.797 const BNodeRefMap& bnode_ref;
7.798 };
7.799
7.800 struct EdgeRefMap {
7.801 - EdgeRefMap(const Target& _target, const Source& _source,
7.802 + EdgeRefMap(const To& _to, const From& _from,
7.803 const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref)
7.804 - : target(_target), source(_source),
7.805 + : to(_to), from(_from),
7.806 uedge_ref(_uedge_ref), node_ref(_node_ref) {}
7.807
7.808 - typedef typename Source::Edge Key;
7.809 - typedef typename Target::Edge Value;
7.810 + typedef typename From::Edge Key;
7.811 + typedef typename To::Edge Value;
7.812
7.813 Value operator[](const Key& key) const {
7.814 bool forward =
7.815 - (source.direction(key) ==
7.816 - (node_ref[source.source(static_cast<const UEdge&>(key))] ==
7.817 - target.source(uedge_ref[static_cast<const UEdge&>(key)])));
7.818 - return target.direct(uedge_ref[key], forward);
7.819 + (from.direction(key) ==
7.820 + (node_ref[from.source(static_cast<const UEdge&>(key))] ==
7.821 + to.source(uedge_ref[static_cast<const UEdge&>(key)])));
7.822 + return to.direct(uedge_ref[key], forward);
7.823 }
7.824
7.825 - const Target& target;
7.826 - const Source& source;
7.827 + const To& to;
7.828 + const From& from;
7.829 const UEdgeRefMap& uedge_ref;
7.830 const NodeRefMap& node_ref;
7.831 };
7.832 @@ -1261,10 +1270,10 @@
7.833
7.834 /// \brief Constructor for the GraphCopy.
7.835 ///
7.836 - /// It copies the content of the \c _source graph into the
7.837 - /// \c _target graph.
7.838 - BpUGraphCopy(Target& _target, const Source& _source)
7.839 - : source(_source), target(_target) {}
7.840 + /// It copies the content of the \c _from graph into the
7.841 + /// \c _to graph.
7.842 + BpUGraphCopy(To& _to, const From& _from)
7.843 + : from(_from), to(_to) {}
7.844
7.845 /// \brief Destructor of the GraphCopy
7.846 ///
7.847 @@ -1293,7 +1302,7 @@
7.848 /// Copies the A-node references into the given map.
7.849 template <typename ANodeRef>
7.850 BpUGraphCopy& aNodeRef(ANodeRef& map) {
7.851 - aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, ANode,
7.852 + aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, ANode,
7.853 ANodeRefMap, ANodeRef>(map));
7.854 return *this;
7.855 }
7.856 @@ -1304,7 +1313,7 @@
7.857 /// the given map.
7.858 template <typename ANodeCrossRef>
7.859 BpUGraphCopy& aNodeCrossRef(ANodeCrossRef& map) {
7.860 - aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
7.861 + aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
7.862 ANode, ANodeRefMap, ANodeCrossRef>(map));
7.863 return *this;
7.864 }
7.865 @@ -1312,13 +1321,13 @@
7.866 /// \brief Make copy of the given A-node map.
7.867 ///
7.868 /// Makes copy of the given map for the newly created graph.
7.869 - /// The new map's key type is the target graph's node type,
7.870 - /// and the copied map's key type is the source graph's node
7.871 + /// The new map's key type is the to graph's node type,
7.872 + /// and the copied map's key type is the from graph's node
7.873 /// type.
7.874 - template <typename TargetMap, typename SourceMap>
7.875 - BpUGraphCopy& aNodeMap(TargetMap& tmap, const SourceMap& map) {
7.876 - aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, ANode,
7.877 - ANodeRefMap, TargetMap, SourceMap>(tmap, map));
7.878 + template <typename ToMap, typename FromMap>
7.879 + BpUGraphCopy& aNodeMap(ToMap& tmap, const FromMap& map) {
7.880 + aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, ANode,
7.881 + ANodeRefMap, ToMap, FromMap>(tmap, map));
7.882 return *this;
7.883 }
7.884
7.885 @@ -1327,7 +1336,7 @@
7.886 /// Copies the B-node references into the given map.
7.887 template <typename BNodeRef>
7.888 BpUGraphCopy& bNodeRef(BNodeRef& map) {
7.889 - bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, BNode,
7.890 + bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, BNode,
7.891 BNodeRefMap, BNodeRef>(map));
7.892 return *this;
7.893 }
7.894 @@ -1338,7 +1347,7 @@
7.895 /// the given map.
7.896 template <typename BNodeCrossRef>
7.897 BpUGraphCopy& bNodeCrossRef(BNodeCrossRef& map) {
7.898 - bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
7.899 + bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
7.900 BNode, BNodeRefMap, BNodeCrossRef>(map));
7.901 return *this;
7.902 }
7.903 @@ -1346,13 +1355,13 @@
7.904 /// \brief Make copy of the given B-node map.
7.905 ///
7.906 /// Makes copy of the given map for the newly created graph.
7.907 - /// The new map's key type is the target graph's node type,
7.908 - /// and the copied map's key type is the source graph's node
7.909 + /// The new map's key type is the to graph's node type,
7.910 + /// and the copied map's key type is the from graph's node
7.911 /// type.
7.912 - template <typename TargetMap, typename SourceMap>
7.913 - BpUGraphCopy& bNodeMap(TargetMap& tmap, const SourceMap& map) {
7.914 - bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, BNode,
7.915 - BNodeRefMap, TargetMap, SourceMap>(tmap, map));
7.916 + template <typename ToMap, typename FromMap>
7.917 + BpUGraphCopy& bNodeMap(ToMap& tmap, const FromMap& map) {
7.918 + bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, BNode,
7.919 + BNodeRefMap, ToMap, FromMap>(tmap, map));
7.920 return *this;
7.921 }
7.922 /// \brief Copies the node references into the given map.
7.923 @@ -1360,7 +1369,7 @@
7.924 /// Copies the node references into the given map.
7.925 template <typename NodeRef>
7.926 BpUGraphCopy& nodeRef(NodeRef& map) {
7.927 - nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node,
7.928 + nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node,
7.929 NodeRefMap, NodeRef>(map));
7.930 return *this;
7.931 }
7.932 @@ -1371,7 +1380,7 @@
7.933 /// the given map.
7.934 template <typename NodeCrossRef>
7.935 BpUGraphCopy& nodeCrossRef(NodeCrossRef& map) {
7.936 - nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
7.937 + nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
7.938 NodeRefMap, NodeCrossRef>(map));
7.939 return *this;
7.940 }
7.941 @@ -1379,13 +1388,13 @@
7.942 /// \brief Make copy of the given map.
7.943 ///
7.944 /// Makes copy of the given map for the newly created graph.
7.945 - /// The new map's key type is the target graph's node type,
7.946 - /// and the copied map's key type is the source graph's node
7.947 + /// The new map's key type is the to graph's node type,
7.948 + /// and the copied map's key type is the from graph's node
7.949 /// type.
7.950 - template <typename TargetMap, typename SourceMap>
7.951 - BpUGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
7.952 - nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node,
7.953 - NodeRefMap, TargetMap, SourceMap>(tmap, map));
7.954 + template <typename ToMap, typename FromMap>
7.955 + BpUGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
7.956 + nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node,
7.957 + NodeRefMap, ToMap, FromMap>(tmap, map));
7.958 return *this;
7.959 }
7.960
7.961 @@ -1393,7 +1402,7 @@
7.962 ///
7.963 /// Make a copy of the given node.
7.964 BpUGraphCopy& node(TNode& tnode, const Node& snode) {
7.965 - nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node,
7.966 + nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node,
7.967 NodeRefMap, TNode>(tnode, snode));
7.968 return *this;
7.969 }
7.970 @@ -1403,7 +1412,7 @@
7.971 /// Copies the edge references into the given map.
7.972 template <typename EdgeRef>
7.973 BpUGraphCopy& edgeRef(EdgeRef& map) {
7.974 - edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge,
7.975 + edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge,
7.976 EdgeRefMap, EdgeRef>(map));
7.977 return *this;
7.978 }
7.979 @@ -1414,7 +1423,7 @@
7.980 /// the given map.
7.981 template <typename EdgeCrossRef>
7.982 BpUGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
7.983 - edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
7.984 + edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
7.985 EdgeRefMap, EdgeCrossRef>(map));
7.986 return *this;
7.987 }
7.988 @@ -1422,13 +1431,13 @@
7.989 /// \brief Make copy of the given map.
7.990 ///
7.991 /// Makes copy of the given map for the newly created graph.
7.992 - /// The new map's key type is the target graph's edge type,
7.993 - /// and the copied map's key type is the source graph's edge
7.994 + /// The new map's key type is the to graph's edge type,
7.995 + /// and the copied map's key type is the from graph's edge
7.996 /// type.
7.997 - template <typename TargetMap, typename SourceMap>
7.998 - BpUGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
7.999 - edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge,
7.1000 - EdgeRefMap, TargetMap, SourceMap>(tmap, map));
7.1001 + template <typename ToMap, typename FromMap>
7.1002 + BpUGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
7.1003 + edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge,
7.1004 + EdgeRefMap, ToMap, FromMap>(tmap, map));
7.1005 return *this;
7.1006 }
7.1007
7.1008 @@ -1436,7 +1445,7 @@
7.1009 ///
7.1010 /// Make a copy of the given edge.
7.1011 BpUGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
7.1012 - edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge,
7.1013 + edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
7.1014 EdgeRefMap, TEdge>(tedge, sedge));
7.1015 return *this;
7.1016 }
7.1017 @@ -1446,7 +1455,7 @@
7.1018 /// Copies the undirected edge references into the given map.
7.1019 template <typename UEdgeRef>
7.1020 BpUGraphCopy& uEdgeRef(UEdgeRef& map) {
7.1021 - uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge,
7.1022 + uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge,
7.1023 UEdgeRefMap, UEdgeRef>(map));
7.1024 return *this;
7.1025 }
7.1026 @@ -1457,7 +1466,7 @@
7.1027 /// references) into the given map.
7.1028 template <typename UEdgeCrossRef>
7.1029 BpUGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
7.1030 - uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source,
7.1031 + uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From,
7.1032 UEdge, UEdgeRefMap, UEdgeCrossRef>(map));
7.1033 return *this;
7.1034 }
7.1035 @@ -1465,13 +1474,13 @@
7.1036 /// \brief Make copy of the given map.
7.1037 ///
7.1038 /// Makes copy of the given map for the newly created graph.
7.1039 - /// The new map's key type is the target graph's undirected edge type,
7.1040 - /// and the copied map's key type is the source graph's undirected edge
7.1041 + /// The new map's key type is the to graph's undirected edge type,
7.1042 + /// and the copied map's key type is the from graph's undirected edge
7.1043 /// type.
7.1044 - template <typename TargetMap, typename SourceMap>
7.1045 - BpUGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
7.1046 - uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge,
7.1047 - UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
7.1048 + template <typename ToMap, typename FromMap>
7.1049 + BpUGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
7.1050 + uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge,
7.1051 + UEdgeRefMap, ToMap, FromMap>(tmap, map));
7.1052 return *this;
7.1053 }
7.1054
7.1055 @@ -1479,7 +1488,7 @@
7.1056 ///
7.1057 /// Make a copy of the given undirected edge.
7.1058 BpUGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
7.1059 - uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge,
7.1060 + uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge,
7.1061 UEdgeRefMap, TUEdge>(tuedge, suedge));
7.1062 return *this;
7.1063 }
7.1064 @@ -1488,48 +1497,48 @@
7.1065 ///
7.1066 /// Executes the copies.
7.1067 void run() {
7.1068 - ANodeRefMap aNodeRefMap(source);
7.1069 - BNodeRefMap bNodeRefMap(source);
7.1070 - NodeRefMap nodeRefMap(source, aNodeRefMap, bNodeRefMap);
7.1071 - UEdgeRefMap uEdgeRefMap(source);
7.1072 - EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
7.1073 - _graph_utils_bits::BpUGraphCopySelector<Target>::
7.1074 - copy(target, source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
7.1075 + ANodeRefMap aNodeRefMap(from);
7.1076 + BNodeRefMap bNodeRefMap(from);
7.1077 + NodeRefMap nodeRefMap(from, aNodeRefMap, bNodeRefMap);
7.1078 + UEdgeRefMap uEdgeRefMap(from);
7.1079 + EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
7.1080 + _graph_utils_bits::BpUGraphCopySelector<To>::
7.1081 + copy(to, from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
7.1082 for (int i = 0; i < int(aNodeMapCopies.size()); ++i) {
7.1083 - aNodeMapCopies[i]->copy(source, aNodeRefMap);
7.1084 + aNodeMapCopies[i]->copy(from, aNodeRefMap);
7.1085 }
7.1086 for (int i = 0; i < int(bNodeMapCopies.size()); ++i) {
7.1087 - bNodeMapCopies[i]->copy(source, bNodeRefMap);
7.1088 + bNodeMapCopies[i]->copy(from, bNodeRefMap);
7.1089 }
7.1090 for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
7.1091 - nodeMapCopies[i]->copy(source, nodeRefMap);
7.1092 + nodeMapCopies[i]->copy(from, nodeRefMap);
7.1093 }
7.1094 for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
7.1095 - uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
7.1096 + uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
7.1097 }
7.1098 for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
7.1099 - edgeMapCopies[i]->copy(source, edgeRefMap);
7.1100 + edgeMapCopies[i]->copy(from, edgeRefMap);
7.1101 }
7.1102 }
7.1103
7.1104 private:
7.1105
7.1106 - const Source& source;
7.1107 - Target& target;
7.1108 + const From& from;
7.1109 + To& to;
7.1110
7.1111 - std::vector<_graph_utils_bits::MapCopyBase<Source, ANode, ANodeRefMap>* >
7.1112 + std::vector<_graph_utils_bits::MapCopyBase<From, ANode, ANodeRefMap>* >
7.1113 aNodeMapCopies;
7.1114
7.1115 - std::vector<_graph_utils_bits::MapCopyBase<Source, BNode, BNodeRefMap>* >
7.1116 + std::vector<_graph_utils_bits::MapCopyBase<From, BNode, BNodeRefMap>* >
7.1117 bNodeMapCopies;
7.1118
7.1119 - std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* >
7.1120 + std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
7.1121 nodeMapCopies;
7.1122
7.1123 - std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* >
7.1124 + std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
7.1125 edgeMapCopies;
7.1126
7.1127 - std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* >
7.1128 + std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* >
7.1129 uEdgeMapCopies;
7.1130
7.1131 };
7.1132 @@ -1544,15 +1553,15 @@
7.1133 ///\endcode
7.1134 ///
7.1135 /// After the copy the \c nr map will contain the mapping from the
7.1136 - /// source graph's nodes to the target graph's nodes and the \c ecr will
7.1137 - /// contain the mapping from the target graph's edges to the source's
7.1138 + /// from graph's nodes to the to graph's nodes and the \c ecr will
7.1139 + /// contain the mapping from the to graph's edges to the from's
7.1140 /// edges.
7.1141 ///
7.1142 /// \see BpUGraphCopy
7.1143 - template <typename Target, typename Source>
7.1144 - BpUGraphCopy<Target, Source>
7.1145 - copyBpUGraph(Target& target, const Source& source) {
7.1146 - return BpUGraphCopy<Target, Source>(target, source);
7.1147 + template <typename To, typename From>
7.1148 + BpUGraphCopy<To, From>
7.1149 + copyBpUGraph(To& to, const From& from) {
7.1150 + return BpUGraphCopy<To, From>(to, from);
7.1151 }
7.1152
7.1153