data: update of default(s) API

This patch updates the SLeaf default and SLeafList defaults API with
logic introduced by libyang v4

Signed-off-by: Stefan Gula <[email protected]>

Author: steweg

cffi/cdefs.h

@@ -367,6 +367,7 @@ LY_ERR lys_print_module(struct ly_out *, const struct lys_module *, LYS_OUTFORMA
 
 struct lysc_module {
 	struct lys_module *mod;
+	const char **features;
 	struct lysc_node *data;
 	struct lysc_node_action *rpcs;
 	struct lysc_node_notif *notifs;
@@ -609,6 +610,11 @@ struct lysp_node_container {
     ...;
 };
 
+struct lysc_value {
+    const char *str;
+    struct lysc_prefix *prefixes;
+};
+
 struct lysc_node_leaf {
     union {
         struct lysc_node node;
@@ -622,7 +628,7 @@ struct lysc_node_leaf {
     struct lysc_when **when;
     struct lysc_type *type;
     const char *units;
-    struct lyd_value *dflt;
+    struct lysc_value dflt;
     ...;
 };
 
@@ -652,7 +658,7 @@ struct lysc_node_leaflist {
     struct lysc_when **when;
     struct lysc_type *type;
     const char *units;
-    struct lyd_value **dflts;
+    struct lysc_value *dflts;
     uint32_t min;
     uint32_t max;
     ...;
@@ -1316,6 +1322,8 @@ struct lyd_attr {
 LY_ERR lyd_new_attr(struct lyd_node *, const char *, const char *, const char *, struct lyd_attr **);
 void lyd_free_attr_single(const struct ly_ctx *ctx, struct lyd_attr *attr);
 
+LY_ERR lyd_value_validate_dflt(const struct lysc_node *, const char *, struct lysc_prefix *, const struct lyd_node *, const struct lysc_type **, const char **);
+
 struct lyd_leafref_links_rec {
     const struct lyd_node_term *node;
     const struct lyd_node_term **leafref_nodes;

cffi/source.c

@@ -6,6 +6,6 @@
 #include <libyang/libyang.h>
 #include <libyang/version.h>
 
-#if LY_VERSION_MAJOR * 10000 + LY_VERSION_MINOR * 100 + LY_VERSION_MICRO < 30801
-#error "This version of libyang bindings only works with libyang soversion 3.8.1+"
+#if LY_VERSION_MAJOR * 10000 + LY_VERSION_MINOR * 100 + LY_VERSION_MICRO < 40100
+#error "This version of libyang bindings only works with libyang soversion 4.1.0+"
 #endif

libyang/schema.py

@@ -1522,21 +1522,35 @@ def new(context: "libyang.Context", cdata) -> "SNode":
 # -------------------------------------------------------------------------------------
 @SNode.register(SNode.LEAF)
 class SLeaf(SNode):
-    __slots__ = ("cdata_leaf", "cdata_leaf_parsed")
+    __slots__ = ("cdata_leaf", "cdata_leaf_parsed", "cdata_default_realtype")
 
     def __init__(self, context: "libyang.Context", cdata):
         super().__init__(context, cdata)
         self.cdata_leaf = ffi.cast("struct lysc_node_leaf *", cdata)
         self.cdata_leaf_parsed = ffi.cast("struct lysp_node_leaf *", self.cdata_parsed)
+        self.cdata_default_realtype = None
 
     def default(self) -> Union[None, bool, int, str, float]:
-        if not self.cdata_leaf.dflt:
+        if not self.cdata_leaf.dflt.str:
             return None
-        val = lib.lyd_value_get_canonical(self.context.cdata, self.cdata_leaf.dflt)
-        if not val:
-            return None
-        val = c2str(val)
-        val_type = Type(self.context, self.cdata_leaf.dflt.realtype, None)
+
+        if self.cdata_default_realtype is None:
+            # calculate real type of default value just once
+            val_type_cdata = ffi.new("struct lysc_type **", ffi.NULL)
+            ret = lib.lyd_value_validate_dflt(
+                self.cdata,
+                self.cdata_leaf.dflt.str,
+                self.cdata_leaf.dflt.prefixes,
+                ffi.NULL,
+                val_type_cdata,
+                ffi.NULL,
+            )
+            if ret != lib.LY_SUCCESS:
+                raise self.context.error("Unable to get real type of default value")
+            self.cdata_default_realtype = Type(self.context, val_type_cdata[0], None)
+
+        val = c2str(self.cdata_leaf.dflt.str)
+        val_type = self.cdata_default_realtype
         if val_type.base() == Type.BOOL:
             return val == "true"
         if val_type.base() in Type.NUM_TYPES:
@@ -1563,14 +1577,15 @@ def __str__(self):
 # -------------------------------------------------------------------------------------
 @SNode.register(SNode.LEAFLIST)
 class SLeafList(SNode):
-    __slots__ = ("cdata_leaflist", "cdata_leaflist_parsed")
+    __slots__ = ("cdata_leaflist", "cdata_leaflist_parsed", "cdata_default_realtypes")
 
     def __init__(self, context: "libyang.Context", cdata):
         super().__init__(context, cdata)
         self.cdata_leaflist = ffi.cast("struct lysc_node_leaflist *", cdata)
         self.cdata_leaflist_parsed = ffi.cast(
             "struct lysp_node_leaflist *", self.cdata_parsed
         )
+        self.cdata_default_realtypes = None
 
     def ordered(self) -> bool:
         return bool(self.cdata_parsed.flags & lib.LYS_ORDBY_USER)
@@ -1586,12 +1601,37 @@ def type(self) -> Type:
     def defaults(self) -> Iterator[Union[None, bool, int, str, float]]:
         if self.cdata_leaflist.dflts == ffi.NULL:
             return
-        for dflt in ly_array_iter(self.cdata_leaflist.dflts):
-            val = lib.lyd_value_get_canonical(self.context.cdata, dflt)
-            if not val:
+
+        if self.cdata_default_realtypes is None:
+            # calculate real types of default values just once
+            val_type_cdata = ffi.new("struct lysc_type **", ffi.NULL)
+            self.cdata_default_realtypes = []
+            for dflt in ly_array_iter(self.cdata_leaflist.dflts):
+                if not dflt.str:
+                    self.cdata_default_realtypes.append(None)
+                    continue
+                val_type_cdata[0] = ffi.NULL
+                ret = lib.lyd_value_validate_dflt(
+                    self.cdata,
+                    dflt.str,
+                    dflt.prefixes,
+                    ffi.NULL,
+                    val_type_cdata,
+                    ffi.NULL,
+                )
+                if ret != lib.LY_SUCCESS:
+                    raise self.context.error("Unable to get real type of default value")
+                self.cdata_default_realtypes.append(
+                    Type(self.context, val_type_cdata[0], None)
+                )
+
+        for dflt, val_type in zip(
+            ly_array_iter(self.cdata_leaflist.dflts), self.cdata_default_realtypes
+        ):
+            if not dflt.str:
                 yield None
-            val = c2str(val)
-            val_type = Type(self.context, dflt.realtype, None)
+                continue
+            val = c2str(dflt.str)
             if val_type.base() == Type.BOOL:
                 yield val == "true"
             elif val_type.base() in Type.NUM_TYPES: