Not checking the return value of each function call

Oct 13, 2025 by talynt.org 130 views

As a university project, developing a plugin can be a challenging yet rewarding experience. However, when dealing with complex data structures and APIs, it's not uncommon to encounter issues that can be frustrating to resolve. In this article, we'll explore the problem of getting changed values with sr_get_items and discuss alternative approaches using sr_get_change_iter and sr_get_next.

The Issue with sr_get_items

The provided code snippet demonstrates the use of sr_get_items to retrieve changed values within a specific XPath expression. However, the author is experiencing issues with sr_get_items returning null values for each data variable. This can be a puzzling problem, especially when working with complex data structures.

Why sr_get_items Might Not Be the Best Approach

While sr_get_items can be a useful function for retrieving changed values, it might not be the most efficient or effective approach in this scenario. The function returns a list of changed values, but it doesn't provide a way to iterate over the changes in a more structured manner.

Introducing sr_get_change_iter and sr_get_next

A more suitable approach might be to use sr_get_change_iter and sr_get_next to iterate over the changes. This method allows you to traverse the changes in a more structured way, making it easier to access each changed leaf value.

Using sr_get_change_iter and sr_get_next

Here's an example of how you can use sr_get_change_iter and sr_get_next to iterate over the changes:

sr_change_iter_t *iter;
sr_change_t *change;

iter = sr_get_change_iter(session, "/test:outer_container/inner_container", 0, SR_OPER_DEFAULT);
if (iter == NULL) {
    SRPLG_LOG_ERR("test", "Failed to get change iterator.");
    return;
}

while (sr_get_next(iter, &change) == SR_ERR_OK) {
    if (change->type == SR_CHANGE_TYPE_LEAF) {
        // Access the changed leaf value
        char* path = change->xpath;
        char* data = change->data.string_val;
        // Some further logic here...
    }
}

In this example, we create a change iterator using sr_get_change_iter and then iterate over the changes using sr_get_next. We check if the change type is SR_CHANGE_TYPE_LEAF and access the changed leaf value using change->xpath and change->data.string_val.

Benefits of Using sr_get_change_iter and sr_get_next

Using sr_get_change_iter and sr_get_next offers several benefits over sr_get_items:

Efficient iteration: sr_get_change_iter and sr_get_next allow you to iterate over the changes in a more structured way, making it easier to access each changed leaf value.
Better error handling: With sr_get_change_iter and sr_get_next, you can handle errors more effectively, as you can check the return value of each function call.
Improved code readability: The code becomes more readable and maintainable, as you can clearly see the iteration logic and access the changed leaf values.

Conclusion

In conclusion, while sr_get_items can be a useful function for retrieving changed values, it might not be the best approach in this scenario. Using sr_get_change_iter and sr_get_next offers several benefits, including efficient iteration, better error handling, and improved code readability. By adopting this approach, you can write more effective and maintainable code for your plugin.

Example Use Case

Here's an example use case that demonstrates how to use sr_get_change_iter and sr_get_next to iterate over the changes:

// Define the plugin configuration change callback function
plugin_config_change_cb(sr_session_ctx_t *session, uint32_t sub_id, const char *module_name, const char *xpath,
        sr_event_t event, uint32_t request_id, void *private_data)
{
    // Create a change iterator
    sr_change_iter_t *iter;
    sr_change_t *change;

    iter = sr_get_change_iter(session, "/test:outer_container/inner_container", 0, SR_OPER_DEFAULT);
    if (iter == NULL) {
        SRPLG_LOG_ERR("test", "Failed to get change iterator.");
        return;
    }

    // Iterate over the changes
    while (sr_get_next(iter, &change) == SR_ERR_OK) {
        if (change->type == SR_CHANGE_TYPE_LEAF) {
            // Access the changed leaf value
            char* path = change->xpath;
            char* data = change->data.string_val;
            // Some further logic here...
        }
    }

    // Clean up the change iterator
    sr_change_iter_free(iter);
}

// Define the plugin initialization function
plugin_init_cb(sr_session_ctx_t *session, int flags, void **private_data)
{
    // Subscribe to the module change event
    sr_module_change_subscribe(session, "/test:outer_container/inner_container", plugin_config_change_cb, NULL, 0, NULL);
    return SR_ERR_OK;
}

// Define the plugin cleanup function
plugin_cleanup_cb(sr_session_ctx_t *session, int flags, void **private_data)
{
    // Unsubscribe from the module change event
    sr_module_change_unsubscribe(session, "/test:outer_container/inner_container");
    return SR_ERR_OK;
}

As we discussed earlier, getting changed values with sr_get_items and sr_get_change_iter can be a bit tricky. In this Q&A article, we'll address some common questions and provide more insights into these functions.

Q: What is the difference between sr_get_items and sr_get_change_iter?

A: sr_get_items and sr_get_change_iter are both used to retrieve changed values, but they work in different ways. sr_get_items returns a list of changed values, while sr_get_change_iter returns an iterator that allows you to traverse the changes.

Q: Why would I use sr_get_change_iter instead of sr_get_items?

A: You would use sr_get_change_iter instead of sr_get_items when you need to iterate over the changes in a more structured way. This is particularly useful when you need to access each changed leaf value.

Q: How do I use sr_get_change_iter to iterate over the changes?

A: To use sr_get_change_iter, you need to create a change iterator using sr_get_change_iter and then iterate over the changes using sr_get_next. Here's an example:

sr_change_iter_t *iter;
sr_change_t *change;

iter = sr_get_change_iter(session, "/test:outer_container/inner_container", 0, SR_OPER_DEFAULT);
if (iter == NULL) {
    SRPLG_LOG_ERR("test", "Failed to get change iterator.");
    return;
}

while (sr_get_next(iter, &change) == SR_ERR_OK) {
    if (change->type == SR_CHANGE_TYPE_LEAF) {
        // Access the changed leaf value
        char* path = change->xpath;
        char* data = change->data.string_val;
        // Some further logic here...
    }
}

Q: What is the difference between sr_get_next and sr_get_prev?

A: sr_get_next and sr_get_prev are both used to retrieve the next or previous change in the iterator, respectively. However, sr_get_next returns the next change in the iterator, while sr_get_prev returns the previous change.

Q: How do I handle errors when using sr_get_change_iter?

A: When using sr_get_change_iter, you should always check the return value of each function call to handle errors. Here's an example:

sr_change_iter_t *iter;
sr_change_t *change;

iter = sr_get_change_iter(session, "/test:outer_container/inner_container", 0, SR_OPER_DEFAULT);
if (iter == NULL) {
    SRPLG_LOG_ERR("test", "Failed to get change iterator.");
    return;
}

while (sr_get_next(iter, &change) == SR_ERR_OK) {
    if (change->type == SR_CHANGE_TYPE_LEAF) {
        // Access the changed leaf value
        char* path = change->xpath;
        char* data = change->data.string_val;
        // Some further logic here...
    } else {
        SRPLG_LOG_ERR("test", "Invalid change type.");
        break;
    }
}

Q: How do I free the change iterator when I'm done with it?

A: To free the change iterator, you can use the sr_change_iter_free function. Here's an example:

sr_change_iter_t *iter;

iter = sr_get_change_iter(session, "/test:outer_container/inner_container", 0, SR_OPER_DEFAULT);
if (iter == NULL) {
    SRPLG_LOG_ERR("test", "Failed to get change iterator.");
    return;
}

// Use the change iterator...

sr_change_iter_free(iter);

Q: What are some common pitfalls to avoid when using sr_get_change_iter?

A: Here are some common pitfalls to avoid when using sr_get_change_iter:

Not checking the return value of each function call: Always check the return value of each function call to handle errors.
Not freeing the change iterator when you're done with it: Make sure to free the change iterator when you're done with it to avoid memory leaks.
Not handling invalid change types: Make sure to handle invalid change types to avoid crashes or unexpected behavior.

By following these best practices and avoiding common pitfalls, you can effectively use sr_get_change_iter to iterate over the changes in your plugin.