RowItemIterator: Removed usage of RowItem::owner()

[pulseview.git] / pv / view / rowitemiterator.hpp

diff --git a/pv/view/rowitemiterator.hpp b/pv/view/rowitemiterator.hpp
index c45507bbb3de46a2545ead04b2d33df1e0d01e4c..9857e8a537ee6f582cae1ac09cc63d18fa5d5d7b 100644 (file)
--- a/pv/view/rowitemiterator.hpp
+++ b/pv/view/rowitemiterator.hpp
@@ -29,8 +29,6 @@
 #include <type_traits>
 #include <vector>
 
-#include <boost/thread.hpp>
-
 #include <pv/session.hpp>
 
 namespace pv {
@@ -51,20 +49,17 @@ public:
 
 public:
        RowItemIterator(Owner *owner) :
-               owner_(owner),
-               lock_(owner->session().signals_mutex()) {}
+               owner_stack_({owner}) {}
 
        RowItemIterator(Owner *owner, child_iterator iter) :
-               owner_(owner),
-               lock_(owner->session().signals_mutex()) {
+               owner_stack_({owner}) {
                assert(owner);
                if (iter != owner->child_items().end())
                        iter_stack_.push(iter);
        }
 
        RowItemIterator(const RowItemIterator<Owner, Item> &o) :
-               owner_(o.owner_),
-               lock_(*o.lock_.mutex()),
+               owner_stack_(o.owner_stack_),
                iter_stack_(o.iter_stack_) {}
 
        reference operator*() const {
@@ -79,21 +74,19 @@ public:
                using std::dynamic_pointer_cast;
                using std::shared_ptr;
 
-               assert(owner_);
+               assert(!owner_stack_.empty());
                assert(!iter_stack_.empty());
 
                shared_ptr<Owner> owner(dynamic_pointer_cast<Owner>(
                        *iter_stack_.top()));
                if (owner && !owner->child_items().empty()) {
-                       owner_ = owner.get();
+                       owner_stack_.push(owner.get());
                        iter_stack_.push(owner->child_items().begin());
                } else {
-                       ++iter_stack_.top();
-                       while (owner_ && iter_stack_.top() ==
-                               owner_->child_items().end()) {
+                       while (!iter_stack_.empty() && (++iter_stack_.top()) ==
+                               owner_stack_.top()->child_items().end()) {
+                               owner_stack_.pop();
                                iter_stack_.pop();
-                               owner_ = iter_stack_.empty() ? nullptr :
-                                       (*iter_stack_.top()++)->owner();
                        }
                }
 
@@ -107,13 +100,10 @@ public:
        }
 
        bool operator==(const RowItemIterator &o) const {
-               return (iter_stack_.empty() && o.iter_stack_.empty()) ||
-                       (owner_ == o.owner_ &&
+               return (iter_stack_.empty() && o.iter_stack_.empty()) || (
                        iter_stack_.size() == o.iter_stack_.size() &&
-                       std::equal(
-                               owner_->child_items().cbegin(),
-                               owner_->child_items().cend(),
-                               o.owner_->child_items().cbegin()));
+                       owner_stack_.top() == o.owner_stack_.top() &&
+                       iter_stack_.top() == o.iter_stack_.top());
        }
 
        bool operator!=(const RowItemIterator &o) const {
@@ -121,13 +111,12 @@ public:
        }
 
        void swap(RowItemIterator<Owner, Item>& other) {
-               swap(owner_, other.owner_);
+               swap(owner_stack_, other.owner_stack_);
                swap(iter_stack_, other.iter_stack_);
        }
 
 private:
-       Owner *owner_;
-       boost::shared_lock<boost::shared_mutex> lock_;
+       std::stack<Owner*> owner_stack_;
        std::stack<child_iterator> iter_stack_;
 };