Slots

Collaboration diagram for Slots:

Typedefs
typedef void(*	amxp_deferred_fn_t) (const amxc_var_t *const data, void *const priv)
	Deferred callback function signature. More...
typedef void(*	amxp_slot_fn_t) (const char *const sig_name, const amxc_var_t *const data, void *const priv)
	Slot callback function signature. More...

Functions
int	amxp_slot_connect (amxp_signal_mngr_t *const sig_mngr, const char *const sig_name, const char *const expression, amxp_slot_fn_t fn, void *const priv)
	Connects a slot (function) to a named signal of a signal manager. More...
int	amxp_slot_connect_filtered (amxp_signal_mngr_t *const sig_mngr, const char *const sig_reg_exp, const char *const expression, amxp_slot_fn_t fn, void *const priv)
	Connects a slot (function) to signals using a regular expression. More...
int	amxp_slot_connect_all (const char *const sig_reg_exp, const char *const expression, amxp_slot_fn_t fn, void *const priv)
	Connects a slot to all existing and future signals. More...
int	amxp_slot_disconnect (amxp_signal_mngr_t *const sig_mngr, const char *const sig_name, amxp_slot_fn_t fn)
	Disconnects a slot from (a) signal(s). More...
int	amxp_slot_disconnect_with_priv (amxp_signal_mngr_t *sig_mngr, amxp_slot_fn_t fn, void *priv)
	Disconnects a slot from (a) signal(s). More...
int	amxp_slot_disconnect_signal_with_priv (amxp_signal_mngr_t *sig_mngr, const char *sig_name, amxp_slot_fn_t fn, void *priv)
	Disconnects a slot from a signal. More...
void	amxp_slot_disconnect_all (amxp_slot_fn_t fn)
	Disconnects a slot from all signals it was connected to. More...

Detailed Description

Slots are callback functions that are connected to named signals.

When a signal is triggered, all slots (callback functions) connected to the named signal are called.

Typedef Documentation

amxp_deferred_fn_t

typedef void(* amxp_deferred_fn_t) (const amxc_var_t *const data, void *const priv)

Deferred callback function signature.

Deferred functions are called from the eventloop

Parameters

data	some data
priv	a pointer to some data

Definition at line 137 of file amxp_signal.h.

amxp_slot_fn_t

typedef void(* amxp_slot_fn_t) (const char *const sig_name, const amxc_var_t *const data, void *const priv)

Slot callback function signature.

A slot is a callback function with this signature.

Parameters

sig_name	the name of the signal
data	the data of the signal
priv	a pointer to some data, provided when connecting

Definition at line 93 of file amxp_slot.h.

Function Documentation

amxp_slot_connect()

int amxp_slot_connect	(	amxp_signal_mngr_t *const	sig_mngr,
		const char *const	sig_name,
		const char *const	expression,
		amxp_slot_fn_t	fn,
		void *const	priv
	)

Connects a slot (function) to a named signal of a signal manager.

When the function (slot) is connected to the signal, the function is called each time the signal is "triggered".

When "*" is used as signal name, the slots is connected to all know signals of the given signal manager or when sig_mngr is NULL to all know signals from all signal managers.

When sig_mgr is NULL and sig_name is "*", the slot will also be connected to new added signals (signals that were not existing at the time of call to this function).

When a valid expression is added the slot is only called when expression evaluates to true, using the signal data as input. If the signal has not data the slot is also called even when an expression is provided.

Use amxp_slot_disconnect or amxp_slot_disconnect_all to disconnect the slot from signals.

Parameters

sig_mngr	the signal manager, or null for the global signal manager
sig_name	the signal you want to connect to
expression	Null or a string containing a valid expression
fn	the slot function (callback function)
priv	a pointer to some data, will be passed to the slot function when the signal is triggered

Returns

0 when connection was successful, otherwise an error occurred

Definition at line 300 of file amxp_slot.c.

                                        {
    int retval = -1;
    amxp_signal_t* sig = NULL;
 
    when_null(sig_name, exit);
    when_true(*sig_name == 0, exit);
    when_null(fn, exit);
 
    if(strcmp(sig_name, "*") == 0) {
        if(sig_mngr == NULL) {
            retval = amxp_slot_connect_all(NULL, expression, fn, priv);
        } else {
            retval = amxp_slot_connnect_all_of(sig_mngr, fn, NULL, expression, priv);
        }
        goto exit;
    }
 
    sig = amxp_slot_find_signal(sig_mngr, sig_name);
    when_null(sig, exit);
 
    retval = amxp_slot_connect_impl(sig, fn, expression, priv);
 
exit:
    return retval;
}

amxp_slot_connect_all()

int amxp_slot_connect_all	(	const char *const	sig_reg_exp,
		const char *const	expression,
		amxp_slot_fn_t	fn,
		void *const	priv
	)

Connects a slot to all existing and future signals.

This function does exactly the same as amxp_slot_connect where sig_name is "*" and sig_mngr is NULL, if no signal regular expression is provided (NULL).

If a regular expression is provided the slot is connected to all known and future signals that matches the regular expression.

Parameters

sig_reg_exp	a regular expression, the slot is connected to all signals matching the regular expression
expression	Null or a string containing a valid expression
fn	the slot function (callback function)
priv	a pointer to some data, will be passed to the slot function when the signal is triggered

Returns

0 when connection was successful, otherwise an error occurred

Definition at line 353 of file amxp_slot.c.

                                            {
    int retval = -1;
    amxc_llist_t* sigmngrs = NULL;
    amxc_llist_t* pending_sigmngrs = NULL;
 
    when_null(fn, exit);
 
    amxp_get_sigmngrs(&sigmngrs, &pending_sigmngrs);
    when_failed(amxp_slot_connnect_all_sigmngrs(sigmngrs,
                                                fn,
                                                sig_reg_exp,
                                                expression,
                                                priv), exit);
    when_failed(amxp_slot_connnect_all_sigmngrs(pending_sigmngrs,
                                                fn,
                                                sig_reg_exp,
                                                expression,
                                                priv), exit);
    retval = 0;
 
exit:
    return retval;
}

amxp_slot_connect_filtered()

int amxp_slot_connect_filtered	(	amxp_signal_mngr_t *const	sig_mngr,
		const char *const	sig_reg_exp,
		const char *const	expression,
		amxp_slot_fn_t	fn,
		void *const	priv
	)

Connects a slot (function) to signals using a regular expression.

The slot is connected to all signals of which the name is matching the given regular expression. If later signals are added and the name of the new signal is also matching the regular expression the slot will be automatically connected to the new signal as well.

Optionally a expression can be added. The expression works only on signals the provide a data. The slot is only called when the expression evalutes to true or when the signal has no data.

Use amxp_slot_disconnect or amxp_slot_disconnect_all to disconnect the slot from signals.

Parameters

sig_mngr	the signal manager, or null for the global signal manager
sig_reg_exp	a regular expression, the slot is connected to all signals matching the regular expression
expression	Null or a string containing a valid expression
fn	the slot function (callback function)
priv	a pointer to some data, will be passed to the slot function when the signal is triggered

Returns

0 when connection was successful, otherwise an error occurred

Definition at line 330 of file amxp_slot.c.

                                                 {
    int retval = -1;
    amxp_signal_mngr_t* mngr = NULL;
    when_null(sig_reg_exp, exit);
    when_true(*sig_reg_exp == 0, exit);
    when_null(fn, exit);
 
    mngr = amxp_get_sigmngr(sig_mngr);
    when_null(mngr, exit);
    retval = amxp_slot_connnect_all_of(mngr,
                                       fn,
                                       sig_reg_exp,
                                       expression,
                                       priv);
 
exit:
    return retval;
}

amxp_slot_disconnect()

int amxp_slot_disconnect	(	amxp_signal_mngr_t *const	sig_mngr,
		const char *const	sig_name,
		amxp_slot_fn_t	fn
	)

Disconnects a slot from (a) signal(s).

Disconnecting a slot using this function will:

• Remove all connections of the slot from the signal with the matching name
• Remove all connections with a regular expression matching the name.

A removed slot will not be called anymore when the signal is triggered.

When "*" is given as sign_name, the slot will be disconnected from all signals of the specified signal manager (sig_mngr), when sig_mngr is NULL, the slot is disconnected from all signals it was connected to.

Parameters

sig_mngr	the signal manager, or null for the global signal manager
sig_name	the signal you want to disconnect from use "*" for all
fn	the slot function (callback function).

Returns

0 when disconnection was successful, otherwise an error occurred.

Definition at line 380 of file amxp_slot.c.

                                            {
    int retval = -1;
 
    when_null(sig_name, exit);
    when_true(*sig_name == 0, exit);
    when_null(fn, exit);
 
    if(strcmp(sig_name, "*") == 0) {
        if(sig_mngr == NULL) {
            amxp_slot_disconnect_all(fn);
        } else {
            amxp_slot_disconnnect_all_of(sig_mngr, fn);
        }
        retval = 0;
        goto exit;
    }
 
    retval = amxp_slot_disconnect_name(sig_mngr, sig_name, fn);
 
exit:
    return retval;
}

amxp_slot_disconnect_all()

void amxp_slot_disconnect_all

(

amxp_slot_fn_t

fn

)

Disconnects a slot from all signals it was connected to.

The slot is removed from all signals it was connected to, including regular expression slot (see amxp_slot_connect_filtered)

Parameters

fn	the slot function (callback function)

Definition at line 459 of file amxp_slot.c.

                                                 {
    amxc_llist_t* sigmngrs = NULL;
    amxc_llist_t* pending_sigmngrs = NULL;
 
    when_null(fn, exit);
 
    amxp_get_sigmngrs(&sigmngrs, &pending_sigmngrs);
    amxp_slot_disconnect_all_sgmngrs(sigmngrs, fn);
    amxp_slot_disconnect_all_sgmngrs(pending_sigmngrs, fn);
 
exit:
    return;
}

amxp_slot_disconnect_signal_with_priv()

int amxp_slot_disconnect_signal_with_priv	(	amxp_signal_mngr_t *	sig_mngr,
		const char *	sig_name,
		amxp_slot_fn_t	fn,
		void *	priv
	)

Disconnects a slot from a signal.

Disconnecting a slot using this function will:

• Remove all connections of the slot with the matching private data from the signal with the given name or from all signals when no signal name is given.
• Remove all connections with a regular expression and matching private data when no signal name is given.

A removed slot will not be called anymore when the signal is triggered.

Parameters

sig_mngr	the signal manager, or null for the global signal manager
sig_name	the signal name, or NULL for all.
fn	the slot function (callback function).
priv	The private data pointer that was provided when connecting

Returns

0 when disconnection was successful, otherwise an error occurred.

Definition at line 411 of file amxp_slot.c.

                                                      {
    int retval = -1;
    amxc_llist_it_t* slot_it = NULL;
    amxc_llist_it_t* next = NULL;
    const amxc_htable_t* signals = NULL;
    sig_mngr = amxp_get_sigmngr(sig_mngr);
    signals = amxp_get_signals(sig_mngr);
 
    amxc_htable_for_each(it, signals) {
        amxp_signal_t* sig = amxc_htable_it_get_data(it, amxp_signal_t, hit);
        if((sig_name != NULL) && (strcmp(sig_name, sig->name) != 0)) {
            continue;
        }
        slot_it = amxc_llist_get_first(&sig->slots);
        while(slot_it != NULL) {
            amxp_slot_t* slot = NULL;
            next = amxc_llist_it_get_next(slot_it);
            slot = amxc_llist_it_get_data(slot_it, amxp_slot_t, it);
            if(((slot->fn == fn) || (fn == NULL)) &&
               ( slot->priv == priv)) {
                slot->deleted = true;
            }
            slot_it = next;
        }
    }
 
    if(sig_name == NULL) {
        slot_it = amxc_llist_get_first(&sig_mngr->regexp_slots);
        while(slot_it != NULL) {
            amxp_slot_t* slot = NULL;
            next = amxc_llist_it_get_next(slot_it);
            slot = amxc_llist_it_get_data(slot_it, amxp_slot_t, it);
            if(((slot->fn == fn) || (fn == NULL)) &&
               ( slot->priv == priv)) {
                amxc_llist_it_clean(slot_it, amxp_free_slots);
            }
            slot_it = next;
        }
    }
 
    retval = 0;
 
    return retval;
}

amxp_slot_disconnect_with_priv()

int amxp_slot_disconnect_with_priv	(	amxp_signal_mngr_t *	sig_mngr,
		amxp_slot_fn_t	fn,
		void *	priv
	)

Disconnects a slot from (a) signal(s).

Disconnecting a slot using this function will:

• Remove all connections of the slot with the matching private data from the signals
• Remove all connections with a regular expression and matching private data

A removed slot will not be called anymore when the signal is triggered.

Parameters

sig_mngr	the signal manager, or null for the global signal manager
fn	the slot function (callback function).
priv	The private data pointer that was provided when connecting

Returns

0 when disconnection was successful, otherwise an error occurred.

Definition at line 405 of file amxp_slot.c.

                                               {
    return amxp_slot_disconnect_signal_with_priv(sig_mngr, NULL, fn, priv);
}