data model path API

Data model path helper functions. More...

Functions
amxd_status_t	amxd_path_init (amxd_path_t *path, const char *object_path)
	Initializes an amxd_path_t structure. More...
void	amxd_path_clean (amxd_path_t *path)
	Cleans an amxd_path_t structure. More...
amxd_status_t	amxd_path_new (amxd_path_t **path, const char *object_path)
	Allocates and initializes an amxd_path_t structure. More...
void	amxd_path_delete (amxd_path_t **path)
	Frees an allocated amxd_path_t structure. More...
void	amxd_path_reset (amxd_path_t *path)
	Resets the amxd_path_t structure. More...
amxd_status_t	amxd_path_vsetf (amxd_path_t *path, bool add_dot, const char *obj_path, va_list args)
	Sets or replaces the path contained in the amxd_path_t structure. More...
amxd_status_t	amxd_path_setf (amxd_path_t *path, bool add_dot, const char *obj_path,...) __attribute__((format(printf
	Sets or replaces the path contained in the amxd_path_t structure. More...
amxd_status_t amxd_status_t	amxd_path_append (amxd_path_t *path, const char *extension, bool add_dot)
	Appends a parameter name or object name/index to the path. More...
amxd_status_t	amxd_path_prepend (amxd_path_t *path, const char *extension)
	Prepends an object name/index to the path. More...
const char *	amxd_path_get (amxd_path_t *path, int flags)
	Returns the path stored in the amxd_path_t structure. More...
const char *	amxd_path_get_param (amxd_path_t *path)
	Gets the parameter name. More...
char *	amxd_path_get_first (amxd_path_t *path, bool remove)
	Gets the first part of the path. More...
char *	amxd_path_get_last (amxd_path_t *path, bool remove)
	Gets the last part of the path. More...
char *	amxd_path_get_fixed_part (amxd_path_t *path, bool remove)
	Gets the fixed part of the path. More...
char *	amxd_path_get_supported_path (amxd_path_t *path)
	Translates the path into a path that can be used to fetch the object definition. More...
char *	amxd_path_get_reference_part (amxd_path_t *path, bool remove)
	Returns the reference path. More...
uint32_t	amxd_path_get_reference_index (amxd_path_t *path)
	Returns the reference path index. More...
char *	amxd_path_build_supported_path (amxd_path_t *path)
	Creates the supported path representation of the given path. More...
uint32_t	amxd_path_get_depth (const amxd_path_t *const path)
	Calculates the depth of the path. More...
static amxd_path_type_t	amxd_path_get_type (amxd_path_t *path)
	Returns the path type. More...
static bool	amxd_path_is_valid (amxd_path_t *path)
	Checks if the path is valid path. More...
static bool	amxd_path_is_search_path (amxd_path_t *path)
	Checks if the path is a search path. More...
static bool	amxd_path_is_supported_path (amxd_path_t *path)
	Checks if the path is in the supported data model. More...
static bool	amxd_path_is_object_path (amxd_path_t *path)
	Checks if the path is an object path. More...
bool	amxd_path_is_instance_path (const amxd_path_t *const path)
	Checks if the path is in the instantiated data model. More...
char *	amxd_path_get_param_path (amxd_path_t *path)
	Get the full parameter path from the provided amxd_path_t struct. More...

Detailed Description

Data model path helper functions.

These functions help in parsing data model paths.

Path Names are represented by a hierarchy of Objects (“parents”) and Sub-Objects (“children”), separated by the dot “.” character, ending with a Parameter if referencing a Parameter Path. There are six different types of Path Names used to address the data model:

• Object Path - This is a Path Name of either a single-instance (“static”) Object, or the Path Name to a Multi-Instance Object). An Object Path ends in a “.” Character (as specified in TR-106), except when used in a reference Parameter. When addressing a multi-instance object in the Supported Data Model that contains one or more Multi-Instance Objects in the Path Name, the sequence “{i}” is used as a placeholder.
• Object Instance Path - This is a Path Name to an instance in a multi-instance object in the Instantiated Data Model. It uses an Instance Identifier to address a particular Instance of the Object. An Object Instance Path ends in a “.” Character (as specified in TR-106), except when used in a reference Parameter.
• Parameter Path - This is a Path Name of a particular Parameter of an Object.
• Command Path - This is a Path Name of an Object defined Operation (aka data model RPC).
• Event Path - This is a Path Name of an Object defined Event.
• Search Path - This is a Path Name that contains search criteria for addressing a set of Multi-Instance Objects and/or their Parameters. A Search Path may contain a Search Expression or Wildcard.

Reference following.

The data model can contain parameters that contains reference paths to other objects in the data model. The Reference Following mechanism allows references to Objects (not Parameters) to be followed from inside a single Path Name. Reference Following is indicated by a “+” character after the Parameter Path, referencing the Object followed by a “.”, optionally followed by a Relative Object or Parameter Path that are children of the Referenced Object.

For example, "Device.NAT.PortMapping.{i}.Interface" references an IP Interface Object (Device.IP.Interface.{i}.) and that Object has a Parameter called “Name”. With Reference Following, a Path Name of "Device.NAT.PortMapping.1.Interface+.Name" references the “Name” Parameter of the Interface Object that the PortMapping is associated with (i.e. it is the equivalent of using Device.IP.Interface.1.Name as the Path Name).

Function Documentation

amxd_path_append()

amxd_status_t amxd_status_t amxd_path_append	(	amxd_path_t *	path,
		const char *	extension,
		bool	add_dot
	)

Appends a parameter name or object name/index to the path.

Adds a parameter name or object name, instance index, wildcard, search expression to the path contained in the amxd_path_t structure.

When add_dot is set to true, a dot is added if the extension doesn't end with a dot.

Parameters

path	amxd_path_t struct containing a path
extension	the string that must be added to the path
add_dot	make sure the path ends with a dot, even if the extension doesn't contain a dot.

Returns

amxd_status_invalid_path when the result is an invalid path, amxd_status_ok otherwise.

Definition at line 441 of file amxd_path.c.

                                                                                       {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(path, exit);
    when_str_empty(extension, exit);
 
    amxc_string_appendf(&path->path, "%s", extension);
    amxd_path_add_dot(path, add_dot);
 
    status = amxd_path_validate(path);
 
exit:
    return status;
}

amxd_path_build_supported_path()

char* amxd_path_build_supported_path

(

amxd_path_t *

path

)

Creates the supported path representation of the given path.

Replaces each index, wildcard or search string into '{i}' placeholder.

Note

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path

Returns

The supported path representation.

Definition at line 699 of file amxd_path.c.

                                                        {
    amxc_string_t sup_path;
    char* supported = NULL;
    char* endptr = NULL;
 
    amxc_string_init(&sup_path, 0);
    when_null(path, exit);
 
    amxc_var_for_each(path_part, (&path->parts)) {
        int length = 0;
        const char* path_str = amxc_var_constcast(cstring_t, path_part);
        if((path_str[0] == '*') || (path_str[0] == '[')) {
            amxc_string_append(&sup_path, "{i}.", 4);
            continue;
        }
        length = strlen(path_str);
        if((path_str[0] == '.') && (length == 1)) {
            continue;
        }
 
        strtoll(path_str, &endptr, 0);
        if((endptr == path_str) || (*endptr != '.')) {
            amxc_string_append(&sup_path, path_str, strlen(path_str));
        } else {
            amxc_string_append(&sup_path, "{i}.", 4);
        }
    }
 
exit:
    supported = amxc_string_take_buffer(&sup_path);
    amxc_string_clean(&sup_path);
    return supported;
}

amxd_path_clean()

void amxd_path_clean

(

amxd_path_t *

path

)

Cleans an amxd_path_t structure.

Frees all allocated memory and resets the amxd_path_t structure.

Parameters

path	amxd_path_t struct containing a path

Definition at line 351 of file amxd_path.c.

                                        {
    when_null(path, exit);
 
    amxc_var_clean(&path->parts);
    amxc_string_clean(&path->path);
    path->reason = NULL;
    free(path->param);
    path->param = NULL;
    path->type = amxd_path_invalid;
 
exit:
    return;
}

amxd_path_delete()

void amxd_path_delete

(

amxd_path_t **

path

)

Frees an allocated amxd_path_t structure.

After freeing the allocated memory, resets the amxd_path_t pointer to NULL.

Note

The allocated amxd_path_t structures must be allocated using amxd_path_new

Parameters

path	amxd_path_t struct containing a path

Definition at line 378 of file amxd_path.c.

                                          {
    when_null(path, exit);
    amxd_path_clean(*path);
 
    free(*path);
    *path = NULL;
 
exit:
    return;
}

amxd_path_get()

const char* amxd_path_get	(	amxd_path_t *	path,
		int	flags
	)

Returns the path stored in the amxd_path_t structure.

Returns the object path as a string that is stored in the amxd_path_t structure.

When the amxd_path_t structure contains a parameter path, this function will only return the object path without the parameter name.

When the full parameter path is needed use amxd_path_get_param_path

Parameters

path	amxd_path_t struct containing a path
flags	bitmap of flags. Currently only AMXD_OBJECT_TERMINATE is supported.

Returns

the path stored in the structure

Definition at line 470 of file amxd_path.c.

                                                        {
    size_t length = 0;
    const char* obj_path = NULL;
 
    when_null(path, exit)
    when_true(amxc_string_is_empty(&path->path), exit);
 
    length = amxc_string_text_length(&path->path);
    obj_path = amxc_string_get(&path->path, 0);
 
    if(flags & AMXD_OBJECT_TERMINATE) {
        if(obj_path[length - 1] != '.') {
            amxc_string_append(&path->path, ".", 1);
        }
    } else {
        amxc_string_trimr(&path->path, isdot);
    }
 
    obj_path = amxc_string_get(&path->path, 0);
 
exit:
    if(obj_path == NULL) {
        obj_path = "";
    }
    return obj_path;
}

amxd_path_get_depth()

uint32_t amxd_path_get_depth

(

const amxd_path_t *const

path

)

Calculates the depth of the path.

Calculates the depth of the path. This is the depth of the hierarchy of the path in the data model. Each object in the hierarchy increases the depth, parameters are not counted as a depth.

Parameters

path	amxd_path_t struct containing a path

Returns

The depth of the path

Definition at line 733 of file amxd_path.c.

                                                            {
    uint32_t level = 0;
 
    when_null(path, exit);
    when_true(amxc_var_type_of(&path->parts) != AMXC_VAR_ID_LIST, exit);
 
    amxc_var_for_each(path_part, (&path->parts)) {
        int length = 0;
        const char* path_str = amxc_var_constcast(cstring_t, path_part);
        length = strlen(path_str);
        if((path_str[0] == '.') && (length == 1)) {
            continue;
        }
        level++;
    }
 
exit:
    return level;
}

amxd_path_get_first()

char* amxd_path_get_first	(	amxd_path_t *	path,
		bool	remove
	)

Gets the first part of the path.

Gets the first part of the path, that is until the first dot encountered.

When remove is set to true, it is removed from the path contained in the amxd_path_t structure.

Note

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path
remove	when set to true it is removed from the path contained in the structure.

Returns

The first part of the path or NULL when the path is empty.

Definition at line 501 of file amxd_path.c.

                                                          {
    amxc_string_t first_part;
    char* first = NULL;
    amxc_var_t* path_part = NULL;
    int length = 0;
    const char* path_str = NULL;
    amxc_string_init(&first_part, 0);
 
    when_null(path, exit);
    when_true(amxc_llist_is_empty(&path->parts.data.vl), exit);
 
    path_part = amxc_var_from_llist_it(amxc_llist_get_first(&path->parts.data.vl));
    path_str = amxc_var_constcast(cstring_t, path_part);
    length = strlen(path_str);
    amxc_string_append(&first_part, path_str, length);
    if(remove) {
        amxc_var_delete(&path_part);
    }
 
    if(remove) {
        amxc_string_reset(&path->path);
        amxc_string_join_var(&path->path, &path->parts, "");
    }
 
exit:
    first = amxc_string_take_buffer(&first_part);
    amxc_string_clean(&first_part);
    return first;
}

amxd_path_get_fixed_part()

char* amxd_path_get_fixed_part	(	amxd_path_t *	path,
		bool	remove
	)

Gets the fixed part of the path.

The fixed part of a path is the path starting from the beginning until a wildcard or seearch expression.

If the path doesn't contain a wildcard or search expression the full path is returned.

When remove is set to true, the fixed part is removed from the path.

Note

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path
remove	when set to true it is removed from the path contained in the structure.

Returns

The fixed part of the path.

Definition at line 576 of file amxd_path.c.

                                                               {
    amxc_string_t fixed_part;
    char* fixed = NULL;
    amxc_string_init(&fixed_part, 0);
 
    when_null(path, exit);
 
    amxc_var_for_each(path_part, (&path->parts)) {
        int length = 0;
        const char* path_str = amxc_var_constcast(cstring_t, path_part);
        if((path_str[0] == '*') ||
           (path_str[0] == '[') ||
           (path_str[0] == '{') ||
           (path_str[0] == '+') ||
           (path_str[0] == '#')) {
            break;
        }
        length = strlen(path_str);
        amxc_string_append(&fixed_part, path_str, length);
        if(remove) {
            amxc_var_delete(&path_part);
        }
    }
 
    if(remove) {
        amxc_string_reset(&path->path);
        amxc_string_join_var(&path->path, &path->parts, "");
    }
 
exit:
    fixed = amxc_string_take_buffer(&fixed_part);
    amxc_string_clean(&fixed_part);
    return fixed;
}

amxd_path_get_last()

char* amxd_path_get_last	(	amxd_path_t *	path,
		bool	remove
	)

Gets the last part of the path.

Gets the last part of the path, that is the part in front of the last dot.

When remove is set to true, it is removed from the path contained in the amxd_path_t structure.

Parameter names are not returned by this function, use amxd_path_get_param to get the parameter name.

Note

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path
remove	when set to true it is removed from the path contained in the structure.

Returns

The last part of the path or NULL if the path is empty.

Definition at line 531 of file amxd_path.c.

                                                         {
    amxc_string_t last_part;
    char* last = NULL;
    amxc_var_t* path_part = NULL;
    int length = 0;
    const char* path_str = NULL;
    amxc_string_init(&last_part, 0);
 
    when_null(path, exit);
    when_true(amxc_llist_is_empty(&path->parts.data.vl), exit);
 
    path_part = amxc_var_from_llist_it(amxc_llist_get_last(&path->parts.data.vl));
    path_str = amxc_var_constcast(cstring_t, path_part);
    length = strlen(path_str);
    amxc_string_prepend(&last_part, path_str, length);
 
    if(path_str[0] == '.') {
        amxc_llist_it_t* prev = NULL;
        if(remove) {
            amxc_var_delete(&path_part);
            prev = amxc_llist_get_last(&path->parts.data.vl);
        } else {
            prev = amxc_llist_it_get_previous(amxc_llist_get_last(&path->parts.data.vl));
        }
        if(prev != NULL) {
            path_part = amxc_var_from_llist_it(prev);
            path_str = amxc_var_constcast(cstring_t, path_part);
            length = strlen(path_str);
            amxc_string_prepend(&last_part, path_str, length);
        }
    }
 
    if(remove) {
        amxc_var_delete(&path_part);
        amxc_string_reset(&path->path);
        amxc_string_join_var(&path->path, &path->parts, "");
    }
    path->type = amxd_path_is(path);
 
exit:
    last = amxc_string_take_buffer(&last_part);
    amxc_string_clean(&last_part);
    return last;
}

amxd_path_get_param()

const char* amxd_path_get_param

(

amxd_path_t *

path

)

Gets the parameter name.

Gets the parameter name if the path is a parameter path. This function returns NULL if the path contained in the amxd_path_t structure is not a parameter path.

Parameters

path	amxd_path_t struct containing a path

Returns

The parameter name or NULL if the path is not a parameter path.

Definition at line 497 of file amxd_path.c.

                                                   {
    return path == NULL ? NULL : path->param;
}

amxd_path_get_param_path()

char* amxd_path_get_param_path

(

amxd_path_t *

path

)

Get the full parameter path from the provided amxd_path_t struct.

Note

If the provided path does not contain a parameter, the function will return NULL.

Parameters

path	amxd_path_t struct containing a parameter path

Returns

Full parameter path in case of success, NULL otherwise

Definition at line 787 of file amxd_path.c.

                                                  {
    char* result = NULL;
    amxc_string_t param_path;
 
    amxc_string_init(&param_path, 0);
 
    when_null(path, exit);
    when_true(amxc_string_is_empty(&path->path), exit);
    when_str_empty(path->param, exit);
 
    amxc_string_setf(&param_path, "%s%s", amxc_string_get(&path->path, 0), path->param);
    result = amxc_string_take_buffer(&param_path);
 
exit:
    amxc_string_clean(&param_path);
    return result;
}

amxd_path_get_reference_index()

uint32_t amxd_path_get_reference_index

(

amxd_path_t *

path

)

Returns the reference path index.

When the given path has reference following decorations, this function will return the index of the reference.

When the parameter that contains the reference is a comma separated list of references, the index is used to specify which item in the list must be used. The index starts with 1 for the first item in the list.

If no index is provided in the reference following decoration, the index returned is 1.

Example: When the path is "Device.NAT.PortMapping.1.Interface+#2.Name" this function returns 2

Parameters

path	amxd_path_t struct containing a path

Returns

The reference index.

Definition at line 689 of file amxd_path.c.

                                                          {
    uint32_t index = 0;
    when_null(path, exit);
 
    index = path->ref_index;
 
exit:
    return index;
}

amxd_path_get_reference_part()

char* amxd_path_get_reference_part	(	amxd_path_t *	path,
		bool	remove
	)

Returns the reference path.

When the given path has reference following decorations, this function will return the reference path.

Example: When the path is "Device.NAT.PortMapping.1.Interface+.Name" this function returns the string "Device.NAT.PortMapping.1.Interface."

When remove is set to true the reference path is removed from the path contained in the amxd_path_t structure.

Note

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path
remove	when set to true it is removed from the path contained in the structure.

Returns

The reference path.

Definition at line 640 of file amxd_path.c.

                                                                   {
    amxc_string_t ref_part;
    char* ref = NULL;
    bool has_ref_index = false;
    amxc_string_init(&ref_part, 0);
 
    when_null(path, exit);
 
    amxc_var_for_each(path_part, (&path->parts)) {
        int length = 0;
        const char* path_str = amxc_var_constcast(cstring_t, path_part);
        if(has_ref_index) {
            if(remove) {
                amxc_var_delete(&path_part);
            }
            has_ref_index = false;
            continue;
        }
        if(path_str[0] == '+') {
            if(remove) {
                amxc_var_delete(&path_part);
            }
            break;
        }
        if(path_str[0] == '#') {
            if(remove) {
                amxc_var_delete(&path_part);
            }
            has_ref_index = true;
            continue;
        }
        length = strlen(path_str);
        amxc_string_append(&ref_part, path_str, length);
        if(remove) {
            amxc_var_delete(&path_part);
        }
    }
 
    if(remove) {
        amxc_string_reset(&path->path);
        amxc_string_join_var(&path->path, &path->parts, "");
    }
 
exit:
    ref = amxc_string_take_buffer(&ref_part);
    amxc_string_clean(&ref_part);
    return ref;
}

amxd_path_get_supported_path()

char* amxd_path_get_supported_path

(

amxd_path_t *

path

)

Translates the path into a path that can be used to fetch the object definition.

This function will remove the '{i}' placeholders or indices from the path contained in the amxd_path_t structure. This will result in an ambiorix data model object definition path.

The resulting path can be used to fetch the object definition.

Note

The provided path must not contain search expressions or wildcards.

The returned string must be freed when not needed anymore.

Parameters

path	amxd_path_t struct containing a path

Returns

The ambiorix data model object definition path.

Definition at line 611 of file amxd_path.c.

                                                      {
    amxc_string_t sup_path;
    char* supported = NULL;
    amxc_string_init(&sup_path, 0);
 
    when_null(path, exit);
 
    amxc_var_for_each(path_part, (&path->parts)) {
        int length = 0;
        const char* path_str = amxc_var_constcast(cstring_t, path_part);
        if(path_str[0] == '{') {
            continue;
        }
        if(isdigit(path_str[0])) {
            continue;
        }
        length = strlen(path_str);
        if((path_str[0] == '.') && (length == 1)) {
            continue;
        }
        amxc_string_append(&sup_path, path_str, strlen(path_str));
    }
 
exit:
    supported = amxc_string_take_buffer(&sup_path);
    amxc_string_clean(&sup_path);
    return supported;
}

amxd_path_get_type()

static amxd_path_type_t amxd_path_get_type ( amxd_path_t *  path )

inlinestatic

Returns the path type.

See amxd_path_type_t for the supported path types.

Parameters

path	amxd_path_t struct containing a path

Returns

The path type.

Definition at line 507 of file amxd_path.h.

                                                       {
    return path == NULL ? amxd_path_invalid : path->type;
}

amxd_path_init()

amxd_status_t amxd_path_init	(	amxd_path_t *	path,
		const char *	object_path
	)

Initializes an amxd_path_t structure.

Initializes an amxd_path_t structure and sets the path.

If the given object path is invalid the structure will be initialized but an error is returned

Parameters

path	amxd_path_t struct containing a path
object_path	NULL or a valid path string

Returns

amxd_status_ok when the structure is initialized and a valid path was given, otherwise an error code is returned.

Definition at line 328 of file amxd_path.c.

                                                      {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(path, exit);
 
    amxc_var_init(&path->parts);
    amxc_var_set_type(&path->parts, AMXC_VAR_ID_LIST);
 
    amxc_string_init(&path->path, 0);
    path->reason = NULL;
    path->param = NULL;
 
    if(object_path != NULL) {
        when_failed(amxc_string_setf(&path->path, "%s", object_path), exit);
    }
 
    status = amxd_path_validate(path);
 
exit:
    return status;
}

amxd_path_is_instance_path()

bool amxd_path_is_instance_path

(

const amxd_path_t *const

path

)

Checks if the path is in the instantiated data model.

A path is in the instantiated data model if the path ends with an instance index, a wildcard or a search expression.

Parameters

path	amxd_path_t struct containing a path

Returns

true when the path is in the instantiated data model, false otherwise

Definition at line 753 of file amxd_path.c.

                                                               {
    bool is_instance = false;
    const amxc_llist_t* parts = NULL;
    amxc_llist_it_t* part_it = NULL;
    const char* part_txt = NULL;
    char* endptr = NULL;
 
    when_null(path, exit);
    when_true(amxc_var_type_of(&path->parts) != AMXC_VAR_ID_LIST, exit);
 
    parts = amxc_var_constcast(amxc_llist_t, &path->parts);
    part_it = amxc_llist_get_last(parts);
    when_null(part_it, exit);
 
    part_txt = amxc_var_constcast(cstring_t, amxc_var_from_llist_it(part_it));
    if((part_txt != NULL) && (*part_txt == '.')) {
        part_it = amxc_llist_it_get_previous(part_it);
        when_null(part_it, exit);
        part_txt = amxc_var_constcast(cstring_t, amxc_var_from_llist_it(part_it));
    }
    when_null(part_txt, exit);
 
    strtoll(part_txt, &endptr, 0);
    if((endptr == NULL) || (*endptr == '.')) {
        is_instance = true;
    }
    if((part_txt[0] == '[') || (part_txt[0] == '*')) {
        is_instance = true;
    }
 
exit:
    return is_instance;
}

amxd_path_is_object_path()

static bool amxd_path_is_object_path ( amxd_path_t *  path )

inlinestatic

Checks if the path is an object path.

An object path is a path pointing to a singleton object or an instance object.

Parameters

path	amxd_path_t struct containing a path

Returns

true when the path is an object path, false otherwise

Definition at line 579 of file amxd_path.h.

                                                 {
    return path == NULL ? false : (path->type == amxd_path_object);
}

amxd_path_is_search_path()

static bool amxd_path_is_search_path ( amxd_path_t *  path )

inlinestatic

Checks if the path is a search path.

A search path is an object path containing a wildcard character ('*') or it contains search expressions (between '[' and ']')

Parameters

path	amxd_path_t struct containing a path

Returns

true when the path is a search path, false otherwise

Definition at line 544 of file amxd_path.h.

                                                 {
    return path == NULL ? false : (path->type == amxd_path_search);
}

amxd_path_is_supported_path()

static bool amxd_path_is_supported_path ( amxd_path_t *  path )

inlinestatic

Checks if the path is in the supported data model.

A path is an supported path if it contains '{i}' or it is pointing to a an object under a template object (not an instance of the template object).

Parameters

path	amxd_path_t struct containing a path

Returns

true when the path is in the supported datamodel, false otherwise

Definition at line 562 of file amxd_path.h.

                                                    {
    return path == NULL ? false : (path->type == amxd_path_supported);
}

amxd_path_is_valid()

static bool amxd_path_is_valid ( amxd_path_t *  path )

inlinestatic

Checks if the path is valid path.

Examples of invalid paths:

• "Device.WiFi.AccessPoint.{some_id}.AssociatedDevice."
• "Device.WiFi.AccessPoint.*.AssociatedDevice.{i}."

Parameters

path	amxd_path_t struct containing a path

Returns

true when the path is valid, false otherwise

Definition at line 526 of file amxd_path.h.

                                           {
    return path == NULL ? false : (path->type != amxd_path_invalid);
}

amxd_path_new()

amxd_status_t amxd_path_new	(	amxd_path_t **	path,
		const char *	object_path
	)

Allocates and initializes an amxd_path_t structure.

Allocates memory on the heap for the amxd_path_t structure and initializes it.

Note

The allocated amxd_path_t structures must be freed when not needed anymore using amxd_path_delete

Parameters

path	amxd_path_t struct containing a path
object_path	NULL or a valid path string

Returns

amxd_status_ok when the structure is allocated initialized and a valid path was given, otherwise an error code is returned.

Definition at line 365 of file amxd_path.c.

                                                     {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(path, exit);
    *path = (amxd_path_t*) calloc(1, sizeof(amxd_path_t));
 
    status = amxd_path_init((*path), object_path);
 
exit:
    return status;
}

amxd_path_prepend()

amxd_status_t amxd_path_prepend	(	amxd_path_t *	path,
		const char *	extension
	)

Prepends an object name/index to the path.

Prepends the current path with an object name, instance index, wildcard, search expression to the path contained in the amxd_path_t structure.

The extension can not be a parameter name in this case, as a parameter name can only be added to the end of the path.

Parameters

path	amxd_path_t struct containing a path
extension	the string that must be prepended to the path

Returns

amxd_status_invalid_path when the result is an invalid path, amxd_status_ok otherwise.

Definition at line 456 of file amxd_path.c.

                                                                          {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(path, exit);
    when_str_empty(extension, exit);
 
    amxc_string_prependf(&path->path, "%s", extension);
 
    status = amxd_path_validate(path);
 
exit:
    return status;
}

amxd_path_reset()

void amxd_path_reset

(

amxd_path_t *

path

)

Resets the amxd_path_t structure.

Parameters

path	amxd_path_t struct containing a path

Definition at line 389 of file amxd_path.c.

                                        {
    when_null(path, exit);
 
    amxc_string_reset(&path->path);
    amxc_var_clean(&path->parts);
    path->type = amxd_path_invalid;
    path->reason = NULL;
    free(path->param);
    path->param = NULL;
 
exit:
    return;
}

amxd_path_setf()

amxd_status_t amxd_path_setf	(	amxd_path_t *	path,
		bool	add_dot,
		const char *	obj_path,
			...
	)

Sets or replaces the path contained in the amxd_path_t structure.

This function supports printf notations in the object path.

When the add_dot argument is set to true, a dot will be added to the end, if no dot at the end was present.

If the given path ends with a dot it will be an object path or an instance path. If the given path doesn't end with a dot it is a parameter path and the last part is the name of the parameter.

When an invalid object path is given, the function will return amxd_invalid_path and the type of the amxd_path_t will be set to amxd_path_invalid.

Parameters

path	amxd_path_t struct containing a path
add_dot	makes sure the path is ended with a dot when set to true
obj_path	the object path that must be set in the amxd_path_t structure. printf like format string is supported.

Returns

amxd_status_invalid_path when the given path is invalid, otherwise amxd_status_ok.

amxd_path_vsetf()

amxd_status_t amxd_path_vsetf	(	amxd_path_t *	path,
		bool	add_dot,
		const char *	obj_path,
		va_list	args
	)

Sets or replaces the path contained in the amxd_path_t structure.

This function does exactly the same as amxd_path_setf, but takes a va_list of values.

Parameters

path	amxd_path_t struct containing a path
add_dot	makes sure the path is ended with a dot when set to true
obj_path	the object path that must be set in the amxd_path_t structure. printf like format string is supported.
args	a va_list, containing the values for the printf formatting

Returns

amxd_status_invalid_path when the given path is invalid, otherwise amxd_status_ok.

Definition at line 403 of file amxd_path.c.

                                            {
    amxd_status_t status = amxd_status_unknown_error;
 
    when_null(path, exit);
    when_str_empty(obj_path, exit);
 
    amxd_path_reset(path);
 
    amxc_string_vsetf(&path->path, obj_path, args);
 
    amxd_path_add_dot(path, add_dot);
 
    status = amxd_path_validate(path);
 
exit:
    return status;
}