COIN-OR::LEMON - Graph Library

Changeset 1193:c8fa41fcc4a7 in lemon for lemon/core.h


Ignore:
Timestamp:
12/01/11 09:05:47 (9 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Phase:
public
Message:

Type safe red and blue node set (#69)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/core.h

    r1190 r1193  
    551551      template <typename From, typename NodeRefMap, typename EdgeRefMap>
    552552      static void copy(const From& from, Graph &to,
    553                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
     553                       NodeRefMap& nodeRefMap,
     554                       EdgeRefMap& edgeRefMap) {
    554555        to.build(from, nodeRefMap, edgeRefMap);
    555556      }
     
    558559    template <typename BpGraph, typename Enable = void>
    559560    struct BpGraphCopySelector {
    560       template <typename From, typename NodeRefMap, typename EdgeRefMap>
     561      template <typename From, typename RedNodeRefMap,
     562                typename BlueNodeRefMap, typename EdgeRefMap>
    561563      static void copy(const From& from, BpGraph &to,
    562                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
     564                       RedNodeRefMap& redNodeRefMap,
     565                       BlueNodeRefMap& blueNodeRefMap,
     566                       EdgeRefMap& edgeRefMap) {
    563567        to.clear();
    564568        for (typename From::RedIt it(from); it != INVALID; ++it) {
    565           nodeRefMap[it] = to.addRedNode();
     569          redNodeRefMap[it] = to.addRedNode();
    566570        }
    567571        for (typename From::BlueIt it(from); it != INVALID; ++it) {
    568           nodeRefMap[it] = to.addBlueNode();
     572          blueNodeRefMap[it] = to.addBlueNode();
    569573        }
    570574        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
    571           edgeRefMap[it] = to.addEdge(nodeRefMap[from.redNode(it)],
    572                                       nodeRefMap[from.blueNode(it)]);
     575          edgeRefMap[it] = to.addEdge(redNodeRefMap[from.redNode(it)],
     576                                      blueNodeRefMap[from.blueNode(it)]);
    573577        }
    574578      }
     
    580584      typename enable_if<typename BpGraph::BuildTag, void>::type>
    581585    {
    582       template <typename From, typename NodeRefMap, typename EdgeRefMap>
     586      template <typename From, typename RedNodeRefMap,
     587                typename BlueNodeRefMap, typename EdgeRefMap>
    583588      static void copy(const From& from, BpGraph &to,
    584                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
    585         to.build(from, nodeRefMap, edgeRefMap);
     589                       RedNodeRefMap& redNodeRefMap,
     590                       BlueNodeRefMap& blueNodeRefMap,
     591                       EdgeRefMap& edgeRefMap) {
     592        to.build(from, redNodeRefMap, blueNodeRefMap, edgeRefMap);
    586593      }
    587594    };
     
    11831190
    11841191    typedef typename To::Node TNode;
     1192    typedef typename To::RedNode TRedNode;
     1193    typedef typename To::BlueNode TBlueNode;
    11851194    typedef typename To::Arc TArc;
    11861195    typedef typename To::Edge TEdge;
    11871196
    1188     typedef typename From::template NodeMap<TNode> NodeRefMap;
     1197    typedef typename From::template RedMap<TRedNode> RedNodeRefMap;
     1198    typedef typename From::template BlueMap<TBlueNode> BlueNodeRefMap;
    11891199    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
     1200
     1201    struct NodeRefMap {
     1202      NodeRefMap(const From& from, const RedNodeRefMap& red_node_ref,
     1203                 const BlueNodeRefMap& blue_node_ref)
     1204        : _from(from), _red_node_ref(red_node_ref),
     1205          _blue_node_ref(blue_node_ref) {}
     1206
     1207      typedef typename From::Node Key;
     1208      typedef typename To::Node Value;
     1209
     1210      Value operator[](const Key& key) const {
     1211        std::pair<RedNode, BlueNode> red_blue_pair = _from.asRedBlueNode(key);
     1212        if (red_blue_pair.first != INVALID) {
     1213          return _red_node_ref[red_blue_pair.first];
     1214        } else {
     1215          return _blue_node_ref[red_blue_pair.second];
     1216        }
     1217      }
     1218
     1219      const From& _from;
     1220      const RedNodeRefMap& _red_node_ref;
     1221      const BlueNodeRefMap& _blue_node_ref;
     1222    };
    11901223
    11911224    struct ArcRefMap {
     
    12931326    BpGraphCopy& redRef(RedRef& map) {
    12941327      _red_maps.push_back(new _core_bits::RefCopy<From, RedNode,
    1295                           NodeRefMap, RedRef>(map));
     1328                          RedNodeRefMap, RedRef>(map));
    12961329      return *this;
    12971330    }
     
    13071340    BpGraphCopy& redCrossRef(RedCrossRef& map) {
    13081341      _red_maps.push_back(new _core_bits::CrossRefCopy<From, RedNode,
    1309                           NodeRefMap, RedCrossRef>(map));
     1342                          RedNodeRefMap, RedCrossRef>(map));
    13101343      return *this;
    13111344    }
     
    13221355    BpGraphCopy& redMap(const FromMap& map, ToMap& tmap) {
    13231356      _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
    1324                            NodeRefMap, FromMap, ToMap>(map, tmap));
     1357                          RedNodeRefMap, FromMap, ToMap>(map, tmap));
     1358      return *this;
     1359    }
     1360
     1361    /// \brief Make a copy of the given red node.
     1362    ///
     1363    /// This function makes a copy of the given red node.
     1364    BpGraphCopy& redNode(const RedNode& node, TRedNode& tnode) {
     1365      _red_maps.push_back(new _core_bits::ItemCopy<From, RedNode,
     1366                          RedNodeRefMap, TRedNode>(node, tnode));
    13251367      return *this;
    13261368    }
     
    13351377    BpGraphCopy& blueRef(BlueRef& map) {
    13361378      _blue_maps.push_back(new _core_bits::RefCopy<From, BlueNode,
    1337                            NodeRefMap, BlueRef>(map));
     1379                           BlueNodeRefMap, BlueRef>(map));
    13381380      return *this;
    13391381    }
     
    13491391    BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
    13501392      _blue_maps.push_back(new _core_bits::CrossRefCopy<From, BlueNode,
    1351                            NodeRefMap, BlueCrossRef>(map));
     1393                           BlueNodeRefMap, BlueCrossRef>(map));
    13521394      return *this;
    13531395    }
     
    13641406    BpGraphCopy& blueMap(const FromMap& map, ToMap& tmap) {
    13651407      _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
    1366                            NodeRefMap, FromMap, ToMap>(map, tmap));
     1408                           BlueNodeRefMap, FromMap, ToMap>(map, tmap));
     1409      return *this;
     1410    }
     1411
     1412    /// \brief Make a copy of the given blue node.
     1413    ///
     1414    /// This function makes a copy of the given blue node.
     1415    BpGraphCopy& blueNode(const BlueNode& node, TBlueNode& tnode) {
     1416      _blue_maps.push_back(new _core_bits::ItemCopy<From, BlueNode,
     1417                           BlueNodeRefMap, TBlueNode>(node, tnode));
    13671418      return *this;
    13681419    }
     
    14711522    /// copying of the assigned data.
    14721523    void run() {
    1473       NodeRefMap nodeRefMap(_from);
     1524      RedNodeRefMap redNodeRefMap(_from);
     1525      BlueNodeRefMap blueNodeRefMap(_from);
     1526      NodeRefMap nodeRefMap(_from, redNodeRefMap, blueNodeRefMap);
    14741527      EdgeRefMap edgeRefMap(_from);
    14751528      ArcRefMap arcRefMap(_from, _to, edgeRefMap);
    14761529      _core_bits::BpGraphCopySelector<To>::
    1477         copy(_from, _to, nodeRefMap, edgeRefMap);
     1530        copy(_from, _to, redNodeRefMap, blueNodeRefMap, edgeRefMap);
    14781531      for (int i = 0; i < int(_node_maps.size()); ++i) {
    14791532        _node_maps[i]->copy(_from, nodeRefMap);
    14801533      }
    14811534      for (int i = 0; i < int(_red_maps.size()); ++i) {
    1482         _red_maps[i]->copy(_from, nodeRefMap);
     1535        _red_maps[i]->copy(_from, redNodeRefMap);
    14831536      }
    14841537      for (int i = 0; i < int(_blue_maps.size()); ++i) {
    1485         _blue_maps[i]->copy(_from, nodeRefMap);
     1538        _blue_maps[i]->copy(_from, blueNodeRefMap);
    14861539      }
    14871540      for (int i = 0; i < int(_edge_maps.size()); ++i) {
     
    15011554      _node_maps;
    15021555
    1503     std::vector<_core_bits::MapCopyBase<From, RedNode, NodeRefMap>* >
     1556    std::vector<_core_bits::MapCopyBase<From, RedNode, RedNodeRefMap>* >
    15041557      _red_maps;
    15051558
    1506     std::vector<_core_bits::MapCopyBase<From, BlueNode, NodeRefMap>* >
     1559    std::vector<_core_bits::MapCopyBase<From, BlueNode, BlueNodeRefMap>* >
    15071560      _blue_maps;
    15081561
Note: See TracChangeset for help on using the changeset viewer.