Header: Moved drag functionality into SelectableItem
[pulseview.git] / pv / view / rowitemiterator.h
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2014 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #ifndef PULSEVIEW_PV_VIEW_ROWITEMITERATOR_H
22 #define PULSEVIEW_PV_VIEW_ROWITEMITERATOR_H
23
24 #include <algorithm>
25 #include <cassert>
26 #include <iterator>
27 #include <memory>
28 #include <stack>
29 #include <type_traits>
30 #include <vector>
31
32 #include <boost/thread.hpp>
33
34 #include <pv/sigsession.h>
35
36 namespace pv {
37 namespace view {
38
39 template<class Owner, class Item> class RowItemIterator
40 {
41 public:
42         typedef typename std::conditional<std::is_const<Owner>::value,
43                 typename Owner::item_list::const_iterator,
44                 typename Owner::item_list::iterator>::type child_iterator;
45
46         typedef std::shared_ptr<Item> value_type;
47         typedef ptrdiff_t difference_type;
48         typedef value_type pointer;
49         typedef value_type& reference;
50         typedef std::forward_iterator_tag iterator_category;
51
52 public:
53         RowItemIterator(Owner *owner) :
54                 _owner(owner),
55                 _lock(owner->session().signals_mutex()) {}
56
57         RowItemIterator(Owner *owner, child_iterator iter) :
58                 _owner(owner),
59                 _lock(owner->session().signals_mutex()) {
60                 assert(owner);
61                 if (iter != owner->child_items().end())
62                         _iter_stack.push(iter);
63         }
64
65         RowItemIterator(const RowItemIterator<Owner, Item> &o) :
66                 _owner(o._owner),
67                 _lock(*o._lock.mutex()),
68                 _iter_stack(o._iter_stack) {}
69
70         reference operator*() const {
71                 return *_iter_stack.top();
72         }
73
74         reference operator->() const {
75                 return *this;
76         }
77
78         RowItemIterator<Owner, Item>& operator++() {
79                 using std::dynamic_pointer_cast;
80                 using std::shared_ptr;
81
82                 assert(_owner);
83                 assert(!_iter_stack.empty());
84
85                 shared_ptr<Owner> owner(dynamic_pointer_cast<Owner>(
86                         *_iter_stack.top()));
87                 if (owner && !owner->child_items().empty()) {
88                         _owner = owner.get();
89                         _iter_stack.push(owner->child_items().begin());
90                 } else {
91                         ++_iter_stack.top();
92                         while (_owner && _iter_stack.top() ==
93                                 _owner->child_items().end()) {
94                                 _iter_stack.pop();
95                                 _owner = _iter_stack.empty() ? nullptr :
96                                         (*_iter_stack.top()++)->owner();
97                         }
98                 }
99
100                 return *this;
101         }
102
103         RowItemIterator<Owner, Item> operator++(int) {
104                 RowItemIterator<Owner, Item> pre = *this;
105                 ++*this;
106                 return pre;
107         }
108
109         bool operator==(const RowItemIterator &o) const {
110                 return (_iter_stack.empty() && o._iter_stack.empty()) ||
111                         (_owner == o._owner &&
112                         _iter_stack.size() == o._iter_stack.size() &&
113                         std::equal(
114                                 _owner->child_items().cbegin(),
115                                 _owner->child_items().cend(),
116                                 o._owner->child_items().cbegin()));
117         }
118
119         bool operator!=(const RowItemIterator &o) const {
120                 return !((const RowItemIterator&)*this == o);
121         }
122
123         void swap(RowItemIterator<Owner, Item>& other) {
124                 swap(_owner, other._owner);
125                 swap(_iter_stack, other._iter_stack);
126         }
127
128 private:
129         Owner *_owner;
130         boost::shared_lock<boost::shared_mutex> _lock;
131         std::stack<child_iterator> _iter_stack;
132 };
133
134 template<class Owner, class Item>
135 void swap(RowItemIterator<Owner, Item>& a, RowItemIterator<Owner, Item>& b)
136 {
137         a.swap(b);
138 }
139
140 } // namespace view
141 } // namespace pv
142
143 #endif // PULSEVIEW_PV_VIEW_ROWITEMITERATOR_H