148 lines
4.4 KiB
C++
148 lines
4.4 KiB
C++
// Boost.Signals2 library
|
|
|
|
// Copyright Douglas Gregor 2001-2004.
|
|
// Copyright Frank Mori Hess 2007-2008.
|
|
// Use, modification and
|
|
// distribution is subject to the Boost Software License, Version
|
|
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// For more information, see http://www.boost.org
|
|
|
|
#ifndef BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
|
|
#define BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
|
|
|
|
#include <boost/assert.hpp>
|
|
#include <boost/aligned_storage.hpp>
|
|
#include <boost/iterator/iterator_facade.hpp>
|
|
#include <boost/optional.hpp>
|
|
#include <boost/scoped_ptr.hpp>
|
|
#include <boost/signals2/connection.hpp>
|
|
#include <boost/signals2/slot_base.hpp>
|
|
#include <boost/signals2/detail/auto_buffer.hpp>
|
|
#include <boost/signals2/detail/unique_lock.hpp>
|
|
#include <boost/weak_ptr.hpp>
|
|
|
|
namespace boost {
|
|
namespace signals2 {
|
|
namespace detail {
|
|
template<typename ResultType, typename Function>
|
|
class slot_call_iterator_cache
|
|
{
|
|
public:
|
|
slot_call_iterator_cache(const Function &f_arg):
|
|
f(f_arg),
|
|
connected_slot_count(0),
|
|
disconnected_slot_count(0)
|
|
{}
|
|
optional<ResultType> result;
|
|
typedef auto_buffer<void_shared_ptr_variant, store_n_objects<10> > tracked_ptrs_type;
|
|
tracked_ptrs_type tracked_ptrs;
|
|
Function f;
|
|
unsigned connected_slot_count;
|
|
unsigned disconnected_slot_count;
|
|
};
|
|
|
|
// Generates a slot call iterator. Essentially, this is an iterator that:
|
|
// - skips over disconnected slots in the underlying list
|
|
// - calls the connected slots when dereferenced
|
|
// - caches the result of calling the slots
|
|
template<typename Function, typename Iterator, typename ConnectionBody>
|
|
class slot_call_iterator_t
|
|
: public boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
|
|
typename Function::result_type,
|
|
boost::single_pass_traversal_tag,
|
|
typename Function::result_type const&>
|
|
{
|
|
typedef boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
|
|
typename Function::result_type,
|
|
boost::single_pass_traversal_tag,
|
|
typename Function::result_type const&>
|
|
inherited;
|
|
|
|
typedef typename Function::result_type result_type;
|
|
|
|
friend class boost::iterator_core_access;
|
|
|
|
public:
|
|
slot_call_iterator_t(Iterator iter_in, Iterator end_in,
|
|
slot_call_iterator_cache<result_type, Function> &c):
|
|
iter(iter_in), end(end_in),
|
|
cache(&c), callable_iter(end_in)
|
|
{
|
|
lock_next_callable();
|
|
}
|
|
|
|
typename inherited::reference
|
|
dereference() const
|
|
{
|
|
if (!cache->result) {
|
|
try
|
|
{
|
|
cache->result.reset(cache->f(*iter));
|
|
}
|
|
catch(expired_slot &)
|
|
{
|
|
(*iter)->disconnect();
|
|
throw;
|
|
}
|
|
}
|
|
return cache->result.get();
|
|
}
|
|
|
|
void increment()
|
|
{
|
|
++iter;
|
|
lock_next_callable();
|
|
cache->result.reset();
|
|
}
|
|
|
|
bool equal(const slot_call_iterator_t& other) const
|
|
{
|
|
return iter == other.iter;
|
|
}
|
|
|
|
private:
|
|
typedef unique_lock<connection_body_base> lock_type;
|
|
|
|
void lock_next_callable() const
|
|
{
|
|
if(iter == callable_iter)
|
|
{
|
|
return;
|
|
}
|
|
for(;iter != end; ++iter)
|
|
{
|
|
lock_type lock(**iter);
|
|
cache->tracked_ptrs.clear();
|
|
(*iter)->nolock_grab_tracked_objects(std::back_inserter(cache->tracked_ptrs));
|
|
if((*iter)->nolock_nograb_connected())
|
|
{
|
|
++cache->connected_slot_count;
|
|
}else
|
|
{
|
|
++cache->disconnected_slot_count;
|
|
}
|
|
if((*iter)->nolock_nograb_blocked() == false)
|
|
{
|
|
callable_iter = iter;
|
|
break;
|
|
}
|
|
}
|
|
if(iter == end)
|
|
{
|
|
callable_iter = end;
|
|
}
|
|
}
|
|
|
|
mutable Iterator iter;
|
|
Iterator end;
|
|
slot_call_iterator_cache<result_type, Function> *cache;
|
|
mutable Iterator callable_iter;
|
|
};
|
|
} // end namespace detail
|
|
} // end namespace BOOST_SIGNALS_NAMESPACE
|
|
} // end namespace boost
|
|
|
|
#endif // BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
|