rename name to path in ctl

Author: lplewa

include/umf/experimental/ctl.h

@@ -17,34 +17,34 @@ extern "C" {
 #endif
 
 ///
-/// @brief Get value of a specified attribute at the given name.
-/// @param name name of an attribute to be retrieved
+/// @brief Get value of a specified attribute at the given path.
+/// @param path path of an attribute to be retrieved
 /// @param arg [out] pointer to the variable where the value will be stored
 /// @param size size of the value, depends on the context
 /// @param ... additional arguments that can be passed to the callback
 /// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
 ///
-umf_result_t umfCtlGet(const char *name, void *arg, size_t size, ...);
+umf_result_t umfCtlGet(const char *path, void *arg, size_t size, ...);
 
 ///
-/// @brief Set value of a specified attribute at the given name.
-/// @param name name of an attribute to be set
+/// @brief Set value of a specified attribute at the given path.
+/// @param path path of an attribute to be set
 /// @param arg [in] pointer to the value that will be set
 /// @param size [in] size of the value, depends on the context
 /// @param ... additional arguments that can be passed to the callback
 /// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
 ///
-umf_result_t umfCtlSet(const char *name, void *arg, size_t size, ...);
+umf_result_t umfCtlSet(const char *path, void *arg, size_t size, ...);
 
 ///
 /// @brief Execute callback related with the specified attribute.
-/// @param name name of an attribute to be executed
+/// @param path path of an attribute to be executed
 /// @param arg [in/out] pointer to the value, can be used as an input or output
 /// @param size [in] size of the value, depends on the context
 /// @param ... additional arguments that can be passed to the callback
 /// @return UMF_RESULT_SUCCESS on success or UMF_RESULT_ERROR_UNKNOWN on failure.
 ///
-umf_result_t umfCtlExec(const char *name, void *arg, size_t size, ...);
+umf_result_t umfCtlExec(const char *path, void *arg, size_t size, ...);
 
 #ifdef __cplusplus
 }

src/ctl/ctl.c

@@ -298,26 +298,26 @@ ctl_exec_query_subtree(void *ctx, const umf_ctl_node_t *n,
  * ctl_find_and_execulte_node -- (internal) searches for a matching entry point in the
  *    provided nodes
  *
- * Name offset is used to return the offset of the name in the query string.
+ * Path offset is used to return the offset of the path in the query string.
  * The caller is responsible for freeing all of the allocated indexes,
  * regardless of the return value.
  */
 
 static optional_umf_result_t
 ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
-                          umf_ctl_query_source_t source, const char *name,
+                          umf_ctl_query_source_t source, const char *path,
                           umf_ctl_query_type_t type, void *arg, size_t size,
                           va_list args) {
     assert(nodes != NULL);
-    assert(name != NULL);
+    assert(path != NULL);
 
     const umf_ctl_node_t *n = NULL;
     optional_umf_result_t ret;
-    size_t name_offset = 0;
+    size_t path_offset = 0;
     ret.is_valid = true;
     ret.value = UMF_RESULT_SUCCESS;
     char *sptr = NULL;
-    char *parse_str = Strdup(name);
+    char *parse_str = Strdup(path);
     if (parse_str == NULL) {
         ret.is_valid = false;
         return ret;
@@ -336,7 +336,7 @@ ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
      */
     while (node_name != NULL) {
         char *next_node = strtok_r(NULL, CTL_QUERY_NODE_SEPARATOR, &sptr);
-        name_offset = node_name - parse_str;
+        path_offset = node_name - parse_str;
         if (n != NULL && n->type == CTL_NODE_SUBTREE) {
             // if a subtree occurs, the subtree handler should be called
             break;
@@ -500,7 +500,7 @@ ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
         // if the node is a subtree, then we need to call the subtree handler
         ret.value =
             ctl_exec_query_subtree(ctx, n, source, arg, size, indexes->next,
-                                   name + name_offset, type, args);
+                                   path + path_offset, type, args);
     } else {
         switch (type) {
         case CTL_QUERY_READ:
@@ -530,25 +530,25 @@ ctl_find_and_execute_node(const umf_ctl_node_t *nodes, void *ctx,
 }
 
 /*
- * ctl_query -- (internal) parses the name and calls the appropriate methods
+ * ctl_query -- (internal) parses the path and calls the appropriate methods
  *    from the ctl tree
  */
 umf_result_t ctl_query(struct ctl *ctl, void *ctx,
-                       umf_ctl_query_source_t source, const char *name,
+                       umf_ctl_query_source_t source, const char *path,
                        umf_ctl_query_type_t type, void *arg, size_t size,
                        va_list args) {
-    if (name == NULL) {
+    if (path == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
     va_list args_copy;
     va_copy(args_copy, args);
 
     optional_umf_result_t ret = ctl_find_and_execute_node(
-        CTL_NODE(global), ctx, source, name, type, arg, size, args_copy);
+        CTL_NODE(global), ctx, source, path, type, arg, size, args_copy);
 
     if (ret.is_valid == false && ctl) {
-        ret = ctl_find_and_execute_node(ctl->root, ctx, source, name, type, arg,
+        ret = ctl_find_and_execute_node(ctl->root, ctx, source, path, type, arg,
                                         size, args);
     }
 
@@ -573,16 +573,16 @@ void ctl_register_module_node(struct ctl *c, const char *name,
 
 /*
  * ctl_parse_query -- (internal) splits an entire query string
- *    into name and value
+ *    into path and value
  */
-static int ctl_parse_query(char *qbuf, char **name, char **value) {
+static int ctl_parse_query(char *qbuf, char **path, char **value) {
     if (qbuf == NULL) {
         return -1;
     }
 
     char *sptr = NULL;
-    *name = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
-    if (*name == NULL) {
+    *path = strtok_r(qbuf, CTL_NAME_VALUE_SEPARATOR, &sptr);
+    if (*path == NULL) {
         return -1;
     }
 
@@ -608,20 +608,20 @@ static umf_result_t ctl_load_config_helper(struct ctl *ctl, void *ctx,
                                            char *buf, ...) {
     umf_result_t ret = UMF_RESULT_SUCCESS;
     char *sptr = NULL; /* for internal use of strtok */
-    char *name;
+    char *path;
     char *value;
     char *qbuf = strtok_r(buf, CTL_STRING_QUERY_SEPARATOR, &sptr);
     va_list empty_args;
     va_start(empty_args, buf);
     while (qbuf != NULL) {
-        int parse_res = ctl_parse_query(qbuf, &name, &value);
+        int parse_res = ctl_parse_query(qbuf, &path, &value);
         if (parse_res != 0) {
             ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
             goto end;
         }
         // we do not need to copy va_list before call as we know that for query_config_input
         // ctl_query will not call va_arg on it. Ref 7.15/3 of C99 standard
-        ret = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, name, CTL_QUERY_WRITE,
+        ret = ctl_query(ctl, ctx, CTL_QUERY_CONFIG_INPUT, path, CTL_QUERY_WRITE,
                         value, strlen(value) + 1, empty_args);
 
         if (ret != UMF_RESULT_SUCCESS && ctx != NULL) {

src/ctl/ctl_internal.h

@@ -198,7 +198,7 @@ int ctl_arg_string(const void *arg, void *dest, size_t dest_size);
 #define CTL_NODE(name, ...) ctl_node_##__VA_ARGS__##_##name
 
 umf_result_t ctl_query(struct ctl *ctl, void *ctx,
-                       umf_ctl_query_source_t source, const char *name,
+                       umf_ctl_query_source_t source, const char *path,
                        umf_ctl_query_type_t type, void *arg, size_t size,
                        va_list args);
 

src/libumf.c

@@ -157,41 +157,41 @@ umf_result_t umfTearDown(void) {
 
 int umfGetCurrentVersion(void) { return UMF_VERSION_CURRENT; }
 
-umf_result_t umfCtlGet(const char *name, void *arg, size_t size, ...) {
+umf_result_t umfCtlGet(const char *path, void *arg, size_t size, ...) {
     libumfInit();
     // ctx can be NULL when getting defaults
-    if (name == NULL || arg == NULL || size == 0) {
+    if (path == NULL || arg == NULL || size == 0) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
     va_list args;
     va_start(args, size);
 
-    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, name,
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
                                  CTL_QUERY_READ, arg, size, args);
     va_end(args);
     return ret;
 }
 
-umf_result_t umfCtlSet(const char *name, void *arg, size_t size, ...) {
+umf_result_t umfCtlSet(const char *path, void *arg, size_t size, ...) {
     libumfInit();
     // ctx can be NULL when setting defaults
-    if (name == NULL || arg == NULL || size == 0) {
+    if (path == NULL || arg == NULL || size == 0) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
     va_list args;
     va_start(args, size);
-    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, name,
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
                                  CTL_QUERY_WRITE, arg, size, args);
     va_end(args);
     return ret;
 }
 
-umf_result_t umfCtlExec(const char *name, void *arg, size_t size, ...) {
+umf_result_t umfCtlExec(const char *path, void *arg, size_t size, ...) {
     libumfInit();
     // arg can be NULL when executing a command
     // ctx can be NULL when executing defaults
     // size can depends on the arg
-    if (name == NULL) {
+    if (path == NULL) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
@@ -201,7 +201,7 @@ umf_result_t umfCtlExec(const char *name, void *arg, size_t size, ...) {
     va_list args;
     va_start(args, size);
 
-    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, name,
+    umf_result_t ret = ctl_query(NULL, NULL, CTL_QUERY_PROGRAMMATIC, path,
                                  CTL_QUERY_RUNNABLE, arg, size, args);
     va_end(args);
     return ret;