// Boost.Signals library
-//
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
+
+// Copyright Douglas Gregor 2001-2004. 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_SIGNALS_SLOT_HEADER
#include <boost/signals/connection.hpp>
#include <boost/signals/trackable.hpp>
#include <boost/visit_each.hpp>
+#include <boost/shared_ptr.hpp>
#include <cassert>
+#ifdef BOOST_HAS_ABI_HEADERS
+# include BOOST_ABI_PREFIX
+#endif
+
namespace boost {
namespace BOOST_SIGNALS_NAMESPACE {
namespace detail {
- class slot_base {
- // We would have to enumerate all of the signalN classes here as
+ class BOOST_SIGNALS_DECL slot_base {
+ // We would have to enumerate all of the signalN classes here as
// friends to make this private (as it otherwise should be). We can't
// name all of them because we don't know how many there are.
public:
+ struct data_t {
+ std::vector<const trackable*> bound_objects;
+ connection watch_bound_objects;
+ };
+ shared_ptr<data_t> get_data() const { return data; }
+
// Get the set of bound objects
- std::vector<const trackable*>& get_bound_objects() const
- { return bound_objects; }
-
+ std::vector<const trackable*>& get_bound_objects() const
+ { return data->bound_objects; }
+
// Determine if this slot is still "active", i.e., all of the bound
// objects still exist
- bool is_active() const { return watch_bound_objects.connected(); }
+ bool is_active() const
+ { return data->watch_bound_objects.connected(); }
protected:
// Create a connection for this slot
void create_connection();
- // Get the slot so that it can be copied
- template<typename F>
- reference_wrapper<const F>
- get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
- { return reference_wrapper<const F>(f); }
-
- template<typename F>
- const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
- { return f; }
-
- template<typename F>
- const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
- { return f; }
-
- // Get the slot so that it can be inspected for trackable objects
- template<typename F>
- const F& get_inspectable_slot(const F& f,
- BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
- { return f; }
-
- template<typename F>
- const F& get_inspectable_slot(const F& f,
- BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
- { return f.get(); }
-
- template<typename F>
- const F& get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
- { return f; }
-
- // Determines the type of the slot - is it a signal, a reference to a
- // slot or just a normal slot.
- template<typename F>
- typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
- tag_type(const F&)
- {
- typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type tag;
- return tag;
- }
-
- mutable std::vector<const trackable*> bound_objects;
- connection watch_bound_objects;
+ shared_ptr<data_t> data;
private:
static void bound_object_destructed(void*, void*) {}
};
} // end namespace detail
+
+ // Get the slot so that it can be copied
+ template<typename F>
+ reference_wrapper<const F>
+ get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
+ { return reference_wrapper<const F>(f); }
+
+ template<typename F>
+ const F&
+ get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
+ { return f; }
+
+ template<typename F>
+ const F&
+ get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
+ { return f; }
+
+ // Get the slot so that it can be inspected for trackable objects
+ template<typename F>
+ const F&
+ get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
+ { return f; }
+
+ template<typename F>
+ const F&
+ get_inspectable_slot(const reference_wrapper<F>& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
+ { return f.get(); }
+
+ template<typename F>
+ const F&
+ get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
+ { return f; }
+
+ // Determines the type of the slot - is it a signal, a reference to a
+ // slot or just a normal slot.
+ template<typename F>
+ typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
+ tag_type(const F&)
+ {
+ typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
+ the_tag_type;
+ the_tag_type tag = the_tag_type();
+ return tag;
+ }
+
} // end namespace BOOST_SIGNALS_NAMESPACE
template<typename SlotFunction>
class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base {
+ typedef BOOST_SIGNALS_NAMESPACE::detail::slot_base inherited;
+ typedef typename inherited::data_t data_t;
+
public:
- template<typename F>
- slot(const F& f) : slot_function(get_invocable_slot(f, tag_type(f)))
+ template<typename F>
+ slot(const F& f) : slot_function(BOOST_SIGNALS_NAMESPACE::get_invocable_slot(f, BOOST_SIGNALS_NAMESPACE::tag_type(f)))
{
+ this->data.reset(new data_t);
+
// Visit each of the bound objects and store them for later use
// An exception thrown here will allow the basic_connection to be
// destroyed when this goes out of scope, and no other connections
// have been made.
- BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor do_bind(bound_objects);
- visit_each(do_bind, get_inspectable_slot(f, tag_type(f)));
-
+ BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor
+ do_bind(this->data->bound_objects);
+ visit_each(do_bind,
+ BOOST_SIGNALS_NAMESPACE::get_inspectable_slot
+ (f, BOOST_SIGNALS_NAMESPACE::tag_type(f)));
create_connection();
}
template<typename F>
slot(F* f) : slot_function(f)
{
+ this->data.reset(new data_t);
create_connection();
}
#endif // __BORLANDC__
// We would have to enumerate all of the signalN classes here as friends
// to make this private (as it otherwise should be). We can't name all of
// them because we don't know how many there are.
- public:
+ public:
// Get the slot function to call the actual slot
const SlotFunction& get_slot_function() const { return slot_function; }
+ void release() const { data->watch_bound_objects.set_controlling(false); }
+
private:
slot(); // no default constructor
slot& operator=(const slot&); // no assignment operator
};
} // end namespace boost
+#ifdef BOOST_HAS_ABI_HEADERS
+# include BOOST_ABI_SUFFIX
+#endif
+
#endif // BOOST_SIGNALS_SLOT_HEADER
projects / lyx.git / blobdiff