amxd_dm.c File Reference

#include <stdlib.h>
#include <string.h>
#include "amxd_priv.h"
#include <amxd/amxd_dm.h>
#include <amxd/amxd_action.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_path.h>
#include "amxd_dm_priv.h"
#include "amxd_object_priv.h"
#include "amxd_assert.h"

Go to the source code of this file.

Functions
static void	amxd_dm_free_mib_object_it (amxc_llist_it_t *it)
static amxd_status_t	amxd_dm_invoke_action_impl (amxc_llist_t *fns, amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval)
static amxd_status_t	amxd_dm_invoke_action_base (amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval)
static bool	amxd_dm_can_invoke_action (int counter, amxd_action_t reason, amxd_object_t *current, amxd_object_t *object)
static amxd_status_t	amxd_dm_invoke_default (amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval)
static amxd_status_t	amxd_dm_check_add_inst_retval (amxc_var_t *retval)
static void	amxd_dm_cleanup_add_inst (amxd_object_t *object, amxc_var_t *retval)
static void	amxd_dm_invoke_action_start (UNUSED amxd_object_t *object, UNUSED amxd_param_t *param, amxd_action_t reason)
static amxd_status_t	amxd_dm_invoke_action_end (amxd_object_t *object, amxd_param_t *param, amxd_status_t status, amxd_action_t reason, amxc_var_t *retval)
amxd_status_t	amxd_dm_new (amxd_dm_t **dm)
	Instantiate a new data model. More...
void	amxd_dm_delete (amxd_dm_t **dm)
	Deletes a data model structure. More...
amxd_status_t	amxd_dm_init (amxd_dm_t *dm)
	Initializes a data model structure. More...
void	amxd_dm_clean (amxd_dm_t *dm)
	Cleans a data model structure. More...
amxd_status_t	amxd_dm_store_mib (amxd_dm_t *const dm, amxd_object_t *const object)
amxd_object_t *	amxd_dm_get_mib (amxd_dm_t *const dm, const char *name)
amxd_status_t	amxd_dm_add_root_object (amxd_dm_t *dm, amxd_object_t *object)
	Adds an object to the root of the data model. More...
amxd_status_t	amxd_dm_remove_root_object (amxd_dm_t *dm, const char *name)
	Removes an object from the root of the data model. More...
amxd_object_t *	amxd_dm_get_root (amxd_dm_t *const dm)
	Fetches the root object of the data model. More...
amxd_object_t *	amxd_dm_get_object (amxd_dm_t *const dm, const char *name)
amxd_object_t *	amxd_dm_findf (amxd_dm_t *const dm, const char *abs_path,...)
amxd_status_t	amxd_dm_resolve_pathf (amxd_dm_t *const dm, amxc_llist_t *paths, const char *abs_path,...)
amxd_status_t	amxd_dm_resolve_pathf_ext (amxd_dm_t *const dm, bool *key_path, amxc_llist_t *paths, const char *abs_path,...)
const char *	amxd_dm_signal_get_path (amxd_dm_t *const dm, const amxc_var_t *const signal_data)
	Get the object path from a data model signal. More...
amxd_object_t *	amxd_dm_signal_get_object (amxd_dm_t *const dm, const amxc_var_t *const signal_data)
	Get the object from a data model using the path in the recieved signal. More...
amxd_status_t	amxd_dm_invoke_action (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval)

Variables
static amxd_action_fn_t	default_actions []

Function Documentation

amxd_dm_can_invoke_action()

static bool amxd_dm_can_invoke_action ( int  counter, amxd_action_t  reason, amxd_object_t *  current, amxd_object_t *  object  )

static

Definition at line 174 of file amxd_dm.c.

                                                             {
    bool retval = false;
    if(counter == 0) {
        retval = true;
    } else if(counter < INT32_MAX) {
        switch(reason) {
        case action_object_read:
        case action_object_list:
        case action_object_validate:
        case action_object_describe:
        case action_param_read:
        case action_param_describe:
        case action_param_validate:
            retval = true;
            break;
        case action_object_destroy:
            retval = (amxd_object_get_parent(object) == NULL ||
                      amxd_object_is_child_of(object, current));
            if(retval) {
                retval = !amxd_object_is_child_of(current, object);
            }
            break;
        case action_object_del_inst:
            retval = amxd_object_is_child_of(object, current);
            break;
        default:
            break;
        }
    }
    return retval;
}

amxd_dm_check_add_inst_retval()

static amxd_status_t amxd_dm_check_add_inst_retval ( amxc_var_t *  retval )

static

Definition at line 229 of file amxd_dm.c.

                                                                       {
    amxd_status_t status = amxd_status_ok;
    amxc_var_t* tmp = NULL;
 
    tmp = amxc_var_get_path(retval, "index", AMXC_VAR_FLAG_DEFAULT);
    when_true_status(amxc_var_is_null(tmp),
                     exit,
                     status = amxd_status_invalid_name);
 
    tmp = amxc_var_get_path(retval, "name", AMXC_VAR_FLAG_DEFAULT);
    when_true_status(amxc_var_is_null(tmp),
                     exit,
                     status = amxd_status_invalid_name);
 
exit:
    return status;
}

amxd_dm_cleanup_add_inst()

static void amxd_dm_cleanup_add_inst ( amxd_object_t *  object, amxc_var_t *  retval  )

static

Definition at line 247 of file amxd_dm.c.

                                                         {
    uint32_t index = 0;
    amxd_object_t* inst = NULL;
    amxc_var_t* var_index = NULL;
    when_true(amxc_var_is_null(retval), exit);
 
    var_index = amxc_var_get_path(retval, "index", AMXC_VAR_FLAG_DEFAULT);
    index = amxc_var_dyncast(uint32_t, var_index);
    when_true(index == 0, exit);
 
    inst = amxd_object_get_instance(object, NULL, index);
    amxd_object_free(&inst);
 
exit:
    return;
}

amxd_dm_findf()

amxd_object_t* amxd_dm_findf	(	amxd_dm_t *const	dm,
		const char *	abs_path,
			...
	)

Definition at line 470 of file amxd_dm.c.

                                  {
    amxd_object_t* object = NULL;
    amxd_object_t* root_obj = NULL;
    amxd_status_t status = amxd_status_ok;
    amxd_path_t path;
    va_list args;
    bool key_path = false;
 
    amxd_path_init(&path, NULL);
 
    when_null(dm, exit);
    root_obj = amxd_dm_get_root(dm);
 
    when_str_empty_status(abs_path, exit, object = root_obj);
 
    va_start(args, abs_path);
    status = amxd_path_vsetf(&path, true, abs_path, args);
    va_end(args);
    dm->status = status;
    when_failed(status, exit);
 
    object = amxd_object_find_internal(root_obj, &key_path, &path, &dm->status);
 
exit:
    amxd_path_clean(&path);
    return object;
}

amxd_dm_free_mib_object_it()

static void amxd_dm_free_mib_object_it ( amxc_llist_it_t *  it )

static

Definition at line 87 of file amxd_dm.c.

                                                            {
    amxd_object_t* object = amxc_llist_it_get_data(it, amxd_object_t, it);
    amxd_object_free(&object);
}

amxd_dm_get_mib()

amxd_object_t* amxd_dm_get_mib	(	amxd_dm_t *const	dm,
		const char *	name
	)

Definition at line 397 of file amxd_dm.c.

                                                 {
    amxd_object_t* mib = NULL;
 
    when_null(dm, exit);
    when_str_empty(name, exit);
 
    amxc_llist_for_each(it, (&dm->mibs)) {
        const char* mib_name = NULL;
        mib = amxc_llist_it_get_data(it, amxd_object_t, it);
        mib_name = amxd_object_get_name(mib, AMXD_OBJECT_NAMED);
        if((mib_name != NULL) && (strcmp(mib_name, name) == 0)) {
            break;
        }
        mib = NULL;
    }
 
exit:
    return mib;
}

amxd_dm_get_object()

amxd_object_t* amxd_dm_get_object	(	amxd_dm_t *const	dm,
		const char *	name
	)

Definition at line 466 of file amxd_dm.c.

                                                                         {
    return amxd_object_get_child(&dm->object, name);
}

amxd_dm_invoke_action()

amxd_status_t amxd_dm_invoke_action	(	amxd_object_t *	object,
		amxd_param_t *	param,
		amxd_action_t	reason,
		const amxc_var_t *const	args,
		amxc_var_t *const	retval
	)

Definition at line 591 of file amxd_dm.c.

                                                              {
    static int in_object_action = 0;
    static int in_param_action = 0;
    static amxd_object_t* current = NULL;
 
    amxd_object_t* temp = NULL;
    amxc_llist_t* cb_fns = NULL;
    int* counter = NULL;
    amxd_status_t status = amxd_status_function_not_implemented;
    when_true(object == NULL && param == NULL, exit);
    when_true_status(reason == action_any, exit, status = amxd_status_invalid_action);
 
    temp = current;
    if(param != NULL) {
        when_true_status(!amxd_dm_can_invoke_action(in_param_action, reason, current, object),
                         exit,
                         status = amxd_status_invalid_action);
        counter = &in_param_action;
        cb_fns = &param->cb_fns;
    } else {
        when_true_status(!amxd_dm_can_invoke_action(in_object_action + in_param_action,
                                                    reason, current, object),
                         exit,
                         status = amxd_status_invalid_action);
        counter = &in_object_action;
        cb_fns = &object->cb_fns;
    }
 
    (*counter)++;
    current = object;
    amxd_dm_invoke_action_start(object, param, reason);
    status = amxd_dm_invoke_action_impl(cb_fns, object, param, reason, args, retval);
    if(status == amxd_status_function_not_implemented) {
        status = amxd_dm_invoke_default(object, param, reason, args, retval);
    }
    (*counter)--;
    status = amxd_dm_invoke_action_end(object, param, status, reason, retval);
 
    current = temp;
 
exit:
    return status;
}

amxd_dm_invoke_action_base()

static amxd_status_t amxd_dm_invoke_action_base ( amxd_object_t *const  object, amxd_param_t *const  param, amxd_action_t  reason, const amxc_var_t *const  args, amxc_var_t *const  retval  )

static

Definition at line 128 of file amxd_dm.c.

                                                                          {
    amxd_status_t status = amxd_status_function_not_implemented;
    amxd_object_t* super = object;
    amxc_llist_t* cb_fns = NULL;
 
    while(super != NULL) {
        if(amxd_object_get_type(super) == amxd_object_instance) {
            super = amxd_object_get_parent(super);
        } else {
            super = (super->derived_from.llist == NULL) ?
                NULL :
                amxc_container_of(super->derived_from.llist,
                                  amxd_object_t,
                                  derived_objects);
        }
 
        if(param != NULL) {
            amxd_param_t* base_param =
                amxd_object_get_param_def(super,
                                          amxd_param_get_name(param));
            cb_fns = (base_param == NULL) ? NULL : &base_param->cb_fns;
        } else {
            cb_fns = (super == NULL) ? NULL : &super->cb_fns;
        }
 
        if(cb_fns != NULL) {
            status = amxd_dm_invoke_action_impl(cb_fns,
                                                object,
                                                param,
                                                reason,
                                                args,
                                                retval);
            if(status == amxd_status_function_not_implemented) {
                continue;
            }
            break;
        }
    }
 
    return status;
}

amxd_dm_invoke_action_end()

static amxd_status_t amxd_dm_invoke_action_end ( amxd_object_t *  object, amxd_param_t *  param, amxd_status_t  status, amxd_action_t  reason, amxc_var_t *  retval  )

static

Definition at line 277 of file amxd_dm.c.

                                                                   {
    amxd_status_t new_status = status;
    switch(reason) {
    case action_object_destroy:
        amxd_object_free(&object);
        new_status = amxd_status_ok;
        break;
    case action_param_destroy:
        amxd_param_free(&param);
        new_status = amxd_status_ok;
        break;
    case action_object_add_inst:
        if(status == amxd_status_ok) {
            new_status = amxd_dm_check_add_inst_retval(retval);
        } else {
            amxd_dm_cleanup_add_inst(object, retval);
        }
        break;
    default:
        break;
    }
 
    return new_status;
}

amxd_dm_invoke_action_impl()

static amxd_status_t amxd_dm_invoke_action_impl ( amxc_llist_t *  fns, amxd_object_t *  object, amxd_param_t *  param, amxd_action_t  reason, const amxc_var_t *const  args, amxc_var_t *const  retval  )

static

Definition at line 92 of file amxd_dm.c.

                                                                          {
    amxd_status_t status = amxd_status_function_not_implemented;
    amxc_var_clean(retval);
    amxc_llist_for_each(it, fns) {
        amxd_dm_cb_t* cb_fn = amxc_llist_it_get_data(it, amxd_dm_cb_t, it);
        if((cb_fn->reason != action_any) &&
           ((cb_fn->reason != reason) ||
            ( cb_fn->fn == NULL) ||
            ( !cb_fn->enable))) {
            continue;
        }
        status = cb_fn->fn(object, param, reason, args, retval, cb_fn->priv);
        if((reason == action_object_destroy) ||
           ( reason == action_param_destroy)) {
            if(((object != NULL) && amxd_object_has_action_cb(object, reason, cb_fn->fn)) ||
               (( param != NULL) && amxd_param_has_action_cb(param, reason, cb_fn->fn))) {
                amxc_llist_it_take(&cb_fn->it);
                free(it);
            }
            status = amxd_status_ok;
            continue;
        }
        if((status != amxd_status_ok) &&
           ( status != amxd_status_function_not_implemented)) {
            break;
        }
    }
 
    return status;
}

amxd_dm_invoke_action_start()

static void amxd_dm_invoke_action_start ( UNUSED amxd_object_t *  object, UNUSED amxd_param_t *  param, amxd_action_t  reason  )

static

Definition at line 265 of file amxd_dm.c.

                                                              {
    switch(reason) {
    case action_object_destroy:
        amxd_object_destroy_handlers(object);
        break;
    default:
        break;
    }
}

amxd_dm_invoke_default()

static amxd_status_t amxd_dm_invoke_default ( amxd_object_t *const  object, amxd_param_t *const  param, amxd_action_t  reason, const amxc_var_t *const  args, amxc_var_t *const  retval  )

static

Definition at line 209 of file amxd_dm.c.

                                                                      {
    amxd_status_t status =
        amxd_dm_invoke_action_base(object, param, reason, args, retval);
    if((status == amxd_status_function_not_implemented) &&
       ( default_actions[reason] != NULL)) {
        status = default_actions[reason](object,
                                         param,
                                         reason,
                                         args,
                                         retval,
                                         NULL);
    }
 
    return status;
}

amxd_dm_resolve_pathf()

amxd_status_t amxd_dm_resolve_pathf	(	amxd_dm_t *const	dm,
		amxc_llist_t *	paths,
		const char *	abs_path,
			...
	)

Definition at line 500 of file amxd_dm.c.

                                         {
    amxd_status_t status = amxd_status_unknown_error;
    amxd_object_t* root_obj = NULL;
    amxd_path_t path;
    va_list args;
    bool key_path = false;
 
    amxd_path_init(&path, NULL);
 
    when_null(dm, exit);
    root_obj = amxd_dm_get_root(dm);
 
    when_str_empty(abs_path, exit);
 
    va_start(args, abs_path);
    status = amxd_path_vsetf(&path, true, abs_path, args);
    va_end(args);
    when_failed(status, exit);
 
    status = amxd_object_resolve_internal(root_obj, &key_path, paths, &path);
 
exit:
    amxd_path_clean(&path);
    return status;
}

amxd_dm_resolve_pathf_ext()

amxd_status_t amxd_dm_resolve_pathf_ext	(	amxd_dm_t *const	dm,
		bool *	key_path,
		amxc_llist_t *	paths,
		const char *	abs_path,
			...
	)

Definition at line 529 of file amxd_dm.c.

                                             {
    amxd_status_t status = amxd_status_unknown_error;
    amxd_object_t* root_obj = NULL;
    amxd_path_t path;
    va_list args;
 
    amxd_path_init(&path, NULL);
 
    when_null(key_path, exit);
    when_null(dm, exit);
    root_obj = amxd_dm_get_root(dm);
    *key_path = false;
 
    when_str_empty(abs_path, exit);
 
    va_start(args, abs_path);
    status = amxd_path_vsetf(&path, true, abs_path, args);
    va_end(args);
    when_failed(status, exit);
 
    status = amxd_object_resolve_internal(root_obj, key_path, paths, &path);
 
exit:
    amxd_path_clean(&path);
    return status;
}

amxd_dm_store_mib()

amxd_status_t amxd_dm_store_mib	(	amxd_dm_t *const	dm,
		amxd_object_t *const	object
	)

Definition at line 378 of file amxd_dm.c.

                                                             {
    amxd_status_t retval = amxd_status_unknown_error;
    const char* mib_name = NULL;
    when_null(dm, exit);
    when_null(object, exit);
    when_true(amxd_object_get_type(object) != amxd_object_mib, exit);
    mib_name = amxd_object_get_name(object, AMXD_OBJECT_NAMED);
    when_true_status(amxd_dm_get_mib(dm, mib_name) != NULL,
                     exit,
                     retval = amxd_status_duplicate);
 
    amxc_llist_append(&dm->mibs, &object->it);
 
    retval = amxd_status_ok;
exit:
    return retval;
}

Variable Documentation

default_actions

amxd_action_fn_t default_actions[]

static

Initial value:

= {
    NULL,                        
    amxd_action_param_read,      
    amxd_action_param_write,     
    amxd_action_param_validate,  
    amxd_action_param_describe,  
    amxd_action_param_destroy,   
    amxd_action_object_read,     
    amxd_action_object_write,    
    amxd_action_object_validate, 
    amxd_action_object_list,     
    amxd_action_object_describe, 
    NULL,                        
    amxd_action_object_add_inst, 
    amxd_action_object_del_inst, 
    amxd_action_object_destroy,  
}

Definition at line 69 of file amxd_dm.c.