Signal.hpp

Allow functions to be bundled (as Actions) and triggered enmasse.

Todo:

Setup easier mechanism to control the order in which actions are triggered.

Signals should have default parameters so not all need be supplied when triggered.

Note

Status: Beta

class SignalKey

#include <Signal.hpp>

SignalKey tracks a specific function triggered by a signal. For now, its just a value pair.

Public Functions

inline SignalKey(uint32_t _kid = 0, uint32_t _sid = 0)

SignalKey(const SignalKey&) = default

SignalKey &operator=(const SignalKey&) = default

inline ~SignalKey()

inline bool operator==(const SignalKey &in) const

Are two signal keys identical?

inline bool operator!=(const SignalKey &in) const

Are two signal keys different?

inline bool operator<(const SignalKey &in) const

inline bool operator>(const SignalKey &in) const

inline bool operator<=(const SignalKey &in) const

inline bool operator>=(const SignalKey &in) const

inline uint32_t GetID() const

What is the KeyID associated with this signal key.

inline uint32_t GetSignalID() const

What is the ID of the signal that this key is associated with.

inline bool IsActive() const

Is this key currently pointing to a signal action?

inline void Set(uint32_t _kid = 0, uint32_t _sid = 0)

Set this key to specified values.

inline void Clear()

Clear this key.

inline operator bool()

Private Functions

inline int Compare(const SignalKey &in) const

Private Members

uint32_t signal_id

Which signal is this key associated with?

uint32_t key_id

Which key id is this.

class SignalBase

#include <Signal.hpp>

Base class for all signals.

Subclassed by Signal< RETURN(ARGS…)>, Signal< void(ARGS…)>

Public Functions

SignalBase() = delete

SignalBase(const SignalBase&) = delete

SignalBase(SignalBase&&) = delete

SignalBase &operator=(const SignalBase&) = delete

SignalBase &operator=(SignalBase&&) = delete

inline virtual ~SignalBase()

virtual SignalBase *Clone() const = 0

inline const std::string &GetName() const

virtual size_t GetNumArgs() const = 0

virtual size_t GetNumActions() const = 0

template<typename ...ARGS>
void BaseTrigger(ARGS... args)

template<typename ...ARGS>
SignalKey AddAction(const std::function<void(ARGS...)> &in_fun)

Actions without arguments or a return type can be associated with any signal.

virtual SignalKey AddAction(ActionBase&) = 0

Add an action using an Action object.

virtual bool TestMatch(ActionBase&) = 0

Test if an action is compatible with a signal.

virtual void Remove(SignalKey key) = 0

Remove an action specified by its key.

inline void Clear()

Remove all actions from this signal.

inline bool Has(SignalKey key) const

Protected Types

using man_t = internal::SignalManager_Base

Protected Functions

inline SignalKey NextSignalKey()

inline SignalBase(const std::string &n, internal::SignalManager_Base *manager = nullptr)

Protected Attributes

std::string name

What is the unique name of this signal?

uint32_t signal_id

What is the unique ID of this signal?

uint32_t next_link_id

What ID should the next link have?

std::map<SignalKey, size_t> link_key_map

Map unique link keys to link index for actions.

vector<man_t*> managers

What manager is handling this signal?

man_t *prime_manager

Which manager leads deletion? (nullptr for self)

Friends

friend class SignalManager

template<typename ...ARGS>
class Signal

#include <Signal.hpp>

Generic version of Signals; needs specialization to a function type..

template<typename ...ARGS>
class Signal<void(ARGS...)> : public SignalBase

#include <Signal.hpp>

Signals with void return.

Public Types

using fun_t = void(ARGS...)

using this_t = Signal<fun_t>

Public Functions

inline Signal(const std::string &name = "", internal::SignalManager_Base *manager = nullptr)

inline Signal(const std::string &name, internal::SignalControl_Base &control)

inline virtual this_t *Clone() const

inline virtual size_t GetNumArgs() const

inline virtual size_t GetNumActions() const

inline void Trigger(ARGS... args)

Trigger this signal, providing all needed arguments.

inline SignalKey AddAction(const std::function<void(ARGS...)> &in_fun)

Add an action that takes the proper arguments.

inline virtual SignalKey AddAction(ActionBase &in_action)

Add a specified action to this signal.

inline virtual bool TestMatch(ActionBase &in_action)

Test if an action is compatible with a signal.

template<typename ...FUN_ARGS, typename ...EXTRA_ARGS>
inline SignalKey AddAction(const std::function<void(FUN_ARGS...)> &in_fun, TypePack<EXTRA_ARGS...>)

Add an action that takes too few arguments… but provide specific padding info.

template<typename ...FUN_ARGS>
inline SignalKey AddAction(const std::function<void(FUN_ARGS...)> &in_fun)

Add an std::function that takes the wrong number of arguments. For now, we will assume that there are too few and we need to figure out how to pad it out.

template<typename ...FUN_ARGS>
inline SignalKey AddAction(void in_fun(FUN_ARGS...))

Add a regular function that takes the wrong number of arguments. For now, we will assume that there are too few and we need to figure out how to pad it out.

inline virtual void Remove(SignalKey key)

Remove an action from this signal by providing its key.

inline size_t GetPriority(SignalKey key)

Retrieve the relative priority associated with a specific.

Protected Attributes

FunctionSet<void(ARGS...)> actions

Set of functions (actions) to be triggered with this signal.

template<typename RETURN, typename ...ARGS>
class Signal<RETURN(ARGS...)> : public SignalBase

#include <Signal.hpp>

Public Types

using fun_t = RETURN(ARGS...)

using this_t = Signal<fun_t>

Public Functions

inline Signal(const std::string &name = "", internal::SignalManager_Base *manager = nullptr)

inline Signal(const std::string &name, internal::SignalControl_Base &control)

inline virtual this_t *Clone() const

inline virtual size_t GetNumArgs() const

inline virtual size_t GetNumActions() const

inline const vector<RETURN> &Trigger(ARGS... args)

inline SignalKey AddAction(const std::function<fun_t> &in_fun)

inline virtual SignalKey AddAction(ActionBase &in_action)

Add an action using an Action object.

inline virtual bool TestMatch(ActionBase &in_action)

Test if an action is compatible with a signal.

template<typename ...FUN_ARGS, typename ...EXTRA_ARGS>
inline SignalKey AddAction(const std::function<RETURN(FUN_ARGS...)> &in_fun, TypePack<EXTRA_ARGS...>)

template<typename ...FUN_ARGS>
inline SignalKey AddAction(const std::function<RETURN(FUN_ARGS...)> &in_fun)

template<typename ...FUN_ARGS>
inline SignalKey AddAction(RETURN in_fun(FUN_ARGS...))

inline virtual void Remove(SignalKey key)

Remove an action specified by its key.

inline size_t GetPriority(SignalKey key)

Protected Attributes

FunctionSet<RETURN(ARGS...)> actions