amxd_action_param_write.c File Reference

#include <stdlib.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxd/amxd_types.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_action.h>
#include <amxd/amxd_parameter.h>
#include <amxd/amxd_object.h>
#include "amxd_priv.h"
#include "amxd_assert.h"

Go to the source code of this file.

Functions
amxd_status_t	amxd_action_param_write (amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, UNUSED amxc_var_t *const retval, UNUSED void *priv)
amxd_status_t	amxd_param_set_value (amxd_param_t *const param, const amxc_var_t *const value)

Function Documentation

amxd_action_param_write()

amxd_status_t amxd_action_param_write	(	amxd_object_t *	object,
		amxd_param_t *	param,
		amxd_action_t	reason,
		const amxc_var_t *const	args,
		UNUSED amxc_var_t *const	retval,
		UNUSED void *	priv
	)

Definition at line 69 of file amxd_action_param_write.c.

                                                         {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(param, exit);
    when_true_status(reason != action_param_write,
                     exit,
                     status = amxd_status_function_not_implemented);
 
    // key parameters are immutable, they can be written once, unless
    // marked as mutable key
    // so if the read-only attribute is not set the parameter can be changed,
    when_true_status((amxd_param_is_attr_set(param, amxd_pattr_key) &&
                      amxd_param_is_attr_set(param, amxd_pattr_read_only)),
                     exit,
                     status = amxd_status_invalid_attr);
 
    if(amxd_object_get_type(object) == amxd_object_instance) {
        when_false_status(amxd_param_is_unique(amxd_object_get_parent(object), object, param, args),
                          exit,
                          status = amxd_status_invalid_value);
    }
 
    when_failed_status(amxc_var_convert(&param->value,
                                        args,
                                        amxc_var_type_of(&param->value)),
                       exit,
                       status = amxd_status_invalid_value);
 
    // key parameters are immutable, once written they can not be changed
    if(amxd_param_is_attr_set(param, amxd_pattr_key) &&
       !amxd_param_is_attr_set(param, amxd_pattr_mutable)) {
        param->attr.read_only = 1;
    }
    status = amxd_status_ok;
 
exit:
    return status;
}

amxd_param_set_value()

amxd_status_t amxd_param_set_value	(	amxd_param_t *const	param,
		const amxc_var_t *const	value
	)

Definition at line 113 of file amxd_action_param_write.c.

                                                                  {
    amxd_status_t retval = amxd_status_unknown_error;
    amxc_var_t backup;
    amxd_object_t* object = NULL;
    int result = 0;
    amxc_var_init(&backup);
 
    when_null(param, exit);
    retval = amxc_var_compare(value, &param->value, &result) == 0 ?
        amxd_status_ok : amxd_status_unknown_error;
    // When the value is not changed, just leave
    when_true(retval == amxd_status_ok && result == 0, exit);
 
    retval = amxd_param_validate(param, value);
    when_failed(retval, exit);
    amxc_var_copy(&backup, &param->value);
 
    object = amxd_param_get_owner(param);
    retval = amxd_dm_invoke_action(object, param, action_param_write, value, NULL);
 
exit:
    if((retval != amxd_status_ok) &&
       ( param != NULL) &&
       !amxc_var_is_null(&backup)) {
        amxc_var_copy(&param->value, &backup);
    }
    amxc_var_clean(&backup);
    return retval;
}