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

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:

• lemon/graph_adaptor.h (modified) (36 diffs)

lemon/graph_adaptor.h

@@ -94 +94 @@
 
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
                   const Edge& prev = INVALID) {
-      return graph->findEdge(source, target, prev);
+      return graph->findEdge(u, v, prev);
     }
   
@@ -103 +103 @@
     }
 
-    Edge addEdge(const Node& source, const Node& target) const { 
-      return Edge(graph->addEdge(source, target)); 
+    Edge addEdge(const Node& u, const Node& v) const { 
+      return Edge(graph->addEdge(u, v)); 
     }
 
@@ -115 +115 @@
     int id(const Edge& e) const { return graph->id(e); }
 
-    Node fromNodeId(int id) const {
-      return graph->fromNodeId(id);
-    }
-
-    Edge fromEdgeId(int id) const {
-      return graph->fromEdgeId(id);
+    Node fromNodeId(int ix) const {
+      return graph->fromNodeId(ix);
+    }
+
+    Edge fromEdgeId(int ix) const {
+      return graph->fromEdgeId(ix);
     }
 
@@ -244 +244 @@
 
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
                   const Edge& prev = INVALID) {
-      return Parent::findEdge(target, source, prev);
+      return Parent::findEdge(v, u, prev);
     }
 
@@ -461 +461 @@
                              template NodeMap<_Value> > Parent;
     
-      NodeMap(const Graph& graph) 
-        : Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
+      NodeMap(const Graph& g) 
+        : Parent(g) {}
+      NodeMap(const Graph& g, const _Value& v) 
+        : Parent(g, v) {}
     
       NodeMap& operator=(const NodeMap& cmap) {
@@ -487 +487 @@
                              template EdgeMap<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-        : Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+        : Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+        : Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -634 +634 @@
                              template NodeMap<_Value> > Parent;
     
-      NodeMap(const Graph& graph) 
-        : Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
+      NodeMap(const Graph& g) 
+        : Parent(g) {}
+      NodeMap(const Graph& g, const _Value& v) 
+        : Parent(g, v) {}
     
       NodeMap& operator=(const NodeMap& cmap) {
@@ -660 +660 @@
                              template EdgeMap<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-        : Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+        : Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+        : Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -1106 +1106 @@
       typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-        : Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-        : Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+        : Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+        : Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -1181 +1181 @@
       : Parent(), edge_notifier(*this), edge_notifier_proxy(*this) {}
 
-    void setGraph(_Graph& graph) {
-      Parent::setGraph(graph);
-      edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+    void setGraph(_Graph& g) {
+      Parent::setGraph(g);
+      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
     }
 
@@ -1221 +1221 @@
       }
 
-      void setNotifier(typename Graph::EdgeNotifier& notifier) {
-        Parent::attach(notifier);
+      void setNotifier(typename Graph::EdgeNotifier& nf) {
+        Parent::attach(nf);
       }
 
@@ -1236 +1236 @@
       virtual void add(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) { 
+        for (int i = 0; i < int(ge.size()); ++i) { 
           edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
           edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
@@ -1250 +1250 @@
       virtual void erase(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) { 
+        for (int i = 0; i < int(ge.size()); ++i) { 
           edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
           edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
@@ -1822 +1822 @@
     };
 
-    void first(Node& node) const {
-      Parent::first(node);
-      node.in_node = true;
-    }
-
-    void next(Node& node) const {
-      if (node.in_node) {
-        node.in_node = false;
+    void first(Node& n) const {
+      Parent::first(n);
+      n.in_node = true;
+    }
+
+    void next(Node& n) const {
+      if (n.in_node) {
+        n.in_node = false;
       } else {
-        node.in_node = true;
-        Parent::next(node);
-      }
-    }
-
-    void first(Edge& edge) const {
-      edge.item.setSecond();
-      Parent::first(edge.item.second());
-      if (edge.item.second() == INVALID) {
-        edge.item.setFirst();
-        Parent::first(edge.item.first());
-      }
-    }
-
-    void next(Edge& edge) const {
-      if (edge.item.secondState()) {
-        Parent::next(edge.item.second());
-        if (edge.item.second() == INVALID) {
-          edge.item.setFirst();
-          Parent::first(edge.item.first());
+        n.in_node = true;
+        Parent::next(n);
+      }
+    }
+
+    void first(Edge& e) const {
+      e.item.setSecond();
+      Parent::first(e.item.second());
+      if (e.item.second() == INVALID) {
+        e.item.setFirst();
+        Parent::first(e.item.first());
+      }
+    }
+
+    void next(Edge& e) const {
+      if (e.item.secondState()) {
+        Parent::next(e.item.second());
+        if (e.item.second() == INVALID) {
+          e.item.setFirst();
+          Parent::first(e.item.first());
         }
       } else {
-        Parent::next(edge.item.first());
+        Parent::next(e.item.first());
       }      
     }
 
-    void firstOut(Edge& edge, const Node& node) const {
-      if (node.in_node) {
-        edge.item.setSecond(node);
+    void firstOut(Edge& e, const Node& n) const {
+      if (n.in_node) {
+        e.item.setSecond(n);
       } else {
-        edge.item.setFirst();
-        Parent::firstOut(edge.item.first(), node);
-      }
-    }
-
-    void nextOut(Edge& edge) const {
-      if (!edge.item.firstState()) {
-        edge.item.setFirst(INVALID);
+        e.item.setFirst();
+        Parent::firstOut(e.item.first(), n);
+      }
+    }
+
+    void nextOut(Edge& e) const {
+      if (!e.item.firstState()) {
+        e.item.setFirst(INVALID);
       } else {
-        Parent::nextOut(edge.item.first());
+        Parent::nextOut(e.item.first());
       }      
     }
 
-    void firstIn(Edge& edge, const Node& node) const {
-      if (!node.in_node) {
-        edge.item.setSecond(node);        
+    void firstIn(Edge& e, const Node& n) const {
+      if (!n.in_node) {
+        e.item.setSecond(n);        
       } else {
-        edge.item.setFirst();
-        Parent::firstIn(edge.item.first(), node);
-      }
-    }
-
-    void nextIn(Edge& edge) const {
-      if (!edge.item.firstState()) {
-        edge.item.setFirst(INVALID);
+        e.item.setFirst();
+        Parent::firstIn(e.item.first(), n);
+      }
+    }
+
+    void nextIn(Edge& e) const {
+      if (!e.item.firstState()) {
+        e.item.setFirst(INVALID);
       } else {
-        Parent::nextIn(edge.item.first());
-      }
-    }
-
-    Node source(const Edge& edge) const {
-      if (edge.item.firstState()) {
-        return Node(Parent::source(edge.item.first()), false);
+        Parent::nextIn(e.item.first());
+      }
+    }
+
+    Node source(const Edge& e) const {
+      if (e.item.firstState()) {
+        return Node(Parent::source(e.item.first()), false);
       } else {
-        return Node(edge.item.second(), true);
-      }
-    }
-
-    Node target(const Edge& edge) const {
-      if (edge.item.firstState()) {
-        return Node(Parent::target(edge.item.first()), true);
+        return Node(e.item.second(), true);
+      }
+    }
+
+    Node target(const Edge& e) const {
+      if (e.item.firstState()) {
+        return Node(Parent::target(e.item.first()), true);
       } else {
-        return Node(edge.item.second(), false);
-      }
-    }
-
-    int id(const Node& node) const {
-      return (Parent::id(node) << 1) | (node.in_node ? 0 : 1);
-    }
-    Node nodeFromId(int id) const {
-      return Node(Parent::nodeFromId(id >> 1), (id & 1) == 0);
+        return Node(e.item.second(), false);
+      }
+    }
+
+    int id(const Node& n) const {
+      return (Parent::id(n) << 1) | (n.in_node ? 0 : 1);
+    }
+    Node nodeFromId(int ix) const {
+      return Node(Parent::nodeFromId(ix >> 1), (ix & 1) == 0);
     }
     int maxNodeId() const {
@@ -1917 +1917 @@
     }
 
-    int id(const Edge& edge) const {
-      if (edge.item.firstState()) {
-        return Parent::id(edge.item.first()) << 1;
+    int id(const Edge& e) const {
+      if (e.item.firstState()) {
+        return Parent::id(e.item.first()) << 1;
       } else {
-        return (Parent::id(edge.item.second()) << 1) | 1;
-      }
-    }
-    Edge edgeFromId(int id) const {
-      if ((id & 1) == 0) {
-        return Edge(Parent::edgeFromId(id >> 1));
+        return (Parent::id(e.item.second()) << 1) | 1;
+      }
+    }
+    Edge edgeFromId(int ix) const {
+      if ((ix & 1) == 0) {
+        return Edge(Parent::edgeFromId(ix >> 1));
       } else {
-        return Edge(Parent::nodeFromId(id >> 1));
+        return Edge(Parent::nodeFromId(ix >> 1));
       }
     }
@@ -1939 +1939 @@
     ///
     /// Returns true when the node is in-node.
-    static bool inNode(const Node& node) {
-      return node.in_node;
+    static bool inNode(const Node& n) {
+      return n.in_node;
     }
 
@@ -1946 +1946 @@
     ///
     /// Returns true when the node is out-node.
-    static bool outNode(const Node& node) {
-      return !node.in_node;
+    static bool outNode(const Node& n) {
+      return !n.in_node;
     }
 
@@ -1953 +1953 @@
     ///
     /// Returns true when the edge is edge in the original graph.
-    static bool origEdge(const Edge& edge) {
-      return edge.item.firstState();
+    static bool origEdge(const Edge& e) {
+      return e.item.firstState();
     }
 
@@ -1960 +1960 @@
     ///
     /// Returns true when the edge binds an in-node and an out-node.
-    static bool bindEdge(const Edge& edge) {
-      return edge.item.secondState();
+    static bool bindEdge(const Edge& e) {
+      return e.item.secondState();
     }
 
@@ -1967 +1967 @@
     ///
     /// Gives back the in-node created from the \c node.
-    static Node inNode(const GraphNode& node) {
-      return Node(node, true);
+    static Node inNode(const GraphNode& n) {
+      return Node(n, true);
     }
 
@@ -1974 +1974 @@
     ///
     /// Gives back the out-node created from the \c node.
-    static Node outNode(const GraphNode& node) {
-      return Node(node, false);
+    static Node outNode(const GraphNode& n) {
+      return Node(n, false);
     }
 
@@ -1981 +1981 @@
     /// 
     /// Gives back the edge binds the two part of the node.
-    static Edge edge(const GraphNode& node) {
-      return Edge(node);
+    static Edge edge(const GraphNode& n) {
+      return Edge(n);
     }
 
@@ -1988 +1988 @@
     /// 
     /// Gives back the edge of the original edge.
-    static Edge edge(const GraphEdge& edge) {
-      return Edge(edge);
+    static Edge edge(const GraphEdge& e) {
+      return Edge(e);
     }
 
@@ -2006 +2006 @@
     typedef True FindEdgeTag;
 
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
                   const Edge& prev = INVALID) const {
-      if (inNode(source)) {
-        if (outNode(target)) {
-          if ((GraphNode&)source == (GraphNode&)target && prev == INVALID) {
-            return Edge(source);
+      if (inNode(u)) {
+        if (outNode(v)) {
+          if (static_cast<const GraphNode&>(u) == 
+              static_cast<const GraphNode&>(v) && prev == INVALID) {
+            return Edge(u);
           }
         }
       } else {
-        if (inNode(target)) {
-          return Edge(findEdge(*Parent::graph, source, target, prev));
+        if (inNode(v)) {
+          return Edge(findEdge(*Parent::graph, u, v, prev));
         }
       }
@@ -2192 +2193 @@
       virtual void add(const std::vector<GraphNode>& gn) {
         std::vector<Node> nodes;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
           nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
@@ -2208 +2209 @@
       virtual void erase(const std::vector<GraphNode>& gn) {
         std::vector<Node> nodes;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
           nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
@@ -2254 +2255 @@
         node_notifier_proxy(*this), edge_notifier_proxy(*this) {}
     
-    void setGraph(_Graph& graph) {
-      Parent::setGraph(graph);
-      node_notifier_proxy.setNotifier(graph.notifier(GraphNode()));
-      edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+    void setGraph(_Graph& g) {
+      Parent::setGraph(g);
+      node_notifier_proxy.setNotifier(g.notifier(GraphNode()));
+      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
     }
 
@@ -2308 +2309 @@
         std::vector<Node> nodes;
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           edges.push_back(AdaptorBase::Parent::edge(gn[i]));
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
@@ -2326 +2327 @@
         std::vector<Node> nodes;
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           edges.push_back(AdaptorBase::Parent::edge(gn[i]));
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
@@ -2336 +2337 @@
       virtual void build() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphNode it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2346 +2347 @@
       virtual void clear() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphNode it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2386 +2387 @@
       virtual void add(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) {
+        for (int i = 0; i < int(ge.size()); ++i) {
           edges.push_back(AdaptorBase::edge(ge[i]));
         }
@@ -2396 +2397 @@
       virtual void erase(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) {
+        for (int i = 0; i < int(ge.size()); ++i) {
           edges.push_back(AdaptorBase::edge(ge[i]));
         }
@@ -2403 +2404 @@
       virtual void build() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphEdge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2412 +2413 @@
       virtual void clear() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphEdge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2510 +2511 @@
     ///
     /// Constructor of the adaptor.
-    SplitGraphAdaptor(_Graph& graph) {
-      Parent::setGraph(graph);
+    SplitGraphAdaptor(_Graph& g) {
+      Parent::setGraph(g);
     }