COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 2386:81b47fc5c444 in lemon-0.x for lemon/list_graph.h


Ignore:
Timestamp:
03/02/07 19:04:28 (17 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3217
Message:

Hard Warning checking

  • based on the remark of the ZIB user
  • we do not use -Winline
File:
1 edited

Legend:

Unmodified
Added
Removed

  • lemon/list_graph.h

    r2381 r2386  
    523523        }
    524524        virtual void erase(const std::vector<Node>& nodes) {
    525           for (int i = 0; i < (int)nodes.size(); ++i) {
     525          for (int i = 0; i < int(nodes.size()); ++i) {
    526526            snapshot.eraseNode(nodes[i]);
    527527          }
    528528        }
    529529        virtual void build() {
    530           NodeNotifier* _notifier = notifier();
    531530          Node node;
    532531          std::vector<Node> nodes;
    533           for (_notifier->first(node); node != INVALID;
    534                _notifier->next(node)) {
     532          for (notifier()->first(node); node != INVALID;
     533               notifier()->next(node)) {
    535534            nodes.push_back(node);
    536535          }
    … …  
    540539        }
    541540        virtual void clear() {
    542           NodeNotifier* _notifier = notifier();
    543541          Node node;
    544           for (_notifier->first(node); node != INVALID;
    545                _notifier->next(node)) {
     542          for (notifier()->first(node); node != INVALID;
     543               notifier()->next(node)) {
    546544            snapshot.eraseNode(node);
    547545          }
    … …  
    575573        }
    576574        virtual void erase(const std::vector<Edge>& edges) {
    577           for (int i = 0; i < (int)edges.size(); ++i) {
     575          for (int i = 0; i < int(edges.size()); ++i) {
    578576            snapshot.eraseEdge(edges[i]);
    579577          }
    580578        }
    581579        virtual void build() {
    582           EdgeNotifier* _notifier = notifier();
    583580          Edge edge;
    584581          std::vector<Edge> edges;
    585           for (_notifier->first(edge); edge != INVALID;
    586                _notifier->next(edge)) {
     582          for (notifier()->first(edge); edge != INVALID;
     583               notifier()->next(edge)) {
    587584            edges.push_back(edge);
    588585          }
    … …  
    592589        }
    593590        virtual void clear() {
    594           EdgeNotifier* _notifier = notifier();
    595591          Edge edge;
    596           for (_notifier->first(edge); edge != INVALID; _notifier->next(edge)) {
     592          for (notifier()->first(edge); edge != INVALID;
     593               notifier()->next(edge)) {
    597594            snapshot.eraseEdge(edge);
    598595          }
    … …  
    12701267        }
    12711268        virtual void erase(const std::vector<Node>& nodes) {
    1272           for (int i = 0; i < (int)nodes.size(); ++i) {
     1269          for (int i = 0; i < int(nodes.size()); ++i) {
    12731270            snapshot.eraseNode(nodes[i]);
    12741271          }
    12751272        }
    12761273        virtual void build() {
    1277           NodeNotifier* _notifier = notifier();
    12781274          Node node;
    12791275          std::vector<Node> nodes;
    1280           for (_notifier->first(node); node != INVALID;
    1281                _notifier->next(node)) {
     1276          for (notifier()->first(node); node != INVALID;
     1277               notifier()->next(node)) {
    12821278            nodes.push_back(node);
    12831279          }
    … …  
    12871283        }
    12881284        virtual void clear() {
    1289           NodeNotifier* _notifier = notifier();
    12901285          Node node;
    1291           for (_notifier->first(node); node != INVALID;
    1292                _notifier->next(node)) {
     1286          for (notifier()->first(node); node != INVALID;
     1287               notifier()->next(node)) {
    12931288            snapshot.eraseNode(node);
    12941289          }
    … …  
    13221317        }
    13231318        virtual void erase(const std::vector<UEdge>& edges) {
    1324           for (int i = 0; i < (int)edges.size(); ++i) {
     1319          for (int i = 0; i < int(edges.size()); ++i) {
    13251320            snapshot.eraseUEdge(edges[i]);
    13261321          }
    13271322        }
    13281323        virtual void build() {
    1329           UEdgeNotifier* _notifier = notifier();
    13301324          UEdge edge;
    13311325          std::vector<UEdge> edges;
    1332           for (_notifier->first(edge); edge != INVALID;
    1333                _notifier->next(edge)) {
     1326          for (notifier()->first(edge); edge != INVALID;
     1327               notifier()->next(edge)) {
    13341328            edges.push_back(edge);
    13351329          }
    … …  
    13391333        }
    13401334        virtual void clear() {
    1341           UEdgeNotifier* _notifier = notifier();
    13421335          UEdge edge;
    1343           for (_notifier->first(edge); edge != INVALID;
    1344                _notifier->next(edge)) {
     1336          for (notifier()->first(edge); edge != INVALID;
     1337               notifier()->next(edge)) {
    13451338            snapshot.eraseUEdge(edge);
    13461339          }
    … …  
    15761569 
    15771570    void first(UEdge& edge) const {
    1578       int aNodeId = first_anode;
    1579       while (aNodeId != -1 && aNodes[aNodeId].first_edge == -1) {
    1580         aNodeId = aNodes[aNodeId].next != -1 ?
    1581           aNodes[aNodeId].next >> 1 : -1;
    1582       }
    1583       if (aNodeId != -1) {
    1584         edge.id = aNodes[aNodeId].first_edge;
     1571      int aid = first_anode;
     1572      while (aid != -1 && aNodes[aid].first_edge == -1) {
     1573        aid = aNodes[aid].next != -1 ?
     1574          aNodes[aid].next >> 1 : -1;
     1575      }
     1576      if (aid != -1) {
     1577        edge.id = aNodes[aid].first_edge;
    15851578      } else {
    15861579        edge.id = -1;
    … …  
    15881581    }
    15891582    void next(UEdge& edge) const {
    1590       int aNodeId = edges[edge.id].aNode >> 1;
     1583      int aid = edges[edge.id].aNode >> 1;
    15911584      edge.id = edges[edge.id].next_out;
    15921585      if (edge.id == -1) {
    1593         aNodeId = aNodes[aNodeId].next != -1 ?
    1594           aNodes[aNodeId].next >> 1 : -1;
    1595         while (aNodeId != -1 && aNodes[aNodeId].first_edge == -1) {
    1596           aNodeId = aNodes[aNodeId].next != -1 ?
    1597           aNodes[aNodeId].next >> 1 : -1;
    1598         }
    1599         if (aNodeId != -1) {
    1600           edge.id = aNodes[aNodeId].first_edge;
     1586        aid = aNodes[aid].next != -1 ?
     1587          aNodes[aid].next >> 1 : -1;
     1588        while (aid != -1 && aNodes[aid].first_edge == -1) {
     1589          aid = aNodes[aid].next != -1 ?
     1590          aNodes[aid].next >> 1 : -1;
     1591        }
     1592        if (aid != -1) {
     1593          edge.id = aNodes[aid].first_edge;
    16011594        } else {
    16021595          edge.id = -1;
    … …  
    16781671
    16791672    Node addANode() {
    1680       int aNodeId;
     1673      int aid;
    16811674      if (first_free_anode == -1) {
    1682         aNodeId = aNodes.size();
     1675        aid = aNodes.size();
    16831676        aNodes.push_back(NodeT());
    16841677      } else {
    1685         aNodeId = first_free_anode;
     1678        aid = first_free_anode;
    16861679        first_free_anode = aNodes[first_free_anode].next;
    16871680      }
    16881681      if (first_anode != -1) {
    1689         aNodes[aNodeId].next = first_anode << 1;
    1690         aNodes[first_anode].prev = aNodeId << 1;
    1691       } else {
    1692         aNodes[aNodeId].next = -1;
    1693       }
    1694       aNodes[aNodeId].prev = -1;
    1695       first_anode = aNodeId;
    1696       aNodes[aNodeId].first_edge = -1;
    1697       return Node(aNodeId << 1);
     1682        aNodes[aid].next = first_anode << 1;
     1683        aNodes[first_anode].prev = aid << 1;
     1684      } else {
     1685        aNodes[aid].next = -1;
     1686      }
     1687      aNodes[aid].prev = -1;
     1688      first_anode = aid;
     1689      aNodes[aid].first_edge = -1;
     1690      return Node(aid << 1);
    16981691    }
    16991692
    17001693    Node addBNode() {
    1701       int bNodeId;
     1694      int bid;
    17021695      if (first_free_bnode == -1) {
    1703         bNodeId = bNodes.size();
     1696        bid = bNodes.size();
    17041697        bNodes.push_back(NodeT());
    17051698      } else {
    1706         bNodeId = first_free_bnode;
     1699        bid = first_free_bnode;
    17071700        first_free_bnode = bNodes[first_free_bnode].next;
    17081701      }
    17091702      if (first_bnode != -1) {
    1710         bNodes[bNodeId].next = (first_bnode << 1) + 1;
    1711         bNodes[first_bnode].prev = (bNodeId << 1) + 1;
    1712       } else {
    1713         bNodes[bNodeId].next = -1;
    1714       }
    1715       bNodes[bNodeId].prev = -1;
    1716       first_bnode = bNodeId;
    1717       bNodes[bNodeId].first_edge = -1;
    1718       return Node((bNodeId << 1) + 1);
     1703        bNodes[bid].next = (first_bnode << 1) + 1;
     1704        bNodes[first_bnode].prev = (bid << 1) + 1;
     1705      } else {
     1706        bNodes[bid].next = -1;
     1707      }
     1708      bNodes[bid].prev = -1;
     1709      first_bnode = bid;
     1710      bNodes[bid].first_edge = -1;
     1711      return Node((bid << 1) + 1);
    17191712    }
    17201713
    … …  
    17531746    void erase(const Node& node) {
    17541747      if (aNode(node)) {
    1755         int aNodeId = node.id >> 1;
    1756         if (aNodes[aNodeId].prev != -1) {
    1757           aNodes[aNodes[aNodeId].prev >> 1].next = aNodes[aNodeId].next;
     1748        int aid = node.id >> 1;
     1749        if (aNodes[aid].prev != -1) {
     1750          aNodes[aNodes[aid].prev >> 1].next = aNodes[aid].next;
    17581751        } else {
    17591752          first_anode =
    1760             aNodes[aNodeId].next != -1 ? aNodes[aNodeId].next >> 1 : -1;
    1761         }
    1762         if (aNodes[aNodeId].next != -1) {
    1763           aNodes[aNodes[aNodeId].next >> 1].prev = aNodes[aNodeId].prev;
    1764         }
    1765         aNodes[aNodeId].next = first_free_anode;
    1766         first_free_anode = aNodeId;
    1767       } else {
    1768         int bNodeId = node.id >> 1;
    1769         if (bNodes[bNodeId].prev != -1) {
    1770           bNodes[bNodes[bNodeId].prev >> 1].next = bNodes[bNodeId].next;
     1753            aNodes[aid].next != -1 ? aNodes[aid].next >> 1 : -1;
     1754        }
     1755        if (aNodes[aid].next != -1) {
     1756          aNodes[aNodes[aid].next >> 1].prev = aNodes[aid].prev;
     1757        }
     1758        aNodes[aid].next = first_free_anode;
     1759        first_free_anode = aid;
     1760      } else {
     1761        int bid = node.id >> 1;
     1762        if (bNodes[bid].prev != -1) {
     1763          bNodes[bNodes[bid].prev >> 1].next = bNodes[bid].next;
    17711764        } else {
    17721765          first_bnode =
    1773             bNodes[bNodeId].next != -1 ? bNodes[bNodeId].next >> 1 : -1;
    1774         }
    1775         if (bNodes[bNodeId].next != -1) {
    1776           bNodes[bNodes[bNodeId].next >> 1].prev = bNodes[bNodeId].prev;
    1777         }
    1778         bNodes[bNodeId].next = first_free_bnode;
    1779         first_free_bnode = bNodeId;
     1766            bNodes[bid].next != -1 ? bNodes[bid].next >> 1 : -1;
     1767        }
     1768        if (bNodes[bid].next != -1) {
     1769          bNodes[bNodes[bid].next >> 1].prev = bNodes[bid].prev;
     1770        }
     1771        bNodes[bid].next = first_free_bnode;
     1772        first_free_bnode = bid;
    17801773      }
    17811774    }
    … …  
    20522045        }
    20532046        virtual void erase(const std::vector<Node>& nodes) {
    2054           for (int i = 0; i < (int)nodes.size(); ++i) {
     2047          for (int i = 0; i < int(nodes.size()); ++i) {
    20552048            snapshot.eraseNode(nodes[i]);
    20562049          }
    20572050        }
    20582051        virtual void build() {
    2059           NodeNotifier* _notifier = notifier();
    20602052          Node node;
    20612053          std::vector<Node> nodes;
    2062           for (_notifier->first(node); node != INVALID;
    2063                _notifier->next(node)) {
     2054          for (notifier()->first(node); node != INVALID;
     2055               notifier()->next(node)) {
    20642056            nodes.push_back(node);
    20652057          }
    … …  
    20692061        }
    20702062        virtual void clear() {
    2071           NodeNotifier* _notifier = notifier();
    20722063          Node node;
    2073           for (_notifier->first(node); node != INVALID;
    2074                _notifier->next(node)) {
     2064          for (notifier()->first(node); node != INVALID;
     2065               notifier()->next(node)) {
    20752066            snapshot.eraseNode(node);
    20762067          }
    … …  
    21042095        }
    21052096        virtual void erase(const std::vector<UEdge>& edges) {
    2106           for (int i = 0; i < (int)edges.size(); ++i) {
     2097          for (int i = 0; i < int(edges.size()); ++i) {
    21072098            snapshot.eraseUEdge(edges[i]);
    21082099          }
    21092100        }
    21102101        virtual void build() {
    2111           UEdgeNotifier* _notifier = notifier();
    21122102          UEdge edge;
    21132103          std::vector<UEdge> edges;
    2114           for (_notifier->first(edge); edge != INVALID;
    2115                _notifier->next(edge)) {
     2104          for (notifier()->first(edge); edge != INVALID;
     2105               notifier()->next(edge)) {
    21162106            edges.push_back(edge);
    21172107          }
    … …  
    21212111        }
    21222112        virtual void clear() {
    2123           UEdgeNotifier* _notifier = notifier();
    21242113          UEdge edge;
    2125           for (_notifier->first(edge); edge != INVALID;
    2126                _notifier->next(edge)) {
     2114          for (notifier()->first(edge); edge != INVALID;
     2115               notifier()->next(edge)) {
    21272116            snapshot.eraseUEdge(edge);
    21282117          }
Note: See TracChangeset for help on using the changeset viewer.