libamxd  6.4.1
Data Model Manager
amxd_dm_priv.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <string.h>
57 
58 #include "amxd_priv.h"
59 
60 #include <amxd/amxd_dm.h>
61 #include <amxd/amxd_action.h>
62 #include <amxd/amxd_object.h>
63 #include <amxd/amxd_dm_functions.h>
64 
65 #include "amxd_dm_priv.h"
66 #include "amxd_object_priv.h"
67 #include "amxd_assert.h"
68 
69 static amxc_llist_t base_objects;
70 static amxd_object_t base_singleton;
71 static amxd_object_t base_template;
72 
73 static amxd_status_t amxd_object_add_list_func(amxd_object_t* object) {
74  amxd_status_t retval = amxd_status_unknown_error;
75  amxc_var_t def_val;
76  amxd_function_t* func = NULL;
77 
78  amxc_var_init(&def_val);
79  amxc_var_set(bool, &def_val, true);
80 
81  retval = amxd_function_new(&func, "_list", AMXC_VAR_ID_HTABLE, amxd_object_func_list);
82  when_failed(retval, exit);
83  amxd_function_set_attr(func, amxd_fattr_template, true);
84  amxd_function_set_attr(func, amxd_fattr_instance, true);
85  amxd_function_set_attr(func, amxd_fattr_protected, true);
86  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_BOOL, &def_val);
87  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
88  when_failed(retval, exit);
89  retval = amxd_function_new_arg(func, "functions", AMXC_VAR_ID_BOOL, &def_val);
90  amxd_function_arg_set_attr(func, "functions", amxd_aattr_in, true);
91  when_failed(retval, exit);
92  retval = amxd_function_new_arg(func, "objects", AMXC_VAR_ID_BOOL, &def_val);
93  amxd_function_arg_set_attr(func, "objects", amxd_aattr_in, true);
94  when_failed(retval, exit);
95  retval = amxd_function_new_arg(func, "instances", AMXC_VAR_ID_BOOL, &def_val);
96  amxd_function_arg_set_attr(func, "instances", amxd_aattr_in, true);
97  when_failed(retval, exit);
98  retval = amxd_function_new_arg(func, "template_info", AMXC_VAR_ID_BOOL, &def_val);
99  amxd_function_arg_set_attr(func, "template_info", amxd_aattr_in, true);
100  when_failed(retval, exit);
101  amxc_var_set(bool, &def_val, false);
102  retval = amxd_function_new_arg(func, "events", AMXC_VAR_ID_BOOL, &def_val);
103  amxd_function_arg_set_attr(func, "events", amxd_aattr_in, true);
104  when_failed(retval, exit);
105  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
106  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
107  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
108  when_failed(retval, exit);
109  amxc_var_set(cstring_t, &def_val, "");
110  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
111  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
112  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
113  when_failed(retval, exit);
114 
115  retval = amxd_object_add_function(object, func);
116 
117 exit:
118  if(retval != 0) {
119  amxd_function_delete(&func);
120  }
121  amxc_var_clean(&def_val);
122  return retval;
123 }
124 
125 static amxd_status_t amxd_object_add_get_func(amxd_object_t* object) {
126  amxd_status_t retval = amxd_status_unknown_error;
127  amxc_var_t def_val;
128  amxd_function_t* func = NULL;
129 
130  amxc_var_init(&def_val);
131  amxc_var_set(cstring_t, &def_val, ".");
132 
133  retval = amxd_function_new(&func, "_get", AMXC_VAR_ID_HTABLE, amxd_object_func_get);
134  when_failed(retval, exit);
135  amxd_function_set_attr(func, amxd_fattr_template, true);
136  amxd_function_set_attr(func, amxd_fattr_instance, true);
137  amxd_function_set_attr(func, amxd_fattr_protected, true);
138  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
139  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
140  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
141  amxc_var_set_type(&def_val, AMXC_VAR_ID_LIST);
142  when_failed(retval, exit);
143  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_LIST, &def_val);
144  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
145  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_strict, true);
146  when_failed(retval, exit);
147  amxc_var_set(uint32_t, &def_val, 0);
148  retval = amxd_function_new_arg(func, "depth", AMXC_VAR_ID_INT32, &def_val);
149  amxd_function_arg_set_attr(func, "depth", amxd_aattr_in, true);
150  when_failed(retval, exit);
151  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
152  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
153  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
154  when_failed(retval, exit);
155  retval = amxd_function_new_arg(func, "filter", AMXC_VAR_ID_CSTRING, NULL);
156  amxd_function_arg_set_attr(func, "filter", amxd_aattr_in, true);
157  amxd_function_arg_set_attr(func, "filter", amxd_aattr_strict, true);
158  when_failed(retval, exit);
159 
160  retval = amxd_object_add_function(object, func);
161 
162 exit:
163  if(retval != 0) {
164  amxd_function_delete(&func);
165  }
166  amxc_var_clean(&def_val);
167  return retval;
168 }
169 
170 static amxd_status_t amxd_object_add_get_instances_func(amxd_object_t* object) {
171  amxd_status_t retval = amxd_status_unknown_error;
172  amxc_var_t def_val;
173  amxd_function_t* func = NULL;
174 
175  amxc_var_init(&def_val);
176  amxc_var_set(cstring_t, &def_val, ".");
177 
178  retval = amxd_function_new(&func, "_get_instances", AMXC_VAR_ID_HTABLE, amxd_object_func_get_instances);
179  when_failed(retval, exit);
180  amxd_function_set_attr(func, amxd_fattr_template, true);
181  amxd_function_set_attr(func, amxd_fattr_instance, true);
182  amxd_function_set_attr(func, amxd_fattr_protected, true);
183  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
184  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
185  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
186  when_failed(retval, exit);
187  amxc_var_set(uint32_t, &def_val, 0);
188  retval = amxd_function_new_arg(func, "depth", AMXC_VAR_ID_INT32, &def_val);
189  amxd_function_arg_set_attr(func, "depth", amxd_aattr_in, true);
190  when_failed(retval, exit);
191  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
192  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
193  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
194  when_failed(retval, exit);
195 
196  retval = amxd_object_add_function(object, func);
197 
198 exit:
199  if(retval != 0) {
200  amxd_function_delete(&func);
201  }
202  amxc_var_clean(&def_val);
203  return retval;
204 }
205 
206 static amxd_status_t amxd_object_add_get_supported_func(amxd_object_t* object) {
207  amxd_status_t retval = amxd_status_unknown_error;
208  amxc_var_t def_val;
209  amxd_function_t* func = NULL;
210 
211  amxc_var_init(&def_val);
212  amxc_var_set(bool, &def_val, true);
213 
214  retval = amxd_function_new(&func,
215  "_get_supported",
216  AMXC_VAR_ID_HTABLE,
217  amxd_object_func_get_supported);
218  when_failed(retval, exit);
219  amxd_function_set_attr(func, amxd_fattr_template, true);
220  amxd_function_set_attr(func, amxd_fattr_instance, true);
221  amxd_function_set_attr(func, amxd_fattr_protected, true);
222  retval = amxd_function_new_arg(func, "first_level_only", AMXC_VAR_ID_BOOL, &def_val);
223  amxd_function_arg_set_attr(func, "first_level_only", amxd_aattr_in, true);
224  when_failed(retval, exit);
225  amxc_var_set(bool, &def_val, false);
226  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_BOOL, &def_val);
227  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
228  when_failed(retval, exit);
229  retval = amxd_function_new_arg(func, "functions", AMXC_VAR_ID_BOOL, &def_val);
230  amxd_function_arg_set_attr(func, "functions", amxd_aattr_in, true);
231  when_failed(retval, exit);
232  retval = amxd_function_new_arg(func, "events", AMXC_VAR_ID_BOOL, &def_val);
233  amxd_function_arg_set_attr(func, "events", amxd_aattr_in, true);
234  when_failed(retval, exit);
235  amxc_var_set(cstring_t, &def_val, "");
236  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
237  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
238  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
239  when_failed(retval, exit);
240  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
241  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
242  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
243  when_failed(retval, exit);
244 
245  retval = amxd_object_add_function(object, func);
246 
247 exit:
248  if(retval != 0) {
249  amxd_function_delete(&func);
250  }
251  amxc_var_clean(&def_val);
252  return retval;
253 }
254 
255 static amxd_status_t amxd_object_add_set_func(amxd_object_t* object) {
256  amxd_status_t retval = amxd_status_unknown_error;
257  amxc_var_t def_val;
258  amxd_function_t* func = NULL;
259 
260  amxc_var_init(&def_val);
261 
262  retval = amxd_function_new(&func, "_set", AMXC_VAR_ID_NULL, amxd_object_func_set);
263  when_failed(retval, exit);
264  amxd_function_set_attr(func, amxd_fattr_template, true);
265  amxd_function_set_attr(func, amxd_fattr_instance, true);
266  amxd_function_set_attr(func, amxd_fattr_protected, true);
267  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
268  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_HTABLE, &def_val);
269  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_strict, true);
270  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
271  when_failed(retval, exit);
272  retval = amxd_function_new_arg(func, "oparameters", AMXC_VAR_ID_HTABLE, &def_val);
273  amxd_function_arg_set_attr(func, "oparameters", amxd_aattr_strict, true);
274  amxd_function_arg_set_attr(func, "oparameters", amxd_aattr_in, true);
275  when_failed(retval, exit);
276  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
277  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
278  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
279  when_failed(retval, exit);
280  amxc_var_set(cstring_t, &def_val, "");
281  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
282  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
283  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
284  when_failed(retval, exit);
285  amxc_var_set(bool, &def_val, false);
286  retval = amxd_function_new_arg(func, "allow_partial", AMXC_VAR_ID_BOOL, &def_val);
287  amxd_function_arg_set_attr(func, "allow_partial", amxd_aattr_in, true);
288  when_failed(retval, exit);
289 
290  retval = amxd_object_add_function(object, func);
291 
292 exit:
293  if(retval != 0) {
294  amxd_function_delete(&func);
295  }
296  amxc_var_clean(&def_val);
297  return retval;
298 }
299 
300 static amxd_status_t amxd_object_add_add_func(amxd_object_t* object) {
301  amxd_status_t retval = amxd_status_unknown_error;
302  amxc_var_t def_val;
303  amxd_function_t* func = NULL;
304 
305  amxc_var_init(&def_val);
306 
307  retval = amxd_function_new(&func, "_add", AMXC_VAR_ID_NULL, amxd_object_func_add);
308  when_failed(retval, exit);
309  amxd_function_set_attr(func, amxd_fattr_template, true);
310  amxd_function_set_attr(func, amxd_fattr_instance, true);
311  amxd_function_set_attr(func, amxd_fattr_protected, true);
312  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_HTABLE, NULL);
313  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_strict, true);
314  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
315  when_failed(retval, exit);
316  retval = amxd_function_new_arg(func, "index", AMXC_VAR_ID_UINT32, NULL);
317  amxd_function_arg_set_attr(func, "index", amxd_aattr_in, true);
318  when_failed(retval, exit);
319  retval = amxd_function_new_arg(func, "name", AMXC_VAR_ID_CSTRING, NULL);
320  amxd_function_arg_set_attr(func, "name", amxd_aattr_in, true);
321  when_failed(retval, exit);
322  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
323  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
324  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
325  when_failed(retval, exit);
326  amxc_var_set(cstring_t, &def_val, "");
327  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
328  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
329  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
330  when_failed(retval, exit);
331 
332  retval = amxd_object_add_function(object, func);
333 
334 exit:
335  if(retval != 0) {
336  amxd_function_delete(&func);
337  }
338  amxc_var_clean(&def_val);
339  return retval;
340 }
341 
342 static amxd_status_t amxd_object_add_del_func(amxd_object_t* object) {
343  amxd_status_t retval = amxd_status_unknown_error;
344  amxc_var_t def_val;
345  amxd_function_t* func = NULL;
346 
347  amxc_var_init(&def_val);
348 
349  retval = amxd_function_new(&func, "_del", AMXC_VAR_ID_NULL, amxd_object_func_del);
350  when_failed(retval, exit);
351  amxd_function_set_attr(func, amxd_fattr_template, true);
352  amxd_function_set_attr(func, amxd_fattr_instance, true);
353  amxd_function_set_attr(func, amxd_fattr_protected, true);
354  retval = amxd_function_new_arg(func, "index", AMXC_VAR_ID_UINT32, NULL);
355  amxd_function_arg_set_attr(func, "index", amxd_aattr_in, true);
356  when_failed(retval, exit);
357  retval = amxd_function_new_arg(func, "name", AMXC_VAR_ID_CSTRING, NULL);
358  amxd_function_arg_set_attr(func, "name", amxd_aattr_in, true);
359  when_failed(retval, exit);
360  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
361  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
362  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
363  when_failed(retval, exit);
364  amxc_var_set(cstring_t, &def_val, "");
365  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
366  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
367  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
368  when_failed(retval, exit);
369 
370  retval = amxd_object_add_function(object, func);
371 
372 exit:
373  if(retval != 0) {
374  amxd_function_delete(&func);
375  }
376  amxc_var_clean(&def_val);
377  return retval;
378 }
379 
380 static amxd_status_t amxd_object_add_describe_func(amxd_object_t* object) {
381  amxd_status_t retval = amxd_status_unknown_error;
382  amxd_function_t* func = NULL;
383  amxc_var_t def_val;
384 
385  amxc_var_init(&def_val);
386  amxc_var_set(bool, &def_val, false);
387 
388  retval = amxd_function_new(&func, "_describe", AMXC_VAR_ID_HTABLE, amxd_object_func_describe);
389  when_failed(retval, exit);
390  amxd_function_set_attr(func, amxd_fattr_template, true);
391  amxd_function_set_attr(func, amxd_fattr_instance, true);
392  amxd_function_set_attr(func, amxd_fattr_protected, true);
393  retval = amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_BOOL, &def_val);
394  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
395  when_failed(retval, exit);
396  retval = amxd_function_new_arg(func, "functions", AMXC_VAR_ID_BOOL, &def_val);
397  amxd_function_arg_set_attr(func, "functions", amxd_aattr_in, true);
398  when_failed(retval, exit);
399  retval = amxd_function_new_arg(func, "objects", AMXC_VAR_ID_BOOL, &def_val);
400  amxd_function_arg_set_attr(func, "objects", amxd_aattr_in, true);
401  when_failed(retval, exit);
402  retval = amxd_function_new_arg(func, "instances", AMXC_VAR_ID_BOOL, &def_val);
403  amxd_function_arg_set_attr(func, "instances", amxd_aattr_in, true);
404  when_failed(retval, exit);
405  retval = amxd_function_new_arg(func, "exists", AMXC_VAR_ID_BOOL, &def_val);
406  amxd_function_arg_set_attr(func, "exists", amxd_aattr_in, true);
407  when_failed(retval, exit);
408  amxc_var_set(uint32_t, &def_val, amxd_dm_access_protected);
409  retval = amxd_function_new_arg(func, "access", AMXC_VAR_ID_UINT32, &def_val);
410  amxd_function_arg_set_attr(func, "access", amxd_aattr_in, true);
411  when_failed(retval, exit);
412  amxc_var_set(cstring_t, &def_val, "");
413  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
414  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
415  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
416  when_failed(retval, exit);
417  amxc_var_set(bool, &def_val, false);
418  retval = amxd_function_new_arg(func, "events", AMXC_VAR_ID_BOOL, &def_val);
419  amxd_function_arg_set_attr(func, "events", amxd_aattr_in, true);
420  when_failed(retval, exit);
421 
422  retval = amxd_object_add_function(object, func);
423 
424 exit:
425  if(retval != 0) {
426  amxd_function_delete(&func);
427  }
428  amxc_var_clean(&def_val);
429  return retval;
430 }
431 
432 static amxd_status_t amxd_object_add_exec_func(amxd_object_t* object) {
433  amxd_status_t retval = amxd_status_unknown_error;
434  amxd_function_t* func = NULL;
435  amxc_var_t def_val;
436 
437  amxc_var_init(&def_val);
438  amxc_var_set(bool, &def_val, false);
439 
440  retval = amxd_function_new(&func, "_exec", AMXC_VAR_ID_ANY, amxd_object_func_exec);
441  when_failed(retval, exit);
442  amxd_function_set_attr(func, amxd_fattr_template, true);
443  amxd_function_set_attr(func, amxd_fattr_instance, true);
444  amxd_function_set_attr(func, amxd_fattr_protected, true);
445  retval = amxd_function_new_arg(func, "method", AMXC_VAR_ID_CSTRING, NULL);
446  amxd_function_arg_set_attr(func, "method", amxd_aattr_in, true);
447  amxd_function_arg_set_attr(func, "method", amxd_aattr_mandatory, true);
448  amxd_function_arg_set_attr(func, "method", amxd_aattr_strict, true);
449  when_failed(retval, exit);
450  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
451  retval = amxd_function_new_arg(func, "args", AMXC_VAR_ID_HTABLE, &def_val);
452  amxd_function_arg_set_attr(func, "args", amxd_aattr_in, true);
453  amxd_function_arg_set_attr(func, "args", amxd_aattr_out, true);
454  amxd_function_arg_set_attr(func, "args", amxd_aattr_strict, true);
455  when_failed(retval, exit);
456  amxc_var_set(cstring_t, &def_val, "");
457  retval = amxd_function_new_arg(func, "rel_path", AMXC_VAR_ID_CSTRING, &def_val);
458  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_in, true);
459  amxd_function_arg_set_attr(func, "rel_path", amxd_aattr_strict, true);
460  when_failed(retval, exit);
461 
462  retval = amxd_object_add_function(object, func);
463 
464 exit:
465  if(retval != 0) {
466  amxd_function_delete(&func);
467  }
468  amxc_var_clean(&def_val);
469  return retval;
470 }
471 
472 void PRIVATE amxd_object_init_base(amxd_object_t* const object,
473  const amxd_object_type_t type) {
474  amxc_llist_it_init(&object->it);
475 
476  object->type = type;
477  object->attr.read_only = 0;
478  object->attr.priv = 0;
479  object->attr.prot = 0;
480  object->attr.persistent = 0;
481  object->attr.locked = 0;
482 
483  object->index = 0;
484  object->last_index = 0;
485 
486  object->name = NULL;
487  object->index_name = NULL;
488 
489  amxc_llist_init(&object->objects);
490  amxc_llist_init(&object->instances);
491  amxc_llist_init(&object->functions);
492  amxc_llist_init(&object->parameters);
493  amxc_var_init(&object->events);
494  amxc_var_set_type(&object->events, AMXC_VAR_ID_HTABLE);
495 
496  amxc_llist_init(&object->cb_fns);
497 
498  amxc_llist_init(&object->derived_objects);
499  amxc_llist_it_init(&object->derived_from);
500 
501  amxc_array_init(&object->mib_names, 0);
502 }
503 
504 bool PRIVATE amxd_object_is_base(const amxd_object_t* const object) {
505  return ((object == &base_singleton) || (object == &base_template));
506 }
507 
508 amxd_status_t PRIVATE amxd_dm_base_add_funcs(amxd_object_t* object) {
509  amxd_status_t retval = amxd_status_unknown_error;
510 
511  // list function
512  retval = amxd_object_add_list_func(object);
513  when_failed(retval, exit);
514 
515  // describe function
516  retval = amxd_object_add_describe_func(object);
517  when_failed(retval, exit);
518 
519  // get function
520  retval = amxd_object_add_get_func(object);
521  when_failed(retval, exit);
522 
523  // get instances function
524  retval = amxd_object_add_get_instances_func(object);
525  when_failed(retval, exit);
526 
527  // get_supported dm function
528  retval = amxd_object_add_get_supported_func(object);
529  when_failed(retval, exit);
530 
531  // set function
532  retval = amxd_object_add_set_func(object);
533  when_failed(retval, exit);
534 
535  // add (inst) function
536  retval = amxd_object_add_add_func(object);
537  when_failed(retval, exit);
538 
539  // del (inst) function
540  retval = amxd_object_add_del_func(object);
541  when_failed(retval, exit);
542 
543  // del (inst) function
544  retval = amxd_object_add_exec_func(object);
545 
546 exit:
547  return retval;
548 }
549 
550 void PRIVATE amxd_dm_event(const char* signal,
551  const amxd_object_t* const object,
552  amxc_var_t* const data,
553  bool trigger) {
554  amxd_dm_t* dm = amxd_object_get_dm(object);
555  char* path = NULL;
556  char* epath = NULL;
557  char* index_path = NULL;
558  amxc_var_t signal_data;
559 
560  when_null(dm, exit);
561 
562  path = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_TERMINATE);
563  epath = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED | AMXD_OBJECT_TERMINATE);
564  index_path = amxd_object_get_path(object, AMXD_OBJECT_INDEXED | AMXD_OBJECT_TERMINATE);
565  amxc_var_init(&signal_data);
566 
567  amxc_var_set_type(&signal_data, AMXC_VAR_ID_HTABLE);
568  amxc_var_add_key(cstring_t, &signal_data, "object", path);
569  amxc_var_add_key(cstring_t, &signal_data, "path", index_path);
570  amxc_var_add_key(cstring_t, &signal_data, "eobject", epath);
571  if(amxc_var_type_of(data) == AMXC_VAR_ID_HTABLE) {
572  const amxc_htable_t* table_data = amxc_var_constcast(amxc_htable_t, data);
573  amxc_htable_it_t* hit = amxc_htable_get_first(table_data);
574  while(hit) {
575  amxc_var_t* part = amxc_var_from_htable_it(hit);
576  const char* key = amxc_htable_it_get_key(hit);
577  if(GET_ARG(&signal_data, key) == NULL) {
578  amxc_var_set_key(&signal_data, key, part, AMXC_VAR_FLAG_DEFAULT);
579  } else {
580  amxc_var_delete(&part);
581  }
582  hit = amxc_htable_get_first(table_data);
583  }
584  } else {
585  amxc_var_set_key(&signal_data, "data", data, AMXC_VAR_FLAG_COPY);
586  }
587  if(trigger) {
588  amxp_sigmngr_trigger_signal(&dm->sigmngr, signal, &signal_data);
589  } else {
590  amxp_sigmngr_emit_signal(&dm->sigmngr, signal, &signal_data);
591  }
592 
593  amxc_var_clean(&signal_data);
594  free(path);
595  free(epath);
596  free(index_path);
597 
598 exit:
599  return;
600 }
601 
602 void PRIVATE amxd_dm_set_derived_from(amxd_object_t* const object) {
603  amxd_object_type_t type = amxd_object_get_type(object);
604  switch(type) {
605  case amxd_object_singleton:
606  case amxd_object_root:
607  amxc_llist_append(&base_singleton.derived_objects, &object->derived_from);
608  break;
609  case amxd_object_template:
610  amxc_llist_append(&base_template.derived_objects, &object->derived_from);
611  break;
612  default:
613  break;
614  }
615 }
616 
617 void PRIVATE amxd_common_set_flag(amxc_var_t** flags, const char* flag) {
618  amxc_var_t* f = NULL;
619 
620  if((*flags) == NULL) {
621  amxc_var_new(flags);
622  amxc_var_set_type((*flags), AMXC_VAR_ID_HTABLE);
623  }
624  f = GET_ARG((*flags), flag);
625  if(f == NULL) {
626  amxc_var_add_key(bool, (*flags), flag, true);
627  } else {
628  amxc_var_set(bool, f, true);
629  }
630 
631  return;
632 }
633 
634 void PRIVATE amxd_common_unset_flag(amxc_var_t** flags, const char* flag) {
635  amxc_var_t* f = NULL;
636  const amxc_htable_t* ht_flags = NULL;
637 
638  when_null((*flags), exit);
639 
640  ht_flags = amxc_var_constcast(amxc_htable_t, *flags);
641  f = GET_ARG((*flags), flag);
642  amxc_var_delete(&f);
643 
644  if(amxc_htable_is_empty(ht_flags)) {
645  amxc_var_delete(flags);
646  }
647 
648 exit:
649  return;
650 }
651 
652 bool PRIVATE amxd_common_has_flag(const amxc_var_t* const flags, const char* flag) {
653  bool retval = false;
654  const amxc_htable_t* ht_flags = NULL;
655 
656  when_null(flags, exit);
657 
658  ht_flags = amxc_var_constcast(amxc_htable_t, flags);
659  retval = amxc_htable_contains(ht_flags, flag);
660 
661 exit:
662  return retval;
663 }
664 
665 void amxd_init_base(void) {
666  if(amxc_llist_is_empty(&base_singleton.functions)) {
667  amxc_llist_init(&base_objects);
668 
669  amxd_object_init_base(&base_singleton, amxd_object_singleton);
670  amxd_dm_base_add_funcs(&base_singleton);
671  amxc_llist_append(&base_objects, &base_singleton.it);
672 
673  amxd_object_init_base(&base_template, amxd_object_template);
674  amxc_llist_append(&base_objects, &base_template.it);
675  amxc_llist_append(&base_singleton.derived_objects, &base_template.derived_from);
676  }
677 }
678 
679 CONSTRUCTOR static void amxd_base_objects_init(void) {
680  amxd_init_base();
681 }
682 
683 DESTRUCTOR static void amxd_base_objects_cleanup(void) {
684  amxc_llist_clean(&base_singleton.functions, amxd_object_free_func_it);
685  amxc_var_clean(&base_singleton.events);
686  amxc_llist_clean(&base_template.functions, amxd_object_free_func_it);
687  amxc_var_clean(&base_template.events);
688 }
amxd_action.h
Ambiorix Data Model Default actions header file.
amxd_assert.h
amxd_dm.h
Ambiorix Data Model API header file.
amxd_dm_functions.h
amxd_object_func_exec
amxd_status_t amxd_object_func_exec(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_get_instances
amxd_status_t amxd_object_func_get_instances(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_get
amxd_status_t amxd_object_func_get(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_list
amxd_status_t amxd_object_func_list(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_add
amxd_status_t amxd_object_func_add(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_del
amxd_status_t amxd_object_func_del(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_set
amxd_status_t amxd_object_func_set(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_get_supported
amxd_status_t amxd_object_func_get_supported(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_func_describe
amxd_status_t amxd_object_func_describe(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
amxd_object_add_list_func
static amxd_status_t amxd_object_add_list_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:73
base_template
static amxd_object_t base_template
Definition: amxd_dm_priv.c:71
amxd_base_objects_init
static CONSTRUCTOR void amxd_base_objects_init(void)
Definition: amxd_dm_priv.c:679
amxd_object_add_exec_func
static amxd_status_t amxd_object_add_exec_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:432
amxd_object_add_describe_func
static amxd_status_t amxd_object_add_describe_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:380
amxd_object_add_add_func
static amxd_status_t amxd_object_add_add_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:300
base_objects
static amxc_llist_t base_objects
Definition: amxd_dm_priv.c:69
amxd_object_init_base
void PRIVATE amxd_object_init_base(amxd_object_t *const object, const amxd_object_type_t type)
Definition: amxd_dm_priv.c:472
amxd_dm_event
void PRIVATE amxd_dm_event(const char *signal, const amxd_object_t *const object, amxc_var_t *const data, bool trigger)
Definition: amxd_dm_priv.c:550
amxd_init_base
void amxd_init_base(void)
Definition: amxd_dm_priv.c:665
amxd_dm_set_derived_from
void PRIVATE amxd_dm_set_derived_from(amxd_object_t *const object)
Definition: amxd_dm_priv.c:602
amxd_object_add_get_func
static amxd_status_t amxd_object_add_get_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:125
amxd_object_add_get_supported_func
static amxd_status_t amxd_object_add_get_supported_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:206
amxd_common_has_flag
bool PRIVATE amxd_common_has_flag(const amxc_var_t *const flags, const char *flag)
Definition: amxd_dm_priv.c:652
amxd_object_add_get_instances_func
static amxd_status_t amxd_object_add_get_instances_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:170
amxd_dm_base_add_funcs
amxd_status_t PRIVATE amxd_dm_base_add_funcs(amxd_object_t *object)
Definition: amxd_dm_priv.c:508
amxd_common_set_flag
void PRIVATE amxd_common_set_flag(amxc_var_t **flags, const char *flag)
Definition: amxd_dm_priv.c:617
amxd_common_unset_flag
void PRIVATE amxd_common_unset_flag(amxc_var_t **flags, const char *flag)
Definition: amxd_dm_priv.c:634
amxd_object_add_set_func
static amxd_status_t amxd_object_add_set_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:255
base_singleton
static amxd_object_t base_singleton
Definition: amxd_dm_priv.c:70
amxd_object_is_base
bool PRIVATE amxd_object_is_base(const amxd_object_t *const object)
Definition: amxd_dm_priv.c:504
amxd_base_objects_cleanup
static DESTRUCTOR void amxd_base_objects_cleanup(void)
Definition: amxd_dm_priv.c:683
amxd_object_add_del_func
static amxd_status_t amxd_object_add_del_func(amxd_object_t *object)
Definition: amxd_dm_priv.c:342
amxd_dm_priv.h
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_priv.h
amxd_object_free_func_it
PRIVATE void amxd_object_free_func_it(amxc_llist_it_t *it)
Definition: amxd_object_priv.c:105
amxd_priv.h
amxd_status_t
enum _amxd_status amxd_status_t
amxd_status_unknown_error
@ amxd_status_unknown_error
Definition: amxd_types.h:79
AMXD_OBJECT_INDEXED
#define AMXD_OBJECT_INDEXED
Name and path format flag - use index for instance objects.
Definition: amxd_object.h:176
amxd_object_type_t
enum _amxd_object_type amxd_object_type_t
The different object types.
AMXD_OBJECT_NAMED
#define AMXD_OBJECT_NAMED
Name and path format flag - default behavior, use name for instance objects.
Definition: amxd_object.h:164
AMXD_OBJECT_EXTENDED
#define AMXD_OBJECT_EXTENDED
Path format flag - set name or index of instrance objects between '[' and ']'.
Definition: amxd_object.h:188
AMXD_OBJECT_TERMINATE
#define AMXD_OBJECT_TERMINATE
Path format flag - when set the object path is terminated with a dot.
Definition: amxd_object.h:214
amxd_fattr_template
@ amxd_fattr_template
Definition: amxd_types.h:311
amxd_fattr_protected
@ amxd_fattr_protected
Definition: amxd_types.h:317
amxd_fattr_instance
@ amxd_fattr_instance
Definition: amxd_types.h:312
amxd_aattr_strict
@ amxd_aattr_strict
Definition: amxd_types.h:286
amxd_aattr_in
@ amxd_aattr_in
Definition: amxd_types.h:283
amxd_aattr_mandatory
@ amxd_aattr_mandatory
Definition: amxd_types.h:285
amxd_aattr_out
@ amxd_aattr_out
Definition: amxd_types.h:284
amxd_dm_access_protected
@ amxd_dm_access_protected
Definition: amxd_types.h:139
amxd_object_root
@ amxd_object_root
Definition: amxd_types.h:178
amxd_object_template
@ amxd_object_template
Definition: amxd_types.h:183
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_object_get_path
amxd_object_t amxd_status_t amxd_status_t char * amxd_object_get_path(const amxd_object_t *object, const uint32_t flags)
Get the full path of the object.
Definition: amxd_object_hierarchy.c:483
amxd_object_get_dm
amxd_dm_t * amxd_object_get_dm(const amxd_object_t *const object)
Get the data model.
Definition: amxd_object_hierarchy.c:265
amxd_object_add_function
amxd_status_t amxd_object_add_function(amxd_object_t *const object, amxd_function_t *const func)
Adds an RPC method definition to the object definition.
Definition: amxd_object_function.c:140
amxd_object_get_type
static amxd_object_type_t amxd_object_get_type(const amxd_object_t *const object)
Returns the object type.
Definition: amxd_object.h:586
amxd_function_set_attr
amxd_status_t amxd_function_set_attr(amxd_function_t *func, const amxd_fattr_id_t attr, const bool enable)
Sets or unsets a method attribute.
Definition: amxd_function.c:283
amxd_function_delete
void amxd_function_delete(amxd_function_t **func)
Data model RPC method destructor function.
Definition: amxd_function.c:169
amxd_function_arg_set_attr
amxd_status_t amxd_function_arg_set_attr(amxd_function_t *const func, const char *name, const amxd_aattr_id_t attr, const bool enable)
Sets or unsets a method argument attribute.
Definition: amxd_function_args.c:183
amxd_function_new
amxd_status_t amxd_function_new(amxd_function_t **func, const char *name, const uint32_t ret_type, amxd_object_fn_t impl)
Data model RPC method constructor function.
Definition: amxd_function.c:146
amxd_function_new_arg
amxd_status_t amxd_function_new_arg(amxd_function_t *func, const char *name, const uint32_t type, amxc_var_t *default_value)
Adds an argument definition to a RPC method definition.
Definition: amxd_function_args.c:140
_amxd_dm
Definition: amxd_types.h:259
_amxd_dm::sigmngr
amxp_signal_mngr_t sigmngr
Definition: amxd_types.h:261
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_amxd_object
Definition: amxd_types.h:229
_amxd_object::derived_objects
amxc_llist_t derived_objects
Definition: amxd_types.h:248
_amxd_object::derived_from
amxc_llist_it_t derived_from
Definition: amxd_types.h:249
_amxd_object::functions
amxc_llist_t functions
Definition: amxd_types.h:245
_amxd_object::cb_fns
amxc_llist_t cb_fns
Definition: amxd_types.h:253
_amxd_object::objects
amxc_llist_t objects
Definition: amxd_types.h:243
_amxd_object::mib_names
amxc_array_t mib_names
Definition: amxd_types.h:254
_amxd_object::it
amxc_llist_it_t it
Definition: amxd_types.h:230
_amxd_object::instances
amxc_llist_t instances
Definition: amxd_types.h:244
_amxd_object::events
amxc_var_t events
Definition: amxd_types.h:256
_amxd_object::parameters
amxc_llist_t parameters
Definition: amxd_types.h:246
dm
static amxd_dm_t dm
Definition: test_amxd_action_object_add.c:79