[PATCH 07/14] rust: define wrappers for methods of the QOM Object class

[Paolo Bonzini <pbonzini@redhat.com>]

Provide a trait that can be used to invoke methods of the QOM object
class.  The trait extends Deref and has a blanket implementation for any
type that dereferences to IsA<Object>.  This way, it can be used on any
struct that dereferences to Object or a subclass.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
 qemu/src/lib.rs        |  2 +
 qemu/src/qom/object.rs | 92 ++++++++++++++++++++++++++++++++++++++++++
 qemu/src/qom/refs.rs   |  8 ++++
 3 files changed, 102 insertions(+)

diff --git a/qemu/src/lib.rs b/qemu/src/lib.rs
index 0d91623..a6e7b17 100644
--- a/qemu/src/lib.rs
+++ b/qemu/src/lib.rs
@@ -5,6 +5,8 @@ pub mod bindings;
 pub use bindings::Object;
 
 pub mod qom;
+pub use qom::object::ObjectClassMethods;
+pub use qom::object::ObjectMethods;
 pub use qom::object::ObjectType;
 pub use qom::refs::ObjectCast;
 pub use qom::refs::Owned;
diff --git a/qemu/src/qom/object.rs b/qemu/src/qom/object.rs
index bd6b957..4e84e29 100644
--- a/qemu/src/qom/object.rs
+++ b/qemu/src/qom/object.rs
@@ -2,12 +2,26 @@
 //!
 //! @author Paolo Bonzini
 
+use std::borrow::Cow;
 use std::ffi::CStr;
+use std::fmt;
+use std::ops::Deref;
 
+use crate::bindings::object_get_typename;
+use crate::bindings::object_property_add_child;
+use crate::bindings::object_new;
+use crate::bindings::object_unparent;
 use crate::bindings::Object;
 
 use crate::qom_isa;
 
+use crate::qom::refs::IsA;
+use crate::qom::refs::ObjectCast;
+use crate::qom::refs::Owned;
+
+use crate::util::foreign::CloneToForeign;
+use crate::util::foreign::FromForeign;
+
 /// Trait exposed by all structs corresponding to QOM objects.
 /// Defines "class methods" for the class.  Usually these can be
 /// implemented on the class itself; here, using a trait allows
@@ -31,4 +45,82 @@ unsafe impl ObjectType for Object {
     const TYPE: &'static CStr = c"object";
 }
 
+// ------------------------------
+// Object class
+
 qom_isa!(Object);
+
+/// Trait for class methods exposed by the Object class.  The methods can be
+/// called on all objects that have the trait `IsA<Object>`.
+///
+/// The trait should only be used through the blanket implementation,
+/// which guarantees safety via `IsA`
+
+pub trait ObjectClassMethods: IsA<Object> {
+    /// Return a new reference counted instance of this class
+    fn new() -> Owned<Self> {
+        // SAFETY: the object created by object_new is allocated on
+        // the heap and has a reference count of 1
+        unsafe {
+            let obj = &*object_new(Self::TYPE.as_ptr());
+            Owned::from_raw(obj.unsafe_cast::<Self>())
+        }
+    }
+}
+
+/// Trait for methods exposed by the Object class.  The methods can be
+/// called on all objects that have the trait `IsA<Object>`.
+///
+/// The trait should only be used through the blanket implementation,
+/// which guarantees safety via `IsA`
+pub trait ObjectMethods: Deref
+where
+    Self::Target: IsA<Object>,
+{
+    /// Return the name of the type of `self`
+    fn typename(&self) -> Cow<'_, str> {
+        let obj = self.upcast::<Object>();
+        // SAFETY: safety of this is the requirement for implementing IsA
+        // The result of the C API has static lifetime
+        unsafe {
+            Cow::cloned_from_foreign(object_get_typename(obj.as_mut_ptr()))
+        }
+    }
+
+    /// Add an object as a child of the receiver.
+    fn property_add_child<T: ObjectType>(&self, name: &str, child: Owned<T>)
+    {
+        let obj = self.upcast::<Object>();
+        let name = name.clone_to_foreign();
+        unsafe {
+            // SAFETY: casting to object is always safe even if `child`'s
+            // target type is an interface type
+            let child = child.unsafe_cast::<Object>();
+            object_property_add_child(obj.as_mut_ptr(),
+                                      name.as_ptr(),
+                                      child.as_mut_ptr());
+
+            // object_property_add_child() added a reference of its own;
+            // dropping the one in `child` is the common case.
+        }
+    }
+
+    /// Remove the object from the QOM tree
+    fn unparent(&self) {
+        let obj = self.upcast::<Object>();
+        // SAFETY: safety of this is the requirement for implementing IsA
+        unsafe {
+            object_unparent(obj.as_mut_ptr());
+        }
+    }
+
+    /// Convenience function for implementing the Debug trait
+    fn debug_fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple(&self.typename())
+            .field(&(self as *const Self))
+            .finish()
+    }
+}
+
+impl<R> ObjectClassMethods for R where R: IsA<Object> {}
+impl<R: Deref> ObjectMethods for R where R::Target: IsA<Object> {}
diff --git a/qemu/src/qom/refs.rs b/qemu/src/qom/refs.rs
index a319bde..431ef0a 100644
--- a/qemu/src/qom/refs.rs
+++ b/qemu/src/qom/refs.rs
@@ -6,9 +6,11 @@ use crate::bindings::object_dynamic_cast;
 use crate::bindings::Object;
 use crate::bindings::{object_ref, object_unref};
 
+use crate::qom::object::ObjectMethods;
 use crate::qom::object::ObjectType;
 
 use std::borrow::Borrow;
+use std::fmt::{self, Debug};
 use std::mem::ManuallyDrop;
 use std::ops::Deref;
 use std::ptr::NonNull;
@@ -272,3 +274,9 @@ impl<T: ObjectType> Drop for Owned<T> {
         }
     }
 }
+
+impl<T: IsA<Object>> Debug for Owned<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().debug_fmt(f)
+    }
+}
-- 
2.45.2