gum::Signaler< Args > Class Template Reference

Variadic template signaler for any number of arguments. More...

#include <agrum/base/core/signal/signaler.h>

Inheritance diagram for gum::Signaler< Args >:

Collaboration diagram for gum::Signaler< Args >:

Public Member Functions
	Signaler ()
	Default constructor.
	Signaler (const Signaler &other)
	Copy constructor.
	~Signaler () override
	Destructor.
template<class TargetClass>
void	attach (TargetClass *target, void(TargetClass::*action)(const void *, Args...))
	Attach a listener with a member function callback.
void	operator() (const void *src, Args... args)
	Emit the signal, notifying all attached listeners.
bool	hasListener () override
void	detach (Listener *target)
	Detach a specific listener from this signaler.

Protected Types
using	ConnectorList

Protected Member Functions
void	detachFromTarget (Listener *target) override
	Called by Listener to detach when the listener is destroyed.
void	duplicateTarget (const Listener *oldTarget, Listener *newTarget) override
	Called by Listener copy constructor to duplicate connections.

Protected Attributes
ConnectorList	_connectors_

Detailed Description

template<typename... Args>
class gum::Signaler< Args >

Variadic template signaler for any number of arguments.

This class implements the signal/slot pattern with C++20 variadic templates. It can be used with any number of arguments (0 to N).

Usage example:

class MyEmitter {
  public:
    Signaler<int, std::string> onValueChanged;
 
    void setValue(int v, const std::string& name) {
      onValueChanged(this, v, name);
    }
};
 
class MyReceiver : public Listener {
  public:
    void handleChange(const void* src, int v, std::string name) {
      // handle the signal
    }
};
 
// Connect:
MyEmitter emitter;
MyReceiver receiver;
emitter.onValueChanged.attach(&receiver, &MyReceiver::handleChange);

Template Parameters

Args	The types of arguments passed when the signal is emitted.

Definition at line 236 of file signaler.h.

Member Typedef Documentation

ConnectorList

using gum::__sig__::BasicSignaler< Args >::ConnectorList

protectedinherited

Definition at line 165 of file signaler.h.

Constructor & Destructor Documentation

Signaler() [1/2]

template<typename... Args>

gum::Signaler< Args >::Signaler ( )

inline

Default constructor.

Definition at line 239 of file signaler.h.

{ GUM_CONSTRUCTOR(Signaler); }

Referenced by Signaler().

Here is the caller graph for this function:

Signaler() [2/2]

template<typename... Args>

gum::Signaler< Args >::Signaler

(

const Signaler< Args > &

other

)

Copy constructor.

Definition at line 158 of file signaler_tpl.h.

                                                     : __sig__::BasicSignaler< Args... >(other) {
    GUM_CONS_CPY(Signaler);
  }

References gum::__sig__::BasicSignaler< Args... >::BasicSignaler(), and Signaler().

Here is the call graph for this function:

~Signaler()

template<typename... Args>

gum::Signaler< Args >::~Signaler ( )

inlineoverride

Destructor.

Definition at line 245 of file signaler.h.

{ GUM_DESTRUCTOR(Signaler); }

Member Function Documentation

attach()

template<typename... Args>

template<class TargetClass>

void gum::Signaler< Args >::attach	(	TargetClass *	target,
		void(TargetClass::*	action )(const void *, Args...) )

Attach a listener with a member function callback.

Template Parameters

TargetClass

The class type of the listener (must derive from Listener).

Parameters

target	Pointer to the listener object.
action	Pointer to the member function to call on signal emission.

Definition at line 164 of file signaler_tpl.h.

                                                                                    {
    auto* conn = new __sig__::Connector< TargetClass, Args... >(target, action);
    this->_connectors_.push_back(conn);
    target->_attachSignal_(this);
  }

References gum::__sig__::BasicSignaler< Args... >::_connectors_.

detach()

void gum::__sig__::BasicSignaler< Args >::detach ( Listener * target )

inherited

Detach a specific listener from this signaler.

Definition at line 181 of file signaler_tpl.h.

                                                        {
    for (auto it = _connectors_.rbegin(); it != _connectors_.rend(); ++it) {
      if ((*it)->target() == target) {
        auto* conn = *it;
        _connectors_.erase(std::next(it).base());
        target->_detachSignal_(this);
        delete conn;
        return;
      }
    }
  }

detachFromTarget()

void gum::__sig__::BasicSignaler< Args >::detachFromTarget ( Listener * target )

overrideprotectedinherited

Called by Listener to detach when the listener is destroyed.

Definition at line 187 of file signaler_tpl.h.

                                                                  {
    for (auto it = _connectors_.begin(); it != _connectors_.end();) {
      if ((*it)->target() == target) {
        delete *it;
        it = _connectors_.erase(it);
      } else {
        ++it;
      }
    }
  }

duplicateTarget()

void gum::__sig__::BasicSignaler< Args >::duplicateTarget ( const Listener * oldTarget, Listener * newTarget )

overrideprotectedinherited

Called by Listener copy constructor to duplicate connections.

Definition at line 190 of file signaler_tpl.h.

                                                                                               {
    ConnectorList toAdd;
    for (auto* connector: _connectors_) {
      if (connector->target() == oldTarget) { toAdd.push_back(connector->duplicate(newTarget)); }
    }
    for (auto* newConn: toAdd) {
      _connectors_.push_back(newConn);
    }
  }

hasListener()

bool gum::__sig__::BasicSignaler< Args >::hasListener ( )

overrideinherited

Returns

true if at least one listener is attached.

Definition at line 178 of file signaler_tpl.h.

                                             {
    return !_connectors_.empty();
  }

operator()()

template<typename... Args>

void gum::Signaler< Args >::operator()	(	const void *	src,
		Args...	args )

Emit the signal, notifying all attached listeners.

Parameters

src	Pointer to the source object (typically this of the emitter).
args	The arguments to pass to each listener's callback.

Definition at line 172 of file signaler_tpl.h.

                                                                    {
    if (this->_connectors_.empty()) { return; }
    for (const auto connectors = this->_connectors_; auto* connector: connectors) {
      connector->notify(src, args...);
    }
  }

References gum::__sig__::BasicSignaler< Args... >::_connectors_.

Member Data Documentation

_connectors_

ConnectorList gum::__sig__::BasicSignaler< Args >::_connectors_

protectedinherited

Definition at line 192 of file signaler.h.

Referenced by gum::Signaler< Args >::attach(), and gum::Signaler< Args >::operator()().

---

The documentation for this class was generated from the following files:

• agrum/base/core/signal/signaler.h
• agrum/base/core/signal/signaler_tpl.h