tree data UPDATE remove value_type from any nodes

Author: michalvasko

doc/transition_4_5.dox

@@ -4,8 +4,9 @@
  * There are few non-backwards-compatible changes that should not affect the majority of users. These include an
  * **updated canonical value** of *date-and-time* value in an unknown timezone. Also, there were minor changes in a few
  * public structures. These include changing the type of the `parent` member of ::lyd_node or
- * removing the `lyd_anydata_value` union. Both these changes made the data node structures more unified and
- * user-friendly.
+ * removing the `lyd_anydata_value` union and `value_type` member of `struct lyd_node_any`. Both these changes made the
+ * data node structures more unified and user-friendly. Anyxml and anydata nodes now have either a data tree or string
+ * value, with string values having hints that aid in correctly printing and preserving the values.
  *
  * To mention all the significant changes, the binary **LYB format was improved** and now fully supports 2 variants.
  * The default one is optimized for performance and has fairly lenient restrictions on the context parsing these data.

src/diff.c

@@ -1890,7 +1890,7 @@ lyd_diff_apply_r(struct lyd_node **first_node, struct lyd_node *parent_node, con
             } else {
                 struct lyd_node_any *any = (struct lyd_node_any *)diff_node;
 
-                LY_CHECK_RET(lyd_any_copy_value(match, any->child ? any->child : (void *)any->value, any->value_type));
+                LY_CHECK_RET(lyd_any_copy_value(match, any->child, any->value, any->hints));
             }
 
             /* with flags */
@@ -2278,7 +2278,7 @@ lyd_diff_merge_replace(struct lyd_node *diff_match, enum lyd_diff_op cur_op, con
 
             /* modify the node value */
             any = (struct lyd_node_any *)src_diff;
-            LY_CHECK_RET(lyd_any_copy_value(diff_match, any->child ? any->child : (void *)any->value, any->value_type));
+            LY_CHECK_RET(lyd_any_copy_value(diff_match, any->child, any->value, any->hints));
             break;
         default:
             LOGINT_RET(LYD_CTX(src_diff));
@@ -3051,7 +3051,7 @@ lyd_diff_reverse_value(struct lyd_node *node, const struct lys_module *mod)
     if (node->schema->nodetype == LYS_LEAF) {
         LY_CHECK_GOTO(ret = lyd_change_term(node, val1), cleanup);
     } else {
-        LY_CHECK_GOTO(ret = lyd_any_copy_value(node, val1, LYD_ANYDATA_STRING), cleanup);
+        LY_CHECK_GOTO(ret = lyd_any_copy_value(node, NULL, val1, 0), cleanup);
     }
     node->flags = flags;
     LY_CHECK_GOTO(ret = lyd_change_meta(meta, val2), cleanup);

src/parser_json.c

@@ -1247,7 +1247,7 @@ lydjson_parse_any(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, co
     switch (*status) {
     case LYJSON_OBJECT:
         /* create empty node */
-        r = lyd_create_any(snode, NULL, LYD_ANYDATA_DATATREE, 1, 0, node);
+        r = lyd_create_any(snode, NULL, NULL, 0, 1, 0, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         break;
     case LYJSON_ARRAY:
@@ -1267,20 +1267,21 @@ lydjson_parse_any(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, co
             rc = LY_EMEM;
             goto cleanup;
         }
-        r = lyd_create_any(snode, val, LYD_ANYDATA_JSON, 1, 0, node);
+        r = lyd_create_any(snode, NULL, val, LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST, 1, 0, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         val = NULL;
         break;
     case LYJSON_STRING:
         /* string value */
         if (lydctx->jsonctx->dynamic) {
-            LY_CHECK_GOTO(rc = lyd_create_any(snode, lydctx->jsonctx->value, LYD_ANYDATA_STRING, 1, 0, node), cleanup);
+            LY_CHECK_GOTO(rc = lyd_create_any(snode, NULL, lydctx->jsonctx->value,
+                    LYD_VALHINT_STRING | LYD_VALHINT_NUM64, 1, 0, node), cleanup);
             lydctx->jsonctx->dynamic = 0;
         } else {
             val = strndup(lydctx->jsonctx->value, lydctx->jsonctx->value_len);
             LY_CHECK_ERR_GOTO(!val, LOGMEM(lydctx->jsonctx->ctx); rc = LY_EMEM, cleanup);
 
-            r = lyd_create_any(snode, val, LYD_ANYDATA_STRING, 1, 0, node);
+            r = lyd_create_any(snode, NULL, val, LYD_VALHINT_STRING | LYD_VALHINT_NUM64, 1, 0, node);
             LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
             val = NULL;
         }
@@ -1293,13 +1294,13 @@ lydjson_parse_any(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, co
         val = strndup(lydctx->jsonctx->value, lydctx->jsonctx->value_len);
         LY_CHECK_ERR_GOTO(!val, LOGMEM(lydctx->jsonctx->ctx); rc = LY_EMEM, cleanup);
 
-        r = lyd_create_any(snode, val, LYD_ANYDATA_JSON, 1, 0, node);
+        r = lyd_create_any(snode, NULL, val, (*status == LYJSON_NUMBER) ? LYD_VALHINT_DECNUM : LYD_VALHINT_BOOLEAN, 1, 0, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         val = NULL;
         break;
     case LYJSON_NULL:
         /* no value */
-        r = lyd_create_any(snode, NULL, LYD_ANYDATA_JSON, 1, 0, node);
+        r = lyd_create_any(snode, NULL, NULL, LYD_VALHINT_EMPTY, 1, 0, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         break;
     default:

src/parser_lyb.c

@@ -1282,9 +1282,8 @@ lyb_parse_node_any(struct lyd_lyb_ctx *lybctx, struct lyd_node *parent, const st
     LY_ERR rc = LY_SUCCESS;
     struct lyd_node *node = NULL, *tree = NULL;
     struct lyd_meta *meta = NULL;
-    LYD_ANYDATA_VALUETYPE value_type = 0;
     char *value = NULL;
-    uint32_t flags = 0, prev_parse_opts, prev_int_opts;
+    uint32_t flags = 0, value_type = 0, prev_parse_opts, prev_int_opts;
     const struct ly_ctx *ctx = lybctx->parse_ctx->ctx;
 
     /* read necessary basic data */
@@ -1295,8 +1294,7 @@ lyb_parse_node_any(struct lyd_lyb_ctx *lybctx, struct lyd_node *parent, const st
     lyb_read_count((uint32_t *)&value_type, lybctx->parse_ctx);
 
     /* create the node */
-    switch (value_type) {
-    case LYD_ANYDATA_DATATREE:
+    if (value_type == 0) {
         /* backup original options and use specific ones */
         prev_parse_opts = lybctx->parse_opts;
         prev_int_opts = lybctx->int_opts;
@@ -1310,23 +1308,19 @@ lyb_parse_node_any(struct lyd_lyb_ctx *lybctx, struct lyd_node *parent, const st
         LY_CHECK_GOTO(rc, cleanup);
 
         /* use the data tree value */
-        rc = lyd_create_any(snode, tree, value_type, 1, 0, &node);
+        rc = lyd_create_any(snode, tree, NULL, 0, 1, 0, &node);
         LY_CHECK_GOTO(rc, cleanup);
         tree = NULL;
-        break;
-    case LYD_ANYDATA_STRING:
-    case LYD_ANYDATA_XML:
-    case LYD_ANYDATA_JSON:
+    } else if (value_type == 1) {
         /* string value */
         rc = lyb_read_string(&value, lybctx->parse_ctx);
         LY_CHECK_GOTO(rc, cleanup);
 
         /* use the string value */
-        rc = lyd_create_any(snode, value, value_type, 1, 0, &node);
+        rc = lyd_create_any(snode, NULL, value, 0, 1, 0, &node);
         LY_CHECK_GOTO(rc, cleanup);
         value = NULL;
-        break;
-    default:
+    } else {
         LOGINT(ctx);
         rc = LY_EINT;
         goto cleanup;

src/parser_xml.c

@@ -934,7 +934,7 @@ lydxml_subtree_any(struct lyd_xml_ctx *lydctx, const struct lysc_node *snode, co
 
     if (xmlctx->ws_only) {
         /* create empty node first */
-        r = lyd_create_any(snode, NULL, LYD_ANYDATA_DATATREE, 1, 0, node);
+        r = lyd_create_any(snode, NULL, NULL, 0, 1, 0, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         datatree_val = 1;
     } else {
@@ -943,7 +943,7 @@ lydxml_subtree_any(struct lyd_xml_ctx *lydctx, const struct lysc_node *snode, co
         LY_CHECK_ERR_GOTO(!val, LOGMEM(xmlctx->ctx); rc = LY_EMEM, cleanup);
 
         /* create node */
-        r = lyd_create_any(snode, val, LYD_ANYDATA_STRING, 1, 1, node);
+        r = lyd_create_any(snode, NULL, val, 0, 1, 1, node);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
         val = NULL;
     }

src/printer_json.c

@@ -4,7 +4,7 @@
  * @author Michal Vasko <mvasko@cesnet.cz>
  * @brief JSON printer for libyang data structure
  *
- * Copyright (c) 2015 - 2023 CESNET, z.s.p.o.
+ * Copyright (c) 2015 - 2026 CESNET, z.s.p.o.
  *
  * This source code is licensed under BSD 3-Clause License (the "License").
  * You may not use this file except in compliance with the License.
@@ -617,12 +617,11 @@ json_print_any_content(struct jsonpr_ctx *pctx, struct lyd_node_any *any)
 
     assert(any->schema->nodetype & LYD_NODE_ANY);
 
-    if ((any->schema->nodetype == LYS_ANYDATA) && (any->value_type != LYD_ANYDATA_DATATREE)) {
+    if ((any->schema->nodetype == LYS_ANYDATA) && any->value) {
         LOGINT_RET(pctx->ctx);
     }
 
-    switch (any->value_type) {
-    case LYD_ANYDATA_DATATREE:
+    if (any->child) {
         /* print as an object */
         ly_print_(pctx->out, "{%s", DO_FORMAT ? "\n" : "");
         LEVEL_INC;
@@ -646,34 +645,22 @@ json_print_any_content(struct jsonpr_ctx *pctx, struct lyd_node_any *any)
         } else {
             ly_print_(pctx->out, "}");
         }
-        break;
-    case LYD_ANYDATA_JSON:
-        if (!any->value) {
-            /* no content */
-            if (any->schema->nodetype == LYS_ANYXML) {
-                ly_print_(pctx->out, "null");
-            } else {
-                ly_print_(pctx->out, "{}");
-            }
-        } else {
-            /* print without escaping special characters */
+    } else if (any->value) {
+        if (any->hints & (LYD_VALHINT_DECNUM | LYD_VALHINT_BOOLEAN | LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
+            /* print directly as JSON data */
             ly_print_(pctx->out, "%s", any->value);
-        }
-        break;
-    case LYD_ANYDATA_STRING:
-    case LYD_ANYDATA_XML:
-        if (!any->value) {
-            /* no content */
-            if (any->schema->nodetype == LYS_ANYXML) {
-                ly_print_(pctx->out, "null");
-            } else {
-                ly_print_(pctx->out, "{}");
-            }
         } else {
             /* print as a string */
             json_print_string(pctx->out, any->value);
         }
-        break;
+    } else {
+        /* no content */
+        if (any->hints & LYD_VALHINT_EMPTY) {
+            assert(any->schema->nodetype != LYS_ANYDATA);
+            ly_print_(pctx->out, "null");
+        } else {
+            ly_print_(pctx->out, "{}");
+        }
     }
 
     return LY_SUCCESS;

src/printer_lyb.c

@@ -1183,32 +1183,25 @@ static LY_ERR
 lyb_print_node_any(struct lyd_node_any *anydata, struct lyd_lyb_ctx *lybctx)
 {
     LY_ERR rc = LY_SUCCESS;
+    uint32_t value_type;
 
-    if ((anydata->schema->nodetype == LYS_ANYDATA) && (anydata->value_type != LYD_ANYDATA_DATATREE)) {
+    if ((anydata->schema->nodetype == LYS_ANYDATA) && anydata->value) {
         LOGINT_RET(lybctx->print_ctx->ctx);
     }
 
     /* write necessary basic data */
     LY_CHECK_RET(lyb_print_node_header((struct lyd_node *)anydata, lybctx));
 
     /* write anydata value type */
-    LY_CHECK_GOTO(rc = lyb_write_count(anydata->value_type, lybctx->print_ctx), cleanup);
+    value_type = (anydata->value ? 1 : 0);
+    LY_CHECK_GOTO(rc = lyb_write_count(value_type, lybctx->print_ctx), cleanup);
 
-    switch (anydata->value_type) {
-    case LYD_ANYDATA_DATATREE:
-        /* print LYB siblings */
-        LY_CHECK_GOTO(rc = lyb_print_siblings(anydata->child, 0, lybctx), cleanup);
-        break;
-    case LYD_ANYDATA_STRING:
-    case LYD_ANYDATA_XML:
-    case LYD_ANYDATA_JSON:
+    if (anydata->value) {
         /* string value */
         LY_CHECK_GOTO(rc = lyb_write_string(anydata->value, 0, lybctx->print_ctx), cleanup);
-        break;
-    default:
-        LOGINT(lybctx->print_ctx->ctx);
-        rc = LY_EINT;
-        goto cleanup;
+    } else {
+        /* print LYB siblings, even empty */
+        LY_CHECK_GOTO(rc = lyb_print_siblings(anydata->child, 0, lybctx), cleanup);
     }
 
 cleanup:

src/printer_xml.c

@@ -440,59 +440,39 @@ xml_print_anydata(struct xmlpr_ctx *pctx, const struct lyd_node_any *node)
     uint32_t prev_opts;
     LY_ERR ret;
 
-    if ((node->schema->nodetype == LYS_ANYDATA) && (node->value_type != LYD_ANYDATA_DATATREE)) {
+    if ((node->schema->nodetype == LYS_ANYDATA) && node->value) {
         LOGINT_RET(pctx->ctx);
     }
 
     xml_print_node_open(pctx, &node->node);
 
-    if (!any->child && !any->value) {
-        /* no content */
-no_content:
-        ly_print_(pctx->out, "/>%s", DO_FORMAT ? "\n" : "");
-        return LY_SUCCESS;
-    } else {
-        switch (any->value_type) {
-        case LYD_ANYDATA_DATATREE:
-            /* close opening tag and print data */
-            prev_opts = pctx->options;
-            pctx->options &= ~LYD_PRINT_SIBLINGS;
-            LEVEL_INC;
-
-            ly_print_(pctx->out, ">%s", DO_FORMAT ? "\n" : "");
-            LY_LIST_FOR(any->child, iter) {
-                ret = xml_print_node(pctx, iter);
-                LY_CHECK_ERR_RET(ret, LEVEL_DEC, ret);
-            }
+    if (any->child) {
+        /* close opening tag and print data */
+        prev_opts = pctx->options;
+        pctx->options &= ~LYD_PRINT_SIBLINGS;
+        LEVEL_INC;
 
-            LEVEL_DEC;
-            pctx->options = prev_opts;
-            break;
-        case LYD_ANYDATA_STRING:
-        case LYD_ANYDATA_JSON:
-            /* escape XML-sensitive characters */
-            if (!any->value[0]) {
-                goto no_content;
-            }
-            /* close opening tag and print data */
-            ly_print_(pctx->out, ">");
-            lyxml_dump_text(pctx->out, any->value, 0);
-            break;
-        case LYD_ANYDATA_XML:
-            /* print without escaping special characters */
-            if (!any->value[0]) {
-                goto no_content;
-            }
-            ly_print_(pctx->out, ">%s", any->value);
-            break;
+        ly_print_(pctx->out, ">%s", DO_FORMAT ? "\n" : "");
+        LY_LIST_FOR(any->child, iter) {
+            ret = xml_print_node(pctx, iter);
+            LY_CHECK_ERR_RET(ret, LEVEL_DEC, ret);
         }
 
+        LEVEL_DEC;
+        pctx->options = prev_opts;
+
         /* closing tag */
-        if (any->value_type == LYD_ANYDATA_DATATREE) {
-            ly_print_(pctx->out, "%*s</%s>%s", INDENT, node->schema->name, DO_FORMAT ? "\n" : "");
-        } else {
-            ly_print_(pctx->out, "</%s>%s", node->schema->name, DO_FORMAT ? "\n" : "");
-        }
+        ly_print_(pctx->out, "%*s</%s>%s", INDENT, node->schema->name, DO_FORMAT ? "\n" : "");
+    } else if (any->value && any->value[0]) {
+        /* close opening tag and print data, escape XML-sensitive characters */
+        ly_print_(pctx->out, ">");
+        lyxml_dump_text(pctx->out, any->value, 0);
+
+        /* closing tag */
+        ly_print_(pctx->out, "</%s>%s", node->schema->name, DO_FORMAT ? "\n" : "");
+    } else {
+        /* no content, close */
+        ly_print_(pctx->out, "/>%s", DO_FORMAT ? "\n" : "");
     }
 
     return LY_SUCCESS;