diff REFACTOR put diff into separate source/header
diff --git a/src/tree_data.c b/src/tree_data.c
index dd419d8..baf96ab 100644
--- a/src/tree_data.c
+++ b/src/tree_data.c
@@ -49,9 +49,6 @@
#include "xml.h"
#include "xpath.h"
-static LY_ERR lyd_path_list_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused,
- int is_static);
-
LY_ERR
lyd_value_parse(struct lyd_node_term *node, const char *value, size_t value_len, int *dynamic, int second,
ly_clb_resolve_prefix get_prefix, void *parser, LYD_FORMAT format, const struct lyd_node *tree)
@@ -2441,1024 +2438,6 @@
return LY_SUCCESS;
}
-struct lyd_diff_userord {
- const struct lysc_node *schema; /**< User-ordered list/leaf-list schema node. */
- uint64_t pos; /**< Current position in the second tree. */
- const struct lyd_node **inst; /**< Sized array of current instance order. */
-};
-
-enum lyd_diff_op {
- LYD_DIFF_OP_CREATE, /**< Subtree created. */
- LYD_DIFF_OP_DELETE, /**< Subtree deleted. */
- LYD_DIFF_OP_REPLACE, /**< Node value changed or (leaf-)list instance moved. */
- LYD_DIFF_OP_NONE, /**< No change of an existing inner node or default flag change of a term node. */
-};
-
-static const char *
-lyd_diff_op2str(enum lyd_diff_op op)
-{
- switch (op) {
- case LYD_DIFF_OP_CREATE:
- return "create";
- case LYD_DIFF_OP_DELETE:
- return "delete";
- case LYD_DIFF_OP_REPLACE:
- return "replace";
- case LYD_DIFF_OP_NONE:
- return "none";
- }
-
- LOGINT(NULL);
- return NULL;
-}
-
-/**
- * @brief Add a new change into diff.
- *
- * @param[in] node Node (subtree) to add into diff.
- * @param[in] op Operation to set.
- * @param[in] orig_default Original default metadata to set.
- * @param[in] orig_value Original value metadata to set.
- * @param[in] key Key metadata to set.
- * @param[in] value Value metadata to set.
- * @param[in] orig_key Original key metadata to set.
- * @param[in,out] diff Diff to append to.
- * @return LY_ERR value.
- */
-static LY_ERR
-lyd_diff_add(const struct lyd_node *node, enum lyd_diff_op op, const char *orig_default, const char *orig_value,
- const char *key, const char *value, const char *orig_key, struct lyd_node **diff)
-{
- struct lyd_node *dup, *siblings, *match = NULL, *diff_parent = NULL;
- const struct lyd_node *parent = NULL;
- const struct lys_module *yang_mod;
-
- /* find the first existing parent */
- siblings = *diff;
- while (1) {
- /* find next node parent */
- parent = node;
- while (parent->parent && (!diff_parent || (parent->parent->schema != diff_parent->schema))) {
- parent = (struct lyd_node *)parent->parent;
- }
- if (parent == node) {
- /* no more parents to find */
- break;
- }
-
- /* check whether it exists in the diff */
- if (lyd_find_sibling_first(siblings, parent, &match)) {
- break;
- }
-
- /* another parent found */
- diff_parent = match;
-
- /* move down in the diff */
- siblings = LYD_CHILD(match);
- }
-
- /* duplicate the subtree (and connect to the diff if possible) */
- dup = lyd_dup(node, (struct lyd_node_inner *)diff_parent, LYD_DUP_RECURSIVE | LYD_DUP_NO_META | LYD_DUP_WITH_PARENTS);
- LY_CHECK_RET(!dup, LY_EMEM);
-
- /* find the first duplicated parent */
- if (!diff_parent) {
- diff_parent = (struct lyd_node *)dup->parent;
- while (diff_parent && diff_parent->parent) {
- diff_parent = (struct lyd_node *)diff_parent->parent;
- }
- } else {
- diff_parent = (struct lyd_node *)dup;
- while (diff_parent->parent && (diff_parent->parent->schema == parent->schema)) {
- diff_parent = (struct lyd_node *)diff_parent->parent;
- }
- }
-
- /* no parent existed, must be manually connected */
- if (!diff_parent) {
- /* there actually was no parent to duplicate */
- if (*diff) {
- lyd_insert_sibling(*diff, dup);
- } else {
- *diff = dup;
- }
- } else if (!diff_parent->parent) {
- if (*diff) {
- lyd_insert_sibling(*diff, diff_parent);
- } else {
- *diff = diff_parent;
- }
- }
-
- /* get module with the operation metadata */
- yang_mod = LYD_NODE_CTX(node)->list.objs[1];
- assert(!strcmp(yang_mod->name, "yang"));
-
- /* add parent operation, if any */
- if (diff_parent && (diff_parent != dup) && !lyd_new_meta(diff_parent, yang_mod, "operation", "none")) {
- return LY_EMEM;
- }
-
- /* add subtree operation */
- if (!lyd_new_meta(dup, yang_mod, "operation", lyd_diff_op2str(op))) {
- return LY_EMEM;
- }
-
- /* orig-default */
- if (orig_default && !lyd_new_meta(dup, yang_mod, "orig-default", orig_default)) {
- return LY_EMEM;
- }
-
- /* orig-value */
- if (orig_value && !lyd_new_meta(dup, yang_mod, "orig-value", orig_value)) {
- return LY_EMEM;
- }
-
- /* key */
- if (key && !lyd_new_meta(dup, yang_mod, "key", key)) {
- return LY_EMEM;
- }
-
- /* value */
- if (value && !lyd_new_meta(dup, yang_mod, "value", value)) {
- return LY_EMEM;
- }
-
- /* orig-key */
- if (orig_key && !lyd_new_meta(dup, yang_mod, "orig-key", orig_key)) {
- return LY_EMEM;
- }
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Get a userord entry for a specific user-ordered list/leaf-list. Create if does not exist yet.
- *
- * @param[in] first
- * @param[in] schema Schema node of the list/leaf-list.
- * @param[in,out] userord Sized array of userord items.
- * @return Userord item for all the user-ordered list/leaf-list instances.
- */
-static struct lyd_diff_userord *
-lyd_diff_userord_get(const struct lyd_node *first, const struct lysc_node *schema, struct lyd_diff_userord **userord)
-{
- struct lyd_diff_userord *item;
- const struct lyd_node *iter, **node;
- LY_ARRAY_COUNT_TYPE u;
-
- LY_ARRAY_FOR(*userord, u) {
- if ((*userord)[u].schema == schema) {
- return &(*userord)[u];
- }
- }
-
- /* it was not added yet, add it now */
- LY_ARRAY_NEW_RET(schema->module->ctx, *userord, item, NULL);
-
- item->schema = schema;
- item->pos = 0;
- item->inst = NULL;
-
- /* store all the instance pointers in the current order */
- if (first) {
- if (first->parent) {
- iter = first->parent->child;
- } else {
- for (iter = first; iter->prev->next; iter = iter->prev);
- }
- for (; iter; iter = iter->next) {
- if (iter->schema == first->schema) {
- LY_ARRAY_NEW_RET(schema->module->ctx, item->inst, node, NULL);
- *node = iter;
- }
- }
- }
-
- return item;
-}
-
-/**
- * @brief Get all the metadata to be stored in a diff for the 2 nodes. Can be used only for user-ordered
- * lists/leaf-lists.
- *
- * @param[in] first Node from the first tree, can be NULL (on create).
- * @param[in] second Node from the second tree, can be NULL (on delete).
- * @param[in] options Diff options.
- * @param[in,out] userord Sized array of userord items for keeping the current node order.
- * @param[out] op Operation.
- * @param[out] orig_default Original default metadata.
- * @param[out] value Value metadata.
- * @param[out] orig_value Original value metadata
- * @param[out] key Key metadata.
- * @param[out] orig_key Original key metadata.
- * @return LY_SUCCESS on success,
- * @return LY_ENOT if there is no change to be added into diff,
- * @return LY_ERR value on other errors.
- */
-static LY_ERR
-lyd_diff_userord_attrs(const struct lyd_node *first, const struct lyd_node *second, int options,
- struct lyd_diff_userord **userord, enum lyd_diff_op *op, const char **orig_default, char **value,
- char **orig_value, char **key, char **orig_key)
-{
- const struct lysc_node *schema;
- int dynamic;
- size_t buflen, bufused, first_pos, second_pos;
- struct lyd_diff_userord *userord_item;
-
- assert(first || second);
-
- *orig_default = NULL;
- *value = NULL;
- *orig_value = NULL;
- *key = NULL;
- *orig_key = NULL;
-
- schema = first ? first->schema : second->schema;
- assert(lysc_is_userordered(schema));
-
- /* get userord entry */
- userord_item = lyd_diff_userord_get(first, schema, userord);
- LY_CHECK_RET(!userord_item, LY_EMEM);
-
- /* prepare position of the next instance */
- second_pos = userord_item->pos++;
-
- /* find user-ordered first position */
- if (first) {
- for (first_pos = second_pos; first_pos < LY_ARRAY_COUNT(userord_item->inst); ++first_pos) {
- if (userord_item->inst[first_pos] == first) {
- break;
- }
- }
- assert(first_pos < LY_ARRAY_COUNT(userord_item->inst));
- } else {
- first_pos = 0;
- }
-
- /* learn operation first */
- if (!second) {
- *op = LYD_DIFF_OP_DELETE;
- } else if (!first) {
- *op = LYD_DIFF_OP_CREATE;
- } else {
- assert(schema->nodetype & (LYS_LIST | LYS_LEAFLIST));
- if (lyd_compare(second, userord_item->inst[second_pos], 0)) {
- /* in first, there is a different instance on the second position, we are going to move 'first' node */
- *op = LYD_DIFF_OP_REPLACE;
- } else if ((options & LYD_DIFF_WITHDEFAULTS) && ((first->flags & LYD_DEFAULT) != (second->flags & LYD_DEFAULT))) {
- /* default flag change */
- *op = LYD_DIFF_OP_NONE;
- } else {
- /* no changes */
- return LY_ENOT;
- }
- }
-
- /*
- * set each attribute correctly based on the operation and node type
- */
-
- /* orig-default */
- if ((options & LYD_DIFF_WITHDEFAULTS) && (schema->nodetype == LYS_LEAFLIST)
- && ((*op == LYD_DIFF_OP_REPLACE) || (*op == LYD_DIFF_OP_NONE))) {
- if (first->flags & LYD_DEFAULT) {
- *orig_default = "true";
- } else {
- *orig_default = "false";
- }
- }
-
- /* value */
- if ((schema->nodetype == LYS_LEAFLIST) && ((*op == LYD_DIFF_OP_REPLACE) || (*op == LYD_DIFF_OP_CREATE))) {
- if (second_pos) {
- *value = (char *)lyd_value2str((struct lyd_node_term *)userord_item->inst[second_pos - 1], &dynamic);
- if (!dynamic) {
- *value = strdup(*value);
- LY_CHECK_ERR_RET(!*value, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- } else {
- *value = strdup("");
- LY_CHECK_ERR_RET(!*value, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- }
-
- /* orig-value */
- if ((schema->nodetype == LYS_LEAFLIST) && ((*op == LYD_DIFF_OP_REPLACE) || (*op == LYD_DIFF_OP_DELETE))) {
- if (first_pos) {
- *orig_value = (char *)lyd_value2str((struct lyd_node_term *)userord_item->inst[first_pos - 1], &dynamic);
- if (!dynamic) {
- *orig_value = strdup(*orig_value);
- LY_CHECK_ERR_RET(!*orig_value, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- } else {
- *orig_value = strdup("");
- LY_CHECK_ERR_RET(!*orig_value, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- }
-
- /* key */
- if ((schema->nodetype == LYS_LIST) && ((*op == LYD_DIFF_OP_REPLACE) || (*op ==LYD_DIFF_OP_CREATE))) {
- if (second_pos) {
- buflen = bufused = 0;
- LY_CHECK_RET(lyd_path_list_predicate(userord_item->inst[second_pos - 1], key, &buflen, &bufused, 0));
- } else {
- *key = strdup("");
- LY_CHECK_ERR_RET(!*key, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- }
-
- /* orig-key */
- if ((schema->nodetype == LYS_LIST) && ((*op == LYD_DIFF_OP_REPLACE) || (*op == LYD_DIFF_OP_DELETE))) {
- if (first_pos) {
- buflen = bufused = 0;
- LY_CHECK_RET(lyd_path_list_predicate(userord_item->inst[first_pos - 1], orig_key, &buflen, &bufused, 0));
- } else {
- *orig_key = strdup("");
- LY_CHECK_ERR_RET(!*orig_key, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- }
-
- /*
- * update our instances - apply the change
- */
- if (*op == LYD_DIFF_OP_CREATE) {
- /* insert the instance */
- LY_ARRAY_RESIZE_ERR_RET(schema->module->ctx, userord_item->inst, LY_ARRAY_COUNT(userord_item->inst) + 1,
- ;, LY_EMEM);
- if (second_pos < LY_ARRAY_COUNT(userord_item->inst)) {
- memmove(userord_item->inst + second_pos + 1, userord_item->inst + second_pos,
- (LY_ARRAY_COUNT(userord_item->inst) - second_pos) * sizeof *userord_item->inst);
- }
- LY_ARRAY_INCREMENT(userord_item->inst);
- userord_item->inst[second_pos] = second;
-
- } else if (*op == LYD_DIFF_OP_DELETE) {
- /* remove the instance */
- if (first_pos + 1 < LY_ARRAY_COUNT(userord_item->inst)) {
- memmove(userord_item->inst + first_pos, userord_item->inst + first_pos + 1,
- (LY_ARRAY_COUNT(userord_item->inst) - first_pos - 1) * sizeof *userord_item->inst);
- }
- LY_ARRAY_DECREMENT(userord_item->inst);
-
- } else if (*op == LYD_DIFF_OP_REPLACE) {
- /* move the instances */
- memmove(userord_item->inst + second_pos + 1, userord_item->inst + second_pos,
- (first_pos - second_pos) * sizeof *userord_item->inst);
- userord_item->inst[second_pos] = first;
- }
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Get all the metadata to be stored in a diff for the 2 nodes. Cannot be used for user-ordered
- * lists/leaf-lists.
- *
- * @param[in] first Node from the first tree, can be NULL (on create).
- * @param[in] second Node from the second tree, can be NULL (on delete).
- * @param[in] options Diff options.
- * @param[out] op Operation.
- * @param[out] orig_default Original default metadata.
- * @param[out] orig_value Original value metadata.
- * @return LY_SUCCESS on success,
- * @return LY_ENOT if there is no change to be added into diff,
- * @return LY_ERR value on other errors.
- */
-static LY_ERR
-lyd_diff_attrs(const struct lyd_node *first, const struct lyd_node *second, int options, enum lyd_diff_op *op,
- const char **orig_default, char **orig_value)
-{
- const struct lysc_node *schema;
- int dynamic;
-
- assert(first || second);
-
- *orig_default = NULL;
- *orig_value = NULL;
-
- schema = first ? first->schema : second->schema;
- assert(!lysc_is_userordered(schema));
-
- /* learn operation first */
- if (!second) {
- *op = LYD_DIFF_OP_DELETE;
- } else if (!first) {
- *op = LYD_DIFF_OP_CREATE;
- } else {
- switch (schema->nodetype) {
- case LYS_CONTAINER:
- case LYS_RPC:
- case LYS_ACTION:
- case LYS_NOTIF:
- /* no changes */
- return LY_ENOT;
- case LYS_LIST:
- case LYS_LEAFLIST:
- if ((options & LYD_DIFF_WITHDEFAULTS) && ((first->flags & LYD_DEFAULT) != (second->flags & LYD_DEFAULT))) {
- /* default flag change */
- *op = LYD_DIFF_OP_NONE;
- } else {
- /* no changes */
- return LY_ENOT;
- }
- break;
- case LYS_LEAF:
- case LYS_ANYXML:
- case LYS_ANYDATA:
- if (lyd_compare(first, second, 0)) {
- /* different values */
- *op = LYD_DIFF_OP_REPLACE;
- } else if ((options & LYD_DIFF_WITHDEFAULTS) && ((first->flags & LYD_DEFAULT) != (second->flags & LYD_DEFAULT))) {
- /* default flag change */
- *op = LYD_DIFF_OP_NONE;
- } else {
- /* no changes */
- return LY_ENOT;
- }
- break;
- default:
- LOGINT_RET(schema->module->ctx);
- }
- }
-
- /*
- * set each attribute correctly based on the operation and node type
- */
-
- /* orig-default */
- if ((options & LYD_DIFF_WITHDEFAULTS) && (schema->nodetype & LYD_NODE_TERM)
- && ((*op == LYD_DIFF_OP_REPLACE) || (*op == LYD_DIFF_OP_NONE))) {
- if (first->flags & LYD_DEFAULT) {
- *orig_default = "true";
- } else {
- *orig_default = "false";
- }
- }
-
- /* orig-value */
- if ((schema->nodetype == LYS_LEAF) && (*op == LYD_DIFF_OP_REPLACE)) {
- /* leaf */
- *orig_value = (char *)lyd_value2str((struct lyd_node_term *)first, &dynamic);
- if (!dynamic) {
- *orig_value = strdup(*orig_value);
- LY_CHECK_ERR_RET(!*orig_value, LOGMEM(schema->module->ctx), LY_EMEM);
- }
- }
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Perform diff for all siblings at certain depth, recursively.
- *
- * For user-ordered lists/leaf-lists a specific structure is used for storing
- * the current order. The idea is to apply all the generated diff changes
- * virtually on the first tree so that we can continue to generate correct
- * changes after some were already generated.
- *
- * The algorithm then uses second tree position-based changes with a before
- * (preceding) item anchor.
- *
- * Example:
- *
- * Virtual first tree leaf-list order:
- * 1 2 [3] 4 5
- *
- * Second tree leaf-list order:
- * 1 2 [5] 3 4
- *
- * We are at the 3rd node now. We look at whether the nodes on the 3rd position
- * match - they do not - move nodes so that the 3rd position node is final ->
- * -> move node 5 to the 3rd position -> move node 5 after node 2.
- *
- * Required properties:
- * Stored operations (move) should not be affected by later operations -
- * - would cause a redundantly long list of operations, possibly inifinite.
- *
- * Implemenation justification:
- * First, all delete operations and only then move/create operations are stored.
- * Also, preceding anchor is used and after each iteration another node is
- * at its final position. That results in the invariant that all preceding
- * nodes are final and will not be changed by the later operations, meaning
- * they can safely be used as anchors for the later operations.
- *
- * @param[in] first First tree first sibling.
- * @param[in] second Second tree first sibling.
- * @param[in] options Diff options.
- * @param[in,out] diff Diff to append to.
- * @return LY_ERR value.
- */
-static LY_ERR
-lyd_diff_siblings_r(const struct lyd_node *first, const struct lyd_node *second, int options, struct lyd_node **diff)
-{
- LY_ERR ret = LY_SUCCESS;
- const struct lyd_node *iter_first, *iter_second;
- struct lyd_node *match_second, *match_first;
- int nosiblings = 0;
- struct lyd_diff_userord *userord = NULL;
- LY_ARRAY_COUNT_TYPE u;
- enum lyd_diff_op op;
- const char *orig_default;
- char *orig_value, *key, *value, *orig_key;
-
- if (options & LYD_DIFF_NOSIBLINGS) {
- /* remember it for this function call only, should not be passed recursively */
- nosiblings = 1;
- options &= ~LYD_DIFF_NOSIBLINGS;
- }
-
- /* compare first tree to the second tree - delete, replace, none */
- LY_LIST_FOR(first, iter_first) {
- assert(!(iter_first->schema->flags & LYS_KEY));
- if ((iter_first->flags & LYD_DEFAULT) && !(options & LYD_DIFF_WITHDEFAULTS)) {
- /* skip default nodes */
- continue;
- }
-
- if (iter_first->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
- /* try to find the exact instance */
- lyd_find_sibling_first(second, iter_first, &match_second);
- } else {
- /* try to simply find the node, there cannot be more instances */
- lyd_find_sibling_val(second, iter_first->schema, NULL, 0, &match_second);
- }
-
- if (match_second && (match_second->flags & LYD_DEFAULT) && !(options & LYD_DIFF_WITHDEFAULTS)) {
- /* ignore default nodes */
- match_second = NULL;
- }
-
- if (lysc_is_userordered(iter_first->schema)) {
- if (match_second) {
- /* we are handling only user-ordered node delete now */
- continue;
- }
-
- /* get all the attributes */
- LY_CHECK_GOTO(lyd_diff_userord_attrs(iter_first, match_second, options, &userord, &op, &orig_default,
- &value, &orig_value, &key, &orig_key), cleanup);
-
- /* there must be changes, it is deleted */
- assert(op == LYD_DIFF_OP_DELETE);
- ret = lyd_diff_add(iter_first, op, orig_default, orig_value, key, value, orig_key, diff);
-
- free(orig_value);
- free(key);
- free(value);
- free(orig_key);
- LY_CHECK_GOTO(ret, cleanup);
- } else {
- /* get all the attributes */
- ret = lyd_diff_attrs(iter_first, match_second, options, &op, &orig_default, &orig_value);
-
- /* add into diff if there are any changes */
- if (!ret) {
- if (op == LYD_DIFF_OP_DELETE) {
- ret = lyd_diff_add(iter_first, op, orig_default, orig_value, NULL, NULL, NULL, diff);
- } else {
- ret = lyd_diff_add(match_second, op, orig_default, orig_value, NULL, NULL, NULL, diff);
- }
-
- free(orig_value);
- LY_CHECK_GOTO(ret, cleanup);
- } else if (ret == LY_ENOT) {
- ret = LY_SUCCESS;
- } else {
- goto cleanup;
- }
- }
-
- /* check descendants, if any, recursively */
- if (match_second) {
- LY_CHECK_GOTO(lyd_diff_siblings_r(LYD_CHILD(iter_first), LYD_CHILD(match_second), options, diff), cleanup);
- }
-
- if (nosiblings) {
- break;
- }
- }
-
- /* reset all cached positions */
- LY_ARRAY_FOR(userord, u) {
- userord[u].pos = 0;
- }
-
- /* compare second tree to the first tree - create, user-ordered move */
- LY_LIST_FOR(second, iter_second) {
- assert(!(iter_second->schema->flags & LYS_KEY));
- if ((iter_second->flags & LYD_DEFAULT) && !(options & LYD_DIFF_WITHDEFAULTS)) {
- /* skip default nodes */
- continue;
- }
-
- if (iter_second->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
- lyd_find_sibling_first(first, iter_second, &match_first);
- } else {
- lyd_find_sibling_val(first, iter_second->schema, NULL, 0, &match_first);
- }
-
- if (match_first && (match_first->flags & LYD_DEFAULT) && !(options & LYD_DIFF_WITHDEFAULTS)) {
- /* ignore default nodes */
- match_first = NULL;
- }
-
- if (lysc_is_userordered(iter_second->schema)) {
- /* get all the attributes */
- ret = lyd_diff_userord_attrs(match_first, iter_second, options, &userord, &op, &orig_default,
- &value, &orig_value, &key, &orig_key);
-
- /* add into diff if there are any changes */
- if (!ret) {
- ret = lyd_diff_add(iter_second, op, orig_default, orig_value, key, value, orig_key, diff);
-
- free(orig_value);
- free(key);
- free(value);
- free(orig_key);
- LY_CHECK_GOTO(ret, cleanup);
- } else if (ret == LY_ENOT) {
- ret = LY_SUCCESS;
- } else {
- goto cleanup;
- }
- } else if (!match_first) {
- /* get all the attributes */
- LY_CHECK_GOTO(lyd_diff_attrs(match_first, iter_second, options, &op, &orig_default, &orig_value), cleanup);
-
- /* there must be changes, it is created */
- assert(op == LYD_DIFF_OP_CREATE);
- ret = lyd_diff_add(iter_second, op, orig_default, orig_value, NULL, NULL, NULL, diff);
-
- free(orig_value);
- LY_CHECK_GOTO(ret, cleanup);
- } /* else was handled */
-
- if (nosiblings) {
- break;
- }
- }
-
-cleanup:
- LY_ARRAY_FOR(userord, u) {
- LY_ARRAY_FREE(userord[u].inst);
- }
- LY_ARRAY_FREE(userord);
- return ret;
-}
-
-API LY_ERR
-lyd_diff(const struct lyd_node *first, const struct lyd_node *second, int options, struct lyd_node **diff)
-{
- const struct ly_ctx *ctx;
-
- LY_CHECK_ARG_RET(NULL, diff, LY_EINVAL);
-
- if (first) {
- ctx = LYD_NODE_CTX(first);
- } else if (second) {
- ctx = LYD_NODE_CTX(second);
- } else {
- ctx = NULL;
- }
-
- if (first && second && (lysc_data_parent(first->schema) != lysc_data_parent(second->schema))) {
- LOGERR(ctx, LY_EINVAL, "Invalid arguments - cannot create diff for unrelated data (%s()).", __func__);
- return LY_EINVAL;
- }
-
- *diff = NULL;
-
- return lyd_diff_siblings_r(first, second, options, diff);
-}
-
-/**
- * @brief Find a matching node in data tree for a diff node.
- *
- * @param[in] first_node First sibling in the data tree.
- * @param[in] diff_node Diff node to match.
- * @param[out] match_p Matching node.
- * @return LY_ERR value.
- */
-static LY_ERR
-lyd_diff_find_node(const struct lyd_node *first_node, const struct lyd_node *diff_node, struct lyd_node **match_p)
-{
- if (diff_node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
- /* try to find the exact instance */
- lyd_find_sibling_first(first_node, diff_node, match_p);
- } else {
- /* try to simply find the node, there cannot be more instances */
- lyd_find_sibling_val(first_node, diff_node->schema, NULL, 0, match_p);
- }
- LY_CHECK_ERR_RET(!*match_p, LOGINT(LYD_NODE_CTX(diff_node)), LY_EINT);
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Learn operation of a diff node.
- *
- * @param[in] diff_node Diff node.
- * @param[out] op Operation.
- * @param[out] key_or_value Optional list instance keys predicate or leaf-list value for move operation.
- * @return LY_ERR value.
- */
-static LY_ERR
-lyd_diff_get_op(const struct lyd_node *diff_node, const char **op, const char **key_or_value)
-{
- struct lyd_meta *meta = NULL;
- const struct lyd_node *diff_parent;
- const char *meta_name, *str;
- int dynamic;
-
- for (diff_parent = diff_node; diff_parent; diff_parent = (struct lyd_node *)diff_parent->parent) {
- LY_LIST_FOR(diff_parent->meta, meta) {
- if (!strcmp(meta->name, "operation") && !strcmp(meta->annotation->module->name, "yang")) {
- str = lyd_meta2str(meta, &dynamic);
- assert(!dynamic);
- if ((str[0] == 'r') && (diff_parent != diff_node)) {
- /* we do not care about this operation if it's in our parent */
- continue;
- }
- *op = str;
- break;
- }
- }
- if (meta) {
- break;
- }
- }
- LY_CHECK_ERR_RET(!meta, LOGINT(LYD_NODE_CTX(diff_node)), LY_EINT);
-
- *key_or_value = NULL;
- if (lysc_is_userordered(diff_node->schema) && (((*op)[0] == 'c') || ((*op)[0] == 'r'))) {
- if (diff_node->schema->nodetype == LYS_LIST) {
- meta_name = "key";
- } else {
- meta_name = "value";
- }
-
- LY_LIST_FOR(diff_node->meta, meta) {
- if (!strcmp(meta->name, meta_name) && !strcmp(meta->annotation->module->name, "yang")) {
- str = lyd_meta2str(meta, &dynamic);
- assert(!dynamic);
- *key_or_value = str;
- break;
- }
- }
- LY_CHECK_ERR_RET(!meta, LOGINT(LYD_NODE_CTX(diff_node)), LY_EINT);
- }
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Insert a diff node into a data tree.
- *
- * @param[in,out] first_node First sibling of the data tree.
- * @param[in] parent_node Data tree sibling parent node.
- * @param[in] new_node Node to insert.
- * @param[in] keys_or_value Optional predicate of relative (leaf-)list instance. If not set, the user-ordered
- * instance will be inserted at the first position.
- * @return err_info, NULL on success.
- */
-static LY_ERR
-lyd_diff_insert(struct lyd_node **first_node, struct lyd_node *parent_node, struct lyd_node *new_node,
- const char *key_or_value)
-{
- LY_ERR ret;
- struct lyd_node *anchor;
-
- assert(new_node);
-
- if (!*first_node) {
- if (!parent_node) {
- /* no parent or siblings */
- *first_node = new_node;
- return LY_SUCCESS;
- }
-
- /* simply insert into parent, no other children */
- if (key_or_value) {
- LOGERR(LYD_NODE_CTX(new_node), LY_EINVAL, "Node \"%s\" instance to insert next to not found.",
- new_node->schema->name);
- return LY_EINVAL;
- }
- return lyd_insert(parent_node, new_node);
- }
-
- assert(!(*first_node)->parent || ((struct lyd_node *)(*first_node)->parent == parent_node));
-
- /* simple insert */
- if (!lysc_is_userordered(new_node->schema)) {
- /* insert at the end */
- return lyd_insert_sibling(*first_node, new_node);
- }
-
- if (key_or_value) {
- /* find the anchor sibling */
- ret = lyd_find_sibling_val(*first_node, new_node->schema, key_or_value, 0, &anchor);
- if (ret == LY_ENOTFOUND) {
- LOGERR(LYD_NODE_CTX(new_node), LY_EINVAL, "Node \"%s\" instance to insert next to not found.",
- new_node->schema->name);
- return LY_EINVAL;
- } else if (ret) {
- return ret;
- }
-
- /* insert after */
- LY_CHECK_RET(lyd_insert_after(anchor, new_node));
- assert(new_node->prev == anchor);
- if (*first_node == new_node) {
- *first_node = anchor;
- }
- } else {
- if ((*first_node)->schema->flags & LYS_KEY) {
- assert(parent_node && (parent_node->schema->nodetype == LYS_LIST));
-
- /* find last key */
- anchor = *first_node;
- while (anchor->next && (anchor->next->schema->flags & LYS_KEY)) {
- anchor = anchor->next;
- }
- /* insert after the last key */
- LY_CHECK_RET(lyd_insert_after(anchor, new_node));
- } else {
- /* insert at the beginning */
- LY_CHECK_RET(lyd_insert_before(*first_node, new_node));
- *first_node = new_node;
- }
- }
-
- return LY_SUCCESS;
-}
-
-/**
- * @brief Apply diff subtree on data tree nodes, recursively.
- *
- * @param[in,out] first_node First sibling of the data tree.
- * @param[in] parent_node Parent of the first sibling.
- * @param[in] diff_node Current diff node.
- * @return LY_ERR value.
- */
-static LY_ERR
-lyd_diff_apply_r(struct lyd_node **first_node, struct lyd_node *parent_node, const struct lyd_node *diff_node,
- lyd_diff_cb diff_cb, void *cb_data)
-{
- LY_ERR ret;
- struct lyd_node *match, *diff_child;
- const char *op, *key_or_value, *str_val;
- int dynamic;
- const struct ly_ctx *ctx = LYD_NODE_CTX(diff_node);
-
- /* read all the valid attributes */
- LY_CHECK_RET(lyd_diff_get_op(diff_node, &op, &key_or_value));
-
- /* handle user-ordered (leaf-)lists separately */
- if (key_or_value) {
- assert((op[0] == 'c') || (op[0] == 'r'));
- if (op[0] == 'r') {
- /* find the node (we must have some siblings because the node was only moved) */
- LY_CHECK_RET(lyd_diff_find_node(*first_node, diff_node, &match));
- } else {
- /* duplicate the node(s) */
- match = lyd_dup(diff_node, NULL, LYD_DUP_NO_META);
- LY_CHECK_RET(!match, LY_EMEM);
- }
-
- /* insert/move the node */
- if (key_or_value[0]) {
- ret = lyd_diff_insert(first_node, parent_node, match, key_or_value);
- } else {
- ret = lyd_diff_insert(first_node, parent_node, match, NULL);
- }
- if (ret) {
- if (op[0] == 'c') {
- lyd_free_tree(match);
- }
- return ret;
- }
-
- goto next_iter_r;
- }
-
- /* apply operation */
- switch (op[0]) {
- case 'n':
- /* find the node */
- LY_CHECK_RET(lyd_diff_find_node(*first_node, diff_node, &match));
-
- if (match->schema->nodetype & LYD_NODE_TERM) {
- /* special case of only dflt flag change */
- if (diff_node->flags & LYD_DEFAULT) {
- match->flags |= LYD_DEFAULT;
- } else {
- match->flags &= ~LYD_DEFAULT;
- }
- } else {
- /* none operation on nodes without children is redundant and hence forbidden */
- if (!LYD_CHILD(diff_node)) {
- LOGINT_RET(ctx);
- }
- }
- break;
- case 'c':
- /* duplicate the node */
- match = lyd_dup(diff_node, NULL, LYD_DUP_NO_META);
- LY_CHECK_RET(!match, LY_EMEM);
-
- /* insert it at the end */
- ret = 0;
- if (*first_node) {
- ret = lyd_insert_after((*first_node)->prev, match);
- } else if (parent_node) {
- ret = lyd_insert(parent_node, match);
- } else {
- *first_node = match;
- }
- if (ret) {
- lyd_free_tree(match);
- return ret;
- }
-
- break;
- case 'd':
- /* find the node */
- LY_CHECK_RET(lyd_diff_find_node(*first_node, diff_node, &match));
-
- /* remove it */
- if ((match == *first_node) && !match->parent) {
- assert(!parent_node);
- /* we have removed the top-level node */
- *first_node = (*first_node)->next;
- }
- lyd_free_tree(match);
-
- /* we are not going recursively in this case, the whole subtree was already deleted */
- return LY_SUCCESS;
- case 'r':
- LY_CHECK_ERR_RET(diff_node->schema->nodetype != LYS_LEAF, LOGINT(ctx), LY_EINT);
-
- /* find the node */
- LY_CHECK_RET(lyd_diff_find_node(*first_node, diff_node, &match));
-
- /* update its value */
- str_val = lyd_value2str((struct lyd_node_term *)diff_node, &dynamic);
- ret = lyd_change_term(match, str_val);
- if (dynamic) {
- free((char *)str_val);
- }
- if (ret && (ret != LY_EEXIST)) {
- LOGINT_RET(ctx);
- }
-
- /* with flags */
- match->flags = diff_node->flags;
- break;
- default:
- LOGINT_RET(ctx);
- }
-
-next_iter_r:
- if (diff_cb) {
- /* call callback */
- LY_CHECK_RET(diff_cb(diff_node, match, cb_data));
- }
-
- /* apply diff recursively */
- LY_LIST_FOR(LYD_CHILD(diff_node), diff_child) {
- LY_CHECK_RET(lyd_diff_apply_r(lyd_node_children_p(match), match, diff_child, diff_cb, cb_data));
- }
-
- return LY_SUCCESS;
-}
-
-API LY_ERR
-lyd_diff_apply_module(struct lyd_node **data, const struct lyd_node *diff, const struct lys_module *mod,
- lyd_diff_cb diff_cb, void *cb_data)
-{
- const struct lyd_node *root;
-
- LY_LIST_FOR(diff, root) {
- if (mod && (lyd_owner_module(root) != mod)) {
- /* skip data nodes from different modules */
- continue;
- }
-
- /* apply relevant nodes from the diff datatree */
- LY_CHECK_RET(lyd_diff_apply_r(data, NULL, root, diff_cb, cb_data));
- }
-
- return LY_SUCCESS;
-}
-
-API LY_ERR
-lyd_diff_apply(struct lyd_node **data, const struct lyd_node *diff)
-{
- return lyd_diff_apply_module(data, diff, NULL, NULL, NULL);
-}
-
static LY_ERR
lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, int is_static)
{
@@ -3481,17 +2460,7 @@
return LY_SUCCESS;
}
-/**
- * @brief Append all list key predicates to path.
- *
- * @param[in] node Node with keys to print.
- * @param[in,out] buffer Buffer to print to.
- * @param[in,out] buflen Current buffer length.
- * @param[in,out] bufused Current number of characters used in @p buffer.
- * @param[in] is_static Whether buffer is static or can be reallocated.
- * @return LY_ERR
- */
-static LY_ERR
+LY_ERR
lyd_path_list_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, int is_static)
{
const struct lyd_node *key;