@@ -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;
@@ -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> {}
@@ -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)
+ }
+}
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(+)