1 // Boost.Signals2 library
2 
3 // Copyright Douglas Gregor 2001-2004.
4 // Copyright Frank Mori Hess 2007-2008.
5 // Use, modification and
6 // distribution is subject to the Boost Software License, Version
7 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9 
10 // For more information, see http://www.boost.org
11 
12 #ifndef BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
13 #define BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
14 
15 #include <boost/assert.hpp>
16 #include <boost/aligned_storage.hpp>
17 #include <boost/core/no_exceptions_support.hpp>
18 #include <boost/iterator/iterator_facade.hpp>
19 #include <boost/optional.hpp>
20 #include <boost/scoped_ptr.hpp>
21 #include <boost/signals2/connection.hpp>
22 #include <boost/signals2/slot_base.hpp>
23 #include <boost/signals2/detail/auto_buffer.hpp>
24 #include <boost/signals2/detail/unique_lock.hpp>
25 #include <boost/type_traits/add_const.hpp>
26 #include <boost/type_traits/add_reference.hpp>
27 #include <boost/weak_ptr.hpp>
28 
29 namespace boost {
30   namespace signals2 {
31     namespace detail {
32       template<typename ResultType, typename Function>
33         class slot_call_iterator_cache
34       {
35       public:
slot_call_iterator_cache(const Function & f_arg)36         slot_call_iterator_cache(const Function &f_arg):
37           f(f_arg),
38           connected_slot_count(0),
39           disconnected_slot_count(0),
40           m_active_slot(0)
41         {}
42 
~slot_call_iterator_cache()43         ~slot_call_iterator_cache()
44         {
45           if(m_active_slot)
46           {
47             garbage_collecting_lock<connection_body_base> lock(*m_active_slot);
48             m_active_slot->dec_slot_refcount(lock);
49           }
50         }
51 
52         template<typename M>
set_active_slot(garbage_collecting_lock<M> & lock,connection_body_base * active_slot)53         void set_active_slot(garbage_collecting_lock<M> &lock,
54           connection_body_base *active_slot)
55         {
56           if(m_active_slot)
57             m_active_slot->dec_slot_refcount(lock);
58           m_active_slot = active_slot;
59           if(m_active_slot)
60             m_active_slot->inc_slot_refcount(lock);
61         }
62 
63         optional<ResultType> result;
64         typedef auto_buffer<void_shared_ptr_variant, store_n_objects<10> > tracked_ptrs_type;
65         tracked_ptrs_type tracked_ptrs;
66         Function f;
67         unsigned connected_slot_count;
68         unsigned disconnected_slot_count;
69         connection_body_base *m_active_slot;
70       };
71 
72       // Generates a slot call iterator. Essentially, this is an iterator that:
73       //   - skips over disconnected slots in the underlying list
74       //   - calls the connected slots when dereferenced
75       //   - caches the result of calling the slots
76       template<typename Function, typename Iterator, typename ConnectionBody>
77       class slot_call_iterator_t
78         : public boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
79         typename Function::result_type,
80         boost::single_pass_traversal_tag,
81         typename boost::add_reference<typename boost::add_const<typename Function::result_type>::type>::type >
82       {
83         typedef boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
84           typename Function::result_type,
85           boost::single_pass_traversal_tag,
86           typename boost::add_reference<typename boost::add_const<typename Function::result_type>::type>::type >
87         inherited;
88 
89         typedef typename Function::result_type result_type;
90 
91         typedef slot_call_iterator_cache<result_type, Function> cache_type;
92 
93         friend class boost::iterator_core_access;
94 
95       public:
slot_call_iterator_t(Iterator iter_in,Iterator end_in,cache_type & c)96         slot_call_iterator_t(Iterator iter_in, Iterator end_in,
97           cache_type &c):
98           iter(iter_in), end(end_in),
99           cache(&c), callable_iter(end_in)
100         {
101           lock_next_callable();
102         }
103 
104         typename inherited::reference
dereference() const105         dereference() const
106         {
107           if (!cache->result) {
108             BOOST_TRY
109             {
110               cache->result.reset(cache->f(*iter));
111             }
112             BOOST_CATCH(expired_slot &)
113             {
114               (*iter)->disconnect();
115               BOOST_RETHROW
116             }
117             BOOST_CATCH_END
118           }
119           return cache->result.get();
120         }
121 
increment()122         void increment()
123         {
124           ++iter;
125           lock_next_callable();
126           cache->result.reset();
127         }
128 
equal(const slot_call_iterator_t & other) const129         bool equal(const slot_call_iterator_t& other) const
130         {
131           return iter == other.iter;
132         }
133 
134       private:
135         typedef garbage_collecting_lock<connection_body_base> lock_type;
136 
set_callable_iter(lock_type & lock,Iterator newValue) const137         void set_callable_iter(lock_type &lock, Iterator newValue) const
138         {
139           callable_iter = newValue;
140           if(callable_iter == end)
141             cache->set_active_slot(lock, 0);
142           else
143             cache->set_active_slot(lock, (*callable_iter).get());
144         }
145 
lock_next_callable() const146         void lock_next_callable() const
147         {
148           if(iter == callable_iter)
149           {
150             return;
151           }
152 
153           for(;iter != end; ++iter)
154           {
155             cache->tracked_ptrs.clear();
156             lock_type lock(**iter);
157             (*iter)->nolock_grab_tracked_objects(lock, std::back_inserter(cache->tracked_ptrs));
158             if((*iter)->nolock_nograb_connected())
159             {
160               ++cache->connected_slot_count;
161             }else
162             {
163               ++cache->disconnected_slot_count;
164             }
165             if((*iter)->nolock_nograb_blocked() == false)
166             {
167               set_callable_iter(lock, iter);
168               break;
169             }
170           }
171 
172           if(iter == end)
173           {
174             if(callable_iter != end)
175             {
176               lock_type lock(**callable_iter);
177               set_callable_iter(lock, end);
178             }
179           }
180         }
181 
182         mutable Iterator iter;
183         Iterator end;
184         cache_type *cache;
185         mutable Iterator callable_iter;
186       };
187     } // end namespace detail
188   } // end namespace BOOST_SIGNALS_NAMESPACE
189 } // end namespace boost
190 
191 #endif // BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
192