COIN-OR::LEMON - Graph Library

Ticket #69: 434a20e74585.patch

File 434a20e74585.patch, 58.0 KB (added by Balazs Dezso, 8 years ago)

Type safe RedNode? and BlueNode?

  • lemon/bits/graph_extender.h

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1322726747 -3600
    # Node ID 434a20e7458562409f15f552583d9ca64f7f8c6c
    # Parent  008af84a4d4af8ab0898ba29bd8c07cceda12e3b
    Type safe red and blue node set
    
    diff -r 008af84a4d4a -r 434a20e74585 lemon/bits/graph_extender.h
    a b  
    760760    typedef True UndirectedTag;
    761761
    762762    typedef typename Parent::Node Node;
     763    typedef typename Parent::RedNode RedNode;
     764    typedef typename Parent::BlueNode BlueNode;
    763765    typedef typename Parent::Arc Arc;
    764766    typedef typename Parent::Edge Edge;
    765767
    766768    // BpGraph extension
    767769
    768     class RedNode : public Node {
    769     public:
    770       RedNode() {}
    771       RedNode(const RedNode& node) : Node(node) {}
    772       RedNode(Invalid) : Node(INVALID){}
    773       RedNode(const Node& node) : Node(node) {}
    774     };
    775     class BlueNode : public Node {
    776     public:
    777       BlueNode() {}
    778       BlueNode(const BlueNode& node) : Node(node) {}
    779       BlueNode(Invalid) : Node(INVALID){}
    780       BlueNode(const Node& node) : Node(node) {}
    781     };
    782 
    783770    using Parent::first;
    784771    using Parent::next;
    785 
    786     void first(RedNode& node) const {
    787       Parent::firstRed(node);
    788     }
    789    
    790     void next(RedNode& node) const {
    791       Parent::nextRed(node);
    792     }
    793 
    794     void first(BlueNode& node) const {
    795       Parent::firstBlue(node);
    796     }
    797 
    798     void next(BlueNode& node) const {
    799       Parent::nextBlue(node);
    800     }
    801 
    802772    using Parent::id;
    803773
    804     int id(const RedNode& node) const {
    805       return Parent::redId(node);
    806     }
    807 
    808     int id(const BlueNode& node) const {
    809       return Parent::blueId(node);
    810     }
    811 
    812774    int maxId(Node) const {
    813775      return Parent::maxNodeId();
    814776    }
     
    862824      return Parent::direct(edge, Parent::redNode(edge) == node);
    863825    }
    864826
     827    RedNode asRedNode(const Node& node) const {
     828      if (node == INVALID || Parent::blue(node)) {
     829        return INVALID;
     830      } else {
     831        return Parent::asRedNodeUnsafe(node);
     832      }
     833    }
     834
     835    BlueNode asBlueNode(const Node& node) const {
     836      if (node == INVALID || Parent::red(node)) {
     837        return INVALID;
     838      } else {
     839        return Parent::asBlueNodeUnsafe(node);
     840      }
     841    }
     842
     843    std::pair<RedNode, BlueNode> asRedBlueNode(const Node& node) const {
     844      if (node == INVALID) {
     845        return std::make_pair(RedNode(INVALID), BlueNode(INVALID));
     846      } else if (Parent::red(node)) {
     847        return std::make_pair(Parent::asRedNodeUnsafe(node), BlueNode(INVALID));
     848      } else {
     849        return std::make_pair(RedNode(INVALID), Parent::asBlueNodeUnsafe(node));
     850      }
     851    }
     852
    865853    // Alterable extension
    866854
    867855    typedef AlterationNotifier<BpGraphExtender, Node> NodeNotifier;
     
    925913
    926914    };
    927915
    928     class RedIt : public Node {
     916    class RedIt : public RedNode {
    929917      const BpGraph* _graph;
    930918    public:
    931919
    932920      RedIt() {}
    933921
    934       RedIt(Invalid i) : Node(i) { }
     922      RedIt(Invalid i) : RedNode(i) { }
    935923
    936924      explicit RedIt(const BpGraph& graph) : _graph(&graph) {
    937         _graph->firstRed(static_cast<Node&>(*this));
     925        _graph->first(static_cast<RedNode&>(*this));
    938926      }
    939927
    940       RedIt(const BpGraph& graph, const Node& node)
    941         : Node(node), _graph(&graph) {
    942         LEMON_DEBUG(_graph->red(node), "Node has to be red.");
    943       }
     928      RedIt(const BpGraph& graph, const RedNode& node)
     929        : RedNode(node), _graph(&graph) {}
    944930
    945931      RedIt& operator++() {
    946         _graph->nextRed(*this);
     932        _graph->next(static_cast<RedNode&>(*this));
    947933        return *this;
    948934      }
    949935
    950936    };
    951937
    952     class BlueIt : public Node {
     938    class BlueIt : public BlueNode {
    953939      const BpGraph* _graph;
    954940    public:
    955941
    956942      BlueIt() {}
    957943
    958       BlueIt(Invalid i) : Node(i) { }
     944      BlueIt(Invalid i) : BlueNode(i) { }
    959945
    960946      explicit BlueIt(const BpGraph& graph) : _graph(&graph) {
    961         _graph->firstBlue(static_cast<Node&>(*this));
     947        _graph->first(static_cast<BlueNode&>(*this));
    962948      }
    963949
    964       BlueIt(const BpGraph& graph, const Node& node)
    965         : Node(node), _graph(&graph) {
    966         LEMON_DEBUG(_graph->blue(node), "Node has to be blue.");
    967       }
     950      BlueIt(const BpGraph& graph, const BlueNode& node)
     951        : BlueNode(node), _graph(&graph) {}
    968952
    969953      BlueIt& operator++() {
    970         _graph->nextBlue(*this);
     954        _graph->next(static_cast<BlueNode&>(*this));
    971955        return *this;
    972956      }
    973957
     
    12581242
    12591243    // Alteration extension
    12601244
    1261     Node addRedNode() {
    1262       Node node = Parent::addRedNode();
     1245    RedNode addRedNode() {
     1246      RedNode node = Parent::addRedNode();
    12631247      notifier(RedNode()).add(node);
    12641248      notifier(Node()).add(node);
    12651249      return node;
    12661250    }
    12671251
    1268     Node addBlueNode() {
    1269       Node node = Parent::addBlueNode();
     1252    BlueNode addBlueNode() {
     1253      BlueNode node = Parent::addBlueNode();
    12701254      notifier(BlueNode()).add(node);
    12711255      notifier(Node()).add(node);
    12721256      return node;
    12731257    }
    12741258
    1275     Edge addEdge(const Node& from, const Node& to) {
     1259    Edge addEdge(const RedNode& from, const BlueNode& to) {
    12761260      Edge edge = Parent::addEdge(from, to);
    12771261      notifier(Edge()).add(edge);
    12781262      std::vector<Arc> av;
     
    13171301      }
    13181302
    13191303      if (Parent::red(node)) {
    1320         notifier(RedNode()).erase(node);
     1304        notifier(RedNode()).erase(asRedNodeUnsafe(node));
    13211305      } else {
    1322         notifier(BlueNode()).erase(node);       
     1306        notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
    13231307      }
    13241308
    13251309      notifier(Node()).erase(node);
  • lemon/concepts/bpgraph.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/concepts/bpgraph.h
    a b  
    149149        /// \sa Invalid for more details.
    150150        RedNode(Invalid) { }
    151151
    152         /// Constructor for conversion from a node.
    153 
    154         /// Constructor for conversion from a node. The conversion can
    155         /// be invalid, since the Node can be member of the blue
    156         /// set.
    157         RedNode(const Node&) {}
    158152      };
    159153
    160154      /// Class to represent blue nodes.
     
    182176        /// \sa Invalid for more details.
    183177        BlueNode(Invalid) { }
    184178
    185         /// Constructor for conversion from a node.
    186 
    187         /// Constructor for conversion from a node. The conversion can
    188         /// be invalid, since the Node can be member of the red
    189         /// set.
    190         BlueNode(const Node&) {}
    191179      };
    192180
    193181      /// Iterator class for the red nodes.
     
    199187      /// int count=0;
    200188      /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
    201189      ///\endcode
    202       class RedIt : public Node {
     190      class RedIt : public RedNode {
    203191      public:
    204192        /// Default constructor
    205193
     
    210198
    211199        /// Copy constructor.
    212200        ///
    213         RedIt(const RedIt& n) : Node(n) { }
     201        RedIt(const RedIt& n) : RedNode(n) { }
    214202        /// %Invalid constructor \& conversion.
    215203
    216204        /// Initializes the iterator to be invalid.
     
    225213
    226214        /// Sets the iterator to the given red node of the given
    227215        /// digraph.
    228         RedIt(const BpGraph&, const Node&) { }
     216        RedIt(const BpGraph&, const RedNode&) { }
    229217        /// Next node.
    230218
    231219        /// Assign the iterator to the next red node.
     
    242230      /// int count=0;
    243231      /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
    244232      ///\endcode
    245       class BlueIt : public Node {
     233      class BlueIt : public BlueNode {
    246234      public:
    247235        /// Default constructor
    248236
     
    253241
    254242        /// Copy constructor.
    255243        ///
    256         BlueIt(const BlueIt& n) : Node(n) { }
     244        BlueIt(const BlueIt& n) : BlueNode(n) { }
    257245        /// %Invalid constructor \& conversion.
    258246
    259247        /// Initializes the iterator to be invalid.
     
    268256
    269257        /// Sets the iterator to the given blue node of the given
    270258        /// digraph.
    271         BlueIt(const BpGraph&, const Node&) { }
     259        BlueIt(const BpGraph&, const BlueNode&) { }
    272260        /// Next node.
    273261
    274262        /// Assign the iterator to the next blue node.
     
    784772      /// Gives back %true for blue nodes.
    785773      bool blue(const Node&) const { return true; }
    786774
     775      /// \brief Converts the node to red node object.
     776      ///
     777      /// This class is converts unsafely the node to red node
     778      /// object. It should be called only if the node is from the red
     779      /// partition or INVALID.
     780      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
     781
     782      /// \brief Converts the node to blue node object.
     783      ///
     784      /// This class is converts unsafely the node to blue node
     785      /// object. It should be called only if the node is from the red
     786      /// partition or INVALID.
     787      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
     788
     789      /// \brief Converts the node to red node object.
     790      ///
     791      /// This class is converts safely the node to red node
     792      /// object. If the node is not from the red partition, then it
     793      /// returns INVALID.
     794      RedNode asRedNode(const Node&) const { return RedNode(); }
     795
     796      /// \brief Converts the node to blue node object.
     797      ///
     798      /// This class is converts unsafely the node to blue node
     799      /// object. If the node is not from the blue partition, then it
     800      /// returns INVALID.
     801      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
     802
     803      /// \brief Convert the node to either red or blue node.
     804      ///
     805      /// If the node is from the red partition then it is returned in
     806      /// first and second is INVALID. If the node is from the blue
     807      /// partition then it is returned in second and first is
     808      /// INVALID. If the node INVALID then both first and second are
     809      /// INVALID in the return value.
     810      std::pair<RedNode, BlueNode> asRedBlueNode(const Node&) const {
     811        return std::make_pair(RedNode(), BlueNode());
     812      }
     813
    787814      /// \brief Gives back the red end node of the edge.
    788815      ///
    789816      /// Gives back the red end node of the edge.
    790       Node redNode(const Edge&) const { return Node(); }
     817      RedNode redNode(const Edge&) const { return RedNode(); }
    791818
    792819      /// \brief Gives back the blue end node of the edge.
    793820      ///
    794821      /// Gives back the blue end node of the edge.
    795       Node blueNode(const Edge&) const { return Node(); }
     822      BlueNode blueNode(const Edge&) const { return BlueNode(); }
    796823
    797824      /// \brief The first node of the edge.
    798825      ///
     
    822849      /// \brief The red ID of the node.
    823850      ///
    824851      /// Returns the red ID of the given node.
    825       int redId(Node) const { return -1; }
    826 
    827       /// \brief The red ID of the node.
    828       ///
    829       /// Returns the red ID of the given node.
    830852      int id(RedNode) const { return -1; }
    831853
    832854      /// \brief The blue ID of the node.
    833855      ///
    834856      /// Returns the blue ID of the given node.
    835       int blueId(Node) const { return -1; }
    836 
    837       /// \brief The blue ID of the node.
    838       ///
    839       /// Returns the blue ID of the given node.
    840857      int id(BlueNode) const { return -1; }
    841858
    842859      /// \brief The ID of the edge.
     
    928945      void first(Node&) const {}
    929946      void next(Node&) const {}
    930947
    931       void firstRed(Node&) const {}
    932       void nextRed(Node&) const {}
     948      void firstRed(RedNode&) const {}
     949      void nextRed(RedNode&) const {}
    933950
    934       void firstBlue(Node&) const {}
    935       void nextBlue(Node&) const {}
     951      void firstBlue(BlueNode&) const {}
     952      void nextBlue(BlueNode&) const {}
    936953
    937954      void first(Edge&) const {}
    938955      void next(Edge&) const {}
  • lemon/concepts/graph_components.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/concepts/graph_components.h
    a b  
    312312
    313313      /// \brief Class to represent red nodes.
    314314      ///
    315       /// This class represents the red nodes of the graph. It does
    316       /// not supposed to be used directly, because the nodes can be
    317       /// represented as Node instances. This class can be used as
    318       /// template parameter for special map classes.
     315      /// This class represents the red nodes of the graph. The red
     316      /// nodes can be used also as normal nodes.
    319317      class RedNode : public Node {
    320318        typedef Node Parent;
    321319
     
    339337        /// It initializes the item to be invalid.
    340338        /// \sa Invalid for more details.
    341339        RedNode(Invalid) {}
    342 
    343         /// \brief Constructor for conversion from a node.
    344         ///
    345         /// Constructor for conversion from a node. The conversion can
    346         /// be invalid, since the Node can be member of the blue
    347         /// set.
    348         RedNode(const Node&) {}
    349340      };
    350341
    351342      /// \brief Class to represent blue nodes.
    352343      ///
    353       /// This class represents the blue nodes of the graph. It does
    354       /// not supposed to be used directly, because the nodes can be
    355       /// represented as Node instances. This class can be used as
    356       /// template parameter for special map classes.
     344      /// This class represents the blue nodes of the graph. The blue
     345      /// nodes can be used also as normal nodes.
    357346      class BlueNode : public Node {
    358347        typedef Node Parent;
    359348
     
    399388      /// \brief Gives back the red end node of the edge.
    400389      ///
    401390      /// Gives back the red end node of the edge.
    402       Node redNode(const Edge&) const { return Node(); }
     391      RedNode redNode(const Edge&) const { return RedNode(); }
    403392
    404393      /// \brief Gives back the blue end node of the edge.
    405394      ///
    406395      /// Gives back the blue end node of the edge.
    407       Node blueNode(const Edge&) const { return Node(); }
     396      BlueNode blueNode(const Edge&) const { return BlueNode(); }
     397
     398      /// \brief Converts the node to red node object.
     399      ///
     400      /// This class is converts unsafely the node to red node
     401      /// object. It should be called only if the node is from the red
     402      /// partition or INVALID.
     403      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
     404
     405      /// \brief Converts the node to blue node object.
     406      ///
     407      /// This class is converts unsafely the node to blue node
     408      /// object. It should be called only if the node is from the red
     409      /// partition or INVALID.
     410      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
     411
     412      /// \brief Converts the node to red node object.
     413      ///
     414      /// This class is converts safely the node to red node
     415      /// object. If the node is not from the red partition, then it
     416      /// returns INVALID.
     417      RedNode asRedNode(const Node&) const { return RedNode(); }
     418
     419      /// \brief Converts the node to blue node object.
     420      ///
     421      /// This class is converts unsafely the node to blue node
     422      /// object. If the node is not from the blue partition, then it
     423      /// returns INVALID.
     424      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
     425
     426      /// \brief Convert the node to either red or blue node.
     427      ///
     428      /// If the node is from the red partition then it is returned in
     429      /// first and second is INVALID. If the node is from the blue
     430      /// partition then it is returned in second and first is
     431      /// INVALID. If the node INVALID then both first and second are
     432      /// INVALID in the return value.
     433      std::pair<RedNode, BlueNode> asRedBlueNode(const Node&) const {
     434        return std::make_pair(RedNode(), BlueNode());
     435      }
    408436
    409437      template <typename _BpGraph>
    410438      struct Constraints {
     
    419447          checkConcept<GraphItem<'n'>, RedNode>();
    420448          checkConcept<GraphItem<'n'>, BlueNode>();
    421449          {
    422             Node n;
    423             RedNode rn = n;
    424             BlueNode bn = bn;
     450            RedNode rn;
     451            BlueNode bn;
     452            Node rnan = rn;
     453            Node bnan = bn;
    425454            Edge e;
    426455            bool b;
    427             b = bpgraph.red(n);
    428             b = bpgraph.blue(n);
    429             n = bpgraph.redNode(e);
    430             n = bpgraph.blueNode(e);
    431             rn = n;
    432             bn = n;
     456            rnan = rn;
     457            bnan = bn;
     458            b = bpgraph.red(rnan);
     459            b = bpgraph.blue(bnan);
     460            rn = bpgraph.redNode(e);
     461            bn = bpgraph.blueNode(e);
     462            rn = bpgraph.asRedNodeUnsafe(rnan);
     463            bn = bpgraph.asBlueNodeUnsafe(bnan);
     464            rn = bpgraph.asRedNode(rnan);
     465            bn = bpgraph.asBlueNode(bnan);
     466            std::pair<RedNode, BlueNode> p = bpgraph.asRedBlueNode(rnan);
    433467          }
    434468        }
    435469
     
    591625      /// \brief Return a unique integer id for the given node in the red set.
    592626      ///
    593627      /// Return a unique integer id for the given node in the red set.
    594       int redId(const Node&) const { return -1; }
    595 
    596       /// \brief Return the same value as redId().
    597       ///
    598       /// Return the same value as redId().
    599628      int id(const RedNode&) const { return -1; }
    600629
    601630      /// \brief Return a unique integer id for the given node in the blue set.
    602631      ///
    603632      /// Return a unique integer id for the given node in the blue set.
    604       int blueId(const Node&) const { return -1; }
    605 
    606       /// \brief Return the same value as blueId().
    607       ///
    608       /// Return the same value as blueId().
    609633      int id(const BlueNode&) const { return -1; }
    610634
    611635      /// \brief Return an integer greater or equal to the maximum
     
    630654          typename _BpGraph::Node node;
    631655          typename _BpGraph::RedNode red;
    632656          typename _BpGraph::BlueNode blue;
    633           int rid = bpgraph.redId(node);
    634           int bid = bpgraph.blueId(node);
    635           rid = bpgraph.id(red);
    636           bid = bpgraph.id(blue);
     657          int rid = bpgraph.id(red);
     658          int bid = bpgraph.id(blue);
    637659          rid = bpgraph.maxRedId();
    638660          bid = bpgraph.maxBlueId();
    639661          ignore_unused_variable_warning(rid);
     
    11211143
    11221144      typedef BAS Base;
    11231145      typedef typename Base::Node Node;
     1146      typedef typename Base::RedNode RedNode;
     1147      typedef typename Base::BlueNode BlueNode;
    11241148      typedef typename Base::Arc Arc;
    11251149      typedef typename Base::Edge Edge;
     1150     
     1151      typedef IterableBpGraphComponent BpGraph;
    11261152
    1127 
    1128       typedef IterableBpGraphComponent BpGraph;
     1153      using IterableGraphComponent<BAS>::first;
     1154      using IterableGraphComponent<BAS>::next;
    11291155
    11301156      /// \name Base Iteration
    11311157      ///
     
    11361162      /// \brief Return the first red node.
    11371163      ///
    11381164      /// This function gives back the first red node in the iteration order.
    1139       void firstRed(Node&) const {}
     1165      void first(RedNode&) const {}
    11401166
    11411167      /// \brief Return the next red node.
    11421168      ///
    11431169      /// This function gives back the next red node in the iteration order.
    1144       void nextRed(Node&) const {}
     1170      void next(RedNode&) const {}
    11451171
    11461172      /// \brief Return the first blue node.
    11471173      ///
    11481174      /// This function gives back the first blue node in the iteration order.
    1149       void firstBlue(Node&) const {}
     1175      void first(BlueNode&) const {}
    11501176
    11511177      /// \brief Return the next blue node.
    11521178      ///
    11531179      /// This function gives back the next blue node in the iteration order.
    1154       void nextBlue(Node&) const {}
     1180      void next(BlueNode&) const {}
    11551181
    11561182
    11571183      /// @}
     
    11651191      /// \brief This iterator goes through each red node.
    11661192      ///
    11671193      /// This iterator goes through each red node.
    1168       typedef GraphItemIt<BpGraph, Node> RedIt;
     1194      typedef GraphItemIt<BpGraph, RedNode> RedIt;
    11691195
    11701196      /// \brief This iterator goes through each blue node.
    11711197      ///
    11721198      /// This iterator goes through each blue node.
    1173       typedef GraphItemIt<BpGraph, Node> BlueIt;
     1199      typedef GraphItemIt<BpGraph, BlueNode> BlueIt;
    11741200
    11751201      /// @}
    11761202
     
    11791205        void constraints() {
    11801206          checkConcept<IterableGraphComponent<Base>, _BpGraph>();
    11811207
    1182           typename _BpGraph::Node node(INVALID);
    1183           bpgraph.firstRed(node);
    1184           bpgraph.nextRed(node);
    1185           bpgraph.firstBlue(node);
    1186           bpgraph.nextBlue(node);
     1208          typename _BpGraph::RedNode rn(INVALID);
     1209          bpgraph.first(rn);
     1210          bpgraph.next(rn);
     1211          typename _BpGraph::BlueNode bn(INVALID);
     1212          bpgraph.first(bn);
     1213          bpgraph.next(bn);
    11871214
    1188           checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::Node>,
     1215          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
    11891216            typename _BpGraph::RedIt>();
    1190           checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::Node>,
     1217          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
    11911218            typename _BpGraph::BlueIt>();
    11921219        }
    11931220
     
    17691796
    17701797          { // int map test
    17711798            typedef typename _BpGraph::template RedMap<int> IntRedMap;
    1772             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, int>,
     1799            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
    17731800              IntRedMap >();
    17741801          } { // bool map test
    17751802            typedef typename _BpGraph::template RedMap<bool> BoolRedMap;
    1776             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, bool>,
     1803            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
    17771804              BoolRedMap >();
    17781805          } { // Dummy map test
    17791806            typedef typename _BpGraph::template RedMap<Dummy> DummyRedMap;
    1780             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, Dummy>,
     1807            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
    17811808              DummyRedMap >();
    17821809          }
    17831810
    17841811          { // int map test
    17851812            typedef typename _BpGraph::template BlueMap<int> IntBlueMap;
    1786             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, int>,
     1813            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
    17871814              IntBlueMap >();
    17881815          } { // bool map test
    17891816            typedef typename _BpGraph::template BlueMap<bool> BoolBlueMap;
    1790             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, bool>,
     1817            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
    17911818              BoolBlueMap >();
    17921819          } { // Dummy map test
    17931820            typedef typename _BpGraph::template BlueMap<Dummy> DummyBlueMap;
    1794             checkConcept<GraphMap<_BpGraph, typename _BpGraph::Node, Dummy>,
     1821            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
    17951822              DummyBlueMap >();
    17961823          }
    17971824        }
     
    19001927
    19011928      typedef BAS Base;
    19021929      typedef typename Base::Node Node;
     1930      typedef typename Base::RedNode RedNode;
     1931      typedef typename Base::BlueNode BlueNode;
    19031932      typedef typename Base::Edge Edge;
    19041933
    19051934      /// \brief Add a new red node to the digraph.
    19061935      ///
    19071936      /// This function adds a red new node to the digraph.
    1908       Node addRedNode() {
     1937      RedNode addRedNode() {
    19091938        return INVALID;
    19101939      }
    19111940
    19121941      /// \brief Add a new blue node to the digraph.
    19131942      ///
    19141943      /// This function adds a blue new node to the digraph.
    1915       Node addBlueNode() {
     1944      BlueNode addBlueNode() {
    19161945        return INVALID;
    19171946      }
    19181947
     
    19211950      /// This function adds a new edge connecting the given two nodes
    19221951      /// of the graph. The first node has to be a red node, and the
    19231952      /// second one a blue node.
    1924       Edge addEdge(const Node&, const Node&) {
     1953      Edge addEdge(const RedNode&, const BlueNode&) {
     1954        return INVALID;
     1955      }
     1956      Edge addEdge(const BlueNode&, const RedNode&) {
    19251957        return INVALID;
    19261958      }
    19271959
     
    19291961      struct Constraints {
    19301962        void constraints() {
    19311963          checkConcept<Base, _BpGraph>();
    1932           typename _BpGraph::Node red_node, blue_node;
     1964          typename _BpGraph::RedNode red_node;
     1965          typename _BpGraph::BlueNode blue_node;
    19331966          red_node = bpgraph.addRedNode();
    19341967          blue_node = bpgraph.addBlueNode();
    19351968          typename _BpGraph::Edge edge;
    19361969          edge = bpgraph.addEdge(red_node, blue_node);
     1970          edge = bpgraph.addEdge(blue_node, red_node);
    19371971        }
    19381972
    19391973        _BpGraph& bpgraph;
  • lemon/core.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/core.h
    a b  
    550550    {
    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      }
    556557    };
    557558
    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      }
    575579    };
     
    579583      BpGraph,
    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    };
    588595
     
    11821189    typedef typename From::EdgeIt EdgeIt;
    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;
    11901200
     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    };
     1223
    11911224    struct ArcRefMap {
    11921225      ArcRefMap(const From& from, const To& to, const EdgeRefMap& edge_ref)
    11931226        : _from(from), _to(to), _edge_ref(edge_ref) {}
     
    12921325    template <typename RedRef>
    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    }
    12981331
     
    13061339    template <typename RedCrossRef>
    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    }
    13121345
     
    13211354    template <typename FromMap, typename ToMap>
    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    }
    13271369
     
    13341376    template <typename BlueRef>
    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    }
    13401382
     
    13481390    template <typename BlueCrossRef>
    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    }
    13541396
     
    13631405    template <typename FromMap, typename ToMap>
    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    }
    13691420
     
    14701521    /// This function executes the copying of the graph along with the
    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) {
    14881541        _edge_maps[i]->copy(_from, edgeRefMap);
     
    15001553    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
    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
    15091562    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
  • lemon/full_graph.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/full_graph.h
    a b  
    651651      bool operator<(const Node& node) const {return _id < node._id;}
    652652    };
    653653
     654    class RedNode : public Node {
     655      friend class FullBpGraphBase;
     656    protected:
     657
     658      explicit RedNode(int pid) : Node(pid) {}
     659
     660    public:
     661      RedNode() {}
     662      RedNode(const RedNode& node) : Node(node) {}
     663      RedNode(Invalid) : Node(INVALID){}
     664    };
     665
     666    class BlueNode : public Node {
     667      friend class FullBpGraphBase;
     668    protected:
     669
     670      explicit BlueNode(int pid) : Node(pid) {}
     671
     672    public:
     673      BlueNode() {}
     674      BlueNode(const BlueNode& node) : Node(node) {}
     675      BlueNode(Invalid) : Node(INVALID){}
     676    };
     677
    654678    class Edge {
    655679      friend class FullBpGraphBase;
    656680    protected:
     
    717741    bool red(Node n) const { return n._id < _red_num; }
    718742    bool blue(Node n) const { return n._id >= _red_num; }
    719743
     744    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
     745    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
     746
    720747    Node source(Arc a) const {
    721748      if (a._id & 1) {
    722749        return Node((a._id >> 1) % _red_num);
     
    732759      }
    733760    }
    734761
    735     Node redNode(Edge e) const {
    736       return Node(e._id % _red_num);
     762    RedNode redNode(Edge e) const {
     763      return RedNode(e._id % _red_num);
    737764    }
    738     Node blueNode(Edge e) const {
    739       return Node(e._id / _red_num + _red_num);
     765    BlueNode blueNode(Edge e) const {
     766      return BlueNode(e._id / _red_num + _red_num);
    740767    }
    741768
    742769    static bool direction(Arc a) {
     
    755782      --node._id;
    756783    }
    757784
    758     void firstRed(Node& node) const {
     785    void first(RedNode& node) const {
    759786      node._id = _red_num - 1;
    760787    }
    761788
    762     static void nextRed(Node& node) {
     789    static void next(RedNode& node) {
    763790      --node._id;
    764791    }
    765792
    766     void firstBlue(Node& node) const {
     793    void first(BlueNode& node) const {
    767794      if (_red_num == _node_num) node._id = -1;
    768795      else node._id = _node_num - 1;
    769796    }
    770797
    771     void nextBlue(Node& node) const {
     798    void next(BlueNode& node) const {
    772799      if (node._id == _red_num) node._id = -1;
    773800      else --node._id;
    774801    }
     
    842869      }
    843870    }
    844871
    845     static int id(Node v) { return v._id; }
    846     int redId(Node v) const {
    847       LEMON_DEBUG(v._id < _red_num, "Node has to be red");
    848       return v._id;
    849     }
    850     int blueId(Node v) const {
    851       LEMON_DEBUG(v._id >= _red_num, "Node has to be blue");
    852       return v._id - _red_num;
    853     }
     872    static int id(const Node& v) { return v._id; }
     873    int id(const RedNode& v) const { return v._id; }
     874    int id(const BlueNode& v) const { return v._id - _red_num; }
    854875    static int id(Arc e) { return e._id; }
    855876    static int id(Edge e) { return e._id; }
    856877   
     
    868889      return e._id >= 0 && e._id < _edge_num;
    869890    }
    870891
    871     Node redNode(int index) const {
    872       return Node(index);
     892    RedNode redNode(int index) const {
     893      return RedNode(index);
    873894    }
    874895
    875     int redIndex(Node n) const {
     896    int index(RedNode n) const {
    876897      return n._id;
    877898    }
    878899
    879     Node blueNode(int index) const {
    880       return Node(index + _red_num);
     900    BlueNode blueNode(int index) const {
     901      return BlueNode(index + _red_num);
    881902    }
    882903
    883     int blueIndex(Node n) const {
     904    int index(BlueNode n) const {
    884905      return n._id - _red_num;
    885906    }
    886907       
     
    10001021    /// structure is completely static, the red nodes can be indexed
    10011022    /// with integers from the range <tt>[0..redNum()-1]</tt>.
    10021023    /// \sa redIndex()
    1003     Node redNode(int index) const { return Parent::redNode(index); }
     1024    RedNode redNode(int index) const { return Parent::redNode(index); }
    10041025
    10051026    /// \brief Returns the index of the given red node.
    10061027    ///
     
    10091030    /// integers from the range <tt>[0..redNum()-1]</tt>.
    10101031    ///
    10111032    /// \sa operator()()
    1012     int redIndex(Node node) const { return Parent::redIndex(node); }
     1033    int index(RedNode node) const { return Parent::index(node); }
    10131034
    10141035    /// \brief Returns the blue node with the given index.
    10151036    ///
     
    10171038    /// structure is completely static, the blue nodes can be indexed
    10181039    /// with integers from the range <tt>[0..blueNum()-1]</tt>.
    10191040    /// \sa blueIndex()
    1020     Node blueNode(int index) const { return Parent::blueNode(index); }
     1041    BlueNode blueNode(int index) const { return Parent::blueNode(index); }
    10211042
    10221043    /// \brief Returns the index of the given blue node.
    10231044    ///
     
    10261047    /// integers from the range <tt>[0..blueNum()-1]</tt>.
    10271048    ///
    10281049    /// \sa operator()()
    1029     int blueIndex(Node node) const { return Parent::blueIndex(node); }
     1050    int index(BlueNode node) const { return Parent::index(node); }
    10301051
    10311052    /// \brief Returns the edge which connects the given nodes.
    10321053    ///
  • lemon/list_graph.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/list_graph.h
    a b  
    16471647      bool operator<(const Node& node) const {return id < node.id;}
    16481648    };
    16491649
     1650    class RedNode : public Node {
     1651      friend class ListBpGraphBase;
     1652    protected:
     1653
     1654      explicit RedNode(int pid) : Node(pid) {}
     1655
     1656    public:
     1657      RedNode() {}
     1658      RedNode(const RedNode& node) : Node(node) {}
     1659      RedNode(Invalid) : Node(INVALID){}
     1660    };
     1661
     1662    class BlueNode : public Node {
     1663      friend class ListBpGraphBase;
     1664    protected:
     1665
     1666      explicit BlueNode(int pid) : Node(pid) {}
     1667
     1668    public:
     1669      BlueNode() {}
     1670      BlueNode(const BlueNode& node) : Node(node) {}
     1671      BlueNode(Invalid) : Node(INVALID){}
     1672    };
     1673
    16501674    class Edge {
    16511675      friend class ListBpGraphBase;
    16521676    protected:
     
    16921716    bool red(Node n) const { return nodes[n.id].red; }
    16931717    bool blue(Node n) const { return !nodes[n.id].red; }
    16941718
     1719    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
     1720    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
     1721
    16951722    int maxNodeId() const { return nodes.size()-1; }
    16961723    int maxRedId() const { return max_red; }
    16971724    int maxBlueId() const { return max_blue; }
     
    17011728    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
    17021729    Node target(Arc e) const { return Node(arcs[e.id].target); }
    17031730
    1704     Node redNode(Edge e) const { return Node(arcs[2 * e.id].target); }
    1705     Node blueNode(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
     1731    RedNode redNode(Edge e) const {
     1732      return RedNode(arcs[2 * e.id].target);
     1733    }
     1734    BlueNode blueNode(Edge e) const {
     1735      return BlueNode(arcs[2 * e.id + 1].target);
     1736    }
    17061737
    17071738    static bool direction(Arc e) {
    17081739      return (e.id & 1) == 1;
     
    17201751      node.id = nodes[node.id].next;
    17211752    }
    17221753
    1723     void firstRed(Node& node) const {
     1754    void first(RedNode& node) const {
    17241755      node.id = first_red;
    17251756    }
    17261757
    1727     void nextRed(Node& node) const {
     1758    void next(RedNode& node) const {
    17281759      node.id = nodes[node.id].partition_next;
    17291760    }
    17301761
    1731     void firstBlue(Node& node) const {
     1762    void first(BlueNode& node) const {
    17321763      node.id = first_blue;
    17331764    }
    17341765
    1735     void nextBlue(Node& node) const {
     1766    void next(BlueNode& node) const {
    17361767      node.id = nodes[node.id].partition_next;
    17371768    }   
    17381769
     
    18351866    }
    18361867
    18371868    static int id(Node v) { return v.id; }
    1838     int redId(Node v) const {
    1839       LEMON_DEBUG(nodes[v.id].red, "Node has to be red");
    1840       return nodes[v.id].partition_index;
    1841     }
    1842     int blueId(Node v) const {
    1843       LEMON_DEBUG(!nodes[v.id].red, "Node has to be blue");
    1844       return nodes[v.id].partition_index;
    1845     }
     1869    int id(RedNode v) const { return nodes[v.id].partition_index; }
     1870    int id(BlueNode v) const { return nodes[v.id].partition_index; }
    18461871    static int id(Arc e) { return e.id; }
    18471872    static int id(Edge e) { return e.id; }
    18481873
     
    18651890        arcs[2 * e.id].prev_out != -2;
    18661891    }
    18671892
    1868     Node addRedNode() {
     1893    RedNode addRedNode() {
    18691894      int n;
    18701895
    18711896      if(first_free_red==-1) {
     
    18901915
    18911916      nodes[n].first_out = -1;
    18921917
    1893       return Node(n);
     1918      return RedNode(n);
    18941919    }
    18951920
    1896     Node addBlueNode() {
     1921    BlueNode addBlueNode() {
    18971922      int n;
    18981923
    18991924      if(first_free_blue==-1) {
     
    19181943
    19191944      nodes[n].first_out = -1;
    19201945
    1921       return Node(n);
     1946      return BlueNode(n);
    19221947    }
    19231948
    19241949    Edge addEdge(Node u, Node v) {
     
    20292054
    20302055  protected:
    20312056
    2032     void changeRed(Edge e, Node n) {
    2033       LEMON_DEBUG(nodes[n].red, "Node has to be red");
     2057    void changeRed(Edge e, RedNode n) {
    20342058      if(arcs[(2 * e.id) | 1].next_out != -1) {
    20352059        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
    20362060          arcs[(2 * e.id) | 1].prev_out;
     
    20522076      nodes[n.id].first_out = ((2 * e.id) | 1);
    20532077    }
    20542078
    2055     void changeBlue(Edge e, Node n) {
    2056       LEMON_DEBUG(nodes[n].red, "Node has to be blue");
    2057       if(arcs[2 * e.id].next_out != -1) {
     2079    void changeBlue(Edge e, BlueNode n) {
     2080       if(arcs[2 * e.id].next_out != -1) {
    20582081        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
    20592082      }
    20602083      if(arcs[2 * e.id].prev_out != -1) {
     
    21192142    ///
    21202143    /// This function adds a red new node to the graph.
    21212144    /// \return The new node.
    2122     Node addRedNode() { return Parent::addRedNode(); }
     2145    RedNode addRedNode() { return Parent::addRedNode(); }
    21232146
    21242147    /// \brief Add a new blue node to the graph.
    21252148    ///
    21262149    /// This function adds a blue new node to the graph.
    21272150    /// \return The new node.
    2128     Node addBlueNode() { return Parent::addBlueNode(); }
     2151    BlueNode addBlueNode() { return Parent::addBlueNode(); }
    21292152
    21302153    /// \brief Add a new edge to the graph.
    21312154    ///
     
    21332156    /// \c u and \c v with inherent orientation from node \c u to
    21342157    /// node \c v.
    21352158    /// \return The new edge.
    2136     Edge addEdge(Node u, Node v) {
     2159    Edge addEdge(RedNode u, BlueNode v) {
     2160      return Parent::addEdge(u, v);
     2161    }
     2162    Edge addEdge(BlueNode v, RedNode u) {
    21372163      return Parent::addEdge(u, v);
    21382164    }
    21392165
     
    21882214    ///
    21892215    ///\warning This functionality cannot be used together with the
    21902216    ///Snapshot feature.
    2191     void changeRed(Edge e, Node n) {
    2192       Parent::changeRed(e,n);
     2217    void changeRed(Edge e, RedNode n) {
     2218      Parent::changeRed(e, n);
    21932219    }
    21942220    /// \brief Change the blue node of an edge.
    21952221    ///
     
    22022228    ///
    22032229    ///\warning This functionality cannot be used together with the
    22042230    ///Snapshot feature.
    2205     void changeBlue(Edge e, Node n) {
    2206       Parent::changeBlue(e,n);
     2231    void changeBlue(Edge e, BlueNode n) {
     2232      Parent::changeBlue(e, n);
    22072233    }
    22082234
    22092235    ///Clear the graph.
  • lemon/smart_graph.h

    diff -r 008af84a4d4a -r 434a20e74585 lemon/smart_graph.h
    a b  
    854854      bool operator<(const Node& node) const {return _id < node._id;}
    855855    };
    856856
     857    class RedNode : public Node {
     858      friend class SmartBpGraphBase;
     859    protected:
     860
     861      explicit RedNode(int pid) : Node(pid) {}
     862
     863    public:
     864      RedNode() {}
     865      RedNode(const RedNode& node) : Node(node) {}
     866      RedNode(Invalid) : Node(INVALID){}
     867    };
     868
     869    class BlueNode : public Node {
     870      friend class SmartBpGraphBase;
     871    protected:
     872
     873      explicit BlueNode(int pid) : Node(pid) {}
     874
     875    public:
     876      BlueNode() {}
     877      BlueNode(const BlueNode& node) : Node(node) {}
     878      BlueNode(Invalid) : Node(INVALID){}
     879    };
     880
    857881    class Edge {
    858882      friend class SmartBpGraphBase;
    859883    protected:
     
    913937    bool red(Node n) const { return nodes[n._id].red; }
    914938    bool blue(Node n) const { return !nodes[n._id].red; }
    915939
     940    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
     941    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
     942
    916943    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
    917944    Node target(Arc a) const { return Node(arcs[a._id].target); }
    918945
    919     Node redNode(Edge e) const { return Node(arcs[2 * e._id].target); }
    920     Node blueNode(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
     946    RedNode redNode(Edge e) const {
     947      return RedNode(arcs[2 * e._id].target);
     948    }
     949    BlueNode blueNode(Edge e) const {
     950      return BlueNode(arcs[2 * e._id + 1].target);
     951    }
    921952
    922953    static bool direction(Arc a) {
    923954      return (a._id & 1) == 1;
     
    935966      --node._id;
    936967    }
    937968
    938     void firstRed(Node& node) const {
     969    void first(RedNode& node) const {
    939970      node._id = first_red;
    940971    }
    941972
    942     void nextRed(Node& node) const {
     973    void next(RedNode& node) const {
    943974      node._id = nodes[node._id].partition_next;
    944975    }
    945976
    946     void firstBlue(Node& node) const {
     977    void first(BlueNode& node) const {
    947978      node._id = first_blue;
    948979    }
    949980
    950     void nextBlue(Node& node) const {
     981    void next(BlueNode& node) const {
    951982      node._id = nodes[node._id].partition_next;
    952983    }
    953984
     
    10051036    }
    10061037
    10071038    static int id(Node v) { return v._id; }
    1008     int redId(Node v) const {
    1009       LEMON_DEBUG(nodes[v._id].red, "Node has to be red");
    1010       return nodes[v._id].partition_index;
    1011     }
    1012     int blueId(Node v) const {
    1013       LEMON_DEBUG(!nodes[v._id].red, "Node has to be blue");
    1014       return nodes[v._id].partition_index;
    1015     }
     1039    int id(RedNode v) const { return nodes[v._id].partition_index; }
     1040    int id(BlueNode v) const { return nodes[v._id].partition_index; }
    10161041    static int id(Arc e) { return e._id; }
    10171042    static int id(Edge e) { return e._id; }
    10181043
     
    10301055      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
    10311056    }
    10321057
    1033     Node addRedNode() {
     1058    RedNode addRedNode() {
    10341059      int n = nodes.size();
    10351060      nodes.push_back(NodeT());
    10361061      nodes[n].first_out = -1;
     
    10391064      nodes[n].partition_next = first_red;
    10401065      first_red = n;
    10411066
    1042       return Node(n);
     1067      return RedNode(n);
    10431068    }
    10441069
    1045     Node addBlueNode() {
     1070    BlueNode addBlueNode() {
    10461071      int n = nodes.size();
    10471072      nodes.push_back(NodeT());
    10481073      nodes[n].first_out = -1;
     
    10511076      nodes[n].partition_next = first_blue;
    10521077      first_blue = n;
    10531078
    1054       return Node(n);
     1079      return BlueNode(n);
    10551080    }
    10561081
    1057     Edge addEdge(Node u, Node v) {
     1082    Edge addEdge(RedNode u, BlueNode v) {
    10581083      int n = arcs.size();
    10591084      arcs.push_back(ArcT());
    10601085      arcs.push_back(ArcT());
     
    11241149    ///
    11251150    /// This function adds a red new node to the graph.
    11261151    /// \return The new node.
    1127     Node addRedNode() { return Parent::addRedNode(); }
     1152    RedNode addRedNode() { return Parent::addRedNode(); }
    11281153
    11291154    /// \brief Add a new blue node to the graph.
    11301155    ///
    11311156    /// This function adds a blue new node to the graph.
    11321157    /// \return The new node.
    1133     Node addBlueNode() { return Parent::addBlueNode(); }
     1158    BlueNode addBlueNode() { return Parent::addBlueNode(); }
    11341159
    11351160    /// \brief Add a new edge to the graph.
    11361161    ///
     
    11381163    /// \c u and \c v with inherent orientation from node \c u to
    11391164    /// node \c v.
    11401165    /// \return The new edge.
    1141     Edge addEdge(Node red, Node blue) {
    1142       LEMON_DEBUG(Parent::red(red) && Parent::blue(blue),
    1143                   "Edge has to be formed by a red and a blue nodes");
    1144       return Parent::addEdge(red, blue);
     1166    Edge addEdge(RedNode u, BlueNode v) {
     1167      return Parent::addEdge(u, v);
     1168    }
     1169    Edge addEdge(BlueNode v, RedNode u) {
     1170      return Parent::addEdge(u, v);
    11451171    }
    11461172
    11471173    /// \brief Node validity check
     
    12371263          } else {
    12381264            max_red = -1;
    12391265          }
    1240           Parent::notifier(RedNode()).erase(node);         
     1266          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));         
    12411267        } else {
    12421268          first_blue = nodes[n].partition_next;
    12431269          if (first_blue != -1) {
     
    12451271          } else {
    12461272            max_blue = -1;
    12471273          }
    1248           Parent::notifier(BlueNode()).erase(node);
     1274          Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
    12491275        }
    12501276        Parent::notifier(Node()).erase(node);
    12511277        nodes.pop_back();
  • test/bpgraph_test.cc

    diff -r 008af84a4d4a -r 434a20e74585 test/bpgraph_test.cc
    a b  
    4141  G.reserveNode(3);
    4242  G.reserveEdge(3);
    4343
    44   Node
     44  RedNode
    4545    rn1 = G.addRedNode();
    4646  checkGraphNodeList(G, 1);
    4747  checkGraphRedNodeList(G, 1);
     
    4949  checkGraphEdgeList(G, 0);
    5050  checkGraphArcList(G, 0);
    5151
    52   Node
     52  BlueNode
    5353    bn1 = G.addBlueNode(),
    5454    bn2 = G.addBlueNode();
    5555  checkGraphNodeList(G, 3);
     
    7676  checkGraphConArcList(G, 2);
    7777
    7878  Edge
    79     e2 = G.addEdge(rn1, bn1),
     79    e2 = G.addEdge(bn1, rn1),
    8080    e3 = G.addEdge(rn1, bn2);
    8181
    8282  checkGraphNodeList(G, 3);
     
    112112  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
    113113
    114114  BpGraph G;
    115   Node
    116     n1 = G.addRedNode(), n2 = G.addBlueNode(),
    117     n3 = G.addBlueNode(), n4 = G.addRedNode();
     115  RedNode
     116    n1 = G.addRedNode(), n4 = G.addRedNode();
     117  BlueNode
     118    n2 = G.addBlueNode(), n3 = G.addBlueNode();
    118119  Edge
    119120    e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
    120121    e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
     
    159160  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
    160161
    161162  BpGraph G;
    162   Node
    163     n1 = G.addRedNode(), n2 = G.addBlueNode(),
    164     n3 = G.addBlueNode(), n4 = G.addRedNode();
     163  RedNode
     164    n1 = G.addRedNode(), n4 = G.addRedNode();
     165  BlueNode
     166    n2 = G.addBlueNode(), n3 = G.addBlueNode();
    165167  Edge
    166168    e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
    167169    e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
     
    209211  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
    210212
    211213  BpGraph G;
    212   Node
    213     n1 = G.addRedNode(),
     214  RedNode
     215    n1 = G.addRedNode();
     216  BlueNode
    214217    n2 = G.addBlueNode(),
    215218    n3 = G.addBlueNode();
    216219  Edge
     
    225228
    226229  typename BpGraph::Snapshot snapshot(G);
    227230
    228   Node n4 = G.addRedNode();
     231  RedNode n4 = G.addRedNode();
    229232  G.addEdge(n4, n2);
    230233  G.addEdge(n4, n3);
    231234
     
    292295  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
    293296  BpGraph g;
    294297
    295   Node
    296     n1 = g.addRedNode(),
     298  RedNode
     299    n1 = g.addRedNode();
     300  BlueNode
    297301    n2 = g.addBlueNode(),
    298302    n3 = g.addBlueNode();
    299303
     
    396400
    397401  for (int i = 0; i < G.redNum(); ++i) {
    398402    check(G.red(G.redNode(i)), "Wrong node");
    399     check(G.redIndex(G.redNode(i)) == i, "Wrong index");
     403    check(G.index(G.redNode(i)) == i, "Wrong index");
    400404  }
    401405
    402406  for (int i = 0; i < G.blueNum(); ++i) {
    403407    check(G.blue(G.blueNode(i)), "Wrong node");
    404     check(G.blueIndex(G.blueNode(i)) == i, "Wrong index");
     408    check(G.index(G.blueNode(i)) == i, "Wrong index");
    405409  }
    406410
    407411  for (NodeIt u(G); u != INVALID; ++u) {
  • test/graph_copy_test.cc

    diff -r 008af84a4d4a -r 434a20e74585 test/graph_copy_test.cc
    a b  
    221221  SmartBpGraph::ArcMap<int> fam(from);
    222222  SmartBpGraph::EdgeMap<int> fem(from);
    223223  SmartBpGraph::Node fn = INVALID;
     224  SmartBpGraph::RedNode frn = INVALID;
     225  SmartBpGraph::BlueNode fbn = INVALID;
    224226  SmartBpGraph::Arc fa = INVALID;
    225227  SmartBpGraph::Edge fe = INVALID;
    226228
    227   std::vector<SmartBpGraph::Node> frnv;
     229  std::vector<SmartBpGraph::RedNode> frnv;
    228230  for (int i = 0; i < nn; ++i) {
    229     SmartBpGraph::Node node = from.addRedNode();
     231    SmartBpGraph::RedNode node = from.addRedNode();
    230232    frnv.push_back(node);
    231233    fnm[node] = i * i;
    232234    frnm[node] = i + i;
    233     if (i == 0) fn = node;
     235    if (i == 0) {
     236      fn = node;
     237      frn = node;
     238    }
    234239  }
    235240
    236   std::vector<SmartBpGraph::Node> fbnv;
     241  std::vector<SmartBpGraph::BlueNode> fbnv;
    237242  for (int i = 0; i < nn; ++i) {
    238     SmartBpGraph::Node node = from.addBlueNode();
     243    SmartBpGraph::BlueNode node = from.addBlueNode();
    239244    fbnv.push_back(node);
    240245    fnm[node] = i * i;
    241246    fbnm[node] = i + i;
     247    if (i == 0) fbn = node;
    242248  }
    243249
    244250  for (int i = 0; i < nn; ++i) {
     
    260266  typename GR::template ArcMap<int> tam(to);
    261267  typename GR::template EdgeMap<int> tem(to);
    262268  typename GR::Node tn;
     269  typename GR::RedNode trn;
     270  typename GR::BlueNode tbn;
    263271  typename GR::Arc ta;
    264272  typename GR::Edge te;
    265273
    266274  SmartBpGraph::NodeMap<typename GR::Node> nr(from);
    267   SmartBpGraph::RedMap<typename GR::Node> rnr(from);
    268   SmartBpGraph::BlueMap<typename GR::Node> bnr(from);
     275  SmartBpGraph::RedMap<typename GR::RedNode> rnr(from);
     276  SmartBpGraph::BlueMap<typename GR::BlueNode> bnr(from);
    269277  SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
    270278  SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
    271279
    272280  typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
    273   typename GR::template RedMap<SmartBpGraph::Node> rncr(to);
    274   typename GR::template BlueMap<SmartBpGraph::Node> bncr(to);
     281  typename GR::template RedMap<SmartBpGraph::RedNode> rncr(to);
     282  typename GR::template BlueMap<SmartBpGraph::BlueNode> bncr(to);
    275283  typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
    276284  typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
    277285
     
    282290    arcRef(ar).edgeRef(er).
    283291    nodeCrossRef(ncr).redCrossRef(rncr).blueCrossRef(bncr).
    284292    arcCrossRef(acr).edgeCrossRef(ecr).
    285     node(fn, tn).arc(fa, ta).edge(fe, te).run();
     293    node(fn, tn).redNode(frn, trn).blueNode(fbn, tbn).
     294    arc(fa, ta).edge(fe, te).run();
    286295
    287296  check(countNodes(from) == countNodes(to), "Wrong copy.");
    288297  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
     
    293302  for (SmartBpGraph::NodeIt it(from); it != INVALID; ++it) {
    294303    check(ncr[nr[it]] == it, "Wrong copy.");
    295304    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
    296     if (from.red(it)) {
    297       check(rnr[it] == nr[it], "Wrong copy.");
    298       check(rncr[rnr[it]] == it, "Wrong copy.");
    299       check(frnm[it] == trnm[rnr[it]], "Wrong copy.");
    300       check(to.red(rnr[it]), "Wrong copy.");
    301     } else {
    302       check(bnr[it] == nr[it], "Wrong copy.");
    303       check(bncr[bnr[it]] == it, "Wrong copy.");
    304       check(fbnm[it] == tbnm[bnr[it]], "Wrong copy.");
    305       check(to.blue(bnr[it]), "Wrong copy.");
    306     }
     305  }
     306
     307  for (SmartBpGraph::RedIt it(from); it != INVALID; ++it) {
     308    check(ncr[nr[it]] == it, "Wrong copy.");
     309    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
     310    check(rnr[it] == nr[it], "Wrong copy.");
     311    check(rncr[rnr[it]] == it, "Wrong copy.");
     312    check(frnm[it] == trnm[rnr[it]], "Wrong copy.");
     313    check(to.red(rnr[it]), "Wrong copy.");
     314  }
     315
     316  for (SmartBpGraph::BlueIt it(from); it != INVALID; ++it) {
     317    check(ncr[nr[it]] == it, "Wrong copy.");
     318    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
     319    check(bnr[it] == nr[it], "Wrong copy.");
     320    check(bncr[bnr[it]] == it, "Wrong copy.");
     321    check(fbnm[it] == tbnm[bnr[it]], "Wrong copy.");
     322    check(to.blue(bnr[it]), "Wrong copy.");
    307323  }
    308324
    309325  for (SmartBpGraph::ArcIt it(from); it != INVALID; ++it) {
     
    342358    check(er[ecr[it]] == it, "Wrong copy.");
    343359  }
    344360  check(tn == nr[fn], "Wrong copy.");
     361  check(trn == rnr[frn], "Wrong copy.");
     362  check(tbn == bnr[fbn], "Wrong copy.");
    345363  check(ta == ar[fa], "Wrong copy.");
    346364  check(te == er[fe], "Wrong copy.");
    347365
  • test/graph_test.h

    diff -r 008af84a4d4a -r 434a20e74585 test/graph_test.h
    a b  
    4646    typename Graph::RedIt n(G);
    4747    for(int i=0;i<cnt;i++) {
    4848      check(n!=INVALID,"Wrong red Node list linking.");
     49      check(G.red(n),"Wrong node set check.");
     50      check(!G.blue(n),"Wrong node set check.");
     51      typename Graph::Node nn = n;
     52      check(G.asRedNodeUnsafe(nn) == n,"Wrong node conversion.");
     53      check(G.asRedNode(nn) == n,"Wrong node conversion.");
     54      check(G.asBlueNode(nn) == INVALID,"Wrong node conversion.");
     55      std::pair<typename Graph::RedNode, typename Graph::BlueNode> rbn =
     56        G.asRedBlueNode(nn);
     57      check(rbn.first == n,"Wrong node conversion.");
     58      check(rbn.second == INVALID,"Wrong node conversion.");
    4959      ++n;
    5060    }
    5161    check(n==INVALID,"Wrong red Node list linking.");
     
    5868    typename Graph::BlueIt n(G);
    5969    for(int i=0;i<cnt;i++) {
    6070      check(n!=INVALID,"Wrong blue Node list linking.");
     71      check(G.blue(n),"Wrong node set check.");
     72      check(!G.red(n),"Wrong node set check.");
     73      typename Graph::Node nn = n;
     74      check(G.asBlueNodeUnsafe(nn) == n,"Wrong node conversion.");
     75      check(G.asBlueNode(nn) == n,"Wrong node conversion.");
     76      check(G.asRedNode(nn) == INVALID,"Wrong node conversion.");
     77      std::pair<typename Graph::RedNode, typename Graph::BlueNode> rbn =
     78        G.asRedBlueNode(nn);
     79      check(rbn.first == INVALID,"Wrong node conversion.");
     80      check(rbn.second == n,"Wrong node conversion.");
    6181      ++n;
    6282    }
    6383    check(n==INVALID,"Wrong blue Node list linking.");
     
    207227    std::set<int> values;
    208228    for (typename Graph::RedIt n(G); n != INVALID; ++n) {
    209229      check(G.red(n), "Wrong partition");
    210       check(G.redId(n) == G.id(RedNode(n)), "Wrong id");
    211       check(values.find(G.redId(n)) == values.end(), "Wrong id");
    212       check(G.redId(n) <= G.maxRedId(), "Wrong maximum id");
     230      check(values.find(G.id(n)) == values.end(), "Wrong id");
     231      check(G.id(n) <= G.maxRedId(), "Wrong maximum id");
    213232      values.insert(G.id(n));
    214233    }
    215234    check(G.maxId(RedNode()) == G.maxRedId(), "Wrong maximum id");
     
    221240    std::set<int> values;
    222241    for (typename Graph::BlueIt n(G); n != INVALID; ++n) {
    223242      check(G.blue(n), "Wrong partition");
    224       check(G.blueId(n) == G.id(BlueNode(n)), "Wrong id");
    225       check(values.find(G.blueId(n)) == values.end(), "Wrong id");
    226       check(G.blueId(n) <= G.maxBlueId(), "Wrong maximum id");
     243      check(values.find(G.id(n)) == values.end(), "Wrong id");
     244      check(G.id(n) <= G.maxBlueId(), "Wrong maximum id");
    227245      values.insert(G.id(n));
    228246    }
    229247    check(G.maxId(BlueNode()) == G.maxBlueId(), "Wrong maximum id");