amxd_dm_priv.h File Reference

Go to the source code of this file.

Data Structures
struct	_amxd_deferred_call

Typedefs
typedef struct _amxd_deferred_call	amxd_deferred_ctx_t

Functions
void PRIVATE	amxd_object_init_base (amxd_object_t *const object, const amxd_object_type_t type)
void PRIVATE	amxd_init_base (void)
void PRIVATE	amxd_dm_event (const char *signal, const amxd_object_t *const object, amxc_var_t *const data, bool trigger)
bool PRIVATE	amxd_object_is_base (const amxd_object_t *const object)
amxd_status_t PRIVATE	amxd_dm_base_add_funcs (amxd_object_t *object)
void PRIVATE	amxd_dm_set_derived_from (amxd_object_t *const object)
void PRIVATE	amxd_def_funcs_remove_args (amxc_var_t *args)
void PRIVATE	amxd_common_set_flag (amxc_var_t **flags, const char *flag)
void PRIVATE	amxd_common_unset_flag (amxc_var_t **flags, const char *flag)
bool PRIVATE	amxd_common_has_flag (const amxc_var_t *const flags, const char *flag)
amxd_deferred_ctx_t *PRIVATE	amxd_find_deferred (uint64_t call_id)
void PRIVATE	amxd_dm_cancel_deferred (amxd_dm_t *dm)

Typedef Documentation

amxd_deferred_ctx_t

typedef struct _amxd_deferred_call amxd_deferred_ctx_t

Function Documentation

amxd_common_has_flag()

bool PRIVATE amxd_common_has_flag	(	const amxc_var_t *const	flags,
		const char *	flag
	)

Definition at line 652 of file amxd_dm_priv.c.

                                                                                   {
    bool retval = false;
    const amxc_htable_t* ht_flags = NULL;
 
    when_null(flags, exit);
 
    ht_flags = amxc_var_constcast(amxc_htable_t, flags);
    retval = amxc_htable_contains(ht_flags, flag);
 
exit:
    return retval;
}

amxd_common_set_flag()

void PRIVATE amxd_common_set_flag	(	amxc_var_t **	flags,
		const char *	flag
	)

Definition at line 617 of file amxd_dm_priv.c.

                                                                        {
    amxc_var_t* f = NULL;
 
    if((*flags) == NULL) {
        amxc_var_new(flags);
        amxc_var_set_type((*flags), AMXC_VAR_ID_HTABLE);
    }
    f = GET_ARG((*flags), flag);
    if(f == NULL) {
        amxc_var_add_key(bool, (*flags), flag, true);
    } else {
        amxc_var_set(bool, f, true);
    }
 
    return;
}

amxd_common_unset_flag()

void PRIVATE amxd_common_unset_flag	(	amxc_var_t **	flags,
		const char *	flag
	)

Definition at line 634 of file amxd_dm_priv.c.

                                                                          {
    amxc_var_t* f = NULL;
    const amxc_htable_t* ht_flags = NULL;
 
    when_null((*flags), exit);
 
    ht_flags = amxc_var_constcast(amxc_htable_t, *flags);
    f = GET_ARG((*flags), flag);
    amxc_var_delete(&f);
 
    if(amxc_htable_is_empty(ht_flags)) {
        amxc_var_delete(flags);
    }
 
exit:
    return;
}

amxd_def_funcs_remove_args()

void PRIVATE amxd_def_funcs_remove_args

(

amxc_var_t *

args

)

Definition at line 71 of file amxd_dm_functions.c.

                                                  {
    amxc_var_t* access = GET_ARG(args, "access");
    uint32_t iaccess = amxc_var_dyncast(uint32_t, access);
    const char* invalid_args[] = {
        "set_read_only",
        NULL
    };
 
    for(int i = 0; invalid_args[i] != NULL; i++) {
        amxc_var_t* arg = GET_ARG(args, invalid_args[i]);
        amxc_var_delete(&arg);
    }
 
    if(iaccess > amxd_dm_access_protected) {
        amxc_var_set(uint32_t, access, amxd_dm_access_protected);
    }
}

amxd_dm_base_add_funcs()

amxd_status_t PRIVATE amxd_dm_base_add_funcs

(

amxd_object_t *

object

)

Definition at line 508 of file amxd_dm_priv.c.

                                                                    {
    amxd_status_t retval = amxd_status_unknown_error;
 
    // list function
    retval = amxd_object_add_list_func(object);
    when_failed(retval, exit);
 
    // describe function
    retval = amxd_object_add_describe_func(object);
    when_failed(retval, exit);
 
    // get function
    retval = amxd_object_add_get_func(object);
    when_failed(retval, exit);
 
    // get instances function
    retval = amxd_object_add_get_instances_func(object);
    when_failed(retval, exit);
 
    // get_supported dm function
    retval = amxd_object_add_get_supported_func(object);
    when_failed(retval, exit);
 
    // set function
    retval = amxd_object_add_set_func(object);
    when_failed(retval, exit);
 
    // add (inst) function
    retval = amxd_object_add_add_func(object);
    when_failed(retval, exit);
 
    // del (inst) function
    retval = amxd_object_add_del_func(object);
    when_failed(retval, exit);
 
    // del (inst) function
    retval = amxd_object_add_exec_func(object);
 
exit:
    return retval;
}

amxd_dm_cancel_deferred()

void PRIVATE amxd_dm_cancel_deferred

(

amxd_dm_t *

dm

)

Definition at line 109 of file amxd_function_deferred.c.

                                            {
    amxc_var_t sig_data;
 
    amxc_var_init(&sig_data);
    amxc_var_set_type(&sig_data, AMXC_VAR_ID_HTABLE);
    amxc_var_add_new_key(&sig_data, "retval");
    amxc_var_add_key(uint32_t, &sig_data, "status", amxd_status_unknown_error);
 
    amxc_llist_for_each(it, &dm->deferred) {
        amxd_deferred_ctx_t* call = amxc_container_of(it, amxd_deferred_ctx_t, dm_it);
        amxd_cancel_deferred(call, &sig_data);
        amxd_delete_deferred(&call->it);
    }
 
    amxc_var_clean(&sig_data);
}

amxd_dm_event()

void PRIVATE amxd_dm_event	(	const char *	signal,
		const amxd_object_t *const	object,
		amxc_var_t *const	data,
		bool	trigger
	)

Definition at line 550 of file amxd_dm_priv.c.

                                         {
    amxd_dm_t* dm = amxd_object_get_dm(object);
    char* path = NULL;
    char* epath = NULL;
    char* index_path = NULL;
    amxc_var_t signal_data;
 
    when_null(dm, exit);
 
    path = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_TERMINATE);
    epath = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED | AMXD_OBJECT_TERMINATE);
    index_path = amxd_object_get_path(object, AMXD_OBJECT_INDEXED | AMXD_OBJECT_TERMINATE);
    amxc_var_init(&signal_data);
 
    amxc_var_set_type(&signal_data, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(cstring_t, &signal_data, "object", path);
    amxc_var_add_key(cstring_t, &signal_data, "path", index_path);
    amxc_var_add_key(cstring_t, &signal_data, "eobject", epath);
    if(amxc_var_type_of(data) == AMXC_VAR_ID_HTABLE) {
        const amxc_htable_t* table_data = amxc_var_constcast(amxc_htable_t, data);
        amxc_htable_it_t* hit = amxc_htable_get_first(table_data);
        while(hit) {
            amxc_var_t* part = amxc_var_from_htable_it(hit);
            const char* key = amxc_htable_it_get_key(hit);
            if(GET_ARG(&signal_data, key) == NULL) {
                amxc_var_set_key(&signal_data, key, part, AMXC_VAR_FLAG_DEFAULT);
            } else {
                amxc_var_delete(&part);
            }
            hit = amxc_htable_get_first(table_data);
        }
    } else {
        amxc_var_set_key(&signal_data, "data", data, AMXC_VAR_FLAG_COPY);
    }
    if(trigger) {
        amxp_sigmngr_trigger_signal(&dm->sigmngr, signal, &signal_data);
    } else {
        amxp_sigmngr_emit_signal(&dm->sigmngr, signal, &signal_data);
    }
 
    amxc_var_clean(&signal_data);
    free(path);
    free(epath);
    free(index_path);
 
exit:
    return;
}

amxd_dm_set_derived_from()

void PRIVATE amxd_dm_set_derived_from

(

amxd_object_t *const

object

)

Definition at line 602 of file amxd_dm_priv.c.

                                                                   {
    amxd_object_type_t type = amxd_object_get_type(object);
    switch(type) {
    case amxd_object_singleton:
    case amxd_object_root:
        amxc_llist_append(&base_singleton.derived_objects, &object->derived_from);
        break;
    case amxd_object_template:
        amxc_llist_append(&base_template.derived_objects, &object->derived_from);
        break;
    default:
        break;
    }
}

amxd_find_deferred()

amxd_deferred_ctx_t* PRIVATE amxd_find_deferred

(

uint64_t

call_id

)

Definition at line 96 of file amxd_function_deferred.c.

                                                          {
    amxd_deferred_ctx_t* data = NULL;
    amxc_llist_for_each(it, &deferred) {
        data = amxc_container_of(it, amxd_deferred_ctx_t, it);
        if(data->call_id == call_id) {
            break;
        }
        data = NULL;
    }
 
    return data;
}

amxd_init_base()

void PRIVATE amxd_init_base

(

void

)

Definition at line 665 of file amxd_dm_priv.c.

                          {
    if(amxc_llist_is_empty(&base_singleton.functions)) {
        amxc_llist_init(&base_objects);
 
        amxd_object_init_base(&base_singleton, amxd_object_singleton);
        amxd_dm_base_add_funcs(&base_singleton);
        amxc_llist_append(&base_objects, &base_singleton.it);
 
        amxd_object_init_base(&base_template, amxd_object_template);
        amxc_llist_append(&base_objects, &base_template.it);
        amxc_llist_append(&base_singleton.derived_objects, &base_template.derived_from);
    }
}

amxd_object_init_base()

void PRIVATE amxd_object_init_base	(	amxd_object_t *const	object,
		const amxd_object_type_t	type
	)

Definition at line 472 of file amxd_dm_priv.c.

                                                                  {
    amxc_llist_it_init(&object->it);
 
    object->type = type;
    object->attr.read_only = 0;
    object->attr.priv = 0;
    object->attr.prot = 0;
    object->attr.persistent = 0;
    object->attr.locked = 0;
 
    object->index = 0;
    object->last_index = 0;
 
    object->name = NULL;
    object->index_name = NULL;
 
    amxc_llist_init(&object->objects);
    amxc_llist_init(&object->instances);
    amxc_llist_init(&object->functions);
    amxc_llist_init(&object->parameters);
    amxc_var_init(&object->events);
    amxc_var_set_type(&object->events, AMXC_VAR_ID_HTABLE);
 
    amxc_llist_init(&object->cb_fns);
 
    amxc_llist_init(&object->derived_objects);
    amxc_llist_it_init(&object->derived_from);
 
    amxc_array_init(&object->mib_names, 0);
}

amxd_object_is_base()

bool PRIVATE amxd_object_is_base

(

const amxd_object_t *const

object

)

Definition at line 504 of file amxd_dm_priv.c.

                                                                    {
    return ((object == &base_singleton) || (object == &base_template));
}