Clean up node iteration

src/compiler/generic-node.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_GENERIC_NODE_H_
 #define V8_COMPILER_GENERIC_NODE_H_
 
 #include "src/v8.h"
 
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class GenericGraphBase;
+template <class N>
+class GenericEdge;
 
 typedef int NodeId;
 
 // A GenericNode<> is the basic primitive of graphs. GenericNode's are
 // chained together by input/use chains but by default otherwise contain only an
 // identifying number which specific applications of graphs and nodes can use
 // to index auxiliary out-of-line data, especially transient data.
 // Specializations of the templatized GenericNode<> class must provide a base
 // class B that contains all of the members to be made available in each
 // specialized Node instance. GenericNode uses a mixin template pattern to
@@ skipping 25 matching lines @@
     }
     return static_cast<S*>(current->from);
   }
   inline void ReplaceUses(GenericNode* replace_to);
   template <class UnaryPredicate>
   inline void ReplaceUsesIf(UnaryPredicate pred, GenericNode* replace_to);
   inline void RemoveAllInputs();
 
   inline void TrimInputCount(int input_count);
 
+  class InputEdges {
+   public:
+    class iterator;
+    iterator begin();
+    iterator end();
+    bool empty() { return begin() == end(); }
+
+    explicit InputEdges(GenericNode* node) : node_(node) {}
+
+   private:
+    GenericNode* node_;
+  };
+
   class Inputs {
    public:
     class iterator;
     iterator begin();
     iterator end();
+    bool empty() { return begin() == end(); }
 
     explicit Inputs(GenericNode* node) : node_(node) {}
 
    private:
     GenericNode* node_;
   };
 
+  InputEdges input_edges() { return InputEdges(this); }
   Inputs inputs() { return Inputs(this); }
 
+  class UseEdges {
+   public:
+    class iterator;
+    iterator begin();
+    iterator end();
+    bool empty() { return begin() == end(); }
+
+    explicit UseEdges(GenericNode* node) : node_(node) {}
+
+   private:
+    GenericNode* node_;
+  };
+
   class Uses {
    public:
     class iterator;
     iterator begin();
     iterator end();
     bool empty() { return begin() == end(); }
 
     explicit Uses(GenericNode* node) : node_(node) {}
 
    private:
     GenericNode* node_;
   };
 
   Uses uses() { return Uses(this); }
-
-  class Edge;
+  UseEdges use_edges() { return UseEdges(this); }
 
   bool OwnedBy(GenericNode* owner) const;
 
   static S* New(GenericGraphBase* graph, int input_count, S** inputs,
                 bool has_extensible_inputs);
 
  protected:
   friend class GenericGraphBase;
+  friend class GenericEdge<S>;
 
   class Use : public ZoneObject {
    public:
     GenericNode* from;
     Use* next;
     Use* prev;
     int input_index;
   };
 
   class Input {
@@ skipping 45 matching lines @@
   } inputs_;
   int use_count_;
   Use* first_use_;
   Use* last_use_;
 
   DISALLOW_COPY_AND_ASSIGN(GenericNode);
 };
 
 // An encapsulation for information associated with a single use of node as a
 // input from another node, allowing access to both the defining node and
-// the ndoe having the input.
-template <class B, class S>
-class GenericNode<B, S>::Edge {
- public:
-  S* from() const { return static_cast<S*>(input_->use->from); }
-  S* to() const { return static_cast<S*>(input_->to); }
+// the node having the input.
+template <class N>
+class GenericEdge {
+ public:
+  GenericEdge(const GenericEdge& other) : input_(other.input_) {}
+  GenericEdge() : input_(NULL) {}
+
+  N* from() const { return static_cast<N*>(input_->use->from); }
+  N* to() const { return static_cast<N*>(input_->to); }
   int index() const {
     int index = input_->use->input_index;
     DCHECK(index < input_->use->from->input_count_);
     return index;
   }
-
- private:
-  friend class GenericNode<B, S>::Uses::iterator;
-  friend class GenericNode<B, S>::Inputs::iterator;
-
-  explicit Edge(typename GenericNode<B, S>::Input* input) : input_(input) {}
-
-  typename GenericNode<B, S>::Input* input_;
-};
+  bool operator==(const GenericEdge& other) { return input_ == other.input_; }
+  bool operator!=(const GenericEdge& other) { return !(*this == other); }
+
+  explicit GenericEdge(typename N::Input* input) : input_(input) {}
+
+  void UpdateTo(N* new_to) { input_->Update(new_to); }
+
+ private:
+  typename N::Input* input_;
+};
+
 
 // A forward iterator to visit the nodes which are depended upon by a node
 // in the order of input.
 template <class B, class S>
+class GenericNode<B, S>::InputEdges::iterator {
+ public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef int difference_type;
+  typedef GenericEdge<S> value_type;
+  typedef GenericEdge<S>* pointer;
+  typedef GenericEdge<S>& reference;
+  iterator(
+      const typename GenericNode<B, S>::InputEdges::iterator& other)  // NOLINT
+      : input_(other.input_) {}
+  iterator() : input_(NULL) {}
+
+  GenericEdge<S> operator*() const { return GenericEdge<S>(input_); }
+  bool operator==(const iterator& other) const { return Equals(other); }
+  bool operator!=(const iterator& other) const { return !Equals(other); }
+  iterator& operator++() {
+    DCHECK(input_ != NULL);
+    GenericEdge<S> edge(input_);
+    GenericNode<B, S>* from = edge.from();
+    SetInput(from, input_->use->input_index + 1);
+    return *this;
+  }
+  iterator& operator++(int) {
+    iterator result(*this);
+    ++(*this);
+    return result;
+  }
+
+ private:
+  friend class GenericNode;
+
+  iterator(GenericNode* from, int index = 0) : input_(NULL) {
+    SetInput(from, index);
+  }
+
+  bool Equals(const iterator& other) const { return other.input_ == input_; }
+  void SetInput(GenericNode* from, int index) {
+    DCHECK(index >= 0 && index <= from->InputCount());
+    if (index < from->InputCount()) {
+      input_ = from->GetInputRecordPtr(index);
+    } else {
+      input_ = NULL;
+    }
+  }
+
+  Input* input_;
+};
+
+
+template <class B, class S>
 class GenericNode<B, S>::Inputs::iterator {
  public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef int difference_type;
+  typedef S value_type;
+  typedef S* pointer;
+  typedef S& reference;
   iterator(const typename GenericNode<B, S>::Inputs::iterator& other)  // NOLINT
-      : node_(other.node_),
-        index_(other.index_) {}
-
-  S* operator*() { return static_cast<S*>(GetInput()->to); }
-  typename GenericNode<B, S>::Edge edge() {
-    return typename GenericNode::Edge(GetInput());
-  }
-  bool operator==(const iterator& other) const {
-    return other.index_ == index_ && other.node_ == node_;
-  }
-  bool operator!=(const iterator& other) const { return !(other == *this); }
-  iterator& operator++() {
-    DCHECK(node_ != NULL);
-    DCHECK(index_ < node_->input_count_);
-    ++index_;
-    return *this;
-  }
-  iterator& UpdateToAndIncrement(GenericNode<B, S>* new_to) {
-    typename GenericNode<B, S>::Input* input = GetInput();
-    input->Update(new_to);
-    index_++;
-    return *this;
-  }
-  int index() { return index_; }
-
- private:
-  friend class GenericNode;
-
-  explicit iterator(GenericNode* node, int index)
-      : node_(node), index_(index) {}
-
-  Input* GetInput() const { return node_->GetInputRecordPtr(index_); }
-
-  GenericNode* node_;
-  int index_;
-};
+      : iter_(other.iter_) {}
+  iterator() {}
+
+  S* operator*() const { return (*iter_).to(); }
+  bool operator==(const iterator& other) const { return Equals(other); }
+  bool operator!=(const iterator& other) const { return !Equals(other); }
+  iterator& operator++() {
+    ++iter_;
+    return *this;
+  }
+  iterator& operator++(int) {
+    iterator result(*this);
+    ++(*this);
+    return result;
+  }
+
+ private:
+  friend class GenericNode<B, S>::Inputs;
+
+  iterator(GenericNode* from, int index = 0) : iter_(from, index) {}
+
+  bool Equals(const iterator& other) const { return other.iter_ == iter_; }
+
+  typename GenericNode<B, S>::InputEdges::iterator iter_;
+};
+
 
 // A forward iterator to visit the uses of a node. The uses are returned in
 // the order in which they were added as inputs.
 template <class B, class S>
+class GenericNode<B, S>::UseEdges::iterator {
+ public:
+  iterator(
+      const typename GenericNode<B, S>::UseEdges::iterator& other)  // NOLINT
+      : current_(other.current_),
+        next_(other.next_),
+        index_(other.index_) {}
+
+  GenericEdge<S> operator*() const { return GenericEdge<S>(CurrentInput()); }
+
+  bool operator==(const iterator& other) { return Equals(other); }
+  bool operator!=(const iterator& other) { return !Equals(other); }
+  iterator& operator++() {
+    DCHECK(current_ != NULL);
+    index_++;
+    current_ = next_;
+    next_ = (current_ == NULL) ? NULL : current_->next;
+    return *this;
+  }
+  iterator& operator++(int) {
+    iterator result(*this);
+    ++(*this);
+    return result;
+  }
+
+ private:
+  friend class GenericNode<B, S>::UseEdges;
+
+  iterator() : current_(NULL), next_(NULL), index_(0) {}
+  explicit iterator(GenericNode<B, S>* node)
+      : current_(node->first_use_),
+        next_(current_ == NULL ? NULL : current_->next),
+        index_(0) {}
+
+  bool Equals(const iterator& other) const {
+    return other.current_ == current_;
+  }
+
+  Input* CurrentInput() const {
+    return current_->from->GetInputRecordPtr(current_->input_index);
+  }
+
+  typename GenericNode<B, S>::Use* current_;
+  typename GenericNode<B, S>::Use* next_;
+  int index_;
+};
+
+
+// A forward iterator to visit the uses edges of a node. The edges are returned
+// in the order in which they were added as inputs.
+template <class B, class S>
 class GenericNode<B, S>::Uses::iterator {
  public:
   iterator(const typename GenericNode<B, S>::Uses::iterator& other)  // NOLINT
-      : current_(other.current_),
-        index_(other.index_) {}
+      : current_(other.current_) {}
 
   S* operator*() { return static_cast<S*>(current_->from); }
-  typename GenericNode<B, S>::Edge edge() {
-    return typename GenericNode::Edge(CurrentInput());
-  }
 
   bool operator==(const iterator& other) { return other.current_ == current_; }
   bool operator!=(const iterator& other) { return other.current_ != current_; }
   iterator& operator++() {
     DCHECK(current_ != NULL);
-    index_++;
     current_ = current_->next;
     return *this;
   }
-  iterator& UpdateToAndIncrement(GenericNode<B, S>* new_to) {
-    DCHECK(current_ != NULL);
-    index_++;
-    typename GenericNode<B, S>::Input* input = CurrentInput();
-    current_ = current_->next;
-    input->Update(new_to);
-    return *this;
-  }
-  int index() const { return index_; }
 
  private:
   friend class GenericNode<B, S>::Uses;
 
-  iterator() : current_(NULL), index_(0) {}
-  explicit iterator(GenericNode<B, S>* node)
-      : current_(node->first_use_), index_(0) {}
+  iterator() : current_(NULL) {}
+  explicit iterator(GenericNode<B, S>* node) : current_(node->first_use_) {}
 
   Input* CurrentInput() const {
     return current_->from->GetInputRecordPtr(current_->input_index);
   }
 
   typename GenericNode<B, S>::Use* current_;
-  int index_;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GENERIC_NODE_H_