lbkit 0.9.7__tar.gz → 0.9.10__tar.gz

{lbkit-0.9.7/lbkit.egg-info → lbkit-0.9.10}/PKG-INFO

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

lbkit-0.9.10/lbkit/__init__.py

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

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/build_conan_parallel.py

@@ -19,7 +19,8 @@ class BuildConanParallel(object):
         self.lockfile = lockfile
 
     def _build_package(self, logfile, build_args, public_args):
-        cmd = f"conan install {build_args} {public_args} --lockfile={self.lockfile} --lockfile-partial"
+        lockfile_out = logfile + ".lock"
+        cmd = f"conan install {build_args} {public_args} --lockfile={self.lockfile} --lockfile-out={lockfile_out}"
         log.info("{}build start:    '{}".format(Color.GREEN, Color.RESET_ALL) + cmd + '  log file: ' + logfile)
         tools.exec(cmd, log_name=logfile, echo_cmd=False)
         log.info("{}build finished: '{}".format(Color.GREEN, Color.RESET_ALL) + cmd + '  log file: ' + logfile)

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/codegen/codegen.py

@@ -7,6 +7,7 @@ import re
 import json
 import yaml
 import argparse
+from concurrent.futures import ProcessPoolExecutor, as_completed
 from lbkit.codegen.idf_interface import IdfInterface
 
 from mako.lookup import TemplateLookup
@@ -100,6 +101,43 @@ def codegen_version_arg(parser: argparse.ArgumentParser, default=__version__.str
     parser.add_argument(short_arg, full_arg, help=help, type=str, default=__version__.str)
 
 
+def _gen_interface(idf_file, directory=".", code_type="all", codegen_version_str="5.4", log_level="NOTSET"):
+    """模块级函数，供多进程调用"""
+    directory = os.path.realpath(directory)
+    codegen_version = Version(codegen_version_str)
+    lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
+    interface = IdfInterface(lookup, idf_file, codegen_version, log_level)
+    code_types = ["server", "client", "public"]
+    if code_type != "all":
+        code_types = [code_type]
+    for ct in code_types:
+        os.makedirs(os.path.join(directory, ct), exist_ok=True)
+        out_file = os.path.join(directory, ct, interface.name + ".xml")
+        interface.render_dbus_xml("interface.introspect.xml.mako", out_file)
+        # 确保生成xml的日志只打印一次
+        if ct == "public" or code_type == ct:
+            log.info("The sha256sum of interface {} is {}".format(out_file, interface.introspect_xml_sha256))
+        out_file = os.path.join(directory, ct, interface.alias + ".h")
+        interface.render_c_source(ct + ".h.mako", out_file)
+        out_file = os.path.join(directory, ct, interface.alias + ".c")
+        interface.render_c_source(ct + ".c.mako", out_file)
+        if "server" == ct:
+            # 生成接口schema文件
+            odf_file = os.path.join(directory, "server", "schema", f"{interface.alias}.json")
+            os.makedirs(os.path.dirname(odf_file), exist_ok=True)
+            odf_data = interface.odf_schema
+            with open(odf_file, "w", encoding="utf-8") as fp:
+                json.dump(odf_data, fp, sort_keys=False, indent=4)
+    json_file = os.path.join(directory, "package.yml")
+    data = {
+        "version": interface.version,
+        "name": interface.name,
+        "alias": interface.alias
+    }
+    with open(json_file, "w", encoding="utf-8") as fp:
+        yaml.dump(data, fp, encoding='utf-8', allow_unicode=True)
+
+
 class CodeGen(object):
     def __init__(self, args):
         Logger("codegen.log")
@@ -109,37 +147,7 @@ class CodeGen(object):
         self.log_level = "NOTSET"
 
     def _gen(self, idf_file, directory=".", code_type="all"):
-        directory = os.path.realpath(directory)
-        interface = self.get_interface(idf_file)
-        code_types = ["server", "client", "public"]
-        if code_type != "all":
-            code_types = [code_type]
-        for ct in code_types:
-            os.makedirs(os.path.join(directory, ct), exist_ok=True)
-            out_file = os.path.join(directory, ct, interface.name + ".xml")
-            interface.render_dbus_xml("interface.introspect.xml.mako", out_file)
-            # 确保生成xml的日志只打印一次
-            if ct == "public" or code_type == ct:
-                log.info("The sha256sum of interface {} is {}".format(out_file, interface.introspect_xml_sha256))
-            out_file = os.path.join(directory, ct, interface.alias + ".h")
-            interface.render_c_source(ct + ".h.mako", out_file)
-            out_file = os.path.join(directory, ct, interface.alias + ".c")
-            interface.render_c_source(ct + ".c.mako", out_file)
-            if "server" == ct:
-                # 生成接口schema文件
-                odf_file = os.path.join(directory, "server", "schema", f"{interface.alias}.json")
-                os.makedirs(os.path.dirname(odf_file), exist_ok=True)
-                odf_data = interface.odf_schema
-                with open(odf_file, "w", encoding="utf-8") as fp:
-                    json.dump(odf_data, fp, sort_keys=False, indent=4)
-        json_file = os.path.join(directory, "package.yml")
-        data = {
-            "version": interface.version,
-            "name": interface.name,
-            "alias": interface.alias
-        }
-        with open(json_file, "w", encoding="utf-8") as fp:
-            yaml.dump(data, fp, encoding='utf-8', allow_unicode=True)
+        _gen_interface(idf_file, directory, code_type, self.codegen_version.str, self.log_level)
 
     def get_interface(self, idf_file):
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
@@ -174,6 +182,8 @@ class CodeGen(object):
                 ver_str = Helper.read_yaml(args.cdf_file, "codegen_version", args.codegen_version)
             version_check(ver_str)
             self.codegen_version = Version(ver_str)
+            # 校验阶段：顺序检查所有配置项
+            gen_tasks = []
             for cfg in configs:
                 file = cfg.get("file")
                 if file is None:
@@ -186,7 +196,12 @@ class CodeGen(object):
                     log.error("%s的自动代码生成配置不正确, %s不是一个文件", args.cdf_file, file)
                     sys.exit(-1)
                 outdir = cfg.get("outdir", os.getcwd())
-                self._gen(file, outdir)
+                gen_tasks.append((file, outdir))
+            # 并行生成阶段
+            with ProcessPoolExecutor(max_workers=os.cpu_count()) as executor:
+                futures = {executor.submit(_gen_interface, file, outdir, "all", self.codegen_version.str, self.log_level): file for file, outdir in gen_tasks}
+                for future in as_completed(futures):
+                    future.result()
             return
         else:
             ver_str = os.environ.get("CODEGEN_VERSION")

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/codegen/ctype_defination.py

@@ -694,7 +694,8 @@ class CTypeBase(object):
                  validator: IdfValidator = None,
                  const_declare = None,
                  const_free_func = None,
-                 const_decode_func = None):
+                 const_decode_func = None,
+                 copy_func = None):
         self.declare = declare
         # 作为函数出参时的变量申明
         self.out_declare = out_declare
@@ -712,9 +713,19 @@ class CTypeBase(object):
             self.const_free_func = self.free_func
         if const_decode_func is None:
             self.const_decode_func = self.decode_func
+        # 直接复制数据的C代码，用于server端属性getter函数
+        # 占位符: <src>=源, <dst>=目标指针, <n_src>=源数组长度, <n_dst>=目标数组长度指针
+        self.copy_func = copy_func if copy_func is not None else []
 
 
 """定义支持的C语言类型"""
+# 值类型直接复制模板
+_COPY_VALUE = ["*<dst> = <src>"]
+# 字符串类型复制模板
+_COPY_STRING = ["*<dst> = g_strdup(<src>)"]
+# variant类型复制模板
+_COPY_VARIANT = ["*<dst> = g_variant_ref(<src>)"]
+
 CTYPE_OBJS = {
     "boolean": CTypeBase(
         ["gboolean <arg_name>"],
@@ -722,7 +733,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_boolean(<arg_name>)"],
         ["<arg_in> = g_variant_get_boolean(<arg_name>)"],
-        BoolValidator("boolean")
+        BoolValidator("boolean"),
+        copy_func=_COPY_VALUE
     ),
     "byte": CTypeBase(
         ["guint8 <arg_name>"],
@@ -730,7 +742,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_byte(<arg_name>)"],
         ["<arg_in> = g_variant_get_byte(<arg_name>)"],
-        IntegerValidator("uint8", 0xff, 0)
+        IntegerValidator("uint8", 0xff, 0),
+        copy_func=_COPY_VALUE
     ),
     "int16": CTypeBase(
         ["gint16 <arg_name>"],
@@ -738,7 +751,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int16(<arg_name>)"],
         ["<arg_in> = g_variant_get_int16(<arg_name>)"],
-        IntegerValidator("int16", 0x7fff, -(0x8000), True)
+        IntegerValidator("int16", 0x7fff, -(0x8000), True),
+        copy_func=_COPY_VALUE
     ),
     "uint16": CTypeBase(
         ["guint16 <arg_name>"],
@@ -746,7 +760,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_uint16(<arg_name>)"],
         ["<arg_in> = g_variant_get_uint16(<arg_name>)"],
-        IntegerValidator("uint16", 0xffff, 0)
+        IntegerValidator("uint16", 0xffff, 0),
+        copy_func=_COPY_VALUE
     ),
     "int32": CTypeBase(
         ["gint32 <arg_name>"],
@@ -754,7 +769,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int32(<arg_name>)"],
         ["<arg_in> = g_variant_get_int32(<arg_name>)"],
-        IntegerValidator("int32", 0x7fff_ffff, -(0x8000_0000), True)
+        IntegerValidator("int32", 0x7fff_ffff, -(0x8000_0000), True),
+        copy_func=_COPY_VALUE
     ),
     "uint32": CTypeBase(
         ["guint32 <arg_name>"],
@@ -762,7 +778,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_uint32(<arg_name>)"],
         ["<arg_in> = g_variant_get_uint32(<arg_name>)"],
-        IntegerValidator("uint32", 0xffff_ffff, 0)
+        IntegerValidator("uint32", 0xffff_ffff, 0),
+        copy_func=_COPY_VALUE
     ),
     "int64": CTypeBase(
         ["gint64 <arg_name>"],
@@ -770,7 +787,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_int64(<arg_name>)"],
         ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        IntegerValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True),
+        copy_func=_COPY_VALUE
     ),
     "uint64": CTypeBase(
         ["guint64 <arg_name>"],
@@ -778,7 +796,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_uint64(<arg_name>)"],
         ["<arg_in> = g_variant_get_uint64(<arg_name>)"],
-        IntegerValidator("uint64", 0xffff_ffff_ffff_ffff, 0)
+        IntegerValidator("uint64", 0xffff_ffff_ffff_ffff, 0),
+        copy_func=_COPY_VALUE
     ),
     "size": CTypeBase(
         ["gsize <arg_name>"],
@@ -786,7 +805,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_tsize(<arg_name>)"],
         ["<arg_in> = g_variant_get_tsize(<arg_name>)"],
-        IntegerValidator("size", 0xffff_ffff_ffff_ffff, 0)
+        IntegerValidator("size", 0xffff_ffff_ffff_ffff, 0),
+        copy_func=_COPY_VALUE
     ),
     "ssize": CTypeBase(
         ["gssize <arg_name>"],
@@ -794,7 +814,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_tssize(<arg_name>)"],
         ["<arg_in> = g_variant_get_tssize(<arg_name>)"],
-        IntegerValidator("ssize", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        IntegerValidator("ssize", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True),
+        copy_func=_COPY_VALUE
     ),
     "double": CTypeBase(
         ["gdouble <arg_name>"],
@@ -802,7 +823,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_double(<arg_name>)"],
         ["<arg_in> = g_variant_get_double(<arg_name>)"],
-        FloatValidator("double")
+        FloatValidator("double"),
+        copy_func=_COPY_VALUE
     ),
     "unixfd": CTypeBase(
         ["gint32 <arg_name>"],
@@ -810,7 +832,8 @@ CTYPE_OBJS = {
         [],
         ["<arg_out> = g_variant_new_handle(<arg_name>)"],
         ["<arg_in> = g_variant_get_handle(<arg_name>)"],
-        IntegerValidator("int32", 0x7fff_ffff_ffff_ffff, 0, True)
+        IntegerValidator("int32", 0x7fff_ffff_ffff_ffff, 0, True),
+        copy_func=_COPY_VALUE
     ),
     "string": CTypeBase(
         ["<const>gchar *<arg_name>"],
@@ -822,6 +845,7 @@ CTYPE_OBJS = {
         ["const gchar *<arg_name>"],
         [],
         ["<arg_in> = g_variant_get_string(<arg_name>, NULL)"],
+        copy_func=_COPY_STRING
     ),
     "object_path": CTypeBase(
         ["<const>gchar *<arg_name>"],
@@ -833,6 +857,7 @@ CTYPE_OBJS = {
         ["const gchar *<arg_name>"],
         [],
         ["<arg_in> = g_variant_get_string(<arg_name>, NULL)"],
+        copy_func=_COPY_STRING
     ),
     "signature": CTypeBase(
         ["<const>gchar *<arg_name>"],
@@ -844,6 +869,7 @@ CTYPE_OBJS = {
         ["const gchar *<arg_name>"],
         [],
         ["<arg_in> = g_variant_get_string(<arg_name>, NULL)"],
+        copy_func=_COPY_STRING
     ),
     "variant": CTypeBase(
         ["GVariant *<arg_name>"],
@@ -851,7 +877,8 @@ CTYPE_OBJS = {
         ["lb_unref_p((GVariant **)&<arg_name>)"],
         ["g_variant_take_ref(<arg_name>)", "<arg_out> = g_variant_new_variant(<arg_name>)"],
         ["<arg_in> = g_variant_get_variant(<arg_name>)"],
-        IdfValidator(None)
+        IdfValidator(None),
+        copy_func=_COPY_VARIANT
     ),
     "array[boolean]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gboolean *<arg_name>"],
@@ -859,7 +886,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_boolean_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_boolean_decode(<arg_name>, &n_<arg_in>)"],
-        BoolArrayValidator("boolean")
+        BoolArrayValidator("boolean"),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gboolean) * <n_src>)"]
     ),
     "array[byte]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint8 *<arg_name>"],
@@ -867,7 +895,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_byte_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_byte_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint8", 0xff, 0)
+        IntegerArrayValidator("uint8", 0xff, 0),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(guint8) * <n_src>)"]
     ),
     "array[int16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint16 *<arg_name>"],
@@ -875,7 +904,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_int16_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_int16_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int16", 0x7fff, -(0x8000), True)
+        IntegerArrayValidator("int16", 0x7fff, -(0x8000), True),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gint16) * <n_src>)"]
     ),
     "array[uint16]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint16 *<arg_name>"],
@@ -883,7 +913,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_uint16_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_uint16_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint16", 0xffff, 0)
+        IntegerArrayValidator("uint16", 0xffff, 0),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(guint16) * <n_src>)"]
     ),
     "array[int32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint32 *<arg_name>"],
@@ -891,7 +922,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_int32_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_int32_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int32", 0x7fff_ffff, -(0x80000000), True)
+        IntegerArrayValidator("int32", 0x7fff_ffff, -(0x80000000), True),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gint32) * <n_src>)"]
     ),
     "array[uint32]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint32 *<arg_name>"],
@@ -899,7 +931,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_uint32_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_uint32_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint32", 0xffff_ffff, 0)
+        IntegerArrayValidator("uint32", 0xffff_ffff, 0),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(guint32) * <n_src>)"]
     ),
     "array[int64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint64 *<arg_name>"],
@@ -907,7 +940,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_int64_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_int64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        IntegerArrayValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gint64) * <n_src>)"]
     ),
     "array[uint64]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>guint64 *<arg_name>"],
@@ -915,7 +949,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_uint64_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint64",0xffff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator("uint64",0xffff_ffff_ffff_ffff, 0),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(guint64) * <n_src>)"]
     ),
     "array[ssize]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gssize *<arg_name>"],
@@ -923,7 +958,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_ssize_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_ssize_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("ssize",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        IntegerArrayValidator("ssize",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gssize) * <n_src>)"]
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gsize *<arg_name>"],
@@ -931,7 +967,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_size_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_size_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("size", 0xffff_ffff_ffff_ffff, 0)
+        IntegerArrayValidator("size", 0xffff_ffff_ffff_ffff, 0),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gsize) * <n_src>)"]
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],
@@ -939,7 +976,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_double_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_double_decode(<arg_name>, &n_<arg_in>)"],
-        FloatArrayValidator("double")
+        FloatArrayValidator("double"),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gdouble) * <n_src>)"]
     ),
     "array[unixfd]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gint32 *<arg_name>"],
@@ -947,7 +985,8 @@ CTYPE_OBJS = {
         ["lb_free_p((void **)&<arg_name>)"],
         ["<arg_out> = lb_array_handle_encode(<arg_name>, n_<arg_name>)"],
         ["<arg_in> = lb_array_handle_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int32", 0x7fff_ffff_ffff_ffff, 0, True)
+        IntegerArrayValidator("int32", 0x7fff_ffff_ffff_ffff, 0, True),
+        copy_func=["*<n_dst> = <n_src>", "*<dst> = g_memdup2(<src>, sizeof(gint32) * <n_src>)"]
     ),
     "array[string]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
@@ -955,7 +994,8 @@ CTYPE_OBJS = {
         ["lb_strfreev_p(&<arg_name>)"],
         ["<arg_out> = lb_array_string_encode(<arg_name>)"],
         ["<arg_in> = lb_array_string_decode(<arg_name>)"],
-        StringArrayValidator("string", "")
+        StringArrayValidator("string", ""),
+        copy_func=["*<dst> = g_strdupv(<src>)"]
     ),
     "array[object_path]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
@@ -963,7 +1003,8 @@ CTYPE_OBJS = {
         ["lb_strfreev_p(&<arg_name>)"],
         ["<arg_out> = lb_array_object_path_encode(<arg_name>)"],
         ["<arg_in> = lb_array_object_path_decode(<arg_name>)"],
-        StringArrayValidator("string", "^(/[A-Z0-9a-z_]+)*$")
+        StringArrayValidator("string", "^(/[A-Z0-9a-z_]+)*$"),
+        copy_func=["*<dst> = g_strdupv(<src>)"]
     ),
     "array[signature]": CTypeBase(
         ["gchar *<const>*<arg_name>"],
@@ -971,6 +1012,7 @@ CTYPE_OBJS = {
         ["lb_strfreev_p(&<arg_name>)"],
         ["<arg_out> = lb_array_signature_encode(<arg_name>)"],
         ["<arg_in> = lb_array_signature_decode(<arg_name>)"],
-        StringArrayValidator("string", "^([abynqiuxtdsogvh\\\\{\\\\}\\\\(\\\\)])+$")
+        StringArrayValidator("string", "^([abynqiuxtdsogvh\\\\{\\\\}\\\\(\\\\)])+$"),
+        copy_func=["*<dst> = g_strdupv(<src>)"]
     )
 }

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/codegen/idf_interface.py

@@ -12,7 +12,6 @@ from lbkit.errors import OdfValidateException, LiteBmcException
 from lbkit.helper import SigInvalidException, validate_glib_signature
 
 log = Logger()
-alias = None
 
 class IDFException(Exception):
     pass
@@ -542,6 +541,36 @@ class IdfCtypeRender():
             else:
                 return [f"<arg_in> = {stru_name}_decode(<arg_name>)"]
 
+    def copy_func(self):
+        """生成直接复制数据的C代码，用于server端属性getter函数
+        返回None表示该类型需要通过GVariant编解码进行深拷贝
+        占位符: <src>=源(obj->prop), <dst>=目标指针(value), <n_src>=源数组长度, <n_dst>=目标数组长度指针
+        """
+        # 基础类型（含数组和variant）
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if match:
+            return CTYPE_OBJS.get(self.ctype).copy_func
+        match = re.match(f"^({CTYPE_REGEX})$", self.ctype)
+        if match:
+            return CTYPE_OBJS.get(self.ctype).copy_func
+        # 非基础类型
+        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"^enum\[(.*)\]$", ctype)
+        if match:
+            _, stru_name = get_intfname_and_ctype(self.intf.alias, match.group(1))
+            if is_array:
+                return ["*<n_dst> = <n_src>", f"*<dst> = g_memdup2(<src>, sizeof({stru_name}) * <n_src>)"]
+            else:
+                return ["*<dst> = <src>"]
+        # 结构体和字典类型需要通过GVariant编解码进行深拷贝
+        return None
+
     def const_declare(self):
         """常量申明，用于方法请求和信号消息结构体顶层成员申明"""
         log.debug(f"Get const_declare info, name: {self.name}, ctype: {self.ctype}")
@@ -1271,8 +1300,6 @@ class IdfInterface(IdfInterfaceBase):
         log.debug(f"validate {self.file} successfully")
         self.version = idf.get("version")
         self.description = idf.get("description", "")
-        global alias
-        alias = self.alias
         # 注释
         flags = idf.get("flags", "").split(",")
         for k, v in ANNOTATION_MAP.items():
@@ -1292,7 +1319,7 @@ class IdfInterface(IdfInterfaceBase):
         items = idf.get("structures", [])
         for item in items:
             obj = IdfStructure(self, item)
-            obj.name = alias + "_" + obj.name
+            obj.name = self.alias + "_" + obj.name
             self.structures[obj.name] = obj
         items = idf.get("errors", [])
         for item in items:
@@ -1302,12 +1329,12 @@ class IdfInterface(IdfInterfaceBase):
         items = idf.get("dictionaries", [])
         for item in items:
             obj = IdfDictionary(self, item)
-            obj.name = alias + "_" + obj.name
+            obj.name = self.alias + "_" + obj.name
             self.dictionaries[obj.name] = obj
         items = idf.get("enumerations", [])
         for item in items:
             obj = IdfEnumeration(self, item)
-            obj.name = alias + "_" + obj.name
+            obj.name = self.alias + "_" + obj.name
             self.enumerations[obj.name] = obj
         plugin = idf.get("plugin", None)
         self.plugin = IdfInterfacePlugin()

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/codegen/template/public.c.mako

@@ -930,23 +930,29 @@ static gboolean ${class_name}_check_${prop.name}_variant(LBO *obj, GVariant *val
 static void ${class_name}_set_${prop.name}_variant(LBO *obj, GVariant *value)
 {
     g_assert(value && obj);
-    struct _${class_name} *real_obj = (struct _${class_name} *)_get_real_object(obj);
+    LBBase *base = _get_real_object(obj);
+    struct _${class_name} *real_obj = (struct _${class_name} *)base;
+    g_rec_mutex_lock(base->lock);
     % for line in prop.free_func():
     ${line.replace("<arg_name>", "real_obj->" + prop.name)};
     % endfor
     % for line in prop.decode_func():
     ${line.replace("n_<arg_in>", "real_obj->n_" + prop.name).replace("<arg_in>", "real_obj->" + prop.name).replace("<arg_name>", "value")};
     % endfor
+    g_rec_mutex_unlock(base->lock);
 }
 
 static GVariant *${class_name}_get_${prop.name}_variant(LBO *obj)
 {
     g_assert(obj);
     GVariant *out = NULL;
-    struct _${class_name} *real_obj = (struct _${class_name} *)_get_real_object(obj);
+    LBBase *base = _get_real_object(obj);
+    struct _${class_name} *real_obj = (struct _${class_name} *)base;
+    g_rec_mutex_lock(base->lock);
     % for line in prop.encode_func():
     ${line.replace("<arg_out>", "out").replace("n_<arg_name>", "real_obj->n_" + prop.name).replace("<arg_name>", "real_obj->" + prop.name)};
     % endfor
+    g_rec_mutex_unlock(base->lock);
     return out;
 }
 

{lbkit-0.9.7 → lbkit-0.9.10}/lbkit/codegen/template/server.c.mako

@@ -51,7 +51,7 @@ gboolean ${class_name}_Emit_${signal.name}(${class_name} obj, const gchar *desti
         }
         return FALSE;
     }
-    __cleanup_error GError *tmp_error = NULL;
+    cleanup_error GError *tmp_error = NULL;
     GError **perror = error;
     if (!error) {
         perror = &tmp_error;
@@ -189,6 +189,53 @@ static LBBase *_get_real_object(LBO *obj)
     return real;
 }
 
+% for prop in intf.properties:
+    % if prop.deprecated:
+__deprecated void ${class_name}_get_${prop.name}(${class_name} obj,
+    ${", ".join(prop.out_declare()).replace("<arg_name>", "value").replace("<const>", "")})
+    % else:
+void ${class_name}_get_${prop.name}(${class_name} obj,
+    ${", ".join(prop.out_declare()).replace("<arg_name>", "value").replace("<const>", "")})
+    % endif
+{
+    % if "gsize n_" in prop.declare()[0]:
+    g_assert(n_value && value);
+    % else:
+    g_assert(value);
+    % endif
+<% copy_lines = prop.copy_func() %>\
+    % if copy_lines is not None:
+    g_rec_mutex_lock(obj->_base.lock);
+    % for line in copy_lines:
+    ${line.replace("<n_src>", "obj->n_" + prop.name).replace("<src>", "obj->" + prop.name).replace("<n_dst>", "n_value").replace("<dst>", "value")};
+    % endfor
+    g_rec_mutex_unlock(obj->_base.lock);
+    % else:
+    % for line in prop.declare():
+        % if "*" in line:
+    ${line.strip().replace("<arg_name>", "tmp_value").replace("<const>", "")} = NULL;
+        % else:
+    ${line.strip().replace("<arg_name>", "tmp_value").replace("<const>", "")};
+        % endif
+    % endfor
+    GVariant *tmp = NULL;
+    g_rec_mutex_lock(obj->_base.lock);
+    % for line in prop.encode_func():
+    ${line.replace("<arg_out>", "tmp").replace("n_<arg_name>", "obj->n_" + prop.name).replace("<arg_name>", "obj->" + prop.name)};
+    % endfor
+    g_rec_mutex_unlock(obj->_base.lock);
+    % for line in prop.decode_func():
+    ${line.replace("<arg_in>", "tmp_value").replace("<arg_name>", "tmp")};
+    % endfor
+    *value = tmp_value;
+    % if "gsize n_" in prop.declare()[0]:
+    *n_value = n_tmp_value;
+    % endif
+    g_variant_unref(tmp);
+    % endif
+}
+
+% endfor
 static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, LBO *obj,
     lbo_property_reference_loaded_handler ref_loaded, gpointer user_data)
 {