libamxo  4.3.4
Object Definition Language (ODL) parsing
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
Data Structures | Macros | Typedefs | Functions | Variables
amxo_parser_dm_sync_utils.c File Reference
#include "amxo_parser_priv.h"
#include "amxo_parser.tab.h"
#include "amxo_parser_hooks_priv.h"

Go to the source code of this file.

Data Structures

struct  _amxo_sync_data
 

Macros

#define _GNU_SOURCE
 
#define MSG_CREATION_FAILED    "Creation failed for %s and %s (direction = %d, status = %d)"
 
#define MSG_SET_DM_FAILED    "Set datamodel for %s and %s failed (direction = %d, status = %d)"
 
#define MSG_MUST_CONTAIN_SYNC_ENTRIES    "Object synchronisation must contain sub-entries"
 
#define MSG_BATCH_PARAM_WITH_CB    "Batch parameter synchronisation with callbacks have no effect"
 

Typedefs

typedef struct _amxo_sync_data amxo_sync_data_t
 
typedef amxs_status_t(* amxo_sync_add_item_fn_t) (amxs_sync_object_t *parent, amxs_sync_object_t *child)
 

Functions

static amxo_sync_data_t * amxo_parser_get_sync_data (amxo_parser_t *pctx)
 
static amxs_status_t amxo_parser_sync_add_item (amxo_parser_t *pctx, amxo_sync_data_t *data, amxo_sync_add_item_fn_t ctx_add, amxo_sync_add_item_fn_t object_add)
 
static amxd_dm_t * amxo_parser_get_sync_dm (amxo_parser_t *pctx, const char *path)
 
static void amxo_parser_sync_set_status (amxo_parser_t *pctx, amxs_status_t status)
 
amxs_sync_entry_type_t amxo_parser_get_sync_type (amxo_parser_t *pctx)
 
bool amxo_parser_is_sync_item (amxo_parser_t *pctx)
 
int amxo_parser_sync_update_flags (int direction)
 
void amxo_parser_del_sync_data (amxc_llist_it_t *it)
 
void amxo_parser_pop_sync_item (amxo_parser_t *pctx)
 
int amxo_parser_push_sync_ctx (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction)
 
int amxo_parser_push_sync_template (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction, const char *name)
 
int amxo_parser_push_sync_object (amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction)
 
int amxo_parser_push_sync_parameter (amxo_parser_t *pctx, const char *param_a, const char *param_b, int direction)
 
amxd_status_t amxo_parser_sync_set_translator (amxo_parser_t *pctx, amxs_translation_cb_t cb)
 
amxd_status_t amxo_parser_sync_set_action (amxo_parser_t *pctx, amxs_action_cb_t cb)
 
bool amxo_parser_sync_item_contains_entries (amxo_parser_t *pctx)
 
int amxo_parser_start_sync (amxc_llist_it_t *it)
 
void amxo_parser_stop_sync (amxc_llist_it_t *it)
 
void amxo_parser_sync_remove_invalid (amxo_parser_t *pctx)
 
amxs_sync_ctx_t * amxo_parser_sync_get (const char *sync_template)
 
 CONSTRUCTOR_LVL (110)
 
 DESTRUCTOR_LVL (110)
 

Variables

static amxc_htable_t sync_templates
 

Macro Definition Documentation

◆ _GNU_SOURCE

#define _GNU_SOURCE

Definition at line 55 of file amxo_parser_dm_sync_utils.c.

◆ MSG_BATCH_PARAM_WITH_CB

#define MSG_BATCH_PARAM_WITH_CB    "Batch parameter synchronisation with callbacks have no effect"

Definition at line 68 of file amxo_parser_dm_sync_utils.c.

◆ MSG_CREATION_FAILED

#define MSG_CREATION_FAILED    "Creation failed for %s and %s (direction = %d, status = %d)"

Definition at line 62 of file amxo_parser_dm_sync_utils.c.

◆ MSG_MUST_CONTAIN_SYNC_ENTRIES

#define MSG_MUST_CONTAIN_SYNC_ENTRIES    "Object synchronisation must contain sub-entries"

Definition at line 66 of file amxo_parser_dm_sync_utils.c.

◆ MSG_SET_DM_FAILED

#define MSG_SET_DM_FAILED    "Set datamodel for %s and %s failed (direction = %d, status = %d)"

Definition at line 64 of file amxo_parser_dm_sync_utils.c.

Typedef Documentation

◆ amxo_sync_add_item_fn_t

typedef amxs_status_t(* amxo_sync_add_item_fn_t) (amxs_sync_object_t *parent, amxs_sync_object_t *child)

Definition at line 77 of file amxo_parser_dm_sync_utils.c.

◆ amxo_sync_data_t

typedef struct _amxo_sync_data amxo_sync_data_t

Function Documentation

◆ amxo_parser_del_sync_data()

void amxo_parser_del_sync_data ( amxc_llist_it_t *  it)

Definition at line 183 of file amxo_parser_dm_sync_utils.c.

183  {
184  amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
185  when_null(data, exit);
186 
187  amxc_llist_it_take(it);
188  amxc_htable_it_clean(&data->hit, NULL);
189 
190  when_null(data->entry, exit);
191 
192  switch(data->entry->type) {
193  case amxs_sync_type_ctx:
194  amxs_sync_ctx_delete(&data->entry);
195  break;
196  case amxs_sync_type_object:
197  amxs_sync_object_delete(&data->entry);
198  break;
199  case amxs_sync_type_param:
200  amxs_sync_param_delete(&data->entry);
201  break;
202  default:
203  break;
204  }
205 
206 exit:
207  free(data);
208 }
_amxo_sync_data
Definition: amxo_parser_dm_sync_utils.c:71
_amxo_sync_data::hit
amxc_htable_it_t hit
Definition: amxo_parser_dm_sync_utils.c:74
_amxo_sync_data::entry
amxs_sync_entry_t * entry
Definition: amxo_parser_dm_sync_utils.c:72

◆ amxo_parser_get_sync_data()

static amxo_sync_data_t* amxo_parser_get_sync_data ( amxo_parser_t *  pctx)
static

Definition at line 82 of file amxo_parser_dm_sync_utils.c.

82  {
83  amxc_llist_it_t* it = amxc_llist_get_last(pctx->sync_contexts);
84  amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
85 
86  return data;
87 }
_amxo_parser::sync_contexts
amxc_llist_t * sync_contexts
Definition: amxo_types.h:290

◆ amxo_parser_get_sync_dm()

static amxd_dm_t* amxo_parser_get_sync_dm ( amxo_parser_t *  pctx,
const char *  path 
)
static

Definition at line 119 of file amxo_parser_dm_sync_utils.c.

120  {
121  amxd_dm_t* dm = amxd_object_get_dm(pctx->object);
122  dm = amxd_dm_findf(dm, "%s", path) == NULL? NULL:dm;
123  return dm;
124 }
_amxo_parser::object
amxd_object_t * object
Definition: amxo_types.h:262

◆ amxo_parser_get_sync_type()

amxs_sync_entry_type_t amxo_parser_get_sync_type ( amxo_parser_t *  pctx)

Definition at line 158 of file amxo_parser_dm_sync_utils.c.

158  {
159  amxs_sync_entry_type_t type = amxs_sync_type_invalid;
160  amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
161  when_null(sync_data, exit);
162  when_null(sync_data->entry, exit);
163 
164  type = sync_data->entry->type;
165 
166 exit:
167  return type;
168 }
amxo_parser_get_sync_data
static amxo_sync_data_t * amxo_parser_get_sync_data(amxo_parser_t *pctx)
Definition: amxo_parser_dm_sync_utils.c:82

◆ amxo_parser_is_sync_item()

bool amxo_parser_is_sync_item ( amxo_parser_t *  pctx)

Definition at line 170 of file amxo_parser_dm_sync_utils.c.

170  {
171  amxs_sync_entry_type_t type = amxo_parser_get_sync_type(pctx);
172  return (type == amxs_sync_type_object || type == amxs_sync_type_param);
173 }
amxo_parser_get_sync_type
amxs_sync_entry_type_t amxo_parser_get_sync_type(amxo_parser_t *pctx)
Definition: amxo_parser_dm_sync_utils.c:158

◆ amxo_parser_pop_sync_item()

void amxo_parser_pop_sync_item ( amxo_parser_t *  pctx)

Definition at line 210 of file amxo_parser_dm_sync_utils.c.

210  {
211  amxo_sync_data_t* data = NULL;
212  when_null(pctx->sync_contexts, exit);
213 
214  data = amxo_parser_get_sync_data(pctx);
215  amxc_llist_it_take(&data->it);
216  free(data);
217 
218 exit:
219  return;
220 }
_amxo_sync_data::it
amxc_llist_it_t it
Definition: amxo_parser_dm_sync_utils.c:73

◆ amxo_parser_push_sync_ctx()

int amxo_parser_push_sync_ctx ( amxo_parser_t *  pctx,
const char *  path_a,
const char *  path_b,
int  direction 
)

Definition at line 222 of file amxo_parser_dm_sync_utils.c.

225  {
226  amxs_status_t status = amxs_status_unknown_error;
227  amxc_string_t res_path_a;
228  amxc_string_t res_path_b;
229  amxd_dm_t* dm_a = NULL;
230  amxd_dm_t* dm_b = NULL;
231  amxo_sync_data_t* data =
232  (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
233 
234  amxc_string_init(&res_path_a, 0);
235  amxc_string_init(&res_path_b, 0);
236  when_null(data, exit);
237 
238  if(amxc_string_set_resolved(&res_path_a, path_a, &pctx->config) > 0) {
239  path_a = amxc_string_get(&res_path_a, 0);
240  }
241  if(amxc_string_set_resolved(&res_path_b, path_b, &pctx->config) > 0) {
242  path_b = amxc_string_get(&res_path_b, 0);
243  }
244 
245  status = amxs_sync_ctx_new(&data->entry, path_a, path_b, direction);
246  if(status != 0) {
247  amxo_parser_msg(pctx, MSG_CREATION_FAILED,
248  path_a, path_b, direction, status);
249  amxo_parser_sync_set_status(pctx, status);
250  data->entry = NULL;
251  goto exit;
252  }
253 
254  if((direction & AMXS_SYNC_ONLY_A_TO_B) == 0) {
255  dm_a = amxo_parser_get_sync_dm(pctx, path_a);
256  }
257  if((direction & AMXS_SYNC_ONLY_B_TO_A) == 0) {
258  dm_b = amxo_parser_get_sync_dm(pctx, path_b);
259  }
260 
261  status = amxs_sync_ctx_set_local_dm(data->entry, dm_a, dm_b);
262  if(status != 0) {
263  amxo_parser_msg(pctx, MSG_SET_DM_FAILED,
264  path_a, path_b, direction, status);
265  amxo_parser_sync_set_status(pctx, status);
266  goto exit;
267  }
268 
269  if(pctx->sync_contexts == NULL) {
270  amxc_llist_new(&pctx->sync_contexts);
271  }
272  amxc_llist_append(pctx->sync_contexts, &data->it);
273 
274 exit:
275  if(status != 0) {
276  if(data != NULL) {
277  amxo_parser_del_sync_data(&data->it);
278  }
279  }
280  amxc_string_clean(&res_path_a);
281  amxc_string_clean(&res_path_b);
282  return status;
283 }
amxo_parser_get_sync_dm
static amxd_dm_t * amxo_parser_get_sync_dm(amxo_parser_t *pctx, const char *path)
Definition: amxo_parser_dm_sync_utils.c:119
amxo_parser_sync_set_status
static void amxo_parser_sync_set_status(amxo_parser_t *pctx, amxs_status_t status)
Definition: amxo_parser_dm_sync_utils.c:126
MSG_SET_DM_FAILED
#define MSG_SET_DM_FAILED
Definition: amxo_parser_dm_sync_utils.c:64
MSG_CREATION_FAILED
#define MSG_CREATION_FAILED
Definition: amxo_parser_dm_sync_utils.c:62
amxo_parser_del_sync_data
void amxo_parser_del_sync_data(amxc_llist_it_t *it)
Definition: amxo_parser_dm_sync_utils.c:183
amxo_parser_msg
PRIVATE void amxo_parser_msg(amxo_parser_t *parser, const char *format,...) __attribute__((format(printf
_amxo_parser::config
amxc_var_t config
Definition: amxo_types.h:250

◆ amxo_parser_push_sync_object()

int amxo_parser_push_sync_object ( amxo_parser_t *  pctx,
const char *  path_a,
const char *  path_b,
int  direction 
)

Definition at line 320 of file amxo_parser_dm_sync_utils.c.

323  {
324  amxs_status_t status = amxs_status_unknown_error;
325  amxc_string_t res_a;
326  amxc_string_t res_b;
327  amxo_sync_data_t* data = NULL;
328 
329  amxc_string_init(&res_a, 0);
330  amxc_string_init(&res_b, 0);
331 
332  data = (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
333  when_null(data, exit);
334 
335  if(amxc_string_set_resolved(&res_a, path_a, &pctx->config) > 0) {
336  path_a = amxc_string_get(&res_a, 0);
337  }
338  if(amxc_string_set_resolved(&res_b, path_b, &pctx->config) > 0) {
339  path_b = amxc_string_get(&res_b, 0);
340  }
341 
342  status = amxs_sync_object_new_copy(&data->entry, path_a, path_b, direction);
343  when_failed_status(status, exit, data->entry = NULL);
344 
345  status = amxo_parser_sync_add_item(pctx, data,
346  amxs_sync_ctx_add_object,
347  amxs_sync_object_add_object);
348 
349 exit:
350  if(status != 0) {
351  amxo_parser_msg(pctx, MSG_CREATION_FAILED,
352  path_a, path_b, direction, status);
353  amxo_parser_sync_set_status(pctx, status);
354  if(data != NULL) {
355  amxs_sync_object_delete(&data->entry);
356  }
357  free(data);
358  }
359  amxc_string_clean(&res_a);
360  amxc_string_clean(&res_b);
361  return status;
362 }
amxo_parser_sync_add_item
static amxs_status_t amxo_parser_sync_add_item(amxo_parser_t *pctx, amxo_sync_data_t *data, amxo_sync_add_item_fn_t ctx_add, amxo_sync_add_item_fn_t object_add)
Definition: amxo_parser_dm_sync_utils.c:89

◆ amxo_parser_push_sync_parameter()

int amxo_parser_push_sync_parameter ( amxo_parser_t *  pctx,
const char *  param_a,
const char *  param_b,
int  direction 
)

Definition at line 364 of file amxo_parser_dm_sync_utils.c.

367  {
368  amxs_status_t status = amxs_status_unknown_error;
369  amxc_string_t res_a;
370  amxc_string_t res_b;
371  amxo_sync_data_t* data = NULL;
372 
373  amxc_string_init(&res_a, 0);
374  amxc_string_init(&res_b, 0);
375 
376  data = (amxo_sync_data_t*) calloc(1, sizeof(amxo_sync_data_t));
377  when_null(data, exit);
378 
379  if(amxc_string_set_resolved(&res_a, param_a, &pctx->config) > 0) {
380  param_a = amxc_string_get(&res_a, 0);
381  }
382  if(amxc_string_set_resolved(&res_b, param_b, &pctx->config) > 0) {
383  param_b = amxc_string_get(&res_b, 0);
384  }
385 
386  status = amxs_sync_param_new_copy(&data->entry, param_a, param_b, direction);
387  when_failed_status(status, exit, data->entry = NULL);
388 
389  status = amxo_parser_sync_add_item(pctx,
390  data,
391  amxs_sync_ctx_add_param,
392  amxs_sync_object_add_param);
393 
394 exit:
395  if(status != 0) {
396  amxo_parser_msg(pctx, MSG_CREATION_FAILED,
397  param_a, param_b, direction, status);
398  amxo_parser_sync_set_status(pctx, status);
399  if(data != NULL) {
400  amxs_sync_param_delete(&data->entry);
401  }
402  free(data);
403  }
404  amxc_string_clean(&res_a);
405  amxc_string_clean(&res_b);
406  return status;
407 }

◆ amxo_parser_push_sync_template()

int amxo_parser_push_sync_template ( amxo_parser_t *  pctx,
const char *  path_a,
const char *  path_b,
int  direction,
const char *  name 
)

Definition at line 285 of file amxo_parser_dm_sync_utils.c.

289  {
290  int status = amxs_status_unknown_error;
291  amxd_path_t path;
292  amxo_sync_data_t* data = NULL;
293  amxd_path_init(&path, NULL);
294 
295  status = amxo_parser_push_sync_ctx(pctx, path_a, path_b, direction);
296  when_failed(status, exit);
297 
298  data = amxo_parser_get_sync_data(pctx);
299  status = amxs_status_invalid_type;
300  amxd_path_setf(&path, false, "%s", data->entry->a);
301  when_true(amxd_path_is_instance_path(&path), exit);
302  when_false(amxd_path_is_supported_path(&path) || amxd_path_is_object_path(&path), exit);
303  amxd_path_setf(&path, false, "%s", data->entry->b);
304  when_true(amxd_path_is_instance_path(&path), exit);
305  when_false(amxd_path_is_supported_path(&path) || amxd_path_is_object_path(&path), exit);
306  status = amxs_status_ok;
307 
308  amxc_htable_insert(&sync_templates, name, &data->hit);
309 
310 exit:
311  if(status != 0) {
312  if(data != NULL) {
313  amxo_parser_del_sync_data(&data->it);
314  }
315  }
316  amxd_path_clean(&path);
317  return status;
318 }
sync_templates
static amxc_htable_t sync_templates
Definition: amxo_parser_dm_sync_utils.c:80
amxo_parser_push_sync_ctx
int amxo_parser_push_sync_ctx(amxo_parser_t *pctx, const char *path_a, const char *path_b, int direction)
Definition: amxo_parser_dm_sync_utils.c:222

◆ amxo_parser_start_sync()

int amxo_parser_start_sync ( amxc_llist_it_t *  it)

Definition at line 464 of file amxo_parser_dm_sync_utils.c.

464  {
465  int status = -1;
466  amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
467  when_null(data, exit);
468  when_null(data->entry, exit);
469  when_false(data->entry->type == amxs_sync_type_ctx, exit);
470 
471  if(amxc_htable_it_get_key(&data->hit) == NULL) {
472  if(!amxs_sync_ctx_is_started(data->entry)) {
473  status = amxs_sync_ctx_start_sync(data->entry);
474  }
475  } else {
476  status = 0;
477  }
478 
479 exit:
480  return status;
481 }

◆ amxo_parser_stop_sync()

void amxo_parser_stop_sync ( amxc_llist_it_t *  it)

Definition at line 483 of file amxo_parser_dm_sync_utils.c.

483  {
484  amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
485  when_null(data, exit);
486  when_null(data->entry, exit);
487  when_false(data->entry->type == amxs_sync_type_ctx, exit);
488 
489  if(amxc_htable_it_get_key(&data->hit) == NULL) {
490  amxs_sync_ctx_stop_sync(data->entry);
491  }
492 
493 exit:
494  return;
495 }

◆ amxo_parser_sync_add_item()

static amxs_status_t amxo_parser_sync_add_item ( amxo_parser_t *  pctx,
amxo_sync_data_t *  data,
amxo_sync_add_item_fn_t  ctx_add,
amxo_sync_add_item_fn_t  object_add 
)
static

Definition at line 89 of file amxo_parser_dm_sync_utils.c.

92  {
93  amxs_status_t status = amxs_status_unknown_error;
94  amxo_sync_data_t* parent = NULL;
95 
96  parent = amxo_parser_get_sync_data(pctx);
97  when_null(parent, exit);
98  when_null(parent->entry, exit);
99 
100  switch(parent->entry->type) {
101  case amxs_sync_type_ctx:
102  status = ctx_add(parent->entry, data->entry);
103  break;
104  case amxs_sync_type_object:
105  status = object_add(parent->entry, data->entry);
106  break;
107  default:
108  break;
109  }
110 
111  if(status == amxs_status_ok) {
112  amxc_llist_append(pctx->sync_contexts, &data->it);
113  }
114 
115 exit:
116  return status;
117 }

◆ amxo_parser_sync_get()

amxs_sync_ctx_t* amxo_parser_sync_get ( const char *  sync_template)

Definition at line 526 of file amxo_parser_dm_sync_utils.c.

526  {
527  amxs_sync_ctx_t* ctx = NULL;
528  amxo_sync_data_t* sync_data = NULL;
529  amxc_htable_it_t* hit = amxc_htable_get(&sync_templates, sync_template);
530 
531  when_null(hit, exit);
532  sync_data = amxc_container_of(hit, amxo_sync_data_t, hit);
533 
534  ctx = sync_data->entry;
535 
536 exit:
537  return ctx;
538 }

◆ amxo_parser_sync_item_contains_entries()

bool amxo_parser_sync_item_contains_entries ( amxo_parser_t *  pctx)

Definition at line 447 of file amxo_parser_dm_sync_utils.c.

447  {
448  bool retval = false;
449  amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
450  when_null(sync_data, exit);
451  when_null(sync_data->entry, exit);
452 
453  retval = true;
454  if(amxc_llist_is_empty(&sync_data->entry->entries)) {
455  amxo_parser_msg(pctx, MSG_MUST_CONTAIN_SYNC_ENTRIES);
456  pctx->status = amxd_status_invalid_action;
457  retval = false;
458  }
459 
460 exit:
461  return retval;
462 }
MSG_MUST_CONTAIN_SYNC_ENTRIES
#define MSG_MUST_CONTAIN_SYNC_ENTRIES
Definition: amxo_parser_dm_sync_utils.c:66
_amxo_parser::status
amxd_status_t status
Definition: amxo_types.h:258

◆ amxo_parser_sync_remove_invalid()

void amxo_parser_sync_remove_invalid ( amxo_parser_t *  pctx)

Definition at line 497 of file amxo_parser_dm_sync_utils.c.

497  {
498  when_null(pctx, exit);
499  when_null(pctx->sync_contexts, exit);
500 
501  amxc_llist_for_each_reverse(it, pctx->sync_contexts) {
502  amxo_sync_data_t* data = amxc_container_of(it, amxo_sync_data_t, it);
503  switch(data->entry->type) {
504  case amxs_sync_type_param:
505  case amxs_sync_type_object:
506  amxo_parser_del_sync_data(it);
507  break;
508  case amxs_sync_type_ctx:
509  if(amxc_llist_is_empty(&data->entry->entries)) {
510  amxo_parser_del_sync_data(it);
511  }
512  break;
513  default:
514  break;
515  }
516  }
517 
518  if(amxc_llist_is_empty(pctx->sync_contexts)) {
519  amxc_llist_delete(&pctx->sync_contexts, NULL);
520  }
521 
522 exit:
523  return;
524 }

◆ amxo_parser_sync_set_action()

amxd_status_t amxo_parser_sync_set_action ( amxo_parser_t *  pctx,
amxs_action_cb_t  cb 
)

Definition at line 428 of file amxo_parser_dm_sync_utils.c.

429  {
430  amxd_status_t status = amxd_status_unknown_error;
431  amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
432  when_null(sync_data, exit);
433  when_null(sync_data->entry, exit);
434 
435  if(amxs_sync_entry_is_batch_param(sync_data->entry)) {
436  amxo_parser_msg(pctx, MSG_BATCH_PARAM_WITH_CB);
437  pctx->status = amxd_status_invalid_action;
438  } else {
439  sync_data->entry->action_cb = cb;
440  status = amxd_status_ok;
441  }
442 
443 exit:
444  return status;
445 }
MSG_BATCH_PARAM_WITH_CB
#define MSG_BATCH_PARAM_WITH_CB
Definition: amxo_parser_dm_sync_utils.c:68

◆ amxo_parser_sync_set_status()

static void amxo_parser_sync_set_status ( amxo_parser_t *  pctx,
amxs_status_t  status 
)
static

Definition at line 126 of file amxo_parser_dm_sync_utils.c.

126  {
127  switch(status) {
128  case amxs_status_ok:
129  pctx->status = amxd_status_ok;
130  break;
131  case amxs_status_duplicate:
132  pctx->status = amxd_status_duplicate;
133  break;
134  case amxs_status_invalid_attr:
135  pctx->status = amxd_status_invalid_attr;
136  break;
137  case amxs_status_invalid_arg:
138  pctx->status = amxd_status_invalid_arg;
139  break;
140  case amxs_status_empty_context:
141  pctx->status = amxd_status_invalid_value;
142  break;
143  case amxs_status_invalid_type:
144  pctx->status = amxd_status_invalid_type;
145  break;
146  case amxs_status_object_not_found:
147  pctx->status = amxd_status_object_not_found;
148  break;
149  case amxs_status_subscription_failed:
150  pctx->status = amxd_status_function_not_found;
151  break;
152  default:
153  pctx->status = amxd_status_unknown_error;
154  break;
155  }
156 }

◆ amxo_parser_sync_set_translator()

amxd_status_t amxo_parser_sync_set_translator ( amxo_parser_t *  pctx,
amxs_translation_cb_t  cb 
)

Definition at line 409 of file amxo_parser_dm_sync_utils.c.

410  {
411  amxd_status_t status = amxd_status_unknown_error;
412  amxo_sync_data_t* sync_data = amxo_parser_get_sync_data(pctx);
413  when_null(sync_data, exit);
414  when_null(sync_data->entry, exit);
415 
416  if(amxs_sync_entry_is_batch_param(sync_data->entry)) {
417  amxo_parser_msg(pctx, MSG_BATCH_PARAM_WITH_CB);
418  pctx->status = amxd_status_invalid_action;
419  } else {
420  sync_data->entry->translation_cb = cb;
421  status = amxd_status_ok;
422  }
423 
424 exit:
425  return status;
426 }

◆ amxo_parser_sync_update_flags()

int amxo_parser_sync_update_flags ( int  direction)

Definition at line 175 of file amxo_parser_dm_sync_utils.c.

175  {
176  if((direction & AMXS_SYNC_ONLY_B_TO_A) == AMXS_SYNC_ONLY_B_TO_A) {
177  direction |= AMXS_SYNC_INIT_B;
178  }
179 
180  return direction;
181 }

◆ CONSTRUCTOR_LVL()

CONSTRUCTOR_LVL ( 110  )

Definition at line 540 of file amxo_parser_dm_sync_utils.c.

540  {
541  amxc_htable_init(&sync_templates, 10);
542 }

◆ DESTRUCTOR_LVL()

DESTRUCTOR_LVL ( 110  )

Definition at line 544 of file amxo_parser_dm_sync_utils.c.

544  {
545  amxc_htable_clean(&sync_templates, NULL);
546 }

Variable Documentation

◆ sync_templates

amxc_htable_t sync_templates
static

Definition at line 80 of file amxo_parser_dm_sync_utils.c.