/usr/include/boost/signals/slot.hpp is in libboost1.65-dev 1.65.1+dfsg-0ubuntu5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | // Boost.Signals library
// 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
#define BOOST_SIGNALS_SLOT_HEADER
#include <boost/signals/detail/signals_common.hpp>
#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 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 data->bound_objects; }
// Determine if this slot is still "active", i.e., all of the bound
// objects still exist
bool is_active() const
{ return data->watch_bound_objects.connected(); }
protected:
// Create a connection for this slot
void create_connection();
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(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(this->data->bound_objects);
visit_each(do_bind,
BOOST_SIGNALS_NAMESPACE::get_inspectable_slot
(f, BOOST_SIGNALS_NAMESPACE::tag_type(f)));
create_connection();
}
#ifdef __BORLANDC__
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:
// 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
SlotFunction slot_function;
};
} // end namespace boost
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_SIGNALS_SLOT_HEADER
|