lbkit 0.8.3__tar.gz → 0.8.5__tar.gz

lbkit-0.8.5/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include lbkit/codegen/template *.mako
+recursive-include lbkit/tasks/template *.mako
+recursive-include lbkit/component/template *.mako

{lbkit-0.8.3/lbkit.egg-info → lbkit-0.8.5}/PKG-INFO

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

lbkit-0.8.5/lbkit/__init__.py

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

{lbkit-0.8.3 → lbkit-0.8.5}/lbkit/cli.py

@@ -10,16 +10,13 @@ from lbkit import __version__ as client_version
 from lbkit.codegen.codegen import CodeGen
 from lbkit.component.build import BuildComponent
 from lbkit.component.test import TestComponent
-from lbkit.integration.build_manifest import BuildManifest
-from lbkit.integration.build_rootfs import BuildRootfs
-from lbkit.integration.build_prepare import BuildPrepare
-from lbkit.integration.build_image import BuildImage
+from lbkit.tasks.executor import Executor
 from lbkit.component.arg_parser import ArgParser
-from lbkit.integration.config import Config
 from lbkit.ci_robot.gitee import Gitee
 from lbkit.log import Logger
 from lbkit import misc
 from lbkit import errors
+from lbkit.utils.env_detector import EnvDetector
 
 log = Logger("cli")
 
@@ -80,26 +77,14 @@ class Command(object):
 
             组件需要支持多种跨平台构建场景，典型的包括DT（X86-64）、交叉编译（arm64）
         """
-        arg_parser = ArgParser.new()
-        build = BuildComponent(arg_parser, sys.argv[2:])
-        build.run()
-
-    # create product package
-    def create(self, *args):
-        """
-        构建组件.
-
-            组件需要支持多种跨平台构建场景，典型的包括DT（X86-64）、交叉编译（arm64）
-        """
-        cfg = Config(sys.argv[2:])
-        build = BuildPrepare(cfg, "create_pre")
-        build.run()
-        build = BuildManifest(cfg, "create_run")
-        build.run()
-        build = BuildRootfs(cfg, "create_rootfs")
-        build.run()
-        build = BuildImage(cfg, "create_image")
-        build.run()
+        env = EnvDetector()
+        if env.component:
+            arg_parser = ArgParser.new()
+            build = BuildComponent(arg_parser, sys.argv[2:])
+            build.run()
+        elif env.manifest:
+            exe = Executor(env)
+            exe.run()
 
     def gitee(self, *args):
         """
@@ -126,7 +111,7 @@ class Command(object):
         """
         grps = [("Code Generate commands", ["gen"]),
                 ("Build Component commands", ["new", "build", "test"]),
-                ("Build Product commands", ["create"]),
+                ("Build Product commands", ["build"]),
                 ("Misc commands", ["help"]),
                 ("CI Robot commands", ["gitee"])
                ]

{lbkit-0.8.3 → lbkit-0.8.5}/lbkit/codegen/idf_interface.py

@@ -19,6 +19,7 @@ class IDFException(Exception):
 class IdfInterfacePlugin(Renderer):
     def __init__(self):
         super().__init__()
+        self.install_dir = None
         self.actions = []
 
 class IdfInterfaceBase(Renderer):
@@ -215,9 +216,9 @@ class IdfCtypeRender():
         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)"]
+            return [f"{stru_name}_validate_odf_v(doc, node, prop, error_list)"]
         else:
-            return [f"_validate_odf_as_{match.group(1)}_{stru_name}(doc, node, prop, error_list)"]
+            return [f"{stru_name}_validate_odf(doc, node, prop, error_list)"]
 
     def odf_match_items(self):
         log.debug(f"Get odf validate info, name: {self.name}, ctype: {self.ctype}")
@@ -599,15 +600,15 @@ class IdfCtypeRender():
         if match.group(1) == "enum":
             if is_array:
                 # 入参为二级指针
-                return f"<arg_name> = _load_odf_as_{stru_name}_v(doc, <node>, &n_<arg_name>)"
+                return f"<arg_name> = {stru_name}_load_from_odf_v(doc, <node>, &n_<arg_name>)"
             else:
-                return f"<arg_name> = _load_odf_as_{stru_name}(doc, <node>)"
+                return f"<arg_name> = {stru_name}_load_from_odf(doc, <node>)"
         else:
             if is_array:
                 # 入参为二级指针
-                return f"<arg_name> = _load_odf_as_{stru_name}_v(doc, <node>)"
+                return f"<arg_name> = {stru_name}_load_from_odf_v(doc, <node>)"
             else:
-                return f"<arg_name> = _load_odf_as_{stru_name}(doc, <node>)"
+                return f"<arg_name> = {stru_name}_load_from_odf(doc, <node>)"
 
     @property
     def validator_cfg(self):
@@ -1288,6 +1289,7 @@ class IdfInterface(IdfInterfaceBase):
         self.plugin = IdfInterfacePlugin()
         if plugin is not None:
             items = plugin.get("actions", [])
+            self.plugin.install_dir = plugin.get("install_dir")
             for item in items:
                 obj = IdfPluginAction(self, item)
                 self.plugin.actions.append(obj)

{lbkit-0.8.3 → lbkit-0.8.5}/lbkit/codegen/template/public.c.mako

@@ -1,5 +1,6 @@
 #include "lb_base.h"
 #include "${intf.name}.h"
+<% import re %>\
 
 <% class_name = intf.alias %>\
 ### 生成Errors错误 START
@@ -59,28 +60,7 @@ GError *${intf.alias}_Error_${name}_new(void)
 %endfor
 
 %endif
-### 生成Errors错误 END
-## 定义结构体ODF加载函数
-% for name, stru in intf.structures.items():
-/* ${name} structure object */
-/* START: 结构体${name}及其数组类型的ODF校验函数 */
-__unused static gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-__unused 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校验函数 */
-__unused static gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-__unused 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():
-__unused static gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
-__unused 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 struct _${name} *value)
@@ -210,7 +190,7 @@ void ${name}_free_v(struct _${name} ***value)
     *value = NULL;
 }
 
-gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     g_assert(doc && node && prop && error_list);
@@ -241,7 +221,7 @@ gboolean _validate_odf_as_struct_${name}(yaml_document_t *doc, yaml_node_t *node
     return valid;
 }
 
-gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf_v(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     g_assert(doc && node && prop && error_list);
@@ -257,7 +237,7 @@ gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *no
     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)) {
+        if (!${name}_validate_odf(doc, val, prop, error_list)) {
             valid = FALSE;
         }
         g_string_truncate(prop, len);
@@ -320,7 +300,7 @@ static const gchar *_${name}StrMap[] = {
 
 const gchar *${name}_as_string(${name} value)
 {
-    if (value >= _${name}Invalid) {
+    if (value >= _${name}_Invalid) {
         return "com.litebmc.Errors.Enum.Invalid";
     }
     return _${name}StrMap[value];
@@ -340,7 +320,7 @@ GVariant *${name}_encode(${name} value)
 ${name} ${name}_decode(GVariant *in)
 {
     if (!in) {
-        return _${name}Invalid;
+        return _${name}_Invalid;
     }
 
     const gchar *in_val = g_variant_get_string(in, NULL);
@@ -349,7 +329,7 @@ ${name} ${name}_decode(GVariant *in)
             return (${name})i;
         }
     }
-    return _${name}Invalid;
+    return _${name}_Invalid;
 }
 
 % endif
@@ -387,6 +367,7 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     }
     ${name} *output = g_new0(${name}, *n);
     while (g_variant_iter_loop(&iter, "s", &str_val)) {
+        output[id] = _${name}_Invalid;
         for (int i = 0; i < ${len(enum.values.parameters)}; i++) {
             if (g_strcmp0(str_val, _${name}StrMap[i]) == 0) {
                 output[id++] = (${name})i;
@@ -396,7 +377,7 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     return output;
 }
 
-gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     gboolean valid = validate_odf_as_string(doc, node, prop, "^.*$", error_list);
@@ -410,12 +391,12 @@ gboolean _validate_odf_as_enum_${name}(yaml_document_t *doc, yaml_node_t *node,
         }
     }
     *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));
+        "the value of property %s is invalid, get %s", prop->str, value));
     return FALSE;
     return FALSE;
 }
 
-gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf_v(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     g_assert(doc && node && prop && error_list);
@@ -431,7 +412,7 @@ gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node
     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)) {
+        if (!${name}_validate_odf(doc, val, prop, error_list)) {
             valid = FALSE;
         }
         g_string_truncate(prop, len);
@@ -440,6 +421,57 @@ gboolean _validate_odf_as_enum_${name}_v(yaml_document_t *doc, yaml_node_t *node
     return valid;
 }
 
+gboolean ${name}_check_enum_variant(LBO *obj, GVariant *value, GError **error)
+{
+    if (!obj || !value) {
+        if (error)
+            *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "parameter error");
+        return FALSE;
+    }
+    ${name} _valid = ${name}_decode(value);
+    if (_valid == _${name}_Invalid) {
+        if (error) {
+            *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invlid enumeration value");
+        }
+        return FALSE;
+    }
+    return TRUE;
+}
+
+gboolean ${name}_check_enum_variant_v(LBO *obj, GVariant *value, GError **error)
+{
+    if (!obj || !value) {
+        if (error)
+            *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "parameter error");
+        return FALSE;
+    }
+    GVariantIter iter;
+    gchar *str_val = NULL;
+
+    (void)g_variant_iter_init(&iter, value);
+    while (g_variant_iter_loop(&iter, "s", &str_val)) {
+        gboolean valid = FALSE;
+        if (g_strcmp0(str_val, "_Invalid") == 0) {
+            if (error) {
+                *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invlid enumeration value");
+            }
+            return FALSE;
+        }
+        for (int i = 0; i < ${len(enum.values.parameters)}; i++) {
+            if (g_strcmp0(str_val, _${name}StrMap[i]) == 0) {
+                valid = TRUE;
+            }
+        }
+        if (!valid) {
+            if (error) {
+                *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invlid enumeration value");
+            }
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
 % endfor
 ## 生成字典处理函数
 % for name, dictionary in intf.dictionaries.items():
@@ -777,7 +809,7 @@ void ${name}_free_v(${name} ***value)
     *value = NULL;
 }
 
-gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     g_assert(doc && node && prop && error_list);
@@ -826,7 +858,7 @@ gboolean _validate_odf_as_dict_${name}(yaml_document_t *doc, yaml_node_t *node,
     return valid;
 }
 
-gboolean _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node,
+gboolean ${name}_validate_odf_v(yaml_document_t *doc, yaml_node_t *node,
     GString *prop, GSList **error_list)
 {
     g_assert(doc && node && prop && error_list);
@@ -842,7 +874,7 @@ gboolean _validate_odf_as_dict_${name}_v(yaml_document_t *doc, yaml_node_t *node
     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)) {
+        if (!${name}_validate_odf(doc, val, prop, error_list)) {
             valid = FALSE;
         }
         g_string_truncate(prop, len);
@@ -986,7 +1018,19 @@ static ${class_name}_Properties _${class_name}_properties =
 % if (prop.signature in ["b", "y", "n", "q", "i", "u", "x", "t", "d", "o", "s", "g", "ab", "ay", "an", "aq", "ai", "au", "ax", "at", "ad", "as", "ao", "ag"] and prop.val_validate()):
         .check = ${class_name}_check_${prop.name}_variant,
 % else:
+<% match = re.match(f"^array\[enum\[(.*)\]\]$", prop.ctype) %>\
+    % if match:
+<% match_enum = re.findall(r"([\w][\w\d]*)", match.group(1)) %>\
+        .check = ${match_enum[-1]}_check_enum_variant_v,
+    % else:
+<% match = re.match(f"^enum\[(.*)\]$", prop.ctype) %>\
+        % if match:
+<% match_enum = re.findall(r"([\w][\w\d]*)", match.group(1)) %>\
+        .check = ${match_enum[-1]}_check_enum_variant,
+        % else:
         .check = NULL,
+        % endif
+    % endif
 % endif
 #endif
 % else:
@@ -1422,6 +1466,174 @@ static gboolean _validate_odf_prop_${prop.name}(yaml_document_t *doc, GHashTable
 }
 
 %endfor
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF加载函数 */
+struct _${name} *${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node)
+{
+<% cnt = 0 %>\
+    % for prop in stru.values.parameters:
+        % if prop.odf_load_func() is not None:
+<% cnt = cnt + 1 %>\
+        % endif
+    % endfor
+% if cnt == 0:
+    return g_new0(struct _${name}, 1);
+% else:
+    __unused yaml_node_t *val;
+    struct _${name} *output = g_new0(struct _${name}, 1);
+    GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
+    % for prop in stru.values.parameters:
+        % if prop.odf_load_func() is not None:
+    /* process ${prop.name} */
+    val = g_hash_table_lookup(prop_table, "${prop.name}");
+    if (val)
+        ${prop.odf_load_func().replace("n_<arg_name>", "output->n_" + prop.name).replace("<arg_name>", "output->" + prop.name).replace("<node>", "val")};
+        % endif
+    % endfor
+
+    g_hash_table_destroy(prop_table);
+    return output;
+% endif
+}
+
+struct _${name} **${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node)
+{
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(struct _${name} *, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    gsize cnt = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    struct _${name} **output = g_new0(struct _${name} *, cnt + 1);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = ${name}_load_from_odf(doc, val);
+    }
+    return output;
+}
+
+% endfor
+## 定义枚举ODF加载函数
+% for name, enum in intf.enumerations.items():
+${name} ${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node)
+{
+% if codegen_version.be("5.0"):
+    g_assert(node->type == YAML_SCALAR_NODE);
+    if (node->type != YAML_SCALAR_NODE) {
+        return _${name}_Invalid;
+    }
+
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0((const gchar *)node->data.scalar.value, ${name}_as_string(i)) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}_Invalid;
+% else:
+    g_assert(node->type == YAML_SCALAR_NODE);
+    if (node->type != YAML_SCALAR_NODE) {
+        return _${name}Invalid;
+    }
+
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0((const gchar *)node->data.scalar.value, ${name}_as_string(i)) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}Invalid;
+% endif
+}
+
+${name} *${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node, gsize *n)
+{
+    g_assert(doc && node && n);
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(${name}, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    *n = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    ${name} *output = g_new0(${name}, *n);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = ${name}_load_from_odf(doc, val);
+    }
+    return output;
+}
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+${name} *${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node)
+{
+    GHashTable *prop_table = NULL;
+    yaml_node_t *val = NULL;
+    ${name} *dict = ${name}_new();
+    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);
+
+        ${", ".join(dictionary.key_obj.declare()).replace("<arg_name>", "key_val").replace("<const>", "")};
+        ${dictionary.key_obj.odf_load_func().replace("<arg_name>", "key_val").replace("<node>", "key")};
+
+        ## 创建一个新的字典成员
+        ${name}${dictionary.key} *item = g_new0(${name}${dictionary.key}, 1);
+        ## 转换成hash表
+        prop_table = load_yaml_mapping_to_hash_table(doc, properties);
+        ## 迭代所有成员并从odf中还原数据
+        % for prop in dictionary.values.parameters:
+            % if prop.odf_load_func() is not None:
+        val = g_hash_table_lookup(prop_table, "${prop.name}");
+        if (val)
+            ${prop.odf_load_func().replace("n_<arg_name>", "item->n_" + prop.name).replace("<arg_name>", "item->" + prop.name).replace("<node>", "val")};
+            % endif
+        % endfor
+        g_hash_table_destroy(prop_table);
+        dict->insert(dict, key_val, &item);
+        % for line in dictionary.key_obj.free_func():
+        ${line.replace("<arg_name>", "key_val")};
+        % endfor
+    }
+    return dict;
+}
+
+${name} **${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node)
+{
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(${name} *, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    gsize cnt = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    ${name} **output = g_new0(${name} *, cnt + 1);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = ${name}_load_from_odf(doc, val);
+    }
+    return output;
+}
+
+% endfor
 gboolean ${intf.name.replace(".", "_")}_validate_odf(yaml_document_t *doc, yaml_node_t *node,
     const gchar *object_name, GSList **error_list)
 {
@@ -1454,4 +1666,4 @@ static void __constructor(101) ${class_name}_public_register(void)
     % endfor
 }
 
-% endif
+% endif

{lbkit-0.8.3 → lbkit-0.8.5}/lbkit/codegen/template/public.h.mako

@@ -183,6 +183,10 @@ GVariant *${name}_encode_v(const ${name} *value, gsize n);
 ${name} *${name}_decode_v(GVariant *in, gsize *n);
 /* END: 枚举${name}及其数组类型的序列化、反序列化、释放函数 */
 
+## 校验枚举变量有效性
+gboolean ${name}_check_enum_variant(LBO *obj, GVariant *value, GError **error);
+gboolean ${name}_check_enum_variant_v(LBO *obj, GVariant *value, GError **error);
+
 % endfor
 ## 定义字典编解码和释放函数
 % for name, dictionary in intf.dictionaries.items():
@@ -196,6 +200,50 @@ ${name} **${name}_decode_v(GVariant *in);
 void ${name}_free_v(${name} ***value);
 /* END: 字典${name}及其数组类型的序列化、反序列化、释放函数 */
 
+% endfor
+### 生成Errors错误 END
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF校验函数 */
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+gboolean ${name}_validate_odf_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校验函数 */
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+gboolean ${name}_validate_odf_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+gboolean ${name}_validate_odf(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+gboolean ${name}_validate_odf_v(yaml_document_t *doc, yaml_node_t *node, GString *prop, GSList **error_list);
+
+% endfor
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF加载函数 */
+struct _${name} *${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node);
+struct _${name} **${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node);
+
+% endfor
+## 定义枚举ODF加载函数
+% for name, enum in intf.enumerations.items():
+/* START: 枚举${name}及其数组类型的ODF加载函数 */
+${name} ${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node);
+${name} *${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node, gsize *n);
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+/* START: 字典${name}及其数组类型的ODF加载函数 */
+${name} *${name}_load_from_odf(yaml_document_t *doc, yaml_node_t *node);
+${name} **${name}_load_from_odf_v(yaml_document_t *doc, yaml_node_t *node);
+
 % endfor
 ### 开始生成方法的请求体、响应体和处理函数
 % for method in intf.fake_methods: