[Lemon-commits] Balazs Dezso: Implementation of BpGraphCopy (#69)
Lemon HG
hg at lemon.cs.elte.hu
Fri Mar 1 17:49:46 CET 2013
details: http://lemon.cs.elte.hu/hg/lemon/rev/523e45e37e52
changeset: 1190:523e45e37e52
user: Balazs Dezso <deba [at] inf.elte.hu>
date: Tue Nov 16 00:59:36 2010 +0100
description:
Implementation of BpGraphCopy (#69)
diffstat:
lemon/core.h | 434 ++++++++++++++++++++++++++++++++++++++++++++++++
test/graph_copy_test.cc | 148 ++++++++++++++++
2 files changed, 582 insertions(+), 0 deletions(-)
diffs (truncated from 616 to 300 lines):
diff --git a/lemon/core.h b/lemon/core.h
--- a/lemon/core.h
+++ b/lemon/core.h
@@ -555,6 +555,37 @@
}
};
+ template <typename BpGraph, typename Enable = void>
+ struct BpGraphCopySelector {
+ template <typename From, typename NodeRefMap, typename EdgeRefMap>
+ static void copy(const From& from, BpGraph &to,
+ NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
+ to.clear();
+ for (typename From::RedIt it(from); it != INVALID; ++it) {
+ nodeRefMap[it] = to.addRedNode();
+ }
+ for (typename From::BlueIt it(from); it != INVALID; ++it) {
+ nodeRefMap[it] = to.addBlueNode();
+ }
+ for (typename From::EdgeIt it(from); it != INVALID; ++it) {
+ edgeRefMap[it] = to.addEdge(nodeRefMap[from.redNode(it)],
+ nodeRefMap[from.blueNode(it)]);
+ }
+ }
+ };
+
+ template <typename BpGraph>
+ struct BpGraphCopySelector<
+ BpGraph,
+ typename enable_if<typename BpGraph::BuildTag, void>::type>
+ {
+ template <typename From, typename NodeRefMap, typename EdgeRefMap>
+ static void copy(const From& from, BpGraph &to,
+ NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
+ to.build(from, nodeRefMap, edgeRefMap);
+ }
+ };
+
}
/// \brief Check whether a graph is undirected.
@@ -1101,6 +1132,409 @@
return GraphCopy<From, To>(from, to);
}
+ /// \brief Class to copy a bipartite graph.
+ ///
+ /// Class to copy a bipartite graph to another graph (duplicate a
+ /// graph). The simplest way of using it is through the
+ /// \c bpGraphCopy() function.
+ ///
+ /// This class not only make a copy of a bipartite graph, but it can
+ /// create references and cross references between the nodes, edges
+ /// and arcs of the two graphs, and it can copy maps for using with
+ /// the newly created graph.
+ ///
+ /// To make a copy from a graph, first an instance of BpGraphCopy
+ /// should be created, then the data belongs to the graph should
+ /// assigned to copy. In the end, the \c run() member should be
+ /// called.
+ ///
+ /// The next code copies a graph with several data:
+ ///\code
+ /// BpGraphCopy<OrigBpGraph, NewBpGraph> cg(orig_graph, new_graph);
+ /// // Create references for the nodes
+ /// OrigBpGraph::NodeMap<NewBpGraph::Node> nr(orig_graph);
+ /// cg.nodeRef(nr);
+ /// // Create cross references (inverse) for the edges
+ /// NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
+ /// cg.edgeCrossRef(ecr);
+ /// // Copy a red map
+ /// OrigBpGraph::RedMap<double> ormap(orig_graph);
+ /// NewBpGraph::RedMap<double> nrmap(new_graph);
+ /// cg.edgeMap(ormap, nrmap);
+ /// // Copy a node
+ /// OrigBpGraph::Node on;
+ /// NewBpGraph::Node nn;
+ /// cg.node(on, nn);
+ /// // Execute copying
+ /// cg.run();
+ ///\endcode
+ template <typename From, typename To>
+ class BpGraphCopy {
+ private:
+
+ typedef typename From::Node Node;
+ typedef typename From::RedNode RedNode;
+ typedef typename From::BlueNode BlueNode;
+ typedef typename From::NodeIt NodeIt;
+ typedef typename From::Arc Arc;
+ typedef typename From::ArcIt ArcIt;
+ typedef typename From::Edge Edge;
+ typedef typename From::EdgeIt EdgeIt;
+
+ typedef typename To::Node TNode;
+ typedef typename To::Arc TArc;
+ typedef typename To::Edge TEdge;
+
+ typedef typename From::template NodeMap<TNode> NodeRefMap;
+ typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
+
+ struct ArcRefMap {
+ ArcRefMap(const From& from, const To& to, const EdgeRefMap& edge_ref)
+ : _from(from), _to(to), _edge_ref(edge_ref) {}
+
+ typedef typename From::Arc Key;
+ typedef typename To::Arc Value;
+
+ Value operator[](const Key& key) const {
+ return _to.direct(_edge_ref[key], _from.direction(key));
+ }
+
+ const From& _from;
+ const To& _to;
+ const EdgeRefMap& _edge_ref;
+ };
+
+ public:
+
+ /// \brief Constructor of BpGraphCopy.
+ ///
+ /// Constructor of BpGraphCopy for copying the content of the
+ /// \c from graph into the \c to graph.
+ BpGraphCopy(const From& from, To& to)
+ : _from(from), _to(to) {}
+
+ /// \brief Destructor of BpGraphCopy
+ ///
+ /// Destructor of BpGraphCopy.
+ ~BpGraphCopy() {
+ for (int i = 0; i < int(_node_maps.size()); ++i) {
+ delete _node_maps[i];
+ }
+ for (int i = 0; i < int(_red_maps.size()); ++i) {
+ delete _red_maps[i];
+ }
+ for (int i = 0; i < int(_blue_maps.size()); ++i) {
+ delete _blue_maps[i];
+ }
+ for (int i = 0; i < int(_arc_maps.size()); ++i) {
+ delete _arc_maps[i];
+ }
+ for (int i = 0; i < int(_edge_maps.size()); ++i) {
+ delete _edge_maps[i];
+ }
+ }
+
+ /// \brief Copy the node references into the given map.
+ ///
+ /// This function copies the node references into the given map.
+ /// The parameter should be a map, whose key type is the Node type of
+ /// the source graph, while the value type is the Node type of the
+ /// destination graph.
+ template <typename NodeRef>
+ BpGraphCopy& nodeRef(NodeRef& map) {
+ _node_maps.push_back(new _core_bits::RefCopy<From, Node,
+ NodeRefMap, NodeRef>(map));
+ return *this;
+ }
+
+ /// \brief Copy the node cross references into the given map.
+ ///
+ /// This function copies the node cross references (reverse references)
+ /// into the given map. The parameter should be a map, whose key type
+ /// is the Node type of the destination graph, while the value type is
+ /// the Node type of the source graph.
+ template <typename NodeCrossRef>
+ BpGraphCopy& nodeCrossRef(NodeCrossRef& map) {
+ _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
+ NodeRefMap, NodeCrossRef>(map));
+ return *this;
+ }
+
+ /// \brief Make a copy of the given node map.
+ ///
+ /// This function makes a copy of the given node map for the newly
+ /// created graph.
+ /// The key type of the new map \c tmap should be the Node type of the
+ /// destination graph, and the key type of the original map \c map
+ /// should be the Node type of the source graph.
+ template <typename FromMap, typename ToMap>
+ BpGraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
+ _node_maps.push_back(new _core_bits::MapCopy<From, Node,
+ NodeRefMap, FromMap, ToMap>(map, tmap));
+ return *this;
+ }
+
+ /// \brief Make a copy of the given node.
+ ///
+ /// This function makes a copy of the given node.
+ BpGraphCopy& node(const Node& node, TNode& tnode) {
+ _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
+ NodeRefMap, TNode>(node, tnode));
+ return *this;
+ }
+
+ /// \brief Copy the red node references into the given map.
+ ///
+ /// This function copies the red node references into the given
+ /// map. The parameter should be a map, whose key type is the
+ /// Node type of the source graph with the red item set, while the
+ /// value type is the Node type of the destination graph.
+ template <typename RedRef>
+ BpGraphCopy& redRef(RedRef& map) {
+ _red_maps.push_back(new _core_bits::RefCopy<From, RedNode,
+ NodeRefMap, RedRef>(map));
+ return *this;
+ }
+
+ /// \brief Copy the red node cross references into the given map.
+ ///
+ /// This function copies the red node cross references (reverse
+ /// references) into the given map. The parameter should be a map,
+ /// whose key type is the Node type of the destination graph with
+ /// the red item set, while the value type is the Node type of the
+ /// source graph.
+ template <typename RedCrossRef>
+ BpGraphCopy& redCrossRef(RedCrossRef& map) {
+ _red_maps.push_back(new _core_bits::CrossRefCopy<From, RedNode,
+ NodeRefMap, RedCrossRef>(map));
+ return *this;
+ }
+
+ /// \brief Make a copy of the given red node map.
+ ///
+ /// This function makes a copy of the given red node map for the newly
+ /// created graph.
+ /// The key type of the new map \c tmap should be the Node type of
+ /// the destination graph with the red items, and the key type of
+ /// the original map \c map should be the Node type of the source
+ /// graph.
+ template <typename FromMap, typename ToMap>
+ BpGraphCopy& redMap(const FromMap& map, ToMap& tmap) {
+ _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
+ NodeRefMap, FromMap, ToMap>(map, tmap));
+ return *this;
+ }
+
+ /// \brief Copy the blue node references into the given map.
+ ///
+ /// This function copies the blue node references into the given
+ /// map. The parameter should be a map, whose key type is the
+ /// Node type of the source graph with the blue item set, while the
+ /// value type is the Node type of the destination graph.
+ template <typename BlueRef>
+ BpGraphCopy& blueRef(BlueRef& map) {
+ _blue_maps.push_back(new _core_bits::RefCopy<From, BlueNode,
+ NodeRefMap, BlueRef>(map));
+ return *this;
+ }
+
+ /// \brief Copy the blue node cross references into the given map.
+ ///
+ /// This function copies the blue node cross references (reverse
+ /// references) into the given map. The parameter should be a map,
+ /// whose key type is the Node type of the destination graph with
+ /// the blue item set, while the value type is the Node type of the
+ /// source graph.
+ template <typename BlueCrossRef>
+ BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
+ _blue_maps.push_back(new _core_bits::CrossRefCopy<From, BlueNode,
+ NodeRefMap, BlueCrossRef>(map));
+ return *this;
+ }
+
+ /// \brief Make a copy of the given blue node map.
+ ///
+ /// This function makes a copy of the given blue node map for the newly
+ /// created graph.
+ /// The key type of the new map \c tmap should be the Node type of
+ /// the destination graph with the blue items, and the key type of
+ /// the original map \c map should be the Node type of the source
+ /// graph.
+ template <typename FromMap, typename ToMap>
+ BpGraphCopy& blueMap(const FromMap& map, ToMap& tmap) {
+ _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
+ NodeRefMap, FromMap, ToMap>(map, tmap));
+ return *this;
+ }
+
+ /// \brief Copy the arc references into the given map.
+ ///
+ /// This function copies the arc references into the given map.
+ /// The parameter should be a map, whose key type is the Arc type of
+ /// the source graph, while the value type is the Arc type of the
+ /// destination graph.
+ template <typename ArcRef>
+ BpGraphCopy& arcRef(ArcRef& map) {
+ _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
+ ArcRefMap, ArcRef>(map));
+ return *this;
+ }
+
+ /// \brief Copy the arc cross references into the given map.
+ ///
+ /// This function copies the arc cross references (reverse references)
+ /// into the given map. The parameter should be a map, whose key type
+ /// is the Arc type of the destination graph, while the value type is
+ /// the Arc type of the source graph.
+ template <typename ArcCrossRef>
More information about the Lemon-commits
mailing list