Variant type specific helper functions. More...

Collaboration diagram for variant type helper functions:

Functions
void	variant_list_it_free (amxc_llist_it_t *it)
	Helper functions, can be used as delete function for linked lists. More...

void	variant_htable_it_free (const char key, amxc_htable_it_t it)
	Helper functions, can be used as delete function for htable. More...

int	amxc_var_set_bool (amxc_var_t *const var, bool boolean)
	Setter helper function. More...

int	amxc_var_set_int8_t (amxc_var_t *const var, int8_t val)
	Setter helper function. More...

int	amxc_var_set_uint8_t (amxc_var_t *const var, uint8_t val)
	Setter helper function. More...

int	amxc_var_set_int16_t (amxc_var_t *const var, int16_t val)
	Setter helper function. More...

int	amxc_var_set_uint16_t (amxc_var_t *const var, uint16_t val)
	Setter helper function. More...

int	amxc_var_set_int32_t (amxc_var_t *const var, int32_t val)
	Setter helper function. More...

int	amxc_var_set_uint32_t (amxc_var_t *const var, uint32_t val)
	Setter helper function. More...

int	amxc_var_set_int64_t (amxc_var_t *const var, int64_t val)
	Setter helper function. More...

int	amxc_var_set_uint64_t (amxc_var_t *const var, uint64_t val)
	Setter helper function. More...

int	amxc_var_set_cstring_t (amxc_var_t const var, const char const val)
	Setter helper function. More...

int	amxc_var_set_csv_string_t (amxc_var_t const var, const char const val)
	Setter helper function. More...

int	amxc_var_set_ssv_string_t (amxc_var_t const var, const char const val)
	Setter helper function. More...

int	amxc_var_set_double (amxc_var_t *var, double val)
	Setter helper function. More...

int	amxc_var_set_fd_t (amxc_var_t *var, int val)
	Setter helper function. More...

int	amxc_var_set_amxc_ts_t (amxc_var_t var, amxc_ts_t val)
	Setter helper function. More...

bool	amxc_var_get_bool (const amxc_var_t *const var)
	Conversion helper function. More...

int8_t	amxc_var_get_int8_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint8_t	amxc_var_get_uint8_t (const amxc_var_t *const var)
	Conversion helper function. More...

int16_t	amxc_var_get_int16_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint16_t	amxc_var_get_uint16_t (const amxc_var_t *var)
	Conversion helper function. More...

int32_t	amxc_var_get_int32_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint32_t	amxc_var_get_uint32_t (const amxc_var_t *var)
	Conversion helper function. More...

int64_t	amxc_var_get_int64_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint64_t	amxc_var_get_uint64_t (const amxc_var_t *const var)
	Conversion helper function. More...

char *	amxc_var_get_cstring_t (const amxc_var_t *const var)
	Conversion helper function. More...

amxc_htable_t *	amxc_var_get_amxc_htable_t (const amxc_var_t *const var)
	Conversion helper function. More...

amxc_llist_t *	amxc_var_get_amxc_llist_t (const amxc_var_t *const var)
	Conversion helper function. More...

double	amxc_var_get_double (const amxc_var_t *var)
	Conversion helper function. More...

int	amxc_var_get_fd_t (const amxc_var_t *var)
	Conversion helper function. More...

amxc_ts_t *	amxc_var_get_amxc_ts_t (const amxc_var_t *var)
	Conversion helper function. More...

AMXC_INLINE char *	amxc_var_get_csv_string_t (const amxc_var_t *const var)
	Conversion helper function. More...

AMXC_INLINE char *	amxc_var_get_ssv_string_t (const amxc_var_t *const var)
	Conversion helper function. More...

const char *	amxc_var_get_const_cstring_t (const amxc_var_t *const var)
	Conversion helper function. More...

const amxc_htable_t *	amxc_var_get_const_amxc_htable_t (const amxc_var_t *const var)
	Conversion helper function. More...

const amxc_llist_t *	amxc_var_get_const_amxc_llist_t (const amxc_var_t *const var)
	Conversion helper function. More...

bool	amxc_var_get_const_bool (const amxc_var_t *const var)
	Conversion helper function. More...

int8_t	amxc_var_get_const_int8_t (const amxc_var_t *const var)
	Conversion helper function. More...

int16_t	amxc_var_get_const_int16_t (const amxc_var_t *const var)
	Conversion helper function. More...

int32_t	amxc_var_get_const_int32_t (const amxc_var_t *const var)
	Conversion helper function. More...

int64_t	amxc_var_get_const_int64_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint8_t	amxc_var_get_const_uint8_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint16_t	amxc_var_get_const_uint16_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint32_t	amxc_var_get_const_uint32_t (const amxc_var_t *const var)
	Conversion helper function. More...

uint64_t	amxc_var_get_const_uint64_t (const amxc_var_t *const var)
	Conversion helper function. More...

double	amxc_var_get_const_double (const amxc_var_t *const var)
	Conversion helper function. More...

int	amxc_var_get_const_fd_t (const amxc_var_t *const var)
	Conversion helper function. More...

const amxc_ts_t *	amxc_var_get_const_amxc_ts_t (const amxc_var_t *const var)
	Conversion helper function. More...

AMXC_INLINE const char *	amxc_var_get_const_csv_string_t (const amxc_var_t *const var)
	Conversion helper function. More...

AMXC_INLINE const char *	amxc_var_get_const_ssv_string_t (const amxc_var_t *const var)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_bool (amxc_var_t *const var, bool boolean)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_int8_t (amxc_var_t *const var, int8_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_uint8_t (amxc_var_t *const var, uint8_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_int16_t (amxc_var_t *const var, int16_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_uint16_t (amxc_var_t *const var, uint16_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_int32_t (amxc_var_t *const var, int32_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_uint32_t (amxc_var_t *const var, uint32_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_int64_t (amxc_var_t *const var, int64_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_uint64_t (amxc_var_t *const var, uint64_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_cstring_t (amxc_var_t const var, const char const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_csv_string_t (amxc_var_t const var, const char const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_ssv_string_t (amxc_var_t const var, const char const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_double (amxc_var_t *const var, double val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_fd_t (amxc_var_t *const var, int val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_amxc_ts_t (amxc_var_t const var, amxc_ts_t ts)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_amxc_llist_t (amxc_var_t const var, const amxc_llist_t list)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_amxc_htable_t (amxc_var_t const var, const amxc_htable_t htable)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_bool (amxc_var_t const var, const char key, bool boolean)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_int8_t (amxc_var_t const var, const char key, int8_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_uint8_t (amxc_var_t const var, const char key, uint8_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_int16_t (amxc_var_t const var, const char key, int16_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_uint16_t (amxc_var_t const var, const char key, uint16_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_int32_t (amxc_var_t const var, const char key, int32_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_uint32_t (amxc_var_t const var, const char key, uint32_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_int64_t (amxc_var_t const var, const char key, int64_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_uint64_t (amxc_var_t const var, const char key, uint64_t val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_cstring_t (amxc_var_t const var, const char key, const char *const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_csv_string_t (amxc_var_t const var, const char key, const char *const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_ssv_string_t (amxc_var_t const var, const char key, const char *const val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_double (amxc_var_t const var, const char key, double val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_fd_t (amxc_var_t const var, const char key, int val)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_amxc_ts_t (amxc_var_t const var, const char key, amxc_ts_t *ts)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_amxc_llist_t (amxc_var_t const var, const char key, const amxc_llist_t *list)
	Conversion helper function. More...

amxc_var_t *	amxc_var_add_new_key_amxc_htable_t (amxc_var_t const var, const char key, const amxc_htable_t *htable)
	Conversion helper function. More...

char *	amxc_var_take_cstring_t (amxc_var_t *const var)
	Takes a value from a variant. More...

amxc_string_t *	amxc_var_take_amxc_string_t (amxc_var_t *const var)
	Takes a value from a variant. More...

AMXC_INLINE char *	amxc_var_take_csv_string_t (amxc_var_t *const var)
	Takes a value from a variant. More...

AMXC_INLINE char *	amxc_var_take_ssv_string_t (amxc_var_t *const var)
	Takes a value from a variant. More...

int	amxc_var_push_cstring_t (amxc_var_t const var, char val)
	Pushes a value in a variant. More...

int	amxc_var_push_csv_string_t (amxc_var_t const var, char val)
	Pushes a value in a variant. More...

int	amxc_var_push_ssv_string_t (amxc_var_t const var, char val)
	Pushes a value in a variant. More...

int	amxc_var_push_amxc_string_t (amxc_var_t const var, amxc_string_t val)
	Pushes a value in a variant. More...

Detailed Description

Variant type specific helper functions.

These functions are normally not used directly. Either they are called using a macro or used as a callback function.

Function Documentation

◆ amxc_var_add_new_amxc_htable_t()

amxc_var_t* amxc_var_add_new_amxc_htable_t	(	amxc_var_t *const	var,
		const amxc_htable_t *	htable
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

If the provided htable pointer is NULL, an empty htable is added.

Note: Do not call this function directly, use macro amxc_var_add with the type argument amxc_htable_t; The htable must be a htable where the values are variants

Parameters

var	pointer to a variant struct
htable	the new htable value

Returns: The new variant

Definition at line 455 of file variant_htable.c.

                                                                         {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
     when_null(htable, exit);
  
     if(variant_htable_copy_htable(subvar, htable) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_amxc_llist_t()

amxc_var_t* amxc_var_add_new_amxc_llist_t	(	amxc_var_t *const	var,
		const amxc_llist_t *	list
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

If the provided list pointer is NULL, an empty list is added.

Note: Do not call this function directly, use macro amxc_var_add with the type argument amxc_llist_t; The list must be a list of variants

Parameters

var	pointer to a variant struct
list	the new list value

Returns: The new variant

Definition at line 422 of file variant_list.c.

                                                                     {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
     when_null(list, exit);
  
     if(variant_list_copy_list(subvar, list) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_amxc_ts_t()

amxc_var_t* amxc_var_add_new_amxc_ts_t	(	amxc_var_t *const	var,
		amxc_ts_t *	ts
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument amxc_ts_t

Parameters

var	pointer to a variant struct
ts	the timestamp value

Returns: The new variant

Definition at line 213 of file variant_timestamp.c.

                                                                              {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(ts == NULL) {
         amxc_var_set_type(subvar, AMXC_VAR_ID_TIMESTAMP);
     } else {
         if(amxc_var_set_amxc_ts_t(subvar, ts) != 0) {
             amxc_var_delete(&subvar);
         }
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_bool()

amxc_var_t* amxc_var_add_new_bool	(	amxc_var_t *const	var,
		bool	boolean
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument bool

Parameters

var	pointer to a variant struct
boolean	the value

Returns: The new variant

Definition at line 259 of file variant_bool.c.

                                                                        {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_bool(subvar, boolean) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_cstring_t()

amxc_var_t* amxc_var_add_new_cstring_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument cstring_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 666 of file variant_char.c.

                                                                                      {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_cstring_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_csv_string_t()

amxc_var_t* amxc_var_add_new_csv_string_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument csv_string_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 681 of file variant_char.c.

                                                                                         {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_csv_string_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_double()

amxc_var_t* amxc_var_add_new_double	(	amxc_var_t *const	var,
		double	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument double

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 339 of file variant_double.c.

                                                                        {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_double(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_fd_t()

amxc_var_t* amxc_var_add_new_fd_t	(	amxc_var_t *const	var,
		int	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument fd_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 328 of file variant_fd.c.

                                                                   {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_fd_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_int16_t()

amxc_var_t* amxc_var_add_new_int16_t	(	amxc_var_t *const	var,
		int16_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument int16_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 329 of file variant_int16.c.

                                                                          {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_int16_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_int32_t()

amxc_var_t* amxc_var_add_new_int32_t	(	amxc_var_t *const	var,
		int32_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument int32_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 334 of file variant_int32.c.

                                                                          {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_int32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_int64_t()

amxc_var_t* amxc_var_add_new_int64_t	(	amxc_var_t *const	var,
		int64_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument int64_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 341 of file variant_int64.c.

                                                                          {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_int64_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_int8_t()

amxc_var_t* amxc_var_add_new_int8_t	(	amxc_var_t *const	var,
		int8_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument int8_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 316 of file variant_int8.c.

                                                                        {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_int8_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_amxc_htable_t()

amxc_var_t* amxc_var_add_new_key_amxc_htable_t	(	amxc_var_t *const	var,
		const char *	key,
		const amxc_htable_t *	htable
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

If the provided htable pointer is NULL, an empty htable is added.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument amxc_htable_t; The linked list must be a list where the values are variants

Parameters

var	pointer to a variant struct
key	the key
htable	the new htable value

Returns: The new variant

Definition at line 474 of file variant_htable.c.

                                                                             {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
     when_null(htable, exit);
  
     if(variant_htable_copy_htable(subvar, htable) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_amxc_llist_t()

amxc_var_t* amxc_var_add_new_key_amxc_llist_t	(	amxc_var_t *const	var,
		const char *	key,
		const amxc_llist_t *	list
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

If the provided list pointer is NULL, an empty list is added.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument amxc_llist_t; The linked list must be a list where the values are variants

Parameters

var	pointer to a variant struct
key	the key
list	the new list value

Returns: The new variant

Definition at line 441 of file variant_list.c.

                                                                         {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
     when_null(list, exit);
  
     if(variant_list_copy_list(subvar, list) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_amxc_ts_t()

amxc_var_t* amxc_var_add_new_key_amxc_ts_t	(	amxc_var_t *const	var,
		const char *	key,
		amxc_ts_t *	ts
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument ts_t

Parameters

var	pointer to a variant struct
key	the key
ts	the timestamp value

Returns: The new variant

Definition at line 232 of file variant_timestamp.c.

                                                           {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(ts == NULL) {
         amxc_var_set_type(subvar, AMXC_VAR_ID_TIMESTAMP);
     } else {
         if(amxc_var_set_amxc_ts_t(subvar, ts) != 0) {
             amxc_var_delete(&subvar);
         }
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_bool()

amxc_var_t* amxc_var_add_new_key_bool	(	amxc_var_t *const	var,
		const char *	key,
		bool	boolean
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument bool

Parameters

var	pointer to a variant struct
key	the key
boolean	the new boolean value

Returns: The new variant

Definition at line 274 of file variant_bool.c.

                                                                                             {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_bool(subvar, boolean) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_cstring_t()

amxc_var_t* amxc_var_add_new_key_cstring_t	(	amxc_var_t *const	var,
		const char *	key,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument cstring_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 711 of file variant_char.c.

                                                                   {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_cstring_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_csv_string_t()

amxc_var_t* amxc_var_add_new_key_csv_string_t	(	amxc_var_t *const	var,
		const char *	key,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument csv_string_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 728 of file variant_char.c.

                                                                      {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_csv_string_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_double()

amxc_var_t* amxc_var_add_new_key_double	(	amxc_var_t *const	var,
		const char *	key,
		double	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument double

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 354 of file variant_double.c.

                                                                                             {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_double(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_fd_t()

amxc_var_t* amxc_var_add_new_key_fd_t	(	amxc_var_t *const	var,
		const char *	key,
		int	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument fd_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 343 of file variant_fd.c.

                                                                                        {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_fd_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_int16_t()

amxc_var_t* amxc_var_add_new_key_int16_t	(	amxc_var_t *const	var,
		const char *	key,
		int16_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument int16_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 344 of file variant_int16.c.

                                                                                               {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_int32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_int32_t()

amxc_var_t* amxc_var_add_new_key_int32_t	(	amxc_var_t *const	var,
		const char *	key,
		int32_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument int32_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 349 of file variant_int32.c.

                                                                                               {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_int32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_int64_t()

amxc_var_t* amxc_var_add_new_key_int64_t	(	amxc_var_t *const	var,
		const char *	key,
		int64_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument int64_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 356 of file variant_int64.c.

                                                                                               {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_int64_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_int8_t()

amxc_var_t* amxc_var_add_new_key_int8_t	(	amxc_var_t *const	var,
		const char *	key,
		int8_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument int8_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 331 of file variant_int8.c.

                                                                                             {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_int32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_ssv_string_t()

amxc_var_t* amxc_var_add_new_key_ssv_string_t	(	amxc_var_t *const	var,
		const char *	key,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument ssv_string_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 745 of file variant_char.c.

                                                                      {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_ssv_string_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_uint16_t()

amxc_var_t* amxc_var_add_new_key_uint16_t	(	amxc_var_t *const	var,
		const char *	key,
		uint16_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument uint16_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 346 of file variant_uint16.c.

                                                                                                 {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint16_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_uint32_t()

amxc_var_t* amxc_var_add_new_key_uint32_t	(	amxc_var_t *const	var,
		const char *	key,
		uint32_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument uint32_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 355 of file variant_uint32.c.

                                                                                                 {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_uint64_t()

amxc_var_t* amxc_var_add_new_key_uint64_t	(	amxc_var_t *const	var,
		const char *	key,
		uint64_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument uint64_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 363 of file variant_uint64.c.

                                                                                                 {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint64_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_key_uint8_t()

amxc_var_t* amxc_var_add_new_key_uint8_t	(	amxc_var_t *const	var,
		const char *	key,
		uint8_t	val
	)

Conversion helper function.

See also: amxc_var_add_key

Creates a new variant and adds it to a composite variant that supports key addressing.

Note: Do not call this function directly, use macro amxc_var_add_key with the type argument uint8_t

Parameters

var	pointer to a variant struct
key	the key
val	the new value

Returns: The new variant

Definition at line 339 of file variant_uint8.c.

                                                                                               {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new_key(var, key);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint8_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_ssv_string_t()

amxc_var_t* amxc_var_add_new_ssv_string_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument ssv_string_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 696 of file variant_char.c.

                                                                                         {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_csv_string_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_uint16_t()

amxc_var_t* amxc_var_add_new_uint16_t	(	amxc_var_t *const	var,
		uint16_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument uint16_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 331 of file variant_uint16.c.

                                                                            {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint16_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_uint32_t()

amxc_var_t* amxc_var_add_new_uint32_t	(	amxc_var_t *const	var,
		uint32_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument uint32_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 340 of file variant_uint32.c.

                                                                            {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint32_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_uint64_t()

amxc_var_t* amxc_var_add_new_uint64_t	(	amxc_var_t *const	var,
		uint64_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument uint64_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 348 of file variant_uint64.c.

                                                                            {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint64_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_add_new_uint8_t()

amxc_var_t* amxc_var_add_new_uint8_t	(	amxc_var_t *const	var,
		uint8_t	val
	)

Conversion helper function.

See also: amxc_var_add

Creates a new variant and adds it to a composite variant that supports index addressing.

Note: Do not call this function directly, use macro amxc_var_add with the type argument uint8_t

Parameters

var	pointer to a variant struct
val	the value

Returns: The new variant

Definition at line 324 of file variant_uint8.c.

                                                                          {
     amxc_var_t* subvar = NULL;
  
     when_null(var, exit);
     subvar = amxc_var_add_new(var);
     when_null(subvar, exit);
  
     if(amxc_var_set_uint8_t(subvar, val) != 0) {
         amxc_var_delete(&subvar);
     }
  
 exit:
     return subvar;
 }

◆ amxc_var_get_amxc_htable_t()

amxc_htable_t* amxc_var_get_amxc_htable_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument amxc_htable_t

Parameters

var	pointer to a variant struct

Returns: amxc_htable_t* value, must be freed when not needed anymore

Definition at line 417 of file variant_htable.c.

                                                                        {
     amxc_htable_t* htable = NULL;
     amxc_htable_it_t* it = NULL;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_HTABLE), exit);
  
     if(amxc_htable_new(&htable, amxc_htable_capacity(&variant.data.vm)) != 0) {
         amxc_var_clean(&variant);
         goto exit;
     }
  
     it = amxc_htable_take_first(&variant.data.vm);
     while(it != NULL) {
         const char* key = amxc_htable_it_get_key(it);
         amxc_htable_insert(htable, key, it);
         it = amxc_htable_take_first(&variant.data.vm);
     }
  
     amxc_var_clean(&variant);
  
 exit:
     return htable;
 }

◆ amxc_var_get_amxc_llist_t()

amxc_llist_t* amxc_var_get_amxc_llist_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument amxc_llist_t

Parameters

var	pointer to a variant struct

Returns: amxc_llist_t* value, must be freed when not needed anymore

Definition at line 385 of file variant_list.c.

                                                                      {
     amxc_llist_t* llist = NULL;
     amxc_llist_it_t* it = NULL;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_LIST), exit);
  
     if(amxc_llist_new(&llist) != 0) {
         amxc_var_clean(&variant);
         goto exit;
     }
  
     it = amxc_llist_take_first(&variant.data.vl);
     while(it != NULL) {
         amxc_llist_append(llist, it);
         it = amxc_llist_take_first(&variant.data.vl);
     }
  
     amxc_var_clean(&variant);
  
 exit:
     return llist;
 }

◆ amxc_var_get_amxc_ts_t()

amxc_ts_t* amxc_var_get_amxc_ts_t ( const amxc_var_t * var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument amxc_ts_t

Parameters

var	pointer to a variant struct

Returns: amxc_ts_t* value, must be freed when not needed anymore

Definition at line 182 of file variant_timestamp.c.

                                                          {
     amxc_ts_t* ts = NULL;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_TIMESTAMP), exit);
     ts = (amxc_ts_t*) calloc(1, sizeof(amxc_ts_t));
     when_null(ts, exit);
  
     ts->sec = variant.data.ts.sec;
     ts->nsec = variant.data.ts.nsec;
     ts->offset = variant.data.ts.offset;
  
     amxc_var_clean(&variant);
  
 exit:
     return ts;
 }

◆ amxc_var_get_bool()

bool amxc_var_get_bool ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument bool

Parameters

var	pointer to a variant struct

Returns: boolean value

Definition at line 234 of file variant_bool.c.

                                               {
     bool boolean = false;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_BOOL), exit);
     boolean = variant.data.b;
     amxc_var_clean(&variant);
  
 exit:
     return boolean;
 }

◆ amxc_var_get_const_amxc_htable_t()

const amxc_htable_t* amxc_var_get_const_amxc_htable_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a table type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument amxc_htable_t; do not free the returned pointer.

Parameters

var	pointer to a variant struct

Returns: amxc_htable_t* value

Definition at line 444 of file variant_htable.c.

                                                                                    {
     const amxc_htable_t* retval = NULL;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_HTABLE, exit);
  
     retval = &var->data.vm;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_amxc_llist_t()

const amxc_llist_t* amxc_var_get_const_amxc_llist_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a list type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument amxc_llist_t; do not free the returned pointer.

Parameters

var	pointer to a variant struct

Returns: amxc_llist_t* value

Definition at line 411 of file variant_list.c.

                                                                                  {
     const amxc_llist_t* retval = NULL;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_LIST, exit);
  
     retval = &var->data.vl;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_amxc_ts_t()

const amxc_ts_t* amxc_var_get_const_amxc_ts_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a timestamp type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument ts_t

Parameters

var	pointer to a variant struct

Returns: amxc_ts_t* value

Definition at line 202 of file variant_timestamp.c.

                                                                            {
     const amxc_ts_t* retval = NULL;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_TIMESTAMP, exit);
  
     retval = &var->data.ts;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_bool()

bool amxc_var_get_const_bool ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return false if the variant is not of a bool type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument bool; do not free the returned pointer.

Parameters

var	pointer to a variant struct

Returns: bool value

Definition at line 248 of file variant_bool.c.

                                                           {
     bool retval = false;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_BOOL, exit);
  
     retval = var->data.b;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_cstring_t()

const char* amxc_var_get_const_cstring_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a string type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument cstring_t; do not free the returned pointer.

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 600 of file variant_char.c.

                                                                           {
     const char* retval = NULL;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_CSTRING &&
               var->type_id != AMXC_VAR_ID_CSV_STRING &&
               var->type_id != AMXC_VAR_ID_SSV_STRING, exit);
  
     retval = var->data.s == NULL ? "" : var->data.s;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_csv_string_t()

AMXC_INLINE const char* amxc_var_get_const_csv_string_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a cstring_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument csv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 2576 of file amxc_variant.h.

                                                                          {
     return amxc_var_get_const_cstring_t(var);
 }

◆ amxc_var_get_const_double()

double amxc_var_get_const_double ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a double type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument double

Parameters

var	pointer to a variant struct

Returns: double value

Definition at line 328 of file variant_double.c.

                                                               {
     double retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_DOUBLE, exit);
  
     retval = var->data.d;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_fd_t()

int amxc_var_get_const_fd_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a fd type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument fd_t

Parameters

var	pointer to a variant struct

Returns: file descriptor value

Definition at line 317 of file variant_fd.c.

                                                           {
     fd_t retval = -1;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_FD, exit);
  
     retval = var->data.fd;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_int16_t()

int16_t amxc_var_get_const_int16_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a int16_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument int16_t

Parameters

var	pointer to a variant struct

Returns: int16_t value

Definition at line 318 of file variant_int16.c.

                                                                 {
     int16_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_INT16, exit);
  
     retval = var->data.i16;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_int32_t()

int32_t amxc_var_get_const_int32_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a int32_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument int32_t

Parameters

var	pointer to a variant struct

Returns: int32_t value

Definition at line 323 of file variant_int32.c.

                                                                 {
     int32_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_INT32, exit);
  
     retval = var->data.i32;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_int64_t()

int64_t amxc_var_get_const_int64_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a int64_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument int64_t

Parameters

var	pointer to a variant struct

Returns: int64_t value

Definition at line 330 of file variant_int64.c.

                                                                 {
     int64_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_INT64, exit);
  
     retval = var->data.i64;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_int8_t()

int8_t amxc_var_get_const_int8_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a int8_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument int8_t

Parameters

var	pointer to a variant struct

Returns: int8_t value

Definition at line 305 of file variant_int8.c.

                                                               {
     int8_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_INT8, exit);
  
     retval = var->data.i8;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_ssv_string_t()

AMXC_INLINE const char* amxc_var_get_const_ssv_string_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return NULL if the variant is not of a cstring_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument ssv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 2599 of file amxc_variant.h.

                                                                          {
     return amxc_var_get_const_cstring_t(var);
 }

◆ amxc_var_get_const_uint16_t()

uint16_t amxc_var_get_const_uint16_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a uint16_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument uint16_t

Parameters

var	pointer to a variant struct

Returns: uint16_t value

Definition at line 320 of file variant_uint16.c.

                                                                   {
     uint32_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_UINT16, exit);
  
     retval = var->data.ui16;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_uint32_t()

uint32_t amxc_var_get_const_uint32_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a uint32_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument uint32_t

Parameters

var	pointer to a variant struct

Returns: uint32_t value

Definition at line 329 of file variant_uint32.c.

                                                                   {
     uint32_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_UINT32, exit);
  
     retval = var->data.ui32;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_uint64_t()

uint64_t amxc_var_get_const_uint64_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a uint64_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument uint64_t

Parameters

var	pointer to a variant struct

Returns: uint64_t value

Definition at line 337 of file variant_uint64.c.

                                                                   {
     uint64_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_UINT64, exit);
  
     retval = var->data.ui64;
  
 exit:
     return retval;
 }

◆ amxc_var_get_const_uint8_t()

uint8_t amxc_var_get_const_uint8_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_constcast

Will return 0 if the variant is not of a uint8_t type

Note: Do not call this function directly, use macro amxc_var_constcast with the type argument uint8_t

Parameters

var	pointer to a variant struct

Returns: uint8_t value

Definition at line 313 of file variant_uint8.c.

                                                                 {
     uint32_t retval = 0;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_UINT8, exit);
  
     retval = var->data.ui8;
  
 exit:
     return retval;
 }

◆ amxc_var_get_cstring_t()

char* amxc_var_get_cstring_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument cstring_t

Parameters

var	pointer to a variant struct

Returns: char* value, must be freed when not needed anymore

Definition at line 585 of file variant_char.c.

                                                               {
     char* retval = NULL;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_CSTRING), exit);
     retval = variant.data.s != NULL ? variant.data.s : strdup("");
     variant.data.s = NULL;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_csv_string_t()

AMXC_INLINE char* amxc_var_get_csv_string_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument csv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value, must be freed when not needed anymore

Definition at line 2234 of file amxc_variant.h.

                                                              {
     return amxc_var_get_cstring_t(var);
 }

◆ amxc_var_get_double()

double amxc_var_get_double ( const amxc_var_t * var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument double

Parameters

var	pointer to a variant struct

Returns: double value

Definition at line 313 of file variant_double.c.

                                                   {
     double retval = 0;
     amxc_var_t variant;
  
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_DOUBLE), exit);
     retval = variant.data.d;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_fd_t()

int amxc_var_get_fd_t ( const amxc_var_t * var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument fd_t

Parameters

var	pointer to a variant struct

Returns: int value

Definition at line 303 of file variant_fd.c.

                                               {
     int64_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_FD), exit);
     retval = variant.data.fd;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_int16_t()

int16_t amxc_var_get_int16_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument int16_t

Parameters

var	pointer to a variant struct

Returns: int16_t value

Definition at line 304 of file variant_int16.c.

                                                     {
     int16_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_INT16), exit);
     retval = variant.data.i16;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_int32_t()

int32_t amxc_var_get_int32_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument int32_t

Parameters

var	pointer to a variant struct

Returns: int32_t value

Definition at line 309 of file variant_int32.c.

                                                     {
     int32_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_INT32), exit);
     retval = variant.data.i32;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_int64_t()

int64_t amxc_var_get_int64_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument int64_t

Parameters

var	pointer to a variant struct

Returns: int64_t value

Definition at line 316 of file variant_int64.c.

                                                     {
     int64_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_INT64), exit);
     retval = variant.data.i64;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_int8_t()

int8_t amxc_var_get_int8_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument int8_t

Parameters

var	pointer to a variant struct

Returns: int8_t value

Definition at line 291 of file variant_int8.c.

                                                   {
     int8_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_INT8), exit);
     retval = variant.data.i8;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_ssv_string_t()

AMXC_INLINE char* amxc_var_get_ssv_string_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument ssv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value, must be freed when not needed anymore

Definition at line 2255 of file amxc_variant.h.

                                                              {
     return amxc_var_get_cstring_t(var);
 }

◆ amxc_var_get_uint16_t()

uint16_t amxc_var_get_uint16_t ( const amxc_var_t * var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument uint16_t

Parameters

var	pointer to a variant struct

Returns: uint16_t value

Definition at line 306 of file variant_uint16.c.

                                                       {
     uint32_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_UINT16), exit);
     retval = variant.data.ui16;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_uint32_t()

uint32_t amxc_var_get_uint32_t ( const amxc_var_t * var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument uint32_t

Parameters

var	pointer to a variant struct

Returns: uint32_t value

Definition at line 315 of file variant_uint32.c.

                                                       {
     uint32_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_UINT32), exit);
     retval = variant.data.ui32;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_uint64_t()

uint64_t amxc_var_get_uint64_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument uint64_t

Parameters

var	pointer to a variant struct

Returns: uint64_t value

Definition at line 323 of file variant_uint64.c.

                                                       {
     uint64_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_UINT64), exit);
     retval = variant.data.ui64;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_get_uint8_t()

uint8_t amxc_var_get_uint8_t ( const amxc_var_t *const var )

Conversion helper function.

See also: amxc_var_dyncast

Note: Do not call this function directly, use macro amxc_var_dyncast with the type argument uint8_t

Parameters

var	pointer to a variant struct

Returns: uint8_t value

Definition at line 299 of file variant_uint8.c.

                                                     {
     uint32_t retval = 0;
     amxc_var_t variant;
     when_null(var, exit);
  
     amxc_var_init(&variant);
     when_failed(amxc_var_convert(&variant, var, AMXC_VAR_ID_UINT8), exit);
     retval = variant.data.ui8;
     amxc_var_clean(&variant);
  
 exit:
     return retval;
 }

◆ amxc_var_push_amxc_string_t()

int amxc_var_push_amxc_string_t	(	amxc_var_t *const	var,
		amxc_string_t *	val
	)

Pushes a value in a variant.

See also: amxc_var_push

Note: Do not call this function directly, use macro amxc_var_push with the type argument amxc_string_t

Parameters

var	pointer to a variant struct
val	the value that is pushed into the variant

Returns: 0 when succesful

Definition at line 696 of file amxc_variant.c.

                                                                            {
     int retval = -1;
     char* buffer = NULL;
  
     when_null(var, exit);
     when_null(val, exit);
  
     amxc_var_clean(var);
  
     buffer = amxc_string_take_buffer(val);
     retval = amxc_var_push_cstring_t(var, buffer);
  
 exit:
     return retval;
 }

◆ amxc_var_push_cstring_t()

int amxc_var_push_cstring_t	(	amxc_var_t *const	var,
		char *	val
	)

Pushes a value in a variant.

See also: amxc_var_push

Note: Do not call this function directly, use macro amxc_var_push with the type argument cstring_t

Parameters

var	pointer to a variant struct
val	the value that is pushed into the variant

Returns: 0 when succesful

Definition at line 629 of file variant_char.c.

                                                               {
     int retval = -1;
  
     when_null(var, exit);
     amxc_var_clean(var);
  
     var->type_id = AMXC_VAR_ID_CSTRING;
     var->data.s = val;
  
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_push_csv_string_t()

int amxc_var_push_csv_string_t	(	amxc_var_t *const	var,
		char *	val
	)

Pushes a value in a variant.

See also: amxc_var_push

Note: Do not call this function directly, use macro amxc_var_push with the type argument csv_string_t

Parameters

var	pointer to a variant struct
val	the value that is pushed into the variant

Returns: 0 when succesful

Definition at line 644 of file variant_char.c.

                                                                  {
     int retval = -1;
  
     retval = amxc_var_push_cstring_t(var, val);
     if(retval == 0) {
         var->type_id = AMXC_VAR_ID_CSV_STRING;
     }
  
     return retval;
 }

◆ amxc_var_push_ssv_string_t()

int amxc_var_push_ssv_string_t	(	amxc_var_t *const	var,
		char *	val
	)

Pushes a value in a variant.

See also: amxc_var_push

Note: Do not call this function directly, use macro amxc_var_push with the type argument ssv_string_t

Parameters

var	pointer to a variant struct
val	the value that is pushed into the variant

Returns: 0 when succesful

Definition at line 655 of file variant_char.c.

                                                                  {
     int retval = -1;
  
     retval = amxc_var_push_cstring_t(var, val);
     if(retval == 0) {
         var->type_id = AMXC_VAR_ID_SSV_STRING;
     }
  
     return retval;
 }

◆ amxc_var_set_amxc_ts_t()

int amxc_var_set_amxc_ts_t	(	amxc_var_t *	var,
		amxc_ts_t *	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument amxc_ts_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 165 of file variant_timestamp.c.

                                                            {
     int retval = -1;
     when_null(var, exit);
     when_null(ts, exit);
  
     amxc_var_set_type(var, AMXC_VAR_ID_TIMESTAMP);
  
     var->data.ts.sec = ts->sec;
     var->data.ts.nsec = ts->nsec;
     var->data.ts.offset = ts->offset;
  
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_bool()

int amxc_var_set_bool	(	amxc_var_t *const	var,
		bool	boolean
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument bool

Parameters

var	pointer to a variant struct
boolean	the bool value to set, either true or false

Returns: 0 when the value was set

Definition at line 221 of file variant_bool.c.

                                                      {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_BOOL), exit);
  
     var->data.b = boolean;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_cstring_t()

int amxc_var_set_cstring_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument cstring_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 549 of file variant_char.c.

                                                                          {
     int retval = -1;
     when_null(var, exit);
     when_null(val, exit);
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_CSTRING), exit);
  
     retval = amxc_var_set_data(var, val);
  
 exit:
     return retval;
 }

◆ amxc_var_set_csv_string_t()

int amxc_var_set_csv_string_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument csv_string_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 561 of file variant_char.c.

                                                                             {
     int retval = -1;
     when_null(var, exit);
     when_null(val, exit);
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_CSV_STRING), exit);
  
     retval = amxc_var_set_data(var, val);
  
 exit:
     return retval;
 }

◆ amxc_var_set_double()

int amxc_var_set_double	(	amxc_var_t *	var,
		double	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument double

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 300 of file variant_double.c.

                                                      {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_DOUBLE), exit);
  
     var->data.d = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_fd_t()

int amxc_var_set_fd_t	(	amxc_var_t *	var,
		int	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument fd_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 285 of file variant_fd.c.

                                                 {
     int retval = -1;
     struct rlimit nofile = { 0, 0 };
     when_null(var, exit);
  
     when_failed(getrlimit(RLIMIT_NOFILE, &nofile), exit);
  
     when_true(val < 0 || (rlim_t) llabs(val) > nofile.rlim_max, exit);
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_FD), exit);
  
     var->data.fd = (int) llabs(val);
  
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_int16_t()

int amxc_var_set_int16_t	(	amxc_var_t *const	var,
		int16_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument int16_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 291 of file variant_int16.c.

                                                        {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_INT16), exit);
  
     var->data.i16 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_int32_t()

int amxc_var_set_int32_t	(	amxc_var_t *const	var,
		int32_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument int32_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 296 of file variant_int32.c.

                                                        {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_INT32), exit);
  
     var->data.i32 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_int64_t()

int amxc_var_set_int64_t	(	amxc_var_t *const	var,
		int64_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument int64_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 303 of file variant_int64.c.

                                                        {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_INT64), exit);
  
     var->data.i64 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_int8_t()

int amxc_var_set_int8_t	(	amxc_var_t *const	var,
		int8_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument int8_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 278 of file variant_int8.c.

                                                      {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_INT8), exit);
  
     var->data.i8 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_ssv_string_t()

int amxc_var_set_ssv_string_t	(	amxc_var_t *const	var,
		const char *const	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument ssv_string_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 573 of file variant_char.c.

                                                                             {
     int retval = -1;
     when_null(var, exit);
     when_null(val, exit);
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_SSV_STRING), exit);
  
     retval = amxc_var_set_data(var, val);
  
 exit:
     return retval;
 }

◆ amxc_var_set_uint16_t()

int amxc_var_set_uint16_t	(	amxc_var_t *const	var,
		uint16_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument uint16_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 293 of file variant_uint16.c.

                                                          {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_UINT16), exit);
  
     var->data.ui16 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_uint32_t()

int amxc_var_set_uint32_t	(	amxc_var_t *const	var,
		uint32_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument uint16_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 302 of file variant_uint32.c.

                                                          {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_UINT32), exit);
  
     var->data.ui32 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_uint64_t()

int amxc_var_set_uint64_t	(	amxc_var_t *const	var,
		uint64_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument uint64_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 310 of file variant_uint64.c.

                                                          {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_UINT64), exit);
  
     var->data.ui64 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_set_uint8_t()

int amxc_var_set_uint8_t	(	amxc_var_t *const	var,
		uint8_t	val
	)

Setter helper function.

See also: amxc_var_set

Note: Do not call this function directly, use macro amxc_var_set with the type argument uint8_t

Parameters

var	pointer to a variant struct
val	the value to set

Returns: 0 when the value was set

Definition at line 286 of file variant_uint8.c.

                                                        {
     int retval = -1;
     when_null(var, exit);
  
     when_failed(amxc_var_set_type(var, AMXC_VAR_ID_UINT8), exit);
  
     var->data.ui8 = val;
     retval = 0;
  
 exit:
     return retval;
 }

◆ amxc_var_take_amxc_string_t()

amxc_string_t* amxc_var_take_amxc_string_t ( amxc_var_t *const var )

Takes a value from a variant.

See also: amxc_var_take

Note: Do not call this function directly, use macro amxc_var_take with the type argument amxc_string_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 676 of file amxc_variant.c.

                                                                   {
     amxc_string_t* retval = NULL;
  
     when_null(var, exit);
     when_true(amxc_var_type_of(var) != AMXC_VAR_ID_CSTRING &&
               amxc_var_type_of(var) != AMXC_VAR_ID_SSV_STRING &&
               amxc_var_type_of(var) != AMXC_VAR_ID_CSV_STRING, exit);
     when_null(var->data.s, exit);
  
     when_failed(amxc_string_new(&retval, 0), exit);
     when_null(retval, exit);
  
     amxc_string_push_buffer(retval, var->data.s, strlen(var->data.s) + 1);
     var->data.s = NULL;
     var->type_id = AMXC_VAR_ID_NULL;
  
 exit:
     return retval;
 }

◆ amxc_var_take_cstring_t()

char* amxc_var_take_cstring_t ( amxc_var_t *const var )

Takes a value from a variant.

See also: amxc_var_take

Note: Do not call this function directly, use macro amxc_var_take with the type argument cstring_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 613 of file variant_char.c.

                                                          {
     char* retval = NULL;
     when_null(var, exit);
     when_true(var->type_id != AMXC_VAR_ID_CSTRING &&
               var->type_id != AMXC_VAR_ID_CSV_STRING &&
               var->type_id != AMXC_VAR_ID_SSV_STRING, exit);
  
     retval = var->data.s;
  
     var->data.s = NULL;
     var->type_id = AMXC_VAR_ID_NULL;
  
 exit:
     return retval;
 }

◆ amxc_var_take_csv_string_t()

AMXC_INLINE char* amxc_var_take_csv_string_t ( amxc_var_t *const var )

Takes a value from a variant.

See also: amxc_var_take

Note: Do not call this function directly, use macro amxc_var_take with the type argument csv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 3418 of file amxc_variant.h.

                                                             {
     return amxc_var_take_cstring_t(var);
 }

◆ amxc_var_take_ssv_string_t()

AMXC_INLINE char* amxc_var_take_ssv_string_t ( amxc_var_t *const var )

Takes a value from a variant.

See also: amxc_var_take

Note: Do not call this function directly, use macro amxc_var_take with the type argument ssv_string_t

Parameters

var	pointer to a variant struct

Returns: char* value

Definition at line 3439 of file amxc_variant.h.

                                                             {
     return amxc_var_take_cstring_t(var);
 }

◆ variant_htable_it_free()

void variant_htable_it_free	(	const char *	key,
		amxc_htable_it_t *	it
	)

Helper functions, can be used as delete function for htable.

When deleting an ambiorix htable and the htable contains only ambiorix variants, this function can be used as callback function to free all variants in the htable, see amxc_htable_delete.

Parameters

key	the key associated with the hash table iterator
it	pointer to a variant htable iterator

◆ variant_list_it_free()

void variant_list_it_free ( amxc_llist_it_t * it )

Helper functions, can be used as delete function for linked lists.

When deleting an ambiorix linked list and the linked list contains only ambiorix variants, this function can be used as callback function to free all variants in the linked list, see amxc_llist_delete

Parameters

it	pointer to a variant linked list iterator

Definition at line 66 of file variant_list.c.

                                                {
     amxc_var_t* var = amxc_var_from_llist_it(it);
     amxc_var_delete(&var);
 }

Functions

Detailed Description

Function Documentation

◆ amxc_var_add_new_amxc_htable_t()

◆ amxc_var_add_new_amxc_llist_t()

◆ amxc_var_add_new_amxc_ts_t()

◆ amxc_var_add_new_bool()

◆ amxc_var_add_new_cstring_t()

◆ amxc_var_add_new_csv_string_t()

◆ amxc_var_add_new_double()

◆ amxc_var_add_new_fd_t()

◆ amxc_var_add_new_int16_t()

◆ amxc_var_add_new_int32_t()

◆ amxc_var_add_new_int64_t()

◆ amxc_var_add_new_int8_t()

◆ amxc_var_add_new_key_amxc_htable_t()

◆ amxc_var_add_new_key_amxc_llist_t()

◆ amxc_var_add_new_key_amxc_ts_t()

◆ amxc_var_add_new_key_bool()

◆ amxc_var_add_new_key_cstring_t()

◆ amxc_var_add_new_key_csv_string_t()

◆ amxc_var_add_new_key_double()

◆ amxc_var_add_new_key_fd_t()

◆ amxc_var_add_new_key_int16_t()

◆ amxc_var_add_new_key_int32_t()

◆ amxc_var_add_new_key_int64_t()

◆ amxc_var_add_new_key_int8_t()

◆ amxc_var_add_new_key_ssv_string_t()

◆ amxc_var_add_new_key_uint16_t()

◆ amxc_var_add_new_key_uint32_t()

◆ amxc_var_add_new_key_uint64_t()

◆ amxc_var_add_new_key_uint8_t()

◆ amxc_var_add_new_ssv_string_t()

◆ amxc_var_add_new_uint16_t()

◆ amxc_var_add_new_uint32_t()

◆ amxc_var_add_new_uint64_t()

◆ amxc_var_add_new_uint8_t()

◆ amxc_var_get_amxc_htable_t()

◆ amxc_var_get_amxc_llist_t()

◆ amxc_var_get_amxc_ts_t()

◆ amxc_var_get_bool()

◆ amxc_var_get_const_amxc_htable_t()

◆ amxc_var_get_const_amxc_llist_t()

◆ amxc_var_get_const_amxc_ts_t()

◆ amxc_var_get_const_bool()

◆ amxc_var_get_const_cstring_t()

◆ amxc_var_get_const_csv_string_t()

◆ amxc_var_get_const_double()

◆ amxc_var_get_const_fd_t()

◆ amxc_var_get_const_int16_t()

◆ amxc_var_get_const_int32_t()

◆ amxc_var_get_const_int64_t()

◆ amxc_var_get_const_int8_t()

◆ amxc_var_get_const_ssv_string_t()

◆ amxc_var_get_const_uint16_t()

◆ amxc_var_get_const_uint32_t()

◆ amxc_var_get_const_uint64_t()

◆ amxc_var_get_const_uint8_t()

◆ amxc_var_get_cstring_t()

◆ amxc_var_get_csv_string_t()

◆ amxc_var_get_double()

◆ amxc_var_get_fd_t()

◆ amxc_var_get_int16_t()

◆ amxc_var_get_int32_t()

◆ amxc_var_get_int64_t()

◆ amxc_var_get_int8_t()

◆ amxc_var_get_ssv_string_t()

◆ amxc_var_get_uint16_t()

◆ amxc_var_get_uint32_t()

◆ amxc_var_get_uint64_t()

◆ amxc_var_get_uint8_t()

◆ amxc_var_push_amxc_string_t()

◆ amxc_var_push_cstring_t()

◆ amxc_var_push_csv_string_t()

◆ amxc_var_push_ssv_string_t()

◆ amxc_var_set_amxc_ts_t()

◆ amxc_var_set_bool()

◆ amxc_var_set_cstring_t()

◆ amxc_var_set_csv_string_t()

◆ amxc_var_set_double()