gio: Add builders for DBus introspection types

tautropfli · tautropfli · commit 25eeadb2603e · 2026-04-24T16:15:49.000+02:00
diff --git a/gio/src/dbus_annotation_info.rs b/gio/src/dbus_annotation_info.rs
@@ -0,0 +1,56 @@
+use std::ffi::CString;
+use std::mem;
+
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{DBusAnnotationInfo, ffi};
+
+impl DBusAnnotationInfo {
+    pub fn builder<'a>() -> DBusAnnotationInfoBuilder<'a> {
+        DBusAnnotationInfoBuilder::default()
+    }
+}
+
+#[derive(Default)]
+pub struct DBusAnnotationInfoBuilder<'a> {
+    key: Option<&'a str>,
+    value: Option<&'a str>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusAnnotationInfoBuilder<'a> {
+    /// Required
+    pub fn key(mut self, key: &'a str) -> Self {
+        self.key = Some(key);
+        self
+    }
+
+    /// Required
+    pub fn value(mut self, value: &'a str) -> Self {
+        self.value = Some(value);
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusAnnotationInfo {
+        let key = self.value.expect("`key` should be set");
+        let value = self.value.expect("`value` should be set");
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusAnnotationInfo>()) }
+                as *mut ffi::GDBusAnnotationInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).key = CString::new(key).unwrap().to_glib_full();
+            (*ptr).value = CString::new(value).unwrap().to_glib_full();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/dbus_arg_info.rs b/gio/src/dbus_arg_info.rs
@@ -0,0 +1,55 @@
+use std::ffi::CString;
+use std::mem;
+
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{DBusAnnotationInfo, DBusArgInfo, ffi};
+
+impl DBusArgInfo {
+    pub fn builder<'a>() -> DBusArgInfoBuilder<'a> {
+        DBusArgInfoBuilder::default()
+    }
+}
+
+#[derive(Default)]
+pub struct DBusArgInfoBuilder<'a> {
+    name: Option<&'a str>,
+    signature: Option<&'a str>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusArgInfoBuilder<'a> {
+    pub fn name<N: Into<Option<&'a str>>>(mut self, name: N) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Required
+    pub fn signature(mut self, signature: &'a str) -> Self {
+        self.signature = Some(signature);
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusArgInfo {
+        let signature = self.signature.expect("`signature` should be set");
+        let name = self.name.map(|name| CString::new(name).unwrap());
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusArgInfo>()) }
+                as *mut ffi::GDBusArgInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).name = name.to_glib_full();
+            (*ptr).signature = CString::new(signature).unwrap().to_glib_full();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/dbus_interface_info.rs b/gio/src/dbus_interface_info.rs
@@ -1,10 +1,20 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::ffi::CStr;
+use std::ffi::{CStr, CString};
+use std::mem;
 
-use crate::DBusInterfaceInfo;
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{
+    DBusAnnotationInfo, DBusInterfaceInfo, DBusMethodInfo, DBusPropertyInfo, DBusSignalInfo, ffi,
+};
 
 impl DBusInterfaceInfo {
+    pub fn builder<'a>() -> DBusInterfaceInfoBuilder<'a> {
+        DBusInterfaceInfoBuilder::default()
+    }
+
     pub fn name(&self) -> &str {
         unsafe {
             let c_obj = self.as_ptr();
@@ -15,3 +25,58 @@ impl DBusInterfaceInfo {
         }
     }
 }
+
+#[derive(Default)]
+pub struct DBusInterfaceInfoBuilder<'a> {
+    name: Option<&'a str>,
+    methods: SmallVec<[DBusMethodInfo; 4]>,
+    signals: SmallVec<[DBusSignalInfo; 4]>,
+    properties: SmallVec<[DBusPropertyInfo; 4]>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusInterfaceInfoBuilder<'a> {
+    /// Required
+    pub fn name(mut self, name: &'a str) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn methods<I: IntoIterator<Item = DBusMethodInfo>>(mut self, methods: I) -> Self {
+        self.methods = methods.into_iter().collect();
+        self
+    }
+
+    pub fn signals<I: IntoIterator<Item = DBusSignalInfo>>(mut self, args: I) -> Self {
+        self.signals = args.into_iter().collect();
+        self
+    }
+
+    pub fn properties<I: IntoIterator<Item = DBusPropertyInfo>>(mut self, args: I) -> Self {
+        self.properties = args.into_iter().collect();
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusInterfaceInfo {
+        let name = self.name.expect("`name` should be set");
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusInterfaceInfo>()) }
+                as *mut ffi::GDBusInterfaceInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).name = CString::new(name).unwrap().to_glib_full();
+            (*ptr).methods = self.methods.to_glib_full();
+            (*ptr).signals = self.signals.to_glib_full();
+            (*ptr).properties = self.properties.to_glib_full();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/dbus_method_info.rs b/gio/src/dbus_method_info.rs
@@ -0,0 +1,61 @@
+use std::ffi::CString;
+use std::mem;
+
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{DBusAnnotationInfo, DBusArgInfo, DBusMethodInfo, ffi};
+
+impl DBusMethodInfo {
+    pub fn builder<'a>() -> DBusMethodInfoBuilder<'a> {
+        DBusMethodInfoBuilder::default()
+    }
+}
+
+#[derive(Default)]
+pub struct DBusMethodInfoBuilder<'a> {
+    name: Option<&'a str>,
+    in_args: SmallVec<[DBusArgInfo; 4]>,
+    out_args: SmallVec<[DBusArgInfo; 2]>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusMethodInfoBuilder<'a> {
+    /// Required
+    pub fn name(mut self, name: &'a str) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn in_args<I: IntoIterator<Item = DBusArgInfo>>(mut self, args: I) -> Self {
+        self.in_args = args.into_iter().collect();
+        self
+    }
+
+    pub fn out_args<I: IntoIterator<Item = DBusArgInfo>>(mut self, args: I) -> Self {
+        self.out_args = args.into_iter().collect();
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusMethodInfo {
+        let name = self.name.expect("`name` should be set");
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusMethodInfo>()) }
+                as *mut ffi::GDBusMethodInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).name = CString::new(name).unwrap().to_glib_full();
+            (*ptr).in_args = self.in_args.to_glib_full();
+            (*ptr).out_args = self.out_args.to_glib_full();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/dbus_property_info.rs b/gio/src/dbus_property_info.rs
@@ -0,0 +1,64 @@
+use std::ffi::CString;
+use std::mem;
+
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{DBusAnnotationInfo, DBusPropertyInfo, DBusPropertyInfoFlags, ffi};
+
+impl DBusPropertyInfo {
+    pub fn builder<'a>() -> DBusPropertyInfoBuilder<'a> {
+        DBusPropertyInfoBuilder::default()
+    }
+}
+
+#[derive(Default)]
+pub struct DBusPropertyInfoBuilder<'a> {
+    name: Option<&'a str>,
+    signature: Option<&'a str>,
+    flags: Option<DBusPropertyInfoFlags>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusPropertyInfoBuilder<'a> {
+    /// Required
+    pub fn name(mut self, name: &'a str) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    /// Required
+    pub fn signature(mut self, signature: &'a str) -> Self {
+        self.signature = Some(signature);
+        self
+    }
+
+    pub fn flags(mut self, flags: DBusPropertyInfoFlags) -> Self {
+        self.flags = Some(flags);
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusPropertyInfo {
+        let name = self.name.expect("`name` should be set");
+        let signature = self.signature.expect("`name` should be set");
+        let flags = self.flags.unwrap_or(DBusPropertyInfoFlags::NONE);
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusPropertyInfo>()) }
+                as *mut ffi::GDBusPropertyInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).name = CString::new(name).unwrap().to_glib_full();
+            (*ptr).signature = CString::new(signature).unwrap().to_glib_full();
+            (*ptr).flags = flags.into_glib();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/dbus_signal_info.rs b/gio/src/dbus_signal_info.rs
@@ -0,0 +1,54 @@
+use std::ffi::CString;
+use std::mem;
+
+use glib::translate::*;
+use smallvec::SmallVec;
+
+use crate::{DBusAnnotationInfo, DBusArgInfo, DBusSignalInfo, ffi};
+
+impl DBusSignalInfo {
+    pub fn builder<'a>() -> DBusSignalInfoBuilder<'a> {
+        DBusSignalInfoBuilder::default()
+    }
+}
+
+#[derive(Default)]
+pub struct DBusSignalInfoBuilder<'a> {
+    name: Option<&'a str>,
+    args: SmallVec<[DBusArgInfo; 4]>,
+    annotations: SmallVec<[DBusAnnotationInfo; 2]>,
+}
+
+impl<'a> DBusSignalInfoBuilder<'a> {
+    /// Required
+    pub fn name(mut self, name: &'a str) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn args<I: IntoIterator<Item = DBusArgInfo>>(mut self, args: I) -> Self {
+        self.args = args.into_iter().collect();
+        self
+    }
+
+    pub fn annotations<I: IntoIterator<Item = DBusAnnotationInfo>>(
+        mut self,
+        annotations: I,
+    ) -> Self {
+        self.annotations = annotations.into_iter().collect();
+        self
+    }
+
+    pub fn build(self) -> DBusSignalInfo {
+        let name = self.name.expect("`name` should be set");
+        unsafe {
+            let ptr = { glib::ffi::g_malloc0(mem::size_of::<ffi::GDBusSignalInfo>()) }
+                as *mut ffi::GDBusSignalInfo;
+            (*ptr).ref_count = 1;
+            (*ptr).name = CString::new(name).unwrap().to_glib_full();
+            (*ptr).args = self.args.to_glib_full();
+            (*ptr).annotations = self.annotations.to_glib_full();
+            from_glib_full(ptr)
+        }
+    }
+}
diff --git a/gio/src/lib.rs b/gio/src/lib.rs
