/usr/include/sigc++-2.0/sigc++/signal_base.h is in libsigc++-2.0-dev 2.2.10-0.2ubuntu2.
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 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 | // -*- c++ -*-
/*
* Copyright 2002, The libsigc++ Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _SIGC_SIGNAL_BASE_H_
#define _SIGC_SIGNAL_BASE_H_
#include <cstddef>
#include <list>
#include <sigc++config.h>
#include <sigc++/type_traits.h>
#include <sigc++/trackable.h>
#include <sigc++/functors/slot.h>
#include <sigc++/functors/mem_fun.h>
/** The libsigc++ namespace.
*/
namespace sigc
{
namespace internal
{
/** Implementation of the signal interface.
* signal_impl manages a list of slots. When a slot becomes
* invalid (because some referred object dies), notify() is executed.
* notify() either calls sweep() directly or defers the execution of
* sweep() when the signal is being emitted. sweep() removes all
* invalid slot from the list.
*/
struct SIGC_API signal_impl
{
typedef size_t size_type;
typedef std::list<slot_base> slot_list;
typedef slot_list::iterator iterator_type;
typedef slot_list::const_iterator const_iterator_type;
signal_impl();
// only MSVC needs this to guarantee that all new/delete are executed from the DLL module
#ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY
void* operator new(size_t size_);
void operator delete(void* p);
#endif
/// Increments the reference counter.
inline void reference()
{ ++ref_count_; }
/// Increments the reference and execution counter.
inline void reference_exec()
{ ++ref_count_; ++exec_count_; }
/** Decrements the reference counter.
* The object is deleted when the reference counter reaches zero.
*/
inline void unreference()
{ if (!(--ref_count_)) delete this; }
/** Decrements the reference and execution counter.
* Invokes sweep() if the execution counter reaches zero and the
* removal of one or more slots has been deferred.
*/
inline void unreference_exec()
{
if (!(--ref_count_)) delete this;
else if (!(--exec_count_) && deferred_) sweep();
}
/** Returns whether the list of slots is empty.
* @return @p true if the list of slots is empty.
*/
inline bool empty() const
{ return slots_.empty(); }
/// Empties the list of slots.
void clear();
/** Returns the number of slots in the list.
* @return The number of slots in the list.
*/
size_type size() const;
/** Adds a slot at the bottom of the list of slots.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type connect(const slot_base& slot_);
/** Adds a slot at the given position into the list of slots.
* @param i An iterator indicating the position where @p slot_ should be inserted.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type insert(iterator_type i, const slot_base& slot_);
/** Removes the slot at the given position from the list of slots.
* @param i An iterator pointing to the slot to be removed.
* @return An iterator pointing to the slot in the list after the one removed.
*/
iterator_type erase(iterator_type i);
/// Removes invalid slots from the list of slots.
void sweep();
/** Callback that is executed when some slot becomes invalid.
* This callback is registered in every slot when inserted into
* the list of slots. It is executed when a slot becomes invalid
* because of some referred object being destroyed.
* It either calls sweep() directly or defers the execution of
* sweep() when the signal is being emitted.
* @param d The signal object (@p this).
*/
static void* notify(void* d);
/** Reference counter.
* The object is destroyed when @em ref_count_ reaches zero.
*/
short ref_count_;
/** Execution counter.
* Indicates whether the signal is being emitted.
*/
short exec_count_;
/// Indicates whether the execution of sweep() is being deferred.
bool deferred_;
/// The list of slots.
std::list<slot_base> slots_;
};
/// Exception safe sweeper for cleaning up invalid slots on the slot list.
struct SIGC_API signal_exec
{
/// The parent sigc::signal_impl object.
signal_impl* sig_;
/** Increments the reference and execution counter of the parent sigc::signal_impl object.
* @param sig The parent sigc::signal_impl object.
*/
inline signal_exec(const signal_impl* sig)
: sig_(const_cast<signal_impl*>(sig) )
{ sig_->reference_exec(); }
/// Decrements the reference and execution counter of the parent sigc::signal_impl object.
inline ~signal_exec()
{ sig_->unreference_exec(); }
};
/** Temporary slot list used during signal emission.
* Through evolution this class is slightly misnamed. It is now
* an index into the slot_list passed into it. It simply keeps track
* of where the end of this list was at construction, and pretends that's
* the end of your list. This way you may connect during emittion without
* inadvertently entering an infinite loop, as well as make other
* modifications to the slot_list at your own risk.
*/
struct temp_slot_list
{
typedef signal_impl::slot_list slot_list;
typedef signal_impl::iterator_type iterator;
typedef signal_impl::const_iterator_type const_iterator;
temp_slot_list(slot_list &slots) : slots_(slots)
{
placeholder = slots_.insert(slots_.end(), slot_base());
}
~temp_slot_list()
{
slots_.erase(placeholder);
}
iterator begin() { return slots_.begin(); }
iterator end() { return placeholder; }
const_iterator begin() const { return slots_.begin(); }
const_iterator end() const { return placeholder; }
private:
slot_list &slots_;
slot_list::iterator placeholder;
};
} /* namespace internal */
/** @defgroup signal Signals
* Use sigc::signal::connect() with sigc::mem_fun() and sigc::ptr_fun() to connect a method or function with a signal.
*
* @code
* signal_clicked.connect( sigc::mem_fun(*this, &MyWindow::on_clicked) );
* @endcode
*
* When the signal is emitted your method will be called.
*
* signal::connect() returns a connection, which you can later use to disconnect your method.
* If the type of your object inherits from sigc::trackable the method is disconnected
* automatically when your object is destroyed.
*
* When signals are copied they share the underlying information,
* so you can have a protected/private sigc::signal member and a public accessor method.
*
* signal and slot objects provide the core functionality of this
* library. A slot is a container for an arbitrary functor.
* A signal is a list of slots that are executed on emission.
* For compile time type safety a list of template arguments
* must be provided for the signal template that determines the
* parameter list for emission. Functors and closures are converted
* into slots implicitely on connection, triggering compiler errors
* if the given functor or closure cannot be invoked with the
* parameter list of the signal to connect to.
*/
/** Base class for the sigc::signal# templates.
* signal_base integrates most of the interface of the derived sigc::signal#
* templates. The implementation, however, resides in sigc::internal::signal_impl.
* A sigc::internal::signal_impl object is dynamically allocated from signal_base
* when first connecting a slot to the signal. This ensures that empty signals
* don't waste memory.
*
* @ingroup signal
*/
struct SIGC_API signal_base : public trackable
{
typedef size_t size_type;
signal_base();
signal_base(const signal_base& src);
~signal_base();
signal_base& operator = (const signal_base& src);
/** Returns whether the list of slots is empty.
* @return @p true if the list of slots is empty.
*/
inline bool empty() const
{ return (!impl_ || impl_->empty()); }
/// Empties the list of slots.
void clear();
/** Returns the number of slots in the list.
* @return The number of slots in the list.
*/
size_type size() const;
protected:
typedef internal::signal_impl::iterator_type iterator_type;
/** Adds a slot at the end of the list of slots.
* With connect(), slots can also be added during signal emission.
* In this case, they won't be executed until the next emission occurs.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type connect(const slot_base& slot_);
/** Adds a slot at the given position into the list of slots.
* Note that this function does not work during signal emission!
* @param i An iterator indicating the position where @e slot_ should be inserted.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type insert(iterator_type i, const slot_base& slot_);
/** Removes the slot at the given position from the list of slots.
* Note that this function does not work during signal emission!
* @param i An iterator pointing to the slot to be removed.
* @return An iterator pointing to the slot in the list after the one removed.
*/
iterator_type erase(iterator_type i);
/** Returns the signal_impl object encapsulating the list of slots.
* @return The signal_impl object encapsulating the list of slots.
*/
internal::signal_impl* impl() const;
/// The signal_impl object encapsulating the slot list.
mutable internal::signal_impl* impl_;
};
} //namespace sigc
#endif /* _SIGC_SIGNAL_BASE_H_ */
|