amxs_util.h File Reference

#include <amxs/amxs_types.h>
#include <amxs/amxs_sync_ctx.h>
#include <amxs/amxs_sync_object.h>
#include <amxs/amxs_sync_param.h>

Go to the source code of this file.

Functions
bool	amxs_sync_entry_remove_bidrection_object (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const char *path)
bool	amxs_sync_entry_check_bidrection_object (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const char *path, const char *opposite_path)
bool	amxs_sync_entry_check_bidirectional_loop (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *value, const char *path, const char *opposite_path)
bool	amxs_sync_entry_is_bidirectional (const amxs_sync_entry_t *entry)
bool	amxs_sync_entry_direction_allowed (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction)
bool	amxs_sync_entry_is_batch_param (const amxs_sync_entry_t *const entry)
const char *	amxs_sync_entry_get_name (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction)
const char *	amxs_sync_entry_get_opposite_name (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction)
amxs_sync_entry_t *	amxs_sync_entry_get_parent (const amxs_sync_entry_t *entry)
amxs_sync_ctx_t *	amxs_sync_entry_get_ctx (const amxs_sync_entry_t *entry)
amxp_signal_mngr_t *	amxs_sync_entry_get_signal_manager (const amxs_sync_entry_t *const entry)
amxb_bus_ctx_t *	amxs_sync_ctx_get_opposite_bus_ctx (const amxs_sync_ctx_t *ctx, amxs_sync_direction_t direction)
amxb_bus_ctx_t *	amxs_sync_ctx_get_bus_ctx (const amxs_sync_ctx_t *ctx, amxs_sync_direction_t direction)
amxd_dm_t *	amxs_sync_ctx_get_opposite_dm (const amxs_sync_ctx_t *ctx, amxs_sync_direction_t direction)
amxd_dm_t *	amxs_sync_ctx_get_dm (const amxs_sync_ctx_t *ctx, amxs_sync_direction_t direction)
unsigned int	amxs_sync_entry_get_opposite_index (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, unsigned int index)
char *	amxs_sync_entry_get_opposite_path (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const char *old_path)
char *	amxs_sync_entry_get_opposite_parent_path (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const char *old_path)
char *	amxs_sync_entry_get_regex_path (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction)
char *	amxs_sync_entry_get_regex_parent_path (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction)
amxs_status_t	amxs_sync_entry_get_batch_params (const amxs_sync_entry_t *const entry, amxc_var_t *params, amxs_sync_direction_t direction)
amxs_status_t	amxs_sync_param_copy_trans_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const amxc_var_t *input, amxc_var_t *output, void *priv)
	Translates data from a dm:object-changed event to data suited for an amxb_set call for a single parameter. More...
amxs_status_t	amxs_sync_batch_param_copy_trans_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const amxc_var_t *input, amxc_var_t *output, void *priv)
	Translates data from a dm:object-changed event to data suited for an amxb_set call for all parameters in the event that are marked as batch copy parameters. More...
amxs_status_t	amxs_sync_param_copy_action_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *data, void *priv)
	Sets the new parameter value. More...
amxs_status_t	amxs_sync_object_copy_trans_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const amxc_var_t *input, amxc_var_t *output, void *priv)
	Translates data from a dm:instance-added or dm:instance-removed event to data suited for an amxb call for this instance and all it's parameters. More...
amxs_status_t	amxs_sync_object_copy_action_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *data, void *priv)
	Adds, removes or updates an object with the given data using an amxb call. More...

Function Documentation

amxs_sync_ctx_get_bus_ctx()

amxb_bus_ctx_t* amxs_sync_ctx_get_bus_ctx	(	const amxs_sync_ctx_t *	ctx,
		amxs_sync_direction_t	direction
	)

Definition at line 343 of file amxs_util.c.

                                                                           {
    amxb_bus_ctx_t* bus_ctx = NULL;
    when_null(ctx, exit);
    when_false(ctx->type == amxs_sync_type_ctx, exit);
 
    bus_ctx = direction == amxs_sync_a_to_b ? ctx->bus_ctx_a : ctx->bus_ctx_b;
 
exit:
    return bus_ctx;
}

amxs_sync_ctx_get_dm()

amxd_dm_t* amxs_sync_ctx_get_dm	(	const amxs_sync_ctx_t *	ctx,
		amxs_sync_direction_t	direction
	)

Definition at line 367 of file amxs_util.c.

                                                                 {
    amxd_dm_t* dm = NULL;
    when_null(ctx, exit);
    when_false(ctx->type == amxs_sync_type_ctx, exit);
 
    dm = direction == amxs_sync_a_to_b ? ctx->local_dm_a : ctx->local_dm_b;
 
exit:
    return dm;
}

amxs_sync_ctx_get_opposite_bus_ctx()

amxb_bus_ctx_t* amxs_sync_ctx_get_opposite_bus_ctx	(	const amxs_sync_ctx_t *	ctx,
		amxs_sync_direction_t	direction
	)

Definition at line 331 of file amxs_util.c.

                                                                                    {
    amxb_bus_ctx_t* bus_ctx = NULL;
    when_null(ctx, exit);
    when_false(ctx->type == amxs_sync_type_ctx, exit);
 
    bus_ctx = direction == amxs_sync_a_to_b ? ctx->bus_ctx_b : ctx->bus_ctx_a;
 
exit:
    return bus_ctx;
}

amxs_sync_ctx_get_opposite_dm()

amxd_dm_t* amxs_sync_ctx_get_opposite_dm	(	const amxs_sync_ctx_t *	ctx,
		amxs_sync_direction_t	direction
	)

Definition at line 355 of file amxs_util.c.

                                                                          {
    amxd_dm_t* dm = NULL;
    when_null(ctx, exit);
    when_false(ctx->type == amxs_sync_type_ctx, exit);
 
    dm = direction == amxs_sync_a_to_b ? ctx->local_dm_b : ctx->local_dm_a;
 
exit:
    return dm;
}

amxs_sync_entry_check_bidirectional_loop()

bool amxs_sync_entry_check_bidirectional_loop	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		amxc_var_t *	value,
		const char *	path,
		const char *	opposite_path
	)

Definition at line 168 of file amxs_util.c.

                                                                         {
    bool ret = false;
    amxc_string_t str;
    amxc_var_t* current_list = NULL;
    amxc_var_t* opposite_list = NULL;
    amxc_var_t* current_table = NULL;
    amxc_var_t* opposite_table = NULL;
    amxc_var_t* value_storage = NULL;
    amxs_sync_ctx_t* ctx = amxs_sync_entry_get_ctx(entry);
 
    amxc_string_init(&str, 0);
 
    when_null(entry, exit);
    when_null(ctx, exit);
    when_null(value, exit);
    when_str_empty(path, exit);
    when_str_empty(opposite_path, exit);
    when_false(amxs_sync_entry_is_bidirectional(entry), exit);
 
    opposite_table = direction == amxs_sync_a_to_b ? &ctx->b_to_a : &ctx->a_to_b;
    current_table = direction == amxs_sync_a_to_b ? &ctx->a_to_b : &ctx->b_to_a;
 
    // Find current path in opposite table
    amxc_string_setf(&str, "%s%s", path, amxs_sync_entry_get_name(entry, direction));
    opposite_list = GET_ARG(opposite_table, amxc_string_get(&str, 0));
    if(opposite_list != NULL) {
        // Entry found, do the regular loop detection for parameters
        ret = amxs_sync_entry_check_bidirectional_param(opposite_list, value);
        when_true(ret, exit);
    }
 
    amxc_string_setf(&str, "%s%s", opposite_path, amxs_sync_entry_get_opposite_name(entry, direction));
    current_list = GET_ARG(current_table, amxc_string_get(&str, 0));
    if(current_list == NULL) {
        // Add the opposite path to the current ctx htable
        current_list = amxc_var_add_key(amxc_llist_t, current_table, amxc_string_get(&str, 0), NULL);
    }
 
    // Add the current value to the current list
    value_storage = amxc_var_add_new(current_list);
    amxc_var_copy(value_storage, value);
 
exit:
    amxc_string_clean(&str);
    return ret;
}

amxs_sync_entry_check_bidrection_object()

bool amxs_sync_entry_check_bidrection_object	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		const char *	path,
		const char *	opposite_path
	)

Definition at line 101 of file amxs_util.c.

                                                                        {
    bool ret = false;
    amxd_path_t check_path;
    amxc_var_t* opposite_list = NULL;
    amxc_var_t* current_list = NULL;
    amxc_var_t* opposite = NULL;
    amxs_sync_ctx_t* ctx = amxs_sync_entry_get_ctx(entry);
 
    amxd_path_init(&check_path, opposite_path);
 
    when_null(entry, exit);
    when_null(ctx, exit);
    when_str_empty(path, exit);
    when_str_empty(opposite_path, exit);
    when_false(amxs_sync_entry_is_bidirectional(entry), exit);
 
    opposite_list = direction == amxs_sync_a_to_b ? &ctx->b_to_a : &ctx->a_to_b;
    current_list = direction == amxs_sync_a_to_b ? &ctx->a_to_b : &ctx->b_to_a;
    opposite = GET_ARG(opposite_list, path);
 
    when_true(amxd_path_is_instance_path(&check_path), exit);
 
    if(opposite != NULL) {
        amxc_var_delete(&opposite);
        ret = true;
    } else {
        amxc_var_add_key(bool, current_list, opposite_path, true);
    }
 
exit:
    amxd_path_clean(&check_path);
    return ret;
}

amxs_sync_entry_direction_allowed()

bool amxs_sync_entry_direction_allowed	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction
	)

Definition at line 231 of file amxs_util.c.

                                                                        {
    bool ret = true;
 
    if((direction == amxs_sync_a_to_b) &&
       ((entry->attributes & AMXS_SYNC_ONLY_B_TO_A) != 0)) {
        ret = false;
        goto exit;
    }
 
    if((direction == amxs_sync_b_to_a) &&
       ((entry->attributes & AMXS_SYNC_ONLY_A_TO_B) != 0)) {
        ret = false;
        goto exit;
    }
 
exit:
    return ret;
}

amxs_sync_entry_get_batch_params()

amxs_status_t amxs_sync_entry_get_batch_params	(	const amxs_sync_entry_t *const	entry,
		amxc_var_t *	params,
		amxs_sync_direction_t	direction
	)

Definition at line 514 of file amxs_util.c.

                                                                                {
    amxs_status_t status = amxs_status_invalid_arg;
 
    when_null(entry, exit);
    when_null(params, exit);
    when_true_status(entry->type == amxs_sync_type_param, exit, status = amxs_status_invalid_type);
 
    amxc_llist_iterate(it, &entry->entries) {
        amxs_sync_entry_t* child = amxc_llist_it_get_data(it, amxs_sync_entry_t, it);
        if(!amxs_sync_entry_is_batch_param(child)) {
            continue;
        }
 
        if(!amxs_sync_entry_direction_allowed(child, direction)) {
            continue;
        }
 
        amxc_var_add(cstring_t, params, direction == amxs_sync_a_to_b ? child->a : child->b);
    }
 
    status = amxs_status_ok;
 
exit:
    return status;
}

amxs_sync_entry_get_ctx()

amxs_sync_ctx_t* amxs_sync_entry_get_ctx

(

const amxs_sync_entry_t *

entry

)

Definition at line 297 of file amxs_util.c.

                                                                               {
    amxs_sync_ctx_t* ctx = NULL;
    amxs_sync_entry_t* tmp = NULL;
    when_null(entry, exit);
 
    when_true_status(entry->type == amxs_sync_type_ctx, exit, ctx = (amxs_sync_ctx_t*) entry);
 
    tmp = amxs_sync_entry_get_parent(entry);
    while(tmp != NULL && tmp->type != amxs_sync_type_ctx) {
        tmp = amxs_sync_entry_get_parent(tmp);
    }
 
    if((tmp != NULL) && (tmp->type == amxs_sync_type_ctx)) {
        ctx = tmp;
    }
 
exit:
    return ctx;
}

amxs_sync_entry_get_name()

const char* amxs_sync_entry_get_name	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction
	)

Definition at line 264 of file amxs_util.c.

                                                                      {
    const char* name = NULL;
    when_null(entry, exit);
 
    name = direction == amxs_sync_a_to_b ? entry->a : entry->b;
 
exit:
    return name;
}

amxs_sync_entry_get_opposite_index()

unsigned int amxs_sync_entry_get_opposite_index	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		unsigned int	index
	)

amxs_sync_entry_get_opposite_name()

const char* amxs_sync_entry_get_opposite_name	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction
	)

Definition at line 275 of file amxs_util.c.

                                                                               {
    const char* opposite = NULL;
    when_null(entry, exit);
 
    opposite = direction == amxs_sync_a_to_b ? entry->b : entry->a;
 
exit:
    return opposite;
}

amxs_sync_entry_get_opposite_parent_path()

char* amxs_sync_entry_get_opposite_parent_path	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		const char *	old_path
	)

Definition at line 456 of file amxs_util.c.

                                                                           {
    char* new_path = NULL;
    amxs_sync_entry_t* parent = amxs_sync_entry_get_parent(entry);
    when_null(parent, exit);
 
    new_path = amxs_sync_entry_get_opposite_path(parent, direction, old_path);
 
exit:
    return new_path;
}

amxs_sync_entry_get_opposite_path()

char* amxs_sync_entry_get_opposite_path	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		const char *	old_path
	)

Definition at line 429 of file amxs_util.c.

                                                                    {
    char* new_path = NULL;
    amxc_string_t path_str;
    amxd_path_t path;
    const amxs_sync_entry_t* tmp = entry;
 
    when_null(entry, exit);
    when_str_empty(old_path, exit);
 
    amxd_path_init(&path, old_path);
    amxc_string_init(&path_str, 0);
 
    while(amxd_path_get_depth(&path) != 0 && tmp != NULL) {
        when_false(amxs_sync_entry_build_opposite_path_entry(tmp, direction, &path, &path_str) == 0, exit);
        tmp = amxs_sync_entry_get_parent(tmp);
    }
 
    new_path = amxc_string_take_buffer(&path_str);
 
exit:
    amxd_path_clean(&path);
    amxc_string_clean(&path_str);
    return new_path;
}

amxs_sync_entry_get_parent()

amxs_sync_entry_t* amxs_sync_entry_get_parent

(

const amxs_sync_entry_t *

entry

)

Definition at line 286 of file amxs_util.c.

                                                                                    {
    amxs_sync_entry_t* parent = NULL;
    when_null(entry, exit);
    when_false(amxc_llist_it_is_in_list(&entry->it), exit);
 
    parent = amxc_container_of(entry->it.llist, amxs_sync_entry_t, entries);
 
exit:
    return parent;
}

amxs_sync_entry_get_regex_parent_path()

char* amxs_sync_entry_get_regex_parent_path	(	const amxs_sync_entry_t *const	entry,
		amxs_sync_direction_t	direction
	)

Definition at line 502 of file amxs_util.c.

                                                                             {
    char* path = NULL;
    amxs_sync_entry_t* parent = amxs_sync_entry_get_parent(entry);
    when_null(parent, exit);
 
    path = amxs_sync_entry_get_regex_path(parent, direction);
 
exit:
    return path;
}

amxs_sync_entry_get_regex_path()

char* amxs_sync_entry_get_regex_path	(	const amxs_sync_entry_t *const	entry,
		amxs_sync_direction_t	direction
	)

Definition at line 469 of file amxs_util.c.

                                                                      {
    char* path_str = NULL;
    const amxs_sync_entry_t* tmp = entry;
    amxc_string_t str;
 
    when_null(entry, exit);
    amxc_string_init(&str, 0);
    amxc_string_set(&str, "$");
 
    while(tmp != NULL) {
        amxd_path_t path;
        const char* name = amxs_sync_entry_get_name(tmp, direction);
        when_str_empty(name, exit);
        amxd_path_init(&path, name);
 
        if((entry->type == amxs_sync_type_object) && (amxd_path_is_instance_path(&path) == false)) {
            amxc_string_prependf(&str, "%s([0-9]+\\.)?", name);
        } else {
            amxc_string_prependf(&str, "%s", name);
        }
        amxd_path_clean(&path);
        tmp = amxs_sync_entry_get_parent(tmp);
    }
    amxc_string_prependf(&str, "%s", "^");
 
    path_str = amxc_string_take_buffer(&str);
 
exit:
    amxc_string_clean(&str);
    return path_str;
}

amxs_sync_entry_get_signal_manager()

amxp_signal_mngr_t* amxs_sync_entry_get_signal_manager

(

const amxs_sync_entry_t *const

entry

)

Definition at line 317 of file amxs_util.c.

                                                                                             {
    amxp_signal_mngr_t* sig_mngr = NULL;
    amxs_sync_ctx_t* ctx = NULL;
 
    ctx = amxs_sync_entry_get_ctx(entry);
    when_null(ctx, exit);
 
    sig_mngr = ctx->sig_mngr;
 
exit:
    return sig_mngr;
}

amxs_sync_entry_is_batch_param()

bool amxs_sync_entry_is_batch_param

(

const amxs_sync_entry_t *const

entry

)

Definition at line 251 of file amxs_util.c.

                                                                          {
    bool ret = false;
 
    when_null(entry, exit);
    when_false(entry->type == amxs_sync_type_param, exit);
    when_true((entry->attributes & AMXS_SYNC_PARAM_BATCH) == 0, exit);
 
    ret = true;
 
exit:
    return ret;
}

amxs_sync_entry_is_bidirectional()

bool amxs_sync_entry_is_bidirectional

(

const amxs_sync_entry_t *

entry

)

Definition at line 219 of file amxs_util.c.

                                                                      {
    bool ret = true;
 
    when_null(entry, exit);
    if((entry->attributes & (AMXS_SYNC_ONLY_B_TO_A | AMXS_SYNC_ONLY_A_TO_B)) != 0) {
        ret = false;
    }
 
exit:
    return ret;
}

amxs_sync_entry_remove_bidrection_object()

bool amxs_sync_entry_remove_bidrection_object	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		const char *	path
	)

Definition at line 76 of file amxs_util.c.

                                                                {
    bool ret = false;
    amxc_var_t* opposite_list = NULL;
    amxc_var_t* opposite = NULL;
    amxs_sync_ctx_t* ctx = amxs_sync_entry_get_ctx(entry);
 
    when_null(entry, exit);
    when_null(ctx, exit);
    when_str_empty(path, exit);
    when_false(amxs_sync_entry_is_bidirectional(entry), exit);
 
    opposite_list = direction == amxs_sync_a_to_b ? &ctx->b_to_a : &ctx->a_to_b;
    opposite = GET_ARG(opposite_list, path);
 
    if(opposite != NULL) {
        amxc_var_delete(&opposite);
        ret = true;
    }
 
exit:
    return ret;
}