amxs_util.c File Reference

#include <stdlib.h>
#include <string.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_path.h>
#include <amxd/amxd_transaction.h>
#include <amxd/amxd_dm.h>
#include <amxs/amxs_types.h>
#include <amxs/amxs_util.h>
#include "amxs_priv.h"

Go to the source code of this file.

Macros
#define	_GNU_SOURCE

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)
static bool	amxs_sync_entry_check_bidirectional_param (amxc_var_t *list, amxc_var_t *value)
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 *const 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 *const entry, amxs_sync_direction_t direction)
const char *	amxs_sync_entry_get_opposite_name (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction)
amxs_sync_entry_t *	amxs_sync_entry_get_parent (const amxs_sync_entry_t *const entry)
amxs_sync_ctx_t *	amxs_sync_entry_get_ctx (const amxs_sync_entry_t *const 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 *const ctx, amxs_sync_direction_t direction)
amxb_bus_ctx_t *	amxs_sync_ctx_get_bus_ctx (const amxs_sync_ctx_t *const 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 *const entry, UNUSED amxs_sync_direction_t direction, unsigned int index)
static int	amxs_sync_entry_build_opposite_path_entry (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction, amxd_path_t *path, amxc_string_t *path_str)
char *	amxs_sync_entry_get_opposite_path (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction, const char *const old_path)
char *	amxs_sync_entry_get_opposite_parent_path (const amxs_sync_entry_t *const entry, amxs_sync_direction_t direction, const char *const 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, UNUSED void *priv)
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, UNUSED void *priv)
amxs_status_t	amxs_sync_param_copy_action_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *data, UNUSED void *priv)
static void	amxs_notify_instance_added (const amxc_var_t *input, amxs_sync_entry_t *entry, const amxs_sync_direction_t direction)
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, UNUSED void *priv)
amxs_status_t	amxs_sync_object_copy_action_cb (const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *data, UNUSED void *priv)

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxs_util.c.

Function Documentation

amxs_notify_instance_added()

static void amxs_notify_instance_added ( const amxc_var_t *  input, amxs_sync_entry_t *  entry, const amxs_sync_direction_t  direction  )

static

Definition at line 742 of file amxs_util.c.

                                                                                                                                 {
    amxc_var_t* parameters = NULL;
    amxc_var_t* changed_value = NULL;
    amxc_var_t event_data;
    amxc_string_t str_object;
    amxc_string_t str_path;
    amxc_string_t str_new_value;
 
    amxc_var_init(&event_data);
    amxc_var_set_type(&event_data, AMXC_VAR_ID_HTABLE);
    amxc_string_init(&str_object, 0);
    amxc_string_init(&str_path, 0);
    amxc_string_init(&str_new_value, 0);
    amxc_string_setf(&str_object, "%s%d.", GET_CHAR(input, "object"), GET_UINT32(input, "index"));
    amxc_string_setf(&str_path, "%s%d.", GET_CHAR(input, "path"), GET_UINT32(input, "index"));
    amxc_string_setf(&str_new_value, "parameters.%s", amxs_sync_entry_get_name(entry, direction));
 
    amxc_var_add_key(cstring_t, &event_data, "notification", "dm:object-changed");
    amxc_var_add_key(cstring_t, &event_data, "object", amxc_string_get(&str_object, 0));
 
    parameters = amxc_var_add_key(amxc_htable_t, &event_data, "parameters", NULL);
    changed_value = amxc_var_add_key(amxc_htable_t, parameters, amxs_sync_entry_get_name(entry, direction), NULL);
    amxc_var_set_key(changed_value, "from", NULL, AMXC_VAR_FLAG_DEFAULT);
    amxc_var_set_key(changed_value, "to", GETP_ARG(input, amxc_string_get(&str_new_value, 0)), AMXC_VAR_FLAG_DEFAULT);
 
    amxc_var_add_key(cstring_t, &event_data, "path", amxc_string_get(&str_path, 0));
    amxp_sigmngr_emit_signal(amxs_sync_entry_get_signal_manager(entry), "sync:instance-added", &event_data);
 
    amxc_var_clean(&event_data);
    amxc_string_clean(&str_new_value);
    amxc_string_clean(&str_path);
    amxc_string_clean(&str_object);
}

amxs_sync_batch_param_copy_trans_cb()

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,
		UNUSED void *	priv
	)

Definition at line 617 of file amxs_util.c.

                                                                     {
    amxs_status_t status = amxs_status_unknown_error;
    amxc_var_t* params = GET_ARG(input, "parameters");
    amxc_var_t* output_params = NULL;
    const char* path = GET_CHAR(input, "path");
    const char* notification = GET_CHAR(input, "notification");
    const char* entry_name = amxs_sync_entry_get_name(entry, direction);
    char* opposite_path = NULL;
 
    when_null(params, exit);
    when_str_empty(path, exit);
    when_str_empty(entry_name, exit);
    when_str_empty(notification, exit);
 
    opposite_path = amxs_sync_entry_get_opposite_path(entry, direction, path);
    when_str_empty(opposite_path, exit);
 
    amxc_var_set_type(output, AMXC_VAR_ID_HTABLE);
    output_params = amxc_var_add_key(amxc_htable_t, output, "parameters", NULL);
    amxc_var_add_key(cstring_t, output, "path", opposite_path);
 
    if((strcmp(notification, "dm:object-added") == 0) ||
       (strcmp(notification, "sync:init-batch-param") == 0)) {
        // Handle loop prevention, returns true if this object-added is to be ignored
        if(amxs_sync_entry_check_bidrection_object(entry, direction, path, opposite_path)) {
            status = amxs_status_ok;
            goto exit;
        }
    } else {
        amxs_sync_entry_remove_bidrection_object(entry, direction, path);
        if(strcmp(notification, "dm:object-removed") == 0) {
            status = amxs_status_ok;
            goto exit;
        }
    }
 
 
    amxc_llist_iterate(it, &entry->entries) {
        amxs_sync_entry_t* child = amxc_llist_it_get_data(it, amxs_sync_entry_t, it);
        amxc_var_t* param = NULL;
        amxc_var_t* new_param = NULL;
        amxc_var_t* value = NULL;
 
        if(!amxs_sync_entry_is_batch_param(child)) {
            continue;
        }
 
        param = GETP_ARG(params, amxs_sync_entry_get_name(child, direction));
        if(param == NULL) {
            continue;
        }
 
        if((strcmp(notification, "sync:init-batch-param") == 0) ||
           (strcmp(notification, "dm:object-added") == 0)) {
            value = param;
        } else {
            value = GET_ARG(param, "to");
        }
 
        // Handle loop prevention, returns true if this parameter is to be ignored
        if(strcmp(notification, "dm:object-added") != 0) {
            if(amxs_sync_entry_check_bidirectional_loop(child, direction, value, path, opposite_path)) {
                continue;
            }
        }
 
        new_param = amxc_var_add_new_key(output_params, amxs_sync_entry_get_opposite_name(child, direction));
        amxc_var_copy(new_param, value);
    }
 
    status = amxs_status_ok;
 
exit:
    free(opposite_path);
    return status;
}

amxs_sync_ctx_get_bus_ctx()

amxb_bus_ctx_t* amxs_sync_ctx_get_bus_ctx	(	const amxs_sync_ctx_t *const	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 *const	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_build_opposite_path_entry()

static int amxs_sync_entry_build_opposite_path_entry ( const amxs_sync_entry_t *const  entry, amxs_sync_direction_t  direction, amxd_path_t *  path, amxc_string_t *  path_str  )

static

Definition at line 391 of file amxs_util.c.

                                                                              {
    char* last = amxd_path_get_last(path, true);
    char* ptr = NULL;
    unsigned int index = strtoul(last, &ptr, 0);
    int ret = -1;
    const char* name = amxs_sync_entry_get_name(entry, direction);
    amxc_string_t str;
 
    amxc_string_init(&str, 0);
 
    if(strcmp(name, last) == 0) {
        amxc_string_prependf(path_str, "%s", amxs_sync_entry_get_opposite_name(entry, direction));
    } else if(strstr(name, last) != NULL) {
        amxc_string_set(&str, last);
        do {
            free(last);
            last = amxd_path_get_last(path, true);
            when_null(last, exit);
            amxc_string_prependf(&str, "%s", last);
        } while(strcmp(amxc_string_get(&str, 0), name) != 0);
        amxc_string_prependf(path_str, "%s", amxs_sync_entry_get_opposite_name(entry, direction));
    } else if(last != ptr) {
        index = amxs_sync_entry_get_opposite_index(entry, direction, index);
        amxc_string_prependf(path_str, "%u.", index);
        amxs_sync_entry_build_opposite_path_entry(entry, direction, path, path_str);
    }
 
    ret = 0;
 
exit:
    free(last);
    amxc_string_clean(&str);
    return ret;
}

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_bidirectional_param()

static bool amxs_sync_entry_check_bidirectional_param ( amxc_var_t *  list, amxc_var_t *  value  )

static

Definition at line 138 of file amxs_util.c.

                                                                         {
    bool ret = false;
 
    when_null(list, exit);
    when_null(value, exit);
 
    amxc_var_for_each(var, list) {
        int count = 1;
        int result = 0;
 
        if((amxc_var_compare(value, var, &result) == 0) && (result == 0)) {
            amxc_var_for_each(var_rm, list) {
                amxc_var_take_it(var_rm);
                amxc_var_delete(&var_rm);
                count--;
                if(count == 0) {
                    break;
                }
            }
            ret = true;
            goto exit;
        }
        count++;
    }
 
exit:
    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 *const	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 *const

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 *const	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 *const	entry,
		UNUSED amxs_sync_direction_t	direction,
		unsigned int	index
	)

Definition at line 379 of file amxs_util.c.

                                                                    {
    int new_index = 0;
    when_null(entry, exit);
 
    new_index = index;
 
exit:
    return new_index;
}

amxs_sync_entry_get_opposite_name()

const char* amxs_sync_entry_get_opposite_name	(	const amxs_sync_entry_t *const	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 *const	entry,
		amxs_sync_direction_t	direction,
		const char *const	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 *const	entry,
		amxs_sync_direction_t	direction,
		const char *const	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 *const

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;
}

amxs_sync_object_copy_action_cb()

amxs_status_t amxs_sync_object_copy_action_cb	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		amxc_var_t *	data,
		UNUSED void *	priv
	)

Definition at line 833 of file amxs_util.c.

                                                                 {
    amxs_status_t status = amxs_status_unknown_error;
    const char* path = GET_CHAR(data, "path");
    const char* notification = GET_CHAR(data, "notification");
    uint32_t index = GET_UINT32(data, "index");
    amxb_bus_ctx_t* bus_ctx = NULL;
    amxc_var_t ret;
 
    amxc_var_init(&ret);
 
    when_null(path, exit);
    when_null(notification, exit);
 
    bus_ctx = amxs_sync_ctx_get_opposite_bus_ctx(amxs_sync_entry_get_ctx(entry), direction);
    when_null(bus_ctx, exit);
 
    if((strcmp(notification, "dm:instance-added") == 0) ||
       (strcmp(notification, "sync:init-object") == 0)) {
        amxc_var_t* params = GET_ARG(data, "parameters");
        amxc_string_t str;
        amxc_string_init(&str, 0);
        amxc_string_setf(&str, "%s%u.", path, index);
        if((amxb_get(bus_ctx, amxc_string_get(&str, 0), 0, &ret, 5) == 0) &&
           (GETP_ARG(&ret, "0.0") != NULL)) {
            if(amxb_set(bus_ctx, amxc_string_get(&str, 0), params, &ret, 5) == 0) {
                status = amxs_status_ok;
            }
        } else {
            if(amxb_add(bus_ctx, path, index, NULL, params, &ret, 5) == 0) {
                status = amxs_status_ok;
            }
        }
        amxc_string_clean(&str);
    } else {
        if(amxb_del(bus_ctx, path, index, NULL, &ret, 5) == 0) {
            status = amxs_status_ok;
        }
    }
 
exit:
    amxc_var_clean(&ret);
    return status;
}

amxs_sync_object_copy_trans_cb()

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,
		UNUSED void *	priv
	)

Definition at line 776 of file amxs_util.c.

                                                                {
    amxs_status_t status = amxs_status_unknown_error;
    const char* path = GET_CHAR(input, "path");
    char* opposite_path = NULL;
    const char* notification = GET_CHAR(input, "notification");
 
    when_str_empty(path, exit);
    when_str_empty(notification, exit);
    opposite_path = amxs_sync_entry_get_opposite_path(entry, direction, path);
    when_str_empty(opposite_path, exit);
 
    amxc_var_set_type(output, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(cstring_t, output, "path", opposite_path);
    amxc_var_add_key(uint32_t, output, "index",
                     amxs_sync_entry_get_opposite_index(entry, direction, GET_UINT32(input, "index")));
    amxc_var_add_key(cstring_t, output, "notification", notification);
 
    if(((strcmp("dm:instance-added", notification) == 0) ||
        (strcmp("sync:init-object", notification) == 0)) &&
       (GET_ARG(input, "parameters") != NULL)) {
        amxc_var_t* params = GET_ARG(input, "parameters");
        amxc_var_t* output_params = amxc_var_add_new_key(output, "parameters");
        amxc_var_set_type(output_params, AMXC_VAR_ID_HTABLE);
 
        amxc_llist_for_each(it, &entry->entries) {
            amxs_sync_entry_t* child = amxc_container_of(it, amxs_sync_entry_t, it);
            if(child->type != amxs_sync_type_param) {
                continue;
            }
            amxc_var_for_each(param, params) {
                if(strcmp(amxc_var_key(param), amxs_sync_entry_get_name(child, direction)) == 0) {
                    amxc_var_t* new_param = amxc_var_add_new_key(output_params, amxs_sync_entry_get_opposite_name(child, direction));
                    amxc_var_copy(new_param, param);
                }
            }
 
            /* Emit a sync:instance-added signal for each non batch parameter */
            if((amxs_sync_entry_is_batch_param(child) == false) &&
               (GET_CHAR(input, "object") != NULL) &&
               (GET_CHAR(input, "path") != NULL) &&
               (strcmp("dm:instance-added", notification) == 0)) {
                amxs_notify_instance_added(input, child, direction);
            }
        }
    }
 
    status = amxs_status_ok;
 
exit:
    free(opposite_path);
    return status;
}

amxs_sync_param_copy_action_cb()

amxs_status_t amxs_sync_param_copy_action_cb	(	const amxs_sync_entry_t *	entry,
		amxs_sync_direction_t	direction,
		amxc_var_t *	data,
		UNUSED void *	priv
	)

Definition at line 698 of file amxs_util.c.

                                                                {
    amxs_status_t status = amxs_status_unknown_error;
    const char* path = GET_CHAR(data, "path");
    amxc_var_t* params = GET_ARG(data, "parameters");
    amxb_bus_ctx_t* bus_ctx = NULL;
    amxc_var_t ret;
    amxd_dm_t* dm = NULL;
 
    amxc_var_init(&ret);
 
    when_null(path, exit);
    when_null(params, exit);
 
    dm = amxs_sync_ctx_get_opposite_dm(amxs_sync_entry_get_ctx(entry), direction);
    if(dm != NULL) {
        amxd_trans_t trans;
 
        amxd_trans_init(&trans);
        amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
        amxd_trans_select_pathf(&trans, "%s", path);
        amxc_var_for_each(var, params) {
            amxd_trans_set_param(&trans, amxc_var_key(var), var);
        }
 
        if(amxd_trans_apply(&trans, dm) == 0) {
            status = amxs_status_ok;
        }
        amxd_trans_clean(&trans);
    } else {
        bus_ctx = amxs_sync_ctx_get_opposite_bus_ctx(amxs_sync_entry_get_ctx(entry), direction);
        when_null(bus_ctx, exit);
        if(amxb_set(bus_ctx, path, params, &ret, 5) == 0) {
            status = amxs_status_ok;
        }
    }
 
exit:
    amxc_var_clean(&ret);
    return status;
}

amxs_sync_param_copy_trans_cb()

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,
		UNUSED void *	priv
	)

Definition at line 542 of file amxs_util.c.

                                                               {
    amxs_status_t status = amxs_status_unknown_error;
    amxc_var_t* params = GET_ARG(input, "parameters");
    amxc_var_t* output_params = NULL;
    const char* path = GET_CHAR(input, "path");
    const char* notification = GET_CHAR(input, "notification");
    const char* entry_name = amxs_sync_entry_get_name(entry, direction);
    char* opposite_path = NULL;
    amxs_sync_entry_t* parent_entry = amxs_sync_entry_get_parent(entry);
 
    when_null(params, exit);
    when_str_empty(path, exit);
    when_str_empty(entry_name, exit);
    when_str_empty(notification, exit);
 
    opposite_path = amxs_sync_entry_get_opposite_parent_path(entry, direction, path);
    when_str_empty(opposite_path, exit);
 
    amxc_var_set_type(output, AMXC_VAR_ID_HTABLE);
    output_params = amxc_var_add_key(amxc_htable_t, output, "parameters", NULL);
    amxc_var_add_key(cstring_t, output, "path", opposite_path);
 
    // When doing initial sync, protect agains loop-back add-object events
    if((strcmp(notification, "dm:object-added") == 0) ||
       (strcmp(notification, "sync:init-param") == 0)) {
        // This translation callback function is called on parameter entries
        // Here the object entry is needed, take parent.
        // Handle loop prevention, returns true if this object-added is to be ignored
        if(amxs_sync_entry_check_bidrection_object(parent_entry, direction, path, opposite_path)) {
            status = amxs_status_ok;
            goto exit;
        }
    } else {
        amxs_sync_entry_remove_bidrection_object(parent_entry, direction, path);
        if(strcmp(notification, "dm:object-removed") == 0) {
            status = amxs_status_ok;
            goto exit;
        }
    }
 
    amxc_var_for_each(param, params) {
        if(strcmp(amxc_var_key(param), entry_name) == 0) {
            amxc_var_t* value = NULL;
            amxc_var_t* new_param = NULL;
 
            if((strcmp(notification, "sync:init-param") == 0) ||
               (strcmp(notification, "dm:object-added") == 0)) {
                value = param;
            } else {
                value = GET_ARG(param, "to");
            }
 
            // Handle loop prevention, returns true if this parameter is to be ignored
            if(strcmp(notification, "dm:object-added") != 0) {
                if(amxs_sync_entry_check_bidirectional_loop(entry, direction, value, path, opposite_path)) {
                    continue;
                }
            }
 
            new_param = amxc_var_add_new_key(output_params, amxs_sync_entry_get_opposite_name(entry, direction));
            amxc_var_copy(new_param, value);
        }
    }
 
    status = amxs_status_ok;
 
exit:
    free(opposite_path);
    return status;
}