COIN-OR::LEMON - Graph Library

Changeset 2381:0248790c66ea in lemon-0.x


Ignore:
Timestamp:
03/01/07 17:47:23 (12 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3212
Message:

Bug fix

Location:
lemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/list_graph.h

    r2343 r2381  
    528528        }
    529529        virtual void build() {
    530           NodeNotifier* notifier = getNotifier();
     530          NodeNotifier* _notifier = notifier();
    531531          Node node;
    532532          std::vector<Node> nodes;
    533           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     533          for (_notifier->first(node); node != INVALID;
     534               _notifier->next(node)) {
    534535            nodes.push_back(node);
    535536          }
     
    539540        }
    540541        virtual void clear() {
    541           NodeNotifier* notifier = getNotifier();
     542          NodeNotifier* _notifier = notifier();
    542543          Node node;
    543           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     544          for (_notifier->first(node); node != INVALID;
     545               _notifier->next(node)) {
    544546            snapshot.eraseNode(node);
    545547          }
     
    578580        }
    579581        virtual void build() {
    580           EdgeNotifier* notifier = getNotifier();
     582          EdgeNotifier* _notifier = notifier();
    581583          Edge edge;
    582584          std::vector<Edge> edges;
    583           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     585          for (_notifier->first(edge); edge != INVALID;
     586               _notifier->next(edge)) {
    584587            edges.push_back(edge);
    585588          }
     
    589592        }
    590593        virtual void clear() {
    591           EdgeNotifier* notifier = getNotifier();
     594          EdgeNotifier* _notifier = notifier();
    592595          Edge edge;
    593           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     596          for (_notifier->first(edge); edge != INVALID; _notifier->next(edge)) {
    594597            snapshot.eraseEdge(edge);
    595598          }
     
    640643      void attach(ListGraph &_graph) {
    641644        graph = &_graph;
    642         node_observer_proxy.attach(graph->getNotifier(Node()));
    643         edge_observer_proxy.attach(graph->getNotifier(Edge()));
     645        node_observer_proxy.attach(graph->notifier(Node()));
     646        edge_observer_proxy.attach(graph->notifier(Edge()));
    644647      }
    645648           
     
    912915    void firstInc(UEdge &e, bool& d, const Node& v) const {
    913916      int de = nodes[v.id].first_out;
    914       e.id = de / 2;
    915       d = ((de & 1) == 1);
     917      if (de != -1 ) {
     918        e.id = de / 2;
     919        d = ((de & 1) == 1);
     920      } else {
     921        e.id = -1;
     922        d = true;
     923      }
    916924    }
    917925    void nextInc(UEdge &e, bool& d) const {
    918926      int de = (edges[(e.id * 2) | (d ? 1 : 0)].next_out);
    919       e.id = de / 2;
    920       d = ((de & 1) == 1);
     927      if (de != -1 ) {
     928        e.id = de / 2;
     929        d = ((de & 1) == 1);
     930      } else {
     931        e.id = -1;
     932        d = true;
     933      }
    921934    }
    922935   
     
    12621275        }
    12631276        virtual void build() {
    1264           NodeNotifier* notifier = getNotifier();
     1277          NodeNotifier* _notifier = notifier();
    12651278          Node node;
    12661279          std::vector<Node> nodes;
    1267           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     1280          for (_notifier->first(node); node != INVALID;
     1281               _notifier->next(node)) {
    12681282            nodes.push_back(node);
    12691283          }
     
    12731287        }
    12741288        virtual void clear() {
    1275           NodeNotifier* notifier = getNotifier();
     1289          NodeNotifier* _notifier = notifier();
    12761290          Node node;
    1277           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     1291          for (_notifier->first(node); node != INVALID;
     1292               _notifier->next(node)) {
    12781293            snapshot.eraseNode(node);
    12791294          }
     
    13121327        }
    13131328        virtual void build() {
    1314           UEdgeNotifier* notifier = getNotifier();
     1329          UEdgeNotifier* _notifier = notifier();
    13151330          UEdge edge;
    13161331          std::vector<UEdge> edges;
    1317           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     1332          for (_notifier->first(edge); edge != INVALID;
     1333               _notifier->next(edge)) {
    13181334            edges.push_back(edge);
    13191335          }
     
    13231339        }
    13241340        virtual void clear() {
    1325           UEdgeNotifier* notifier = getNotifier();
     1341          UEdgeNotifier* _notifier = notifier();
    13261342          UEdge edge;
    1327           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     1343          for (_notifier->first(edge); edge != INVALID;
     1344               _notifier->next(edge)) {
    13281345            snapshot.eraseUEdge(edge);
    13291346          }
     
    13741391      void attach(ListUGraph &_graph) {
    13751392        graph = &_graph;
    1376         node_observer_proxy.attach(graph->getNotifier(Node()));
    1377         edge_observer_proxy.attach(graph->getNotifier(UEdge()));
     1393        node_observer_proxy.attach(graph->notifier(Node()));
     1394        edge_observer_proxy.attach(graph->notifier(UEdge()));
    13781395      }
    13791396           
     
    20402057        }
    20412058        virtual void build() {
    2042           NodeNotifier* notifier = getNotifier();
     2059          NodeNotifier* _notifier = notifier();
    20432060          Node node;
    20442061          std::vector<Node> nodes;
    2045           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     2062          for (_notifier->first(node); node != INVALID;
     2063               _notifier->next(node)) {
    20462064            nodes.push_back(node);
    20472065          }
     
    20512069        }
    20522070        virtual void clear() {
    2053           NodeNotifier* notifier = getNotifier();
     2071          NodeNotifier* _notifier = notifier();
    20542072          Node node;
    2055           for (notifier->first(node); node != INVALID; notifier->next(node)) {
     2073          for (_notifier->first(node); node != INVALID;
     2074               _notifier->next(node)) {
    20562075            snapshot.eraseNode(node);
    20572076          }
     
    20902109        }
    20912110        virtual void build() {
    2092           UEdgeNotifier* notifier = getNotifier();
     2111          UEdgeNotifier* _notifier = notifier();
    20932112          UEdge edge;
    20942113          std::vector<UEdge> edges;
    2095           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     2114          for (_notifier->first(edge); edge != INVALID;
     2115               _notifier->next(edge)) {
    20962116            edges.push_back(edge);
    20972117          }
     
    21012121        }
    21022122        virtual void clear() {
    2103           UEdgeNotifier* notifier = getNotifier();
     2123          UEdgeNotifier* _notifier = notifier();
    21042124          UEdge edge;
    2105           for (notifier->first(edge); edge != INVALID; notifier->next(edge)) {
     2125          for (_notifier->first(edge); edge != INVALID;
     2126               _notifier->next(edge)) {
    21062127            snapshot.eraseUEdge(edge);
    21072128          }
     
    21522173      void attach(ListBpUGraph &_graph) {
    21532174        graph = &_graph;
    2154         node_observer_proxy.attach(graph->getNotifier(Node()));
    2155         edge_observer_proxy.attach(graph->getNotifier(UEdge()));
     2175        node_observer_proxy.attach(graph->notifier(Node()));
     2176        edge_observer_proxy.attach(graph->notifier(UEdge()));
    21562177      }
    21572178           
  • lemon/smart_graph.h

    r2350 r2381  
    287287      while(s.edge_num<edges.size()) {
    288288        Edge edge = edgeFromId(edges.size()-1);
    289         Parent::getNotifier(Edge()).erase(edge);
     289        Parent::notifier(Edge()).erase(edge);
    290290        nodes[edges.back().source].first_out=edges.back().next_out;
    291291        nodes[edges.back().target].first_in=edges.back().next_in;
     
    294294      while(s.node_num<nodes.size()) {
    295295        Node node = nodeFromId(nodes.size()-1);
    296         Parent::getNotifier(Node()).erase(node);
     296        Parent::notifier(Node()).erase(node);
    297297        nodes.pop_back();
    298298      }
     
    506506    void firstInc(UEdge &edge, bool& d, const Node& v) const {
    507507      int de = nodes[v.id].first_out;
    508       edge.id = de / 2;
    509       d = ((de & 1) == 1);
     508      if (de != -1) {
     509        edge.id = de / 2;
     510        d = ((de & 1) == 1);
     511      } else {
     512        edge.id = -1;
     513        d = true;
     514      }
    510515    }
    511516    void nextInc(UEdge &edge, bool& d) const {
    512517      int de = (edges[(edge.id * 2) | (d ? 1 : 0)].next_out);
    513       edge.id = de / 2;
    514       d = ((de & 1) == 1);
     518      if (de != -1) {
     519        edge.id = de / 2;
     520        d = ((de & 1) == 1);
     521      } else {
     522        edge.id = -1;
     523        d = true;     
     524      }
    515525    }
    516526   
     
    642652        int n=edges.size()-1;
    643653        UEdge edge=uEdgeFromId(n/2);
    644         Parent::getNotifier(UEdge()).erase(edge);
     654        Parent::notifier(UEdge()).erase(edge);
    645655        std::vector<Edge> dir;
    646656        dir.push_back(edgeFromId(n));
    647657        dir.push_back(edgeFromId(n-1));
    648         Parent::getNotifier(Edge()).erase(dir);
     658        Parent::notifier(Edge()).erase(dir);
    649659        nodes[edges[n].target].first_out=edges[n].next_out;
    650660        nodes[edges[n-1].target].first_out=edges[n-1].next_out;
     
    655665        int n=nodes.size()-1;
    656666        Node node = nodeFromId(n);
    657         Parent::getNotifier(Node()).erase(node);
     667        Parent::notifier(Node()).erase(node);
    658668        nodes.pop_back();
    659669      }
     
    10241034      while(s.edge_num<edges.size()) {
    10251035        UEdge edge = uEdgeFromId(edges.size()-1);
    1026         Parent::getNotifier(UEdge()).erase(edge);
     1036        Parent::notifier(UEdge()).erase(edge);
    10271037        std::vector<Edge> dir;
    10281038        dir.push_back(Parent::direct(edge, true));
    10291039        dir.push_back(Parent::direct(edge, false));
    1030         Parent::getNotifier(Edge()).erase(dir);
     1040        Parent::notifier(Edge()).erase(dir);
    10311041        aNodes[edges.back().aNode >> 1].first=edges.back().next_out;
    10321042        bNodes[edges.back().bNode >> 1].first=edges.back().next_in;
     
    10351045      while(s.anode_num<aNodes.size()) {
    10361046        Node node = nodeFromANodeId(aNodes.size() - 1);
    1037         Parent::getNotifier(ANode()).erase(node);
    1038         Parent::getNotifier(Node()).erase(node);
     1047        Parent::notifier(ANode()).erase(node);
     1048        Parent::notifier(Node()).erase(node);
    10391049        aNodes.pop_back();
    10401050      }
    10411051      while(s.bnode_num<bNodes.size()) {
    10421052        Node node = nodeFromBNodeId(bNodes.size() - 1);
    1043         Parent::getNotifier(BNode()).erase(node);
    1044         Parent::getNotifier(Node()).erase(node);
     1053        Parent::notifier(BNode()).erase(node);
     1054        Parent::notifier(Node()).erase(node);
    10451055        bNodes.pop_back();
    10461056      }
  • lemon/ugraph_adaptor.h

    r2096 r2381  
    152152    typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
    153153
    154     NodeNotifier& getNotifier(Node) const {
    155       return graph->getNotifier(Node());
     154    NodeNotifier& notifier(Node) const {
     155      return graph->notifier(Node());
    156156    }
    157157
    158158    typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier;
    159159
    160     EdgeNotifier& getNotifier(Edge) const {
    161       return graph->getNotifier(Edge());
     160    EdgeNotifier& notifier(Edge) const {
     161      return graph->notifier(Edge());
    162162    }
    163163
    164164    typedef typename ItemSetTraits<Graph, UEdge>::ItemNotifier UEdgeNotifier;
    165165
    166     UEdgeNotifier& getNotifier(UEdge) const {
    167       return graph->getNotifier(UEdge());
     166    UEdgeNotifier& notifier(UEdge) const {
     167      return graph->notifier(UEdge());
    168168    }
    169169
     
    312312      Parent::firstInc(i, d, n);
    313313      while (i!=INVALID && (!(*uedge_filter_map)[i]
     314            || !(*node_filter_map)[Parent::source(i)]
    314315            || !(*node_filter_map)[Parent::target(i)])) Parent::nextInc(i, d);
    315316    }
     
    348349    void nextInc(UEdge& i, bool& d) const {
    349350      Parent::nextInc(i, d);
    350       while (i!=INVALID && (!(*uedge_filter_map)[i]
    351             || !(*node_filter_map)[Parent::source(i)])) Parent::nextInc(i, d);
     351      while (i!=INVALID && (!(*uedge_filter_map)[i]
     352            || !(*node_filter_map)[Parent::source(i)]
     353            || !(*node_filter_map)[Parent::target(i)])) Parent::nextInc(i, d);
    352354    }
    353355
     
    988990    typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
    989991
    990     NodeNotifier& getNotifier(Node) const {
    991       return graph->getNotifier(Node());
     992    NodeNotifier& notifier(Node) const {
     993      return graph->notifier(Node());
    992994    }
    993995
    994996    typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier;
    995997
    996     EdgeNotifier& getNotifier(Edge) const {
    997       return graph->getNotifier(Edge());
     998    EdgeNotifier& notifier(Edge) const {
     999      return graph->notifier(Edge());
    9981000    }
    9991001
Note: See TracChangeset for help on using the changeset viewer.