lbkit 0.8.3__tar.gz → 0.8.4__tar.gz

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

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

lbkit-0.8.4/lbkit/__init__.py

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

{lbkit-0.8.3 → lbkit-0.8.4}/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.4}/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.4}/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:

{lbkit-0.8.3 → lbkit-0.8.4}/lbkit/codegen/template/server.c.mako

@@ -7,196 +7,7 @@ class_name = intf.alias
 properties = "_" + class_name + "_properties"
 signal_processer = "_" + class_name + "_signals"
 %>\
-## 定义结构体ODF加载函数
-% for name, stru in intf.structures.items():
-/* ${name} structure object */
-/* START: 结构体${name}及其数组类型的ODF加载函数 */
-struct _${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
-struct _${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node);
 
-% endfor
-## 定义枚举ODF加载函数
-% for name, enum in intf.enumerations.items():
-/* START: 枚举${name}及其数组类型的ODF加载函数 */
-${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
-${name} *_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node, gsize *n);
-
-% endfor
-## 定义字典ODF加载函数
-% for name, dictionary in intf.dictionaries.items():
-/* START: 字典${name}及其数组类型的ODF加载函数 */
-${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
-${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node);
-
-% endfor
-## 定义结构体ODF加载函数
-% for name, stru in intf.structures.items():
-/* ${name} structure object */
-/* START: 结构体${name}及其数组类型的ODF加载函数 */
-struct _${name} *_load_odf_as_${name}(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} **_load_odf_as_${name}_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++] = _load_odf_as_${name}(doc, val);
-    }
-    return output;
-}
-
-% endfor
-## 定义枚举ODF加载函数
-% for name, enum in intf.enumerations.items():
-${name} _load_odf_as_${name}(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} *_load_odf_as_${name}_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++] = _load_odf_as_${name}(doc, val);
-    }
-    return output;
-}
-
-% endfor
-## 定义字典ODF加载函数
-% for name, dictionary in intf.dictionaries.items():
-${name} *_load_odf_as_${name}(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} **_load_odf_as_${name}_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++] = _load_odf_as_${name}(doc, val);
-    }
-    return output;
-}
-
-% endfor
 static ${class_name}_Properties ${properties};
 static const ${class_name}_Signals *${signal_processer} = NULL;
 
@@ -271,10 +82,17 @@ static LBInterface _${class_name}_interface = {
     .name = "${intf.name}",
     .properties = (LBProperty *)&${properties},
     .interface = NULL,  /* load from usr/share/dbus-1/interfaces/${intf.name} by lb_init */
+#ifdef LB_CODEGEN_BE_5_2
+    % if intf.plugin.install_dir:
+    .plugin_dir = "${intf.plugin.install_dir}",
+    % else:
+    .plugin_dir = NULL,
+    % endif
+#endif
 };
 
 % for prop in intf.properties:
-static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *prop_table,
+static void ${class_name}_load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *prop_table,
     struct _${class_name} *obj, lbo_property_reference_loaded_handler ref_loaded, gpointer user_data)
 {
     __unused gint i = 0;
@@ -391,7 +209,7 @@ static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, LBO *obj,
     ${class_name}_clean(real_obj);
     GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
     % for prop in intf.properties:
-    _load_odf_as_prop_${prop.name}(doc, prop_table, real_obj, ref_loaded, user_data);
+    ${class_name}_load_odf_as_prop_${prop.name}(doc, prop_table, real_obj, ref_loaded, user_data);
     % endfor
 
     g_hash_table_destroy(prop_table);

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

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

lbkit-0.8.3/lbkit/__init__.py

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