Changeset 1194:699c7eac2c6d in lemon for lemon/bits

Timestamp:

01/11/12 22:21:07 (12 years ago)

Author:

Balazs Dezso <deba@…>

Branch:

default

Phase:

public

Message:

Renamings in BpGraphs? (#69)

• RedIt?->RedNodeIt?
• BlueIt?->BlueNodeIt?
• RedMap?->RedNodeMap?
• BlueMap?->BlueNodeMap?

Location:

lemon/bits

Files:

• graph_extender.h (modified) (4 diffs)
• traits.h (modified) (2 diffs)

lemon/bits/graph_extender.h

@@ -914 +914 @@
     };
 
-    class RedIt : public RedNode {
+    class RedNodeIt : public RedNode {
       const BpGraph* _graph;
     public:
 
-      RedIt() {}
-
-      RedIt(Invalid i) : RedNode(i) { }
-
-      explicit RedIt(const BpGraph& graph) : _graph(&graph) {
+      RedNodeIt() {}
+
+      RedNodeIt(Invalid i) : RedNode(i) { }
+
+      explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
         _graph->first(static_cast<RedNode&>(*this));
       }
 
-      RedIt(const BpGraph& graph, const RedNode& node)
+      RedNodeIt(const BpGraph& graph, const RedNode& node)
         : RedNode(node), _graph(&graph) {}
 
-      RedIt& operator++() {
+      RedNodeIt& operator++() {
         _graph->next(static_cast<RedNode&>(*this));
         return *this;
@@ -936 +936 @@
     };
 
-    class BlueIt : public BlueNode {
+    class BlueNodeIt : public BlueNode {
       const BpGraph* _graph;
     public:
 
-      BlueIt() {}
-
-      BlueIt(Invalid i) : BlueNode(i) { }
-
-      explicit BlueIt(const BpGraph& graph) : _graph(&graph) {
+      BlueNodeIt() {}
+
+      BlueNodeIt(Invalid i) : BlueNode(i) { }
+
+      explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
         _graph->first(static_cast<BlueNode&>(*this));
       }
 
-      BlueIt(const BpGraph& graph, const BlueNode& node)
+      BlueNodeIt(const BpGraph& graph, const BlueNode& node)
         : BlueNode(node), _graph(&graph) {}
 
-      BlueIt& operator++() {
+      BlueNodeIt& operator++() {
         _graph->next(static_cast<BlueNode&>(*this));
         return *this;
@@ -1145 +1145 @@
 
     template <typename _Value>
-    class RedMap
+    class RedNodeMap
       : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
       typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
 
     public:
-      explicit RedMap(const BpGraph& bpgraph)
+      explicit RedNodeMap(const BpGraph& bpgraph)
         : Parent(bpgraph) {}
-      RedMap(const BpGraph& bpgraph, const _Value& value)
+      RedNodeMap(const BpGraph& bpgraph, const _Value& value)
         : Parent(bpgraph, value) {}
 
     private:
-      RedMap& operator=(const RedMap& cmap) {
-        return operator=<RedMap>(cmap);
+      RedNodeMap& operator=(const RedNodeMap& cmap) {
+        return operator=<RedNodeMap>(cmap);
       }
 
       template <typename CMap>
-      RedMap& operator=(const CMap& cmap) {
+      RedNodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
@@ -1169 +1169 @@
 
     template <typename _Value>
-    class BlueMap
+    class BlueNodeMap
       : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
       typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
 
     public:
-      explicit BlueMap(const BpGraph& bpgraph)
+      explicit BlueNodeMap(const BpGraph& bpgraph)
         : Parent(bpgraph) {}
-      BlueMap(const BpGraph& bpgraph, const _Value& value)
+      BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
         : Parent(bpgraph, value) {}
 
     private:
-      BlueMap& operator=(const BlueMap& cmap) {
-        return operator=<BlueMap>(cmap);
+      BlueNodeMap& operator=(const BlueNodeMap& cmap) {
+        return operator=<BlueNodeMap>(cmap);
       }
 
       template <typename CMap>
-      BlueMap& operator=(const CMap& cmap) {
+      BlueNodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;

lemon/bits/traits.h

@@ -173 +173 @@
 
     typedef typename GR::RedNode Item;
-    typedef typename GR::RedIt ItemIt;
+    typedef typename GR::RedNodeIt ItemIt;
 
     typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
 
     template <typename V>
-    class Map : public GR::template RedMap<V> {
-      typedef typename GR::template RedMap<V> Parent;
-
-    public:
-      typedef typename GR::template RedMap<V> Type;
+    class Map : public GR::template RedNodeMap<V> {
+      typedef typename GR::template RedNodeMap<V> Parent;
+
+    public:
+      typedef typename GR::template RedNodeMap<V> Type;
       typedef typename Parent::Value Value;
 
@@ -214 +214 @@
 
     typedef typename GR::BlueNode Item;
-    typedef typename GR::BlueIt ItemIt;
+    typedef typename GR::BlueNodeIt ItemIt;
 
     typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
 
     template <typename V>
-    class Map : public GR::template BlueMap<V> {
-      typedef typename GR::template BlueMap<V> Parent;
-
-    public:
-      typedef typename GR::template BlueMap<V> Type;
+    class Map : public GR::template BlueNodeMap<V> {
+      typedef typename GR::template BlueNodeMap<V> Parent;
+
+    public:
+      typedef typename GR::template BlueNodeMap<V> Type;
       typedef typename Parent::Value Value;