libamxd  6.4.1
Data Model Manager
Functions
test_amxd_parameter.c File Reference
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <cmocka.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxd/amxd_common.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_parameter.h>
#include "test_amxd_parameter.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_amxd_parameter_new_delete (UNUSED void **state)
 
void test_amxd_parameter_new_delete_invalid_args (UNUSED void **state)
 
void test_amxd_parameter_copy (UNUSED void **state)
 
void test_amxd_parameter_copy_invalid (UNUSED void **state)
 
void test_amxd_parameter_owner (UNUSED void **state)
 
void test_amxd_parameter_name (UNUSED void **state)
 
void test_amxd_param_attributes (UNUSED void **state)
 
void test_amxd_param_get_value (UNUSED void **state)
 
void test_amxd_param_set_value (UNUSED void **state)
 
void test_amxd_param_validate (UNUSED void **state)
 
void test_amxd_param_delete (UNUSED void **state)
 
void test_amxd_param_describe (UNUSED void **state)
 
void test_amxd_param_type (UNUSED void **state)
 

Function Documentation

◆ test_amxd_param_attributes()

void test_amxd_param_attributes ( UNUSED void **  state)

Definition at line 192 of file test_amxd_parameter.c.

192  {
193  amxd_param_t* param = NULL;
194 
195  assert_int_equal(amxd_param_new(&param, "templ_func", AMXC_VAR_ID_CSTRING), 0);
196  assert_false(amxd_param_is_attr_set(param, amxd_pattr_template));
197  assert_false(amxd_param_is_attr_set(param, amxd_pattr_instance));
198  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
199  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
200  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
201  assert_false(amxd_param_is_attr_set(param, amxd_pattr_persistent));
202 
203  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
204  assert_true(amxd_param_is_attr_set(param, amxd_pattr_template));
205  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, false), 0);
206  assert_false(amxd_param_is_attr_set(param, amxd_pattr_template));
207 
208  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_instance, true), 0);
209  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
210  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_instance, false), 0);
211  assert_false(amxd_param_is_attr_set(param, amxd_pattr_instance));
212 
213  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_private, true), 0);
214  assert_true(amxd_param_is_attr_set(param, amxd_pattr_private));
215  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_private, false), 0);
216  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
217 
218  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_read_only, true), 0);
219  assert_true(amxd_param_is_attr_set(param, amxd_pattr_read_only));
220  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_read_only, false), 0);
221  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
222 
223  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_variable, true), 0);
224  assert_true(amxd_param_is_attr_set(param, amxd_pattr_variable));
225  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_variable, false), 0);
226  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
227 
228  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_persistent, true), 0);
229  assert_true(amxd_param_is_attr_set(param, amxd_pattr_persistent));
230  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_persistent, false), 0);
231  assert_false(amxd_param_is_attr_set(param, amxd_pattr_persistent));
232 
233 
234  assert_int_not_equal(amxd_param_set_attr(NULL, amxd_pattr_persistent, true), 0);
235  assert_false(amxd_param_is_attr_set(NULL, amxd_pattr_persistent));
236 
237  assert_int_equal(amxd_param_set_attrs(param, SET_BIT(amxd_pattr_template) |
238  SET_BIT(amxd_pattr_instance) |
239  SET_BIT(amxd_pattr_private) |
240  SET_BIT(amxd_pattr_read_only) |
241  SET_BIT(amxd_pattr_variable) |
242  SET_BIT(amxd_pattr_persistent), false), 0);
243  assert_false(amxd_param_is_attr_set(param, amxd_pattr_template));
244  assert_false(amxd_param_is_attr_set(param, amxd_pattr_instance));
245  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
246  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
247  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
248  assert_false(amxd_param_is_attr_set(param, amxd_pattr_persistent));
249 
250  assert_int_equal(amxd_param_set_attrs(param, SET_BIT(amxd_pattr_template) |
251  SET_BIT(amxd_pattr_instance) |
252  SET_BIT(amxd_pattr_private) |
253  SET_BIT(amxd_pattr_read_only) |
254  SET_BIT(amxd_pattr_variable) |
255  SET_BIT(amxd_pattr_persistent), true), 0);
256  assert_true(amxd_param_is_attr_set(param, amxd_pattr_template));
257  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
258  assert_true(amxd_param_is_attr_set(param, amxd_pattr_private));
259  assert_true(amxd_param_is_attr_set(param, amxd_pattr_read_only));
260  assert_true(amxd_param_is_attr_set(param, amxd_pattr_variable));
261  assert_true(amxd_param_is_attr_set(param, amxd_pattr_persistent));
262 
263  assert_int_equal(amxd_param_set_attrs(param, SET_BIT(amxd_pattr_template) |
264  SET_BIT(amxd_pattr_instance) |
265  SET_BIT(amxd_pattr_private) |
266  SET_BIT(amxd_pattr_read_only) |
267  SET_BIT(amxd_pattr_variable) |
268  SET_BIT(amxd_pattr_persistent), false), 0);
269  assert_false(amxd_param_is_attr_set(param, amxd_pattr_template));
270  assert_false(amxd_param_is_attr_set(param, amxd_pattr_instance));
271  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
272  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
273  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
274  assert_false(amxd_param_is_attr_set(param, amxd_pattr_persistent));
275 
276  assert_int_not_equal(amxd_param_set_attrs(param, SET_BIT(amxd_pattr_template) |
277  SET_BIT(amxd_pattr_instance) |
278  SET_BIT(amxd_pattr_private) |
279  SET_BIT((amxd_pattr_max + 1)), false), 0);
280  assert_int_not_equal(amxd_param_set_attrs(NULL, SET_BIT(amxd_pattr_template) |
281  SET_BIT(amxd_pattr_instance) |
282  SET_BIT(amxd_pattr_private), true), 0);
283 
284  amxd_param_delete(&param);
285 }
SET_BIT
#define SET_BIT(x)
Definition: amxd_common.h:65
amxd_param_is_attr_set
bool amxd_param_is_attr_set(const amxd_param_t *const param, const amxd_pattr_id_t attr)
Definition: amxd_parameter.c:397
amxd_param_set_attrs
amxd_status_t amxd_param_set_attrs(amxd_param_t *param, const uint32_t bitmask, bool enable)
Definition: amxd_parameter.c:350
amxd_param_new
amxd_status_t amxd_param_new(amxd_param_t **param, const char *name, const uint32_t type)
Definition: amxd_parameter.c:239
amxd_param_set_attr
amxd_status_t amxd_param_set_attr(amxd_param_t *param, const amxd_pattr_id_t attr, const bool enable)
Definition: amxd_parameter.c:326
amxd_param_delete
amxd_status_t amxd_param_delete(amxd_param_t **param)
Definition: amxd_action_param_destroy.c:109
amxd_pattr_template
@ amxd_pattr_template
Definition: amxd_types.h:355
amxd_pattr_private
@ amxd_pattr_private
Definition: amxd_types.h:357
amxd_pattr_persistent
@ amxd_pattr_persistent
Definition: amxd_types.h:359
amxd_pattr_variable
@ amxd_pattr_variable
Definition: amxd_types.h:360
amxd_pattr_instance
@ amxd_pattr_instance
Definition: amxd_types.h:356
amxd_pattr_read_only
@ amxd_pattr_read_only
Definition: amxd_types.h:358
amxd_pattr_max
@ amxd_pattr_max
Definition: amxd_types.h:366
_amxd_parameter
Definition: amxd_types.h:386

◆ test_amxd_param_delete()

void test_amxd_param_delete ( UNUSED void **  state)

Definition at line 338 of file test_amxd_parameter.c.

338  {
339  amxd_param_t* param = NULL;
340 
341  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
342  assert_ptr_not_equal(param, NULL);
343 
344  amxd_param_delete(&param);
345  assert_ptr_equal(param, NULL);
346  amxd_param_delete(&param);
347 
348  amxd_param_delete(NULL);
349 
350  amxd_param_delete(&param);
351 }

◆ test_amxd_param_describe()

void test_amxd_param_describe ( UNUSED void **  state)

Definition at line 353 of file test_amxd_parameter.c.

353  {
354  amxd_param_t* param = NULL;
355  amxc_var_t value;
356 
357  amxc_var_init(&value);
358 
359  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
360  assert_ptr_not_equal(param, NULL);
361 
362  assert_int_equal(amxd_param_describe(param, &value), 0);
363  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_HTABLE);
364  assert_ptr_not_equal(amxc_var_get_key(&value, "name", AMXC_VAR_FLAG_DEFAULT), NULL);
365  assert_ptr_not_equal(amxc_var_get_key(&value, "type_name", AMXC_VAR_FLAG_DEFAULT), NULL);
366  assert_ptr_not_equal(amxc_var_get_key(&value, "type_id", AMXC_VAR_FLAG_DEFAULT), NULL);
367  assert_ptr_not_equal(amxc_var_get_key(&value, "attributes", AMXC_VAR_FLAG_DEFAULT), NULL);
368 
369  assert_int_not_equal(amxd_param_describe(param, NULL), 0);
370  assert_int_not_equal(amxd_param_describe(NULL, &value), 0);
371 
372  amxc_var_clean(&value);
373  amxd_param_delete(&param);
374 }
amxd_param_describe
amxd_status_t amxd_param_describe(amxd_param_t *const param, amxc_var_t *const value)
Definition: amxd_action_param_describe.c:181

◆ test_amxd_param_get_value()

void test_amxd_param_get_value ( UNUSED void **  state)

Definition at line 287 of file test_amxd_parameter.c.

287  {
288  amxd_param_t* param = NULL;
289  amxc_var_t value;
290 
291  amxc_var_init(&value);
292  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
293  assert_ptr_not_equal(param, NULL);
294 
295  assert_int_equal(amxd_param_get_value(param, &value), 0);
296  assert_int_not_equal(amxd_param_get_value(param, NULL), 0);
297  assert_int_not_equal(amxd_param_get_value(NULL, &value), 0);
298 
299  amxd_param_delete(&param);
300 }
amxd_param_get_value
amxd_status_t amxd_param_get_value(amxd_param_t *const param, amxc_var_t *const value)
Definition: amxd_action_param_read.c:116

◆ test_amxd_param_set_value()

void test_amxd_param_set_value ( UNUSED void **  state)

Definition at line 302 of file test_amxd_parameter.c.

302  {
303  amxd_param_t* param = NULL;
304  amxc_var_t value;
305 
306  amxc_var_init(&value);
307  amxc_var_set(cstring_t, &value, "ABCD");
308 
309  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
310  assert_ptr_not_equal(param, NULL);
311 
312  assert_int_equal(amxd_param_set_value(param, &value), 0);
313  assert_int_not_equal(amxd_param_set_value(param, NULL), 0);
314  assert_int_not_equal(amxd_param_set_value(NULL, &value), 0);
315 
316  amxd_param_delete(&param);
317  amxc_var_clean(&value);
318 }
amxd_param_set_value
amxd_status_t amxd_param_set_value(amxd_param_t *const param, const amxc_var_t *const value)
Definition: amxd_action_param_write.c:113

◆ test_amxd_param_type()

void test_amxd_param_type ( UNUSED void **  state)

Definition at line 376 of file test_amxd_parameter.c.

376  {
377  amxd_param_t* param = NULL;
378 
379  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
380  assert_ptr_not_equal(param, NULL);
381  assert_int_equal(amxd_param_get_type(param), AMXC_VAR_ID_CSTRING);
382  amxd_param_delete(&param);
383 
384  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_ANY), 0);
385  assert_ptr_equal(param, NULL);
386 
387  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_LIST), 0);
388  assert_ptr_equal(param, NULL);
389 
390  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_HTABLE), 0);
391  assert_ptr_equal(param, NULL);
392 
393  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CUSTOM_BASE), 0);
394  assert_ptr_equal(param, NULL);
395 
396  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CUSTOM_BASE + 100), 0);
397  assert_ptr_equal(param, NULL);
398 
399  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_BOOL), 0);
400  assert_ptr_not_equal(param, NULL);
401  assert_int_equal(amxd_param_get_type(param), AMXC_VAR_ID_BOOL);
402  amxd_param_delete(&param);
403 
404  amxd_param_delete(&param);
405 }
amxd_param_get_type
static uint32_t amxd_param_get_type(const amxd_param_t *const param)
Definition: amxd_parameter.h:81

◆ test_amxd_param_validate()

void test_amxd_param_validate ( UNUSED void **  state)

Definition at line 320 of file test_amxd_parameter.c.

320  {
321  amxd_param_t* param = NULL;
322  amxc_var_t value;
323 
324  amxc_var_init(&value);
325  amxc_var_set(cstring_t, &value, "ABCD");
326 
327  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
328  assert_ptr_not_equal(param, NULL);
329 
330  assert_int_equal(amxd_param_validate(param, &value), 0);
331  assert_int_not_equal(amxd_param_validate(param, NULL), 0);
332  assert_int_not_equal(amxd_param_validate(NULL, &value), 0);
333 
334  amxd_param_delete(&param);
335  amxc_var_clean(&value);
336 }
amxd_param_validate
amxd_status_t amxd_param_validate(amxd_param_t *const param, const amxc_var_t *const value)
Definition: amxd_action_param_validate.c:448

◆ test_amxd_parameter_copy()

void test_amxd_parameter_copy ( UNUSED void **  state)

Definition at line 125 of file test_amxd_parameter.c.

125  {
126  amxd_param_t* param = NULL;
127  amxd_param_t* cparam = NULL;
128 
129  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_BOOL), 0);
130  assert_int_equal(amxd_param_copy(&cparam, param), 0);
131  assert_int_equal(amxc_var_type_of(&cparam->value), AMXC_VAR_ID_BOOL);
132  assert_string_equal(cparam->name, "Param1");
133  assert_int_equal(cparam->attr.templ, 0);
134  assert_int_equal(cparam->attr.instance, 0);
135  assert_int_equal(cparam->attr.priv, 0);
136  assert_int_equal(cparam->attr.read_only, 0);
137  assert_int_equal(cparam->attr.persistent, 0);
138  assert_int_equal(cparam->attr.variable, 0);
139  amxd_param_delete(&cparam);
140 
141  amxd_param_set_flag(param, "TestFlag");
142  assert_int_equal(amxd_param_copy(&cparam, param), 0);
143  assert_true(amxd_param_has_flag(cparam, "TestFlag"));
144 
145  amxd_param_delete(&cparam);
146  amxd_param_delete(&param);
147 }
amxd_param_copy
amxd_status_t amxd_param_copy(amxd_param_t **dest, const amxd_param_t *const source)
Definition: amxd_parameter.c:280
amxd_param_has_flag
bool amxd_param_has_flag(const amxd_param_t *const param, const char *flag)
Definition: amxd_parameter.c:433
amxd_param_set_flag
void amxd_param_set_flag(amxd_param_t *param, const char *flag)
Definition: amxd_parameter.c:411
_amxd_param_attr::templ
uint32_t templ
Definition: amxd_types.h:370
_amxd_param_attr::persistent
uint32_t persistent
Definition: amxd_types.h:375
_amxd_param_attr::read_only
uint32_t read_only
Definition: amxd_types.h:374
_amxd_param_attr::variable
uint32_t variable
Definition: amxd_types.h:377
_amxd_param_attr::instance
uint32_t instance
Definition: amxd_types.h:371
_amxd_param_attr::priv
uint32_t priv
Definition: amxd_types.h:373
_amxd_parameter::name
char * name
Definition: amxd_types.h:389
_amxd_parameter::value
amxc_var_t value
Definition: amxd_types.h:390
_amxd_parameter::attr
amxd_param_attr_t attr
Definition: amxd_types.h:388

◆ test_amxd_parameter_copy_invalid()

void test_amxd_parameter_copy_invalid ( UNUSED void **  state)

Definition at line 149 of file test_amxd_parameter.c.

149  {
150  amxd_param_t* param = NULL;
151  amxd_param_t* cparam = NULL;
152 
153  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_BOOL), 0);
154  assert_int_not_equal(amxd_param_copy(NULL, param), 0);
155  assert_int_not_equal(amxd_param_copy(&cparam, NULL), 0);
156 
157  amxd_param_delete(&param);
158  amxd_param_delete(&cparam);
159 }

◆ test_amxd_parameter_name()

void test_amxd_parameter_name ( UNUSED void **  state)

Definition at line 183 of file test_amxd_parameter.c.

183  {
184  amxd_param_t* param1 = NULL;
185  assert_int_equal(amxd_param_new(&param1, "param", AMXC_VAR_ID_CSTRING), 0);
186  assert_string_equal(amxd_param_get_name(param1), "param");
187  assert_ptr_equal(amxd_param_get_name(NULL), NULL);
188 
189  amxd_param_delete(&param1);
190 }
amxd_param_get_name
const char * amxd_param_get_name(const amxd_param_t *const param)
Definition: amxd_parameter.c:322

◆ test_amxd_parameter_new_delete()

void test_amxd_parameter_new_delete ( UNUSED void **  state)

Definition at line 76 of file test_amxd_parameter.c.

76  {
77  amxd_param_t* param = NULL;
78 
79  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
80  assert_ptr_not_equal(param, NULL);
81  assert_int_equal(amxc_var_type_of(&param->value), AMXC_VAR_ID_CSTRING);
82  assert_int_equal(param->attr.templ, 0);
83  assert_int_equal(param->attr.instance, 0);
84  assert_int_equal(param->attr.priv, 0);
85  assert_int_equal(param->attr.read_only, 0);
86  assert_int_equal(param->attr.persistent, 0);
87  assert_int_equal(param->attr.variable, 0);
88 
89  amxd_param_delete(&param);
90  assert_ptr_equal(param, NULL);
91  amxd_param_delete(&param);
92 
93  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
94  assert_ptr_not_equal(param, NULL);
95  amxd_param_delete(&param);
96  amxd_param_delete(NULL);
97  assert_ptr_equal(param, NULL);
98 }

◆ test_amxd_parameter_new_delete_invalid_args()

void test_amxd_parameter_new_delete_invalid_args ( UNUSED void **  state)

Definition at line 100 of file test_amxd_parameter.c.

100  {
101  amxd_param_t* param = NULL;
102 
103  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
104  assert_ptr_not_equal(param, NULL);
105  amxd_param_delete(&param);
106 
107  assert_int_not_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CUSTOM_BASE + 100), 0);
108  assert_ptr_equal(param, NULL);
109 
110  assert_int_not_equal(amxd_param_new(NULL, "Param1", AMXC_VAR_ID_CSTRING), 0);
111  assert_ptr_equal(param, NULL);
112 
113  assert_int_not_equal(amxd_param_new(&param, "123", AMXC_VAR_ID_CSTRING), 0);
114  assert_ptr_equal(param, NULL);
115  assert_int_not_equal(amxd_param_new(&param, "MyParam@test", AMXC_VAR_ID_CSTRING), 0);
116  assert_ptr_equal(param, NULL);
117  assert_int_not_equal(amxd_param_new(&param, "", AMXC_VAR_ID_CSTRING), 0);
118  assert_ptr_equal(param, NULL);
119  assert_int_not_equal(amxd_param_new(&param, NULL, AMXC_VAR_ID_CSTRING), 0);
120  assert_ptr_equal(param, NULL);
121 
122  amxd_param_delete(&param);
123 }

◆ test_amxd_parameter_owner()

void test_amxd_parameter_owner ( UNUSED void **  state)

Definition at line 161 of file test_amxd_parameter.c.

161  {
162  amxd_object_t* object1 = NULL;
163  amxd_object_t* object2 = NULL;
164  amxd_param_t* param1 = NULL;
165  amxd_param_t* param2 = NULL;
166 
167  assert_int_equal(amxd_object_new(&object1, amxd_object_singleton, "obj1"), 0);
168  assert_int_equal(amxd_object_new(&object2, amxd_object_singleton, "obj2"), 0);
169  assert_int_equal(amxd_param_new(&param1, "param", AMXC_VAR_ID_CSTRING), 0);
170  assert_int_equal(amxd_param_new(&param2, "param", AMXC_VAR_ID_CSTRING), 0);
171  assert_int_equal(amxd_object_add_param(object1, param1), 0);
172  assert_int_not_equal(amxd_object_add_param(object2, param1), 0);
173 
174  assert_ptr_equal(amxd_param_get_owner(param1), object1);
175  assert_ptr_equal(amxd_param_get_owner(param2), NULL);
176  assert_ptr_equal(amxd_param_get_owner(NULL), NULL);
177 
178  amxd_object_delete(&object1);
179  amxd_object_delete(&object2);
180  amxd_param_delete(&param2);
181 }
amxd_param_get_owner
amxd_object_t * amxd_param_get_owner(const amxd_param_t *const param)
Definition: amxd_parameter.c:311
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_object_add_param
amxd_status_t amxd_object_add_param(amxd_object_t *const object, amxd_param_t *const param)
Adds a parameter definition to an object.
Definition: amxd_object_parameter.c:96
amxd_object_new
amxd_status_t amxd_object_new(amxd_object_t **object, const amxd_object_type_t type, const char *name)
Data model object constructor function.
Definition: amxd_object.c:185
amxd_object_delete
void amxd_object_delete(amxd_object_t **object)
Invokes the destroy handler(s) of the object.
Definition: amxd_action_object_destroy.c:80
_amxd_object
Definition: amxd_types.h:229