lbkit 0.5.6__tar.gz → 0.5.7__tar.gz

{lbkit-0.5.6/lbkit.egg-info → lbkit-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.6
+Version: 0.5.7
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.7/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.5.7'

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/ctype_defination.py

@@ -1,14 +1,30 @@
 """语言相关类型定义"""
 import sys
+from lbkit.errors import OdfValidateException
 
 
 class IdfValidator():
-    def odf_schema(self, allow_ref, idf_validator):
+    validator = {}
+
+    def set_validator(self, value):
+        self.validator = value
+
+    def odf_validate(self):
+        idf_validator = idf_validator
+        return []
+
+    def odf_schema(self, allow_ref):
+        allow_ref = allow_ref
+        idf_validator = idf_validator
         return None
 
 
 class BoolValidator(IdfValidator):
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_boolean(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             return {
                 "anyOf": [
@@ -27,8 +43,12 @@ class BoolValidator(IdfValidator):
 
 
 class BoolArrayValidator(BoolValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = ["validate_odf_as_boolean_v(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -54,29 +74,57 @@ class IntegerValidator(IdfValidator):
     maximum = sys.maxsize * 2
     minimum = -(sys.maxsize + 1) * 2
 
-    def __init__(self, max, min):
+    def __init__(self, max, min, signed=False):
         self.maximum = max
         self.minimum = min
+        self.signed = signed
+        if not self.signed and self.minimum < 0:
+            self.minimum = 0
+        if self.maximum < self.minimum:
+            raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}")
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
-        """
-            返回整数类型成员的ODF schema
-            idf_validator为IDF模型中加载的数据验证器的对象
-        """
-        max = idf_validator.get("max", self.maximum)
+    def set_validator(self, value):
+        super().set_validator(value)
+        max = self.validator.get("max", self.maximum)
         if max > self.maximum:
             max = self.maximum
-        min = idf_validator.get("min", self.minimum)
+        min = self.validator.get("min", self.minimum)
         if min < self.minimum:
             min = self.minimum
+        self.maximum = max
+        self.minimum = min
+        if not self.signed and self.minimum < 0:
+            self.minimum = 0
+        if self.maximum < self.minimum:
+            raise OdfValidateException(f"The max value {self.maximum} less than or equal to {self.minimum}")
+
+    def odf_validate(self):
+        func = []
+        if self.signed:
+            if self.minimum == -9223372036854775808:
+                func.append(f"validate_odf_as_signed(doc, node, prop, {self.maximum}, G_MININT64, error_list)")
+            else:
+                func.append(f"validate_odf_as_signed(doc, node, prop, {self.maximum}, {self.minimum}, error_list)")
+        else:
+            if self.maximum == 18446744073709551615:
+                func.append(f"validate_odf_as_unsigned(doc, node, prop, G_MAXUINT64, {self.minimum}, error_list)")
+            else:
+                func.append(f"validate_odf_as_unsigned(doc, node, prop, {self.maximum}, {self.minimum}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        """
+            返回整数类型成员的ODF schema
+            idf_validator为IDF模型中加载的数据验证器的对象
+        """
         if allow_ref:
             return {
                 "anyOf": [
                     {
                         "type": "integer",
-                        "maximum": max,
-                        "minimum": min
+                        "maximum": self.maximum,
+                        "minimum": self.minimum
                     },
                     {
                         "$ref": "#/$defs/ref_value"
@@ -86,14 +134,33 @@ class IntegerValidator(IdfValidator):
         else:
             return {
                 "type": "integer",
-                "maximum": max,
-                "minimum": min
+                "maximum": self.maximum,
+                "minimum": self.minimum
             }
 
 
 class IntegerArrayValidator(IntegerValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = []
+        min = self.minimum
+        max = self.maximum
+        if self.signed:
+            if self.minimum <= -0x8000_0000_0000_0000:
+                min = "G_MININT64"
+            if self.maximum >= 0x7fff_ffff_ffff_ffff:
+                max = "G_MAXINT64"
+        else:
+            if self.maximum >= 0xffff_ffff_ffff_ffff:
+                max = "G_MAXUINT64"
+
+        if self.signed:
+            func.append(f"validate_odf_as_signed_v(doc, node, prop, {max}, {min}, error_list)")
+        else:
+            func.append(f"validate_odf_as_unsigned_v(doc, node, prop, {max}, {min}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -119,35 +186,58 @@ class FloatValidator(IdfValidator):
     maximum = sys.float_info.max
     minimum = -sys.float_info.max
 
+    exclusive_max = None
+    exclusive_min = None
+
     def __init__(self):
+        self.max_key = "maximum"
+        self.max_val = self.maximum
+        self.min_key = "minimum"
+        self.min_val = self.minimum
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_double(doc, node, prop, error_list)"]
+        if self.exclusive_max is not None:
+            func.append(f"validate_odf_as_float_exclusive_max(doc, node, prop, {self.exclusive_max}, error_list)")
+        elif self.maximum != sys.float_info.max:
+            func.append(f"validate_odf_as_float_max(doc, node, prop, {self.maximum}, error_list)")
+
+        if self.exclusive_min is not None:
+            func.append(f"validate_odf_as_float_exclusive_min(doc, node, prop, {self.exclusive_min}, error_list)")
+        elif self.minimum != (-sys.float_info.max):
+            func.append(f"validate_odf_as_float_min(doc, node, prop, {self.minimum}, error_list)")
+        return func
+
+    def set_validator(self, value):
+        super().set_validator(value)
+        self.maximum = self.validator.get("max", self.maximum)
+        self.minimum = self.validator.get("min", self.minimum)
+        self.exclusive_max = self.validator.get("exclusive_max", None)
+        self.exclusive_min = self.validator.get("exclusive_min", None)
+        self.max_key = "maximum"
+        self.min_key = "minimum"
+        self.max_val = self.maximum
+        self.min_val = self.minimum
+        if self.exclusive_max is not None:
+            self.max_key = "exclusiveMaximum"
+            self.max_val = self.exclusive_max
+        if self.exclusive_min is not None:
+            self.max_key = "exclusiveMinimum"
+            self.min_val = self.exclusive_min
+
+    def odf_schema(self, allow_ref):
         """
             返回整数类型成员的ODF schema
             idf_validator为IDF模型中加载的数据验证器的对象
         """
-        max = idf_validator.get("max", self.maximum)
-        min = idf_validator.get("min", self.minimum)
-        exclusive_max = idf_validator.get("exclusive_max", None)
-        exclusive_min = idf_validator.get("exclusive_min", None)
-        max_key = "maximum"
-        max_val = max
-        min_key = "minimum"
-        min_val = min
-        if exclusive_max is not None:
-            max_key = "exclusiveMaximum"
-            max_val = exclusive_max
-        if exclusive_min is not None:
-            max_key = "exclusiveMinimum"
-            min_val = exclusive_min
         if allow_ref:
             return {
                 "anyOf": [
                     {
                         "type": "number",
-                        max_key: max_val,
-                        min_key: min_val
+                        self.max_key: self.max_val,
+                        self.min_key: self.min_val
                     },
                     {
                         "$ref": "#/$defs/ref_value"
@@ -157,14 +247,27 @@ class FloatValidator(IdfValidator):
         else:
             return {
                 "type": "number",
-                max_key: max_val,
-                min_key: min_val
+                self.max_key: self.max_val,
+                self.min_key: self.min_val
             }
 
 
 class FloatArrayValidator(FloatValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = ["validate_odf_as_double_v(doc, node, prop, error_list)"]
+        if self.exclusive_max is not None:
+            func.append(f"validate_odf_as_float_exclusive_max_v(doc, node, prop, {self.exclusive_max}, error_list)")
+        elif self.maximum != sys.float_info.max:
+            func.append(f"validate_odf_as_float_max_v(doc, node, prop, {self.maximum}, error_list)")
+
+        if self.exclusive_min is not None:
+            func.append(f"validate_odf_as_float_exclusive_min_v(doc, node, prop, {self.exclusive_min}, error_list)")
+        elif self.minimum != (-sys.float_info.max):
+            func.append(f"validate_odf_as_float_min_v(doc, node, prop, {self.minimum}, error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -191,32 +294,54 @@ class StringValidator(IdfValidator):
         self.pattern = pattern
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
-        pattern = idf_validator.get("pattern", self.pattern)
+    def set_validator(self, value):
+        self.pattern = self.validator.get("pattern", self.pattern)
+        super().set_validator(value)
+
+    def odf_validate(self):
+        func = []
+        if self.pattern is not None:
+            func.append(f"validate_odf_as_string(doc, node, prop, \"{self.pattern}\", error_list)")
+        else:
+            pattern = "^()|(((\\\\$)|[^$]).*)$"
+            func.append(f"validate_odf_as_string(doc, node, prop, \"{pattern}\", error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
                     {
-                        "type": "string"
+                        "type": "string",
+                        "pattern": "^()|(((\\\\$)|[^$]).*)$"
                     },
                     {
                         "$ref": "#/$defs/ref_value"
                     }
                 ]
             }
-            if pattern is not None:
-                schema["anyOf"][0]["pattern"] = pattern
+            if self.pattern is not None:
+                schema["anyOf"][0]["pattern"] = self.pattern
         else:
             schema = {
                 "type": "string",
-                "pattern": pattern
+                "pattern": self.pattern
             }
         return schema
 
 
 class StringArrayValidator(StringValidator):
-    def odf_schema(self, allow_ref, idf_validator):
-        parent_schema = super().odf_schema(False, idf_validator)
+    def odf_validate(self):
+        func = []
+        if self.pattern is not None:
+            func.append(f"validate_odf_as_string_v(doc, node, prop, \"{self.pattern}\", error_list)")
+        else:
+            pattern = "^()|(((\\\\$)|[^$]).*)$"
+            func.append(f"validate_odf_as_string_v(doc, node, prop, \"{pattern}\", error_list)")
+        return func
+
+    def odf_schema(self, allow_ref):
+        parent_schema = super().odf_schema(False)
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -240,7 +365,11 @@ class RefObjValidator(IdfValidator):
     def __init__(self):
         super().__init__()
 
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_ref_obj(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -260,7 +389,11 @@ class RefObjValidator(IdfValidator):
 
 
 class RefObjArrayValidator(RefObjValidator):
-    def odf_schema(self, allow_ref, idf_validator):
+    def odf_validate(self):
+        func = ["validate_odf_as_ref_obj_v(doc, node, prop, error_list)"]
+        return func
+
+    def odf_schema(self, allow_ref):
         if allow_ref:
             schema = {
                 "anyOf": [
@@ -310,7 +443,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int16(<arg_name>)"],
         ["<arg_in> = g_variant_get_int16(<arg_name>)"],
-        IntegerValidator(0x7fff, -(0x8000))
+        IntegerValidator(0x7fff, -(0x8000), True)
     ),
     "uint16": CTypeBase(
         ["guint16 <arg_name>"],
@@ -324,7 +457,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int32(<arg_name>)"],
         ["<arg_in> = g_variant_get_int32(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff, -(0x8000_0000))
+        IntegerValidator(0x7fff_ffff, -(0x8000_0000), True)
     ),
     "uint32": CTypeBase(
         ["guint32 <arg_name>"],
@@ -338,7 +471,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int64(<arg_name>)"],
         ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "uint64": CTypeBase(
         ["guint64 <arg_name>"],
@@ -359,7 +492,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int64(<arg_name>)"],
         ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "double": CTypeBase(
         ["gdouble <arg_name>"],
@@ -373,7 +506,7 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_handle(<arg_name>)"],
         ["<arg_in> = g_variant_get_handle(<arg_name>)"],
-        IntegerValidator(0x7fff_ffff_ffff_ffff, 0)
+        IntegerValidator(0x7fff_ffff_ffff_ffff, 0, True)
     ),
     "string": CTypeBase(
         ["<const>gchar *<arg_name>"],
@@ -394,7 +527,7 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_signature_encode(<arg_name>)"],
         ["<arg_in> = g_strdup(g_variant_get_string(<arg_name>, NULL))"],
-        StringValidator("^([abynqiuxtdsogv\\{\\}\\(\\)])+$")
+        StringValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$")
     ),
     "variant": CTypeBase(
         ["GVariant *<arg_name>"],
@@ -422,7 +555,7 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_int16_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_int16_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0x7fff, -(0x8000))
+        IntegerArrayValidator(0x7fff, -(0x8000), True)
     ),
     "array[uint16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint16 *<arg_name>"],
@@ -436,7 +569,7 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_int32_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_int32_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0x7fff_ffff, -(0x80000000))
+        IntegerArrayValidator(0x7fff_ffff, -(0x80000000), True)
     ),
     "array[uint32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint32 *<arg_name>"],
@@ -450,7 +583,7 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_int64_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_int64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[uint64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint64 *<arg_name>"],
@@ -464,14 +597,14 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_int64_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_int64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gsize *<arg_name>"],
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_uint64_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000))
+        IntegerArrayValidator(0xffff_ffff_ffff_ffff, 0)
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],
@@ -485,27 +618,27 @@ CTYPE_OBJS = {
         ["gcl_free_p((void **)&<arg_name>)"],
         ["<arg_out> = gcl_array_handle_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = gcl_array_handle_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator(0x7fff_ffff_ffff_ffff, 0, True)
     ),
     "array[string]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<arg_name>"],
         ["gcl_strfreev_p(&<arg_name>)"],
         ["<arg_out> = gcl_array_string_encode(<arg_name>)"],
         ["<arg_in> = gcl_array_string_decode(<arg_name>)"],
         StringArrayValidator("^.*$")
     ),
     "array[object_path]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<arg_name>"],
         ["gcl_strfreev_p(&<arg_name>)"],
         ["<arg_out> = gcl_array_object_path_encode(<arg_name>)"],
         ["<arg_in> = gcl_array_object_path_decode(<arg_name>)"],
         StringArrayValidator("^(/[A-Z0-9a-z_]+)*$")
     ),
     "array[signature]": CTypeBase(
-        ["gchar * <const>*<arg_name>"],
+        ["gchar *<const>*<arg_name>"],
         ["gcl_strfreev_p(&<arg_name>)"],
         ["<arg_out> = gcl_array_signature_encode(<arg_name>)"],
         ["<arg_in> = gcl_array_signature_decode(<arg_name>)"],
-        StringArrayValidator("^([abynqiuxtdsogv\\{\\}\\(\\)])+$")
+        StringArrayValidator("^([abynqiuxtdsogv\\\\{\\\\}\\\\(\\\\)])+$")
     )
 }

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/idf_interface.py

@@ -12,6 +12,8 @@ log = Logger("gen_interface")
 class IDFException(Exception):
     pass
 
+class IdfInterfacePlugin(Renderer):
+    actions = []
 
 class IdfInterfaceBase(Renderer):
     def __init__(self) -> None:
@@ -24,6 +26,7 @@ class IdfInterfaceBase(Renderer):
         self.dictionaries = {}
         self.enumerations = {}
         self.annotations = []
+        self.plugin: IdfInterfacePlugin = None
         self.description = None
         self.version = None
         self.alias = None
@@ -135,6 +138,39 @@ class IdfCtypeRender():
         if match:
             self.ctype = f"array[enum[{match.group(1)}]]"
 
+    def odf_validate(self, allow_ref):
+        log.debug(f"Get odf validate info, name: {self.name}, ctype: {self.ctype}")
+        if "variant" == self.ctype:
+            return []
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if match:
+            if "refobj" in self.flags:
+                valiator = RefObjArrayValidator()
+                return valiator.odf_validate()
+            ctype_obj = CTYPE_OBJS.get(self.ctype)
+            return ctype_obj.validator.odf_validate()
+        match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
+        if match:
+            if "refobj" in self.flags:
+                valiator = RefObjValidator()
+                return valiator.odf_validate()
+            ctype_obj = CTYPE_OBJS.get(self.ctype)
+            return ctype_obj.validator.odf_validate()
+        # 非基础类型
+        is_array = False
+        ctype = self.ctype
+        match = re.match(f"^array\[(.*)\]$", ctype)
+        if match:
+            is_array = True
+            ctype = match.group(1)
+        match = re.match(f"^(struct|enum|dict)\[(.*)\]$", ctype)
+        _, stru_name = get_intfname_and_ctype(match.group(2))
+        if is_array:
+            return [f"_validate_odf_as_{match.group(1)}_{stru_name}_v(doc, node, prop, error_list)"]
+        else:
+            return [f"_validate_odf_as_{match.group(1)}_{stru_name}(doc, node, prop, error_list)"]
+
+
     def odf_schema(self, allow_ref):
         log.debug(f"Get odf schema info, name: {self.name}, ctype: {self.ctype}")
         if "variant" == self.ctype:
@@ -143,16 +179,16 @@ class IdfCtypeRender():
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjArrayValidator()
-                return valiator.odf_schema(allow_ref, {})
+                return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref, {})
+            return ctype_obj.validator.odf_schema(allow_ref)
         match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjValidator()
-                return valiator.odf_schema(allow_ref, {})
+                return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref, {})
+            return ctype_obj.validator.odf_schema(allow_ref)
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -231,7 +267,7 @@ class IdfCtypeRender():
         if match.group(1) == "struct":
             if is_array:
                 # 结构体数组初始化时为二级空指针，以空指针结束
-                return [f"{stru_name} * <const>*<arg_name>"]
+                return [f"{stru_name} *<const>*<arg_name>"]
             else:
                 # 结构体成员初始化时为空结构体，由反序列化时填充内容
                 return [f"<const>{stru_name} *<arg_name>"]
@@ -482,6 +518,7 @@ class IdfBase():
 
 
 class IdfMethod(IdfBase):
+    is_plugin = False
     def __init__(self, intf: IdfInterfaceBase, method_data):
         super().__init__(intf, method_data)
         self.parameters: IdfParameters = IdfParameters(intf, method_data.get("parameters", []))
@@ -529,6 +566,15 @@ class IdfStructure(IdfBase):
         }
         return odf
 
+
+class IdfPluginAction(IdfMethod):
+    is_plugin = True
+
+    def __init__(self, intf: IdfInterfaceBase, method_data):
+        self.policy = method_data.get("policy", "continue_always")
+        super().__init__(intf, method_data)
+
+
 class IdfEnumeration(IdfBase):
     def __init__(self, intf: IdfInterfaceBase, enum_data):
         super().__init__(intf, enum_data)
@@ -652,6 +698,7 @@ class IdfInterface(IdfInterfaceBase):
         self.dictionaries: dict[str, IdfDictionary] = {}
         self.enumerations: dict[str, IdfEnumeration] = {}
         self.annotations: list[IdfAnnotation] = []
+        self.plugin: IdfInterfacePlugin = IdfInterfacePlugin()
         self.description = None
         self.version = None
         self.alias = None
@@ -721,6 +768,15 @@ class IdfInterface(IdfInterfaceBase):
             }
         return odf
 
+    @property
+    def fake_methods(self):
+        methods = []
+        for method in self.methods:
+            methods.append(method)
+        for action in self.plugin.actions:
+            methods.append(action)
+        return methods
+
     def load_elements(self):
         # 使用schema校验数据，确保IDF文件符合格式要求，减少程序处理过程中的异常处理
         # 验证失败时抛异常，此处不用处理，由外层处理
@@ -759,6 +815,12 @@ class IdfInterface(IdfInterfaceBase):
         for item in items:
             obj = IdfEnumeration(self, item)
             self.enumerations[obj.name] = obj
+        plugin = idf.get("plugin", None)
+        if plugin is not None:
+            items = plugin.get("actions", [])
+            for item in items:
+                obj = IdfPluginAction(self, item)
+                self.plugin.actions.append(obj)
         log.debug("interface signature: " + self.signature)
         for signal in self.signals:
             log.debug(f"{signal.name} signature: " + signal.signature)

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/template/public.c.mako

@@ -2,6 +2,27 @@
 #include "${intf.name}.h"
 
 <% class_name = intf.alias %>\
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF校验函数 */
+static gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+
+% endfor
+## 定义枚举ODF加载函数
+% for name, enum in intf.enumerations.items():
+/* START: 枚举${name}及其数组类型的ODF校验函数 */
+static gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+static gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+static gboolean _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+
+% endfor
 % for name, stru in intf.structures.items():
 /* ${name}结构体类型序列化（struct转GVariant）函数 */
 GVariant *${name}_encode(const ${name} *value)
@@ -131,6 +152,58 @@ void ${name}_free_v(${name} ***value)
     *value = NULL;
 }
 
+gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    g_assert(doc && node && prop && error_list);
+    if (node->type != YAML_MAPPING_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of property %s is not a mapping, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+    gsize len = prop->len;
+    gboolean valid = TRUE;
+    yaml_node_t *val;
+    GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
+    % for prop in stru.values.parameters:
+    val = g_hash_table_lookup(prop_table, "${prop.name}");
+    if (val) {
+        g_string_append(prop, ".${prop.name}");
+        % for func in prop.odf_validate(False):
+        if (!${func.replace("node,", "val,")})
+            valid = FALSE;
+        % endfor
+        g_string_truncate(prop, len);
+    }
+    % endfor
+    return valid;
+}
+
+gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    g_assert(doc && node && prop && error_list);
+    if (node->type != YAML_SEQUENCE_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of property %s is not a sequence, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+    gsize len = prop->len;
+    gint i = 0;
+    yaml_node_t *val = NULL;
+    gboolean valid = TRUE;
+    for (yaml_node_item_t *item = node->data.sequence.items.start; item < node->data.sequence.items.top; item++) {
+        g_string_append_printf(prop, ".%d", i);
+        val = yaml_document_get_node(doc, *item);
+        if (!_validate_odf_as_struct_${name}(doc, val, prop, error_list)) {
+            valid = FALSE;
+        }
+        g_string_truncate(prop, len);
+        i++;
+    }
+    return valid;
+}
+
 %endfor
 % for name, enum in intf.enumerations.items():
 ## 枚举序列化和反序列化函数
@@ -217,6 +290,50 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     return output;
 }
 
+gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    gboolean valid = validate_odf_as_string(doc, node, prop, "^.*$", error_list);
+    if (!valid) {
+        return FALSE;
+    }
+    const gchar *value = node->data.scalar.value;
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0(value, ${name}_as_string(i)) == 0) {
+            return TRUE;
+        }
+    }
+    *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+        "the value of property %s is is unsupportted, get %s", prop->str, value));
+    return FALSE;
+    return FALSE;
+}
+
+gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    g_assert(doc && node && prop && error_list);
+    if (node->type != YAML_SEQUENCE_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of property %s is not a sequence, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+    gsize len = prop->len;
+    gint i = 0;
+    yaml_node_t *val = NULL;
+    gboolean valid = TRUE;
+    for (yaml_node_item_t *item = node->data.sequence.items.start; item < node->data.sequence.items.top; item++) {
+        g_string_append_printf(prop, ".%d", i);
+        val = yaml_document_get_node(doc, *item);
+        if (!_validate_odf_as_enum_${name}(doc, val, prop, error_list)) {
+            valid = FALSE;
+        }
+        g_string_truncate(prop, len);
+        i++;
+    }
+    return valid;
+}
+
 % endfor
 ## 生成字典处理函数
 % for name, dictionary in intf.dictionaries.items():
@@ -555,6 +672,80 @@ void ${name}_free_v(${name} ***value)
     *value = NULL;
 }
 
+gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    g_assert(doc && node && prop && error_list);
+    if (node->type != YAML_SEQUENCE_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of property %s is not a sequence, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+
+    gboolean valid = TRUE;
+    GHashTable *prop_table = NULL;
+    yaml_node_t *val = NULL;
+    gsize len = prop->len;
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        ## 转换成hash表以获取key和properties
+        prop_table = load_yaml_mapping_to_hash_table(doc, val);
+        yaml_node_t *key = g_hash_table_lookup(prop_table, "key");
+        yaml_node_t *properties = g_hash_table_lookup(prop_table, "properties");
+        g_hash_table_destroy(prop_table);
+        g_string_append_printf(prop, ".key");
+        % for func in dictionary.key_obj.odf_validate(False):
+        if (!${func.replace("node,", "key,")})
+            valid = FALSE;
+        % endfor
+        g_string_truncate(prop, len);
+
+        ## 转换成hash表
+        prop_table = load_yaml_mapping_to_hash_table(doc, properties);
+        ## 迭代所有成员并从odf中还原数据
+        % for prop in dictionary.values.parameters:
+        val = g_hash_table_lookup(prop_table, "${prop.name}");
+        if (val) {
+            g_string_append(prop, ".properties.${prop.name}");
+            % for func in prop.odf_validate(False):
+            if (!${func.replace("node,", "val,")})
+                valid = FALSE;
+            % endfor
+            g_string_truncate(prop, len);
+        }
+        % endfor
+        g_hash_table_destroy(prop_table);
+    }
+    return valid;
+}
+
+gboolean _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+    GString *prop, GSList **error_list)
+{
+    g_assert(doc && node && prop && error_list);
+    if (node->type != YAML_SEQUENCE_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of property %s is not a sequence, get %s", prop->str, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+    gsize len = prop->len;
+    gint i = 0;
+    yaml_node_t *val = NULL;
+    gboolean valid = TRUE;
+    for (yaml_node_item_t *item = node->data.sequence.items.start; item < node->data.sequence.items.top; item++) {
+        g_string_append_printf(prop, ".%d", i);
+        val = yaml_document_get_node(doc, *item);
+        if (!_validate_odf_as_dict_${name}(doc, val, prop, error_list)) {
+            valid = FALSE;
+        }
+        g_string_truncate(prop, len);
+        i++;
+    }
+    return valid;
+}
+
 % endfor
 ## 生成每个属性的GDBus属性GDBusPropertyInfo对象name}
 % for prop in intf.properties:
@@ -625,7 +816,8 @@ const ${class_name}_Properties *${class_name}_properties_const(void)
     return &_${class_name}_properties;
 }
 
-% for method in intf.methods:
+% for method in intf.fake_methods:
+% if not method.is_plugin:
 ## 方法${method.name}的请求体序列化函数
 /* ${class_name}_${method.name}_Req请求结构体类型序列化（struct转GVariant）函数 */
 static GVariant *${class_name}_${method.name}_Req_encode(${class_name}_${method.name}_Req *value)
@@ -669,6 +861,7 @@ static ${class_name}_${method.name}_Req *${class_name}_${method.name}_Req_decode
     % endfor
     return output;
 }
+% endif
 
 ## 方法${method.name}的请求体释放函数
 /* ${class_name}_${method.name}_Req结构体指针释放 */
@@ -686,6 +879,7 @@ void ${class_name}_${method.name}_Req_free(${class_name}_${method.name}_Req **va
     *value = NULL;
 }
 
+% if not method.is_plugin:
 /* ${class_name}_${method.name}_Rsp请求结构体类型序列化（struct转GVariant）函数 */
 static GVariant *${class_name}_${method.name}_Rsp_encode(${class_name}_${method.name}_Rsp *value)
 {
@@ -728,6 +922,7 @@ static ${class_name}_${method.name}_Rsp *${class_name}_${method.name}_Rsp_decode
     % endfor
     return output;
 }
+% endif
 
 ## 方法${method.name}的响应体释放函数
 /* ${class_name}_${method.name}_Rsp结构体指针释放 */
@@ -749,8 +944,7 @@ void ${class_name}_${method.name}_Rsp_free(${class_name}_${method.name}_Rsp **va
 static ${class_name}_Methods _${class_name}_methods =
 {
 % for method in intf.methods:
-    .${method.name} =
-{
+    .${method.name} = {
         .name = "${method.name}",
         .req_signature = "${method.in_signature}",
         .req_decode = (gcl_message_decode)${class_name}_${method.name}_Req_decode,
@@ -762,8 +956,7 @@ static ${class_name}_Methods _${class_name}_methods =
         .rsp_free = (gcl_message_free)${class_name}_${method.name}_Rsp_free,
     },
 % endfor
-    .__reserved__ =
-{
+    .__reserved__ = {
         .name = NULL,
     }
 };
@@ -773,6 +966,96 @@ ${class_name}_Methods *${class_name}_methods(void)
     return &_${class_name}_methods;
 }
 
+% if len(intf.plugin.actions) > 0:
+    % for action in intf.plugin.actions:
+typedef struct {
+    gpointer user_data;
+    ${class_name}_${action.name}_action action;
+} _${class_name}_${action.name}_PluginAction;
+static GSList *_${class_name}_${action.name}_actions = NULL;
+static GMutex _${class_name}_${action.name}_lock;
+
+/* Register a new plugin action, can't register repeated with same action */
+int ${class_name}_${action.name}_register(const gchar *req_signature, const gchar *rsp_signature,
+    ${class_name}_${action.name}_action action, gpointer user_data)
+{
+    if (!req_signature) {
+        log_error("Register ${action.name} failed because parameter req_signature is NULL");
+        return -1;
+    }
+    if (!rsp_signature) {
+        log_error("Register ${action.name} failed because parameter rsp_signature is NULL");
+        return -1;
+    }
+    if (g_strcmp0(req_signature, "${action.in_signature}") != 0) {
+        log_error("Register ${action.name} failed because parameter "
+            "req_signature not match with \"{action.in_signature}\", get \"%s\"", req_signature);
+        return -1;
+    }
+    if (g_strcmp0(rsp_signature, "${action.out_signature}") != 0) {
+        log_error("Register ${action.name} failed because parameter "
+            "rsp_signature not match with \"{action.out_signature}\", get \"%s\"", rsp_signature);
+        return -1;
+    }
+    g_mutex_lock(&_${class_name}_${action.name}_lock);
+    for (GSList *item = _${class_name}_${action.name}_actions; item; item = item->next) {
+        _${class_name}_${action.name}_PluginAction *old_handler = (_${class_name}_${action.name}_PluginAction *)item->data;
+        if (action == old_handler->action || user_data == old_handler->user_data) {
+            g_mutex_unlock(&_${class_name}_${action.name}_lock);
+            return 0;
+        }
+    }
+    _${class_name}_${action.name}_PluginAction *handler = g_new0(_${class_name}_${action.name}_PluginAction, 1);
+    handler->user_data = user_data;
+    handler->action = action;
+    _${class_name}_${action.name}_actions = g_slist_append(_${class_name}_${action.name}_actions, handler);
+    g_mutex_unlock(&_${class_name}_${action.name}_lock);
+    return 0;
+}
+
+void ${class_name}_${action.name}_unregister(${class_name}_${action.name}_action action)
+{
+    g_mutex_lock(&_${class_name}_${action.name}_lock);
+    for (GSList *item = _${class_name}_${action.name}_actions; item; item = item->next) {
+        _${class_name}_${action.name}_PluginAction *old_handler = (_${class_name}_${action.name}_PluginAction *)item->data;
+        if (action == old_handler->action) {
+            _${class_name}_${action.name}_actions = g_slist_remove(_${class_name}_${action.name}_actions, old_handler);
+            g_free(old_handler);
+            break;
+        }
+        old_handler = NULL;
+    }
+    g_mutex_unlock(&_${class_name}_${action.name}_lock);
+}
+
+int ${class_name}_${action.name}_run(const ${class_name} *object, const ${class_name}_${action.name}_Req *req, ${class_name}_${action.name}_Rsp **rsp)
+{
+    gint result = 0;
+    g_mutex_lock(&_${class_name}_${action.name}_lock);
+    for (GSList *item = _${class_name}_${action.name}_actions; item; item = item->next) {
+        if (rsp && *rsp) {
+            ${class_name}_${action.name}_Rsp_free(rsp);
+        }
+        _${class_name}_${action.name}_PluginAction *handler = (_${class_name}_${action.name}_PluginAction *)item->data;
+        gint ret = handler->action(object, req, rsp, handler->user_data);
+        if (ret != 0)
+            result = ret;
+        % if action.policy == "return_any_success":
+        /* return when any action success(ret == 0) */
+        if (ret == 0)
+            break;
+        % elif action.policy == "return_any_fail":
+        /* return when any action failed(ret != 0) */
+        if (ret != 0)
+            break;
+        % endif
+    }
+    g_mutex_unlock(&_${class_name}_${action.name}_lock);
+    return result;
+}
+
+    % endfor
+% endif
 % for signal in intf.signals:
 ## 方法${method.name}的响应体序列化函数
 /* ${class_name}_${signal.name}_Msg请求结构体类型序列化（struct转GVariant）函数 */
@@ -855,3 +1138,67 @@ ${class_name}_Signals *${class_name}_signals(void)
 {
     return &_${class_name}_signals;
 }
+
+% for prop in intf.properties:
+static gboolean _validate_odf_prop_${prop.name}(yaml_document_t *doc, GHashTable *prop_table,
+    GString *prop, GSList **error_list)
+{
+    gboolean valid = TRUE;
+    gsize len = prop->len;
+    yaml_node_t *node = g_hash_table_lookup(prop_table, "${prop.name}");
+    do {
+        if (!node)
+            break;
+        g_string_append(prop, ".${prop.name}");
+    % if "refobj" not in prop.flags:
+        if (validate_odf_as_ref_prop(doc, node, prop))
+            break;
+    % endif
+    % if len(prop.odf_validate(True)) > 1:
+        % for func in prop.odf_validate(True):
+        if (valid && !${func})
+            valid = FALSE;
+        % endfor
+    % else:
+        % for func in prop.odf_validate(True):
+        valid = ${func};
+        % endfor
+    % endif
+    } while (0);
+    g_string_truncate(prop, len);
+    return valid;
+}
+
+%endfor
+gboolean ${intf.name.replace(".", "_")}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
+    const gchar *object_name, GSList **error_list)
+{
+    g_assert(doc && node && object_name && error_list);
+    if (!doc || !node || !object_name || !error_list) {
+        return FALSE;
+    }
+
+    if (node->type != YAML_MAPPING_NODE) {
+        *error_list = g_slist_append(*error_list, g_error_new(ODF_ERROR, ODF_ERROR_PROP_VALIDATE_TYPE_ERROR,
+            "the node type of object %s is not a mapping, get %s", object_name, gcl_yaml_node_type_str(node->type)));
+        return FALSE;
+    }
+    GString *prop = g_string_sized_new(128);
+    g_string_printf(prop, "%s", object_name);
+    gboolean valid = TRUE;
+    GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
+    % for prop in stru.values.parameters:
+    valid = _validate_odf_prop_${prop.name}(doc, prop_table, prop, error_list) && valid;
+    % endfor
+    return valid;
+}
+
+% if len(intf.plugin.actions) > 0:
+static void __attribute__((constructor(101))) ${class_name}_public_register(void)
+{
+    % for action in intf.plugin.actions:
+    g_mutex_init(&_${class_name}_${action.name}_lock);
+    % endfor
+}
+
+% endif

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/template/public.h.mako

@@ -129,7 +129,7 @@ void ${name}_free_v(${name} ***value);
 % endfor
 
 ### 开始生成方法的请求体、响应体和处理函数
-% for method in intf.methods:
+% for method in intf.fake_methods:
 /* ${method.name}方法的请求体 */
 typedef struct {
         % for arg in method.parameters.parameters:
@@ -148,7 +148,9 @@ typedef struct {
         % endfor
 } ${class_name}_${method.name}_Rsp;
 
+% if not method.is_plugin:
 typedef int (*${class_name}_${method.name}_Method)(const ${class_name} *object, const ${class_name}_${method.name}_Req *req, ${class_name}_${method.name}_Rsp **rsp, GError **error);
+% endif
 void ${class_name}_${method.name}_Req_free(${class_name}_${method.name}_Req **value);
 void ${class_name}_${method.name}_Rsp_free(${class_name}_${method.name}_Rsp **value);
 %endfor
@@ -172,6 +174,18 @@ typedef struct {
     GclMethod __reserved__;
 } ${class_name}_Methods;
 
+% if len(intf.plugin.actions) > 0:
+% for action in intf.plugin.actions:
+typedef int (*${class_name}_${action.name}_action)(const ${class_name} *object, const ${class_name}_${action.name}_Req *req, ${class_name}_${action.name}_Rsp **rsp, gpointer user_data);
+
+/* Register a new plugin action, can't register repeated with same action and user_data */
+int ${class_name}_${action.name}_register(const gchar *req_signature, const gchar *rsp_signature,
+    ${class_name}_${action.name}_action action, gpointer user_data);
+void ${class_name}_${action.name}_unregister(${class_name}_${action.name}_action action);
+int ${class_name}_${action.name}_run(const ${class_name} *object, const ${class_name}_${action.name}_Req *req, ${class_name}_${action.name}_Rsp **rsp);
+
+% endfor
+% endif
 ### 开始生成方法的请求体、响应体和处理函数
 % for signal in intf.signals:
 /* ${signal.name}信号的消息体 */
@@ -220,6 +234,9 @@ typedef struct {
     GclProperty __reserved__;
 } ${class_name}_Properties;
 
+
+gboolean ${intf.name.replace(".", "_")}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
+    const gchar *object_name, GSList **error_list);
 // 不要使用此函数返回的对象，需要使用${class_name}_properties() 或${class_name}_Cli_properties()
 const ${class_name}_Properties *${class_name}_properties_const(void);
 // 同时加载客户端和服务端时Processer是共享的，因此可以直接调用Processer定义的handler函数

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/template/server.c.mako

@@ -1,3 +1,4 @@
+<% from lbkit.codegen.ctype_defination import StringValidator %>\
 #include "gcl_base.h"
 #include "${intf.name}.h"
 
@@ -236,6 +237,8 @@ gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const
 static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
 static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *gcl_obj,
     property_reference_loaded ref_loaded, gpointer user_data);
+static void _valid_from_odf(yaml_document_t *doc, yaml_node_t *node, const gchar *object_name);
+
 /*
  * interface: ${intf.name}
 % for c in intf.description.split("\n"):
@@ -244,7 +247,8 @@ static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *g
  */
 static GclInterface _${class_name}_interface = {
     .create = _${intf.alias}_create,
-    .load_from_odf = (object_load_from_odf)_load_from_odf,
+    .validate_odf = ${intf.name.replace(".", "_")}_validate_odf,
+    .load_from_odf = _load_from_odf,
     .is_remote = 0,
     .name = "${intf.name}",
     .properties = (GclProperty *)&${properties},

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/codegen/template/server.h.mako

@@ -37,7 +37,6 @@ gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const
 GclInterface *${class_name}_interface(void);
 #define ${class_name.upper()}_INTERFACE ${class_name}_interface()
 ${class_name}_Properties *${class_name}_properties(void);
-${class_name}_Methods *${class_name}_methods(void);
 
 #ifdef __cplusplus
 }

{lbkit-0.5.6 → lbkit-0.5.7}/lbkit/misc.py

@@ -88,4 +88,4 @@ def validate_yml_with_json_schema(yml_file, default_json_schema_file):
     except ValidationError as exc:
         raise PackageConfigException(f"validate {yml_file} failed, schema file is {schema_file}, "
                                      f"message: {exc.message}\n"
-                                     "installing redhat.vscode-yaml plugin in vscode will help you write odf files") from exec
+                                     "installing redhat.vscode-yaml plugin in vscode will help you write odf files")

{lbkit-0.5.6 → lbkit-0.5.7/lbkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.6
+Version: 0.5.7
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.6/lbkit/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.5.6'