mon_arg

typedef struct {
	/* Argument name and data type. Only simple types are allowed */
	mon_type		*type;
	/* Argument value */
	mon_simple_val		value;
} mon_arg;

The mon_arg structure contains the actual value of a metric parameter.

mon_arg_list

typedef struct {
	unsigned int		cnt;
	GList			*list;
} mon_arg_list;

The mon_arg_list structure contains a list of metric arguments.

mon_arg_cmp ()

int         mon_arg_cmp                     (const mon_arg *arg1,
                                             const mon_arg *arg2);

Compares two arguments and decides their lexicographical order by first comparing their names, then their types and finally their values.

mon_arg_free ()

void        mon_arg_free                    (mon_arg *arg);

Frees the memory allocated to a mon_arg.

mon_arg_list_new ()

mon_arg_list* mon_arg_list_new              (void);

Allocates a new mon_arg_list.

mon_arg_list_free ()

void        mon_arg_list_free               (mon_arg_list *arglist);

Frees every element of a mon_arg_list and frees the memory allocated to the list itself.

mon_arg_list_add ()

int         mon_arg_list_add                (mon_arg_list *arglist,
                                             mon_type *type,
                                             const mon_simple_val *val);

Add a new argument to a mon_arg_list.

mon_arg_list_del ()

void        mon_arg_list_del                (mon_arg_list *arglist,
                                             const char *name);

Removes a named argument from an argument list. In case of multi-valued arguments, all values are removed.

mon_arg_list_add_simple ()

int         mon_arg_list_add_simple         (mon_arg_list *arglist,
                                             const char *name,
                                             mon_basic_type type,
                                             const mon_simple_val *val);

Add an argument of a simple type to a mon_arg_list.

mon_arg_list_add_string ()

int         mon_arg_list_add_string         (mon_arg_list *arglist,
                                             const char *name,
                                             const char *value);

Add a string argument to a mon_arg_list.

mon_arg_list_add_int32 ()

int         mon_arg_list_add_int32          (mon_arg_list *arglist,
                                             const char *name,
                                             int32_t value);

Add a 32-bit signed integer to a mon_arg_list.

mon_arg_list_add_uint32 ()

int         mon_arg_list_add_uint32         (mon_arg_list *arglist,
                                             const char *name,
                                             uint32_t value);

Add a 32-bit unsigned integer to a mon_arg_list.

mon_arg_list_add_int64 ()

int         mon_arg_list_add_int64          (mon_arg_list *arglist,
                                             const char *name,
                                             int64_t value);

Add a 64-bit signed integer to a mon_arg_list.

mon_arg_list_add_uint64 ()

int         mon_arg_list_add_uint64         (mon_arg_list *arglist,
                                             const char *name,
                                             uint64_t value);

Add a 64-bit unsigned integer to a mon_arg_list.

mon_arg_list_add_double ()

int         mon_arg_list_add_double         (mon_arg_list *arglist,
                                             const char *name,
                                             double value);

Add a 64-bit double precision floating point number to a mon_arg_list.

mon_arg_list_add_parsed ()

int         mon_arg_list_add_parsed         (mon_arg_list *arglist,
                                             const char *name,
                                             mon_basic_type type,
                                             const char *value);

Parse an argument given as a string and append it to arglist.

This function is useful when the user specifies an argument in a textual format (e.g. command line).

mon_arg_list_copy ()

mon_arg_list* mon_arg_list_copy             (const mon_arg_list *src);

Makes a deep copy of a mon_arg_list.

mon_arg_list_find ()

mon_arg*    mon_arg_list_find               (const mon_arg_list *arglist,
                                             const char *name);

Find a named argument in a mon_arg_list.

mon_arg_list_val ()

mon_simple_val* mon_arg_list_val            (const mon_arg_list *arglist,
                                             const char *name);

Like mon_arg_list_find(), but returns the argument's value instead of the mon_arg structure.

mon_arg_list_print ()

int         mon_arg_list_print              (const mon_arg_list *arglist,
                                             char **dst);

Convert an argument list to a string (mainly for debugging).

mon_arg_list_cmp ()

int         mon_arg_list_cmp                (const mon_arg_list *args1,
                                             const mon_arg_list *args2);

Compares two argument lists according to a lexicographical ordering.

mon_arg_list_encode ()

int         mon_arg_list_encode             (mon_buffer *buf,
                                             const mon_arg_list *arglist);

Encodes a mon_arg_list according to the monp:// protocol binding.

mon_arg_list_decode ()

int         mon_arg_list_decode             (mon_buffer *buf,
                                             mon_arg_list **arglist);

Decodes a mon_arg_list encoded by mon_arg_list_encode().