Merge pull request #94 from ratijas/refactor

Author: ratijas

qmetaobject/qmetaobject_rust.hpp

@@ -98,9 +98,9 @@ struct RustObject : Base {
 struct RustObjectDescription {
     size_t size;
     const QMetaObject *baseMetaObject;
-    QObject *(*create)(const TraitObject*, const TraitObject*);
-    void (*qmlConstruct)(void*, const TraitObject*, const TraitObject*, void (*extra_destruct)(QObject *));
-    TraitObject (*get_rust_refcell)(QObject*); // Possible optimisation: make this an offset
+    QObject *(*create)(const TraitObject *, const TraitObject *);
+    void (*qmlConstruct)(void *, const TraitObject *, const TraitObject *, void (*extra_destruct)(QObject *));
+    TraitObject (*get_rust_refcell)(QObject *); // Possible optimisation: make this an offset
 };
 
 template<typename T>
@@ -121,15 +121,13 @@ const RustObjectDescription *rustObjectDescription() {
             q->ptr_qobject = *self_ptr;
             q->extra_destruct = extra_destruct;
         },
-        [](QObject *q) { return static_cast<T*>(q)->ptr_qobject; }
-
+        [](QObject *q) { return static_cast<T *>(q)->ptr_qobject; }
     };
     return &desc;
 }
 
 using CreatorFunction = void (*)(void *);
 
-
 namespace QtPrivate {
 // Hack to access QMetaType::registerConverterFunction which is private, but ConverterFunctor
 // is a friend

qmetaobject/src/connections.rs

@@ -20,51 +20,58 @@ use std;
 use std::os::raw::c_void;
 
 cpp! {{
-#include <QtCore/QObject>
-#include "qmetaobject_rust.hpp"
+    #include <QtCore/QObject>
+    #include "qmetaobject_rust.hpp"
 
-// Access private function of QObject. Pretend to define QObjectPrivate.
-// This rely on QObjectPrivate being a friend of QObject.
-class QObjectPrivate {
+    // Access private function of QObject. Pretend to define QObjectPrivate.
+    // This rely on QObjectPrivate being a friend of QObject.
+    class QObjectPrivate {
     public:
-    static QMetaObject::Connection rust_connectImpl(const QObject *sender, void **signal,
-            const QObject *receiver, void **slotPtr,
-            QtPrivate::QSlotObjectBase *slot, Qt::ConnectionType type,
-            const int *types, const QMetaObject *senderMetaObject) {
-        return QObject::connectImpl(sender, signal, receiver, slotPtr, slot, type, types, senderMetaObject);
-    }
-};
-
-class RustSlotOject : public QtPrivate::QSlotObjectBase
-{
-    TraitObject slot;
-    static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret) {
-        switch (which) {
-        case Destroy:
-            delete static_cast<RustSlotOject*>(this_);
-            break;
-        case Call: {
-            auto slot = static_cast<RustSlotOject*>(this_)->slot;
-            rust!(RustSlotObject_call[slot : *mut dyn FnMut(*const *const c_void) as "TraitObject",
-                                      a : *const *const c_void as "void**"] {
-                   unsafe { (*slot)(a); }
-            });
-            break;
+        static QMetaObject::Connection rust_connectImpl(
+            const QObject *sender,
+            void **signal,
+            const QObject *receiver,
+            void **slotPtr,
+            QtPrivate::QSlotObjectBase *slot,
+            Qt::ConnectionType type,
+            const int *types,
+            const QMetaObject *senderMetaObject
+        ) {
+            return QObject::connectImpl(sender, signal, receiver, slotPtr, slot,
+                                        type, types, senderMetaObject);
         }
-        case Compare: // not implemented
-        case NumOperations:
-            Q_UNUSED(ret); Q_UNUSED(r);
+    };
+
+    class RustSlotOject : public QtPrivate::QSlotObjectBase
+    {
+        TraitObject slot;
+        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret) {
+            switch (which) {
+            case Destroy:
+                delete static_cast<RustSlotOject*>(this_);
+                break;
+            case Call: {
+                auto slot = static_cast<RustSlotOject*>(this_)->slot;
+                rust!(RustSlotObject_call[slot : *mut dyn FnMut(*const *const c_void) as "TraitObject",
+                                          a : *const *const c_void as "void**"] {
+                       unsafe { (*slot)(a); }
+                });
+                break;
+            }
+            case Compare: // not implemented
+            case NumOperations:
+                Q_UNUSED(ret); Q_UNUSED(r);
+            }
         }
-    }
-public:
-    explicit RustSlotOject(TraitObject slot) : QSlotObjectBase(&impl), slot(slot) {}
-    ~RustSlotOject() {
-        rust!(RustSlotOject_destruct [slot : *mut dyn FnMut(*const *const c_void) as "TraitObject"] {
-            let _ = unsafe { Box::from_raw(slot) };
-        });
-    }
-    Q_DISABLE_COPY(RustSlotOject);
-};
+    public:
+        explicit RustSlotOject(TraitObject slot) : QSlotObjectBase(&impl), slot(slot) {}
+        ~RustSlotOject() {
+            rust!(RustSlotOject_destruct [slot : *mut dyn FnMut(*const *const c_void) as "TraitObject"] {
+                let _ = unsafe { Box::from_raw(slot) };
+            });
+        }
+        Q_DISABLE_COPY(RustSlotOject);
+    };
 
 
 }}
@@ -75,28 +82,31 @@ cpp_class!(
     /// Can be used to detect if a connection is valid, and to disconnect a connection.
     pub unsafe struct ConnectionHandle as "QMetaObject::Connection"
 );
+
 impl ConnectionHandle {
     /// Disconnect this connection.
     ///
     /// After this function is called, all ConnectionHandle referring to this connection will be invalided.
     /// Calling disconnect on an invalided connection does nothing.
     pub fn disconnect(&mut self) {
-        unsafe { cpp!([self as "const QMetaObject::Connection*"] { QObject::disconnect(*self);  }) }
+        cpp!(unsafe [self as "const QMetaObject::Connection *"] {
+            QObject::disconnect(*self);
+        })
     }
 
     /// Returns true if the connection is valid.
     pub fn is_valid(&self) -> bool {
-        unsafe {
-            cpp!([self as "const QMetaObject::Connection*"] -> bool as "bool" { return *self; })
-        }
+        cpp!(unsafe [self as "const QMetaObject::Connection *"] -> bool as "bool" {
+            return *self; // implicit conversion
+        })
     }
 }
 
 cpp_class!(
     /// Internal class that can be used to construct C++ signal.  Should only be used as an implementation
-    /// details when writing bindings to Qt signals to construct a `CppSignal<...>`
+    /// details when writing bindings to Qt signals to construct a `CppSignal<...>`.
     ///
-    /// It has the same size as a `void(QObject::*)()` and can be constructed from signals.
+    /// It has the same size as a `void (QObject::*)()` and can be constructed from signals.
     pub unsafe struct SignalCppRepresentation as "SignalCppRepresentation"
 );
 
@@ -108,16 +118,19 @@ pub struct CppSignal<Args> {
     inner: SignalCppRepresentation,
     phantom: std::marker::PhantomData<Args>,
 }
+
 impl<Args> CppSignal<Args> {
     pub unsafe fn new(inner: SignalCppRepresentation) -> Self {
         CppSignal { inner, phantom: Default::default() }
     }
 }
+
 impl<Args> Clone for CppSignal<Args> {
     fn clone(&self) -> Self {
         *self
     }
 }
+
 impl<Args> Copy for CppSignal<Args> {}
 
 /// Types of signals constructed with the qt_signal! macro.
@@ -129,11 +142,16 @@ pub struct RustSignal<Args> {
     phantom: std::marker::PhantomData<Args>,
     _u: bool, // Actually put a field so it has a size;
 }
+
 impl<Args> Default for RustSignal<Args> {
     fn default() -> Self {
-        RustSignal { phantom: Default::default(), _u: false }
+        RustSignal {
+            phantom: Default::default(),
+            _u: Default::default()
+        }
     }
 }
+
 impl<Args> RustSignal<Args> {
     /// return a CppSignal corresponding to this signal.
     ///
@@ -225,11 +243,20 @@ pub unsafe fn connect<Args, F: Slot<Args>>(
     let apply_closure = move |a: *const *const c_void| slot.apply(a);
     let b: Box<dyn FnMut(*const *const c_void)> = Box::new(apply_closure);
     let slot_raw = Box::into_raw(b);
-    /*unsafe*/
-    {
-        cpp!([sender as "const QObject*", mut cpp_signal as "SignalCppRepresentation", slot_raw as "TraitObject"] -> ConnectionHandle as "QMetaObject::Connection" {
-            return QObjectPrivate::rust_connectImpl(sender, reinterpret_cast<void **>(&cpp_signal), sender, nullptr,
-                        new RustSlotOject(slot_raw), Qt::DirectConnection, nullptr, sender->metaObject());
-        })
-    }
+    cpp!(unsafe [
+        sender as "const QObject *",
+        mut cpp_signal as "SignalCppRepresentation",
+        slot_raw as "TraitObject"
+    ] -> ConnectionHandle as "QMetaObject::Connection" {
+        return QObjectPrivate::rust_connectImpl(
+            sender,
+            reinterpret_cast<void **>(&cpp_signal),
+            sender,
+            nullptr,
+            new RustSlotOject(slot_raw),
+            Qt::DirectConnection,
+            nullptr,
+            sender->metaObject()
+        );
+    })
 }

qmetaobject/src/future.rs

@@ -101,8 +101,8 @@ cpp! {{
 /// Note that this function returns immediately. A Qt event loop need to be running
 /// on the current thread so the future can be executed. (It is Ok if the Qt event
 /// loop hasn't started yet when this function is called)
-pub fn execute_async(f: impl Future<Output = ()> + 'static) {
-    let f = Box::into_raw(Box::new(f)) as *mut dyn Future<Output = ()>;
+pub fn execute_async(f: impl Future<Output=()> + 'static) {
+    let f: *mut dyn Future<Output=()> = Box::into_raw(Box::new(f));
     unsafe {
         let waker = cpp!([f as "TraitObject"] -> *const() as "Waker*" {
             return new Waker(f);
@@ -112,7 +112,7 @@ pub fn execute_async(f: impl Future<Output = ()> + 'static) {
 }
 
 // SAFETY: caller must ensure that given future hasn't returned Poll::Ready earlier.
-unsafe fn poll_with_qt_waker(waker: *const (), future: Pin<&mut dyn Future<Output = ()>>) -> bool {
+unsafe fn poll_with_qt_waker(waker: *const (), future: Pin<&mut dyn Future<Output=()>>) -> bool {
     cpp!([waker as "Waker*"] { waker->refs++; });
     let waker = std::task::RawWaker::new(waker, &QT_WAKER_VTABLE);
     let waker = std::task::Waker::from_raw(waker);
@@ -133,22 +133,26 @@ unsafe fn poll_with_qt_waker(waker: *const (), future: Pin<&mut dyn Future<Outpu
 pub unsafe fn wait_on_signal<Args: SignalArgArrayToTuple>(
     sender: *const c_void,
     signal: crate::connections::CppSignal<Args>,
-) -> impl Future<Output = <Args as SignalArgArrayToTuple>::Tuple> {
+) -> impl Future<Output=<Args as SignalArgArrayToTuple>::Tuple> {
     enum ConnectionFutureState<Args: SignalArgArrayToTuple> {
         Init { sender: *const c_void, signal: crate::connections::CppSignal<Args> },
         Started { handle: crate::connections::ConnectionHandle, waker: std::task::Waker },
         Finished { result: <Args as SignalArgArrayToTuple>::Tuple },
         Invalid,
     }
+
     impl<Args: SignalArgArrayToTuple> std::marker::Unpin for ConnectionFutureState<Args> {}
+
     struct ConnectionFuture<Args: SignalArgArrayToTuple>(ConnectionFutureState<Args>);
+
     impl<Args: SignalArgArrayToTuple> Drop for ConnectionFuture<Args> {
         fn drop(&mut self) {
             if let ConnectionFutureState::Started { ref mut handle, .. } = &mut self.0 {
                 handle.disconnect();
             }
         }
     }
+
     impl<Args: SignalArgArrayToTuple> Future for ConnectionFuture<Args> {
         type Output = <Args as SignalArgArrayToTuple>::Tuple;
         fn poll(