Cleanup

Author: Boddlnagg

examples/async.rs

@@ -47,7 +47,7 @@ async fn run() {
     // println!("status: {:?}", status);
 
     let mut interval = Interval::new(Duration::from_millis(100));
-    let mut async_op = DeviceInformation::find_all_async().unwrap().fuse(); // TODO: get rid of fuse()
+    let mut async_op = DeviceInformation::find_all_async().unwrap().fuse();
 
     let work = async {
         let mut result = None;

src/rt/async_util.rs

@@ -1,5 +1,6 @@
 use futures::future::Future;
 use std::pin::Pin;
+use std::ops::Deref;
 use std::task::{Context, Poll};
 use std::sync::{Arc, Mutex, Condvar};
 
@@ -78,8 +79,7 @@ macro_rules! impl_blocking_wait {
     }
 }
 
-impl RtAsyncAction for IAsyncAction
-{
+impl RtAsyncAction for IAsyncAction {
     impl_blocking_wait!{ AsyncActionCompletedHandler }
 }
 
@@ -95,39 +95,6 @@ impl<T: RtType + 'static> RtAsyncAction for IAsyncOperation<T>
     impl_blocking_wait!{ AsyncOperationCompletedHandler }
 }
 
-impl<'a, T: RtType + 'static> Future for crate::ComPtr<IAsyncOperation<T>>
-    where AsyncOperationCompletedHandler<T>: ComIid
-{
-    type Output = Result<<T as RtType>::Out>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        use std::ops::Deref;
-
-        let info = crate::comptr::query_interface::<_, IAsyncInfo>(self.deref().deref()).expect("query_interface failed");
-        let status = info.get_status().expect("get_status failed");
-        match status {
-            crate::langcompat::ASYNC_STATUS_COMPLETED => {
-                Poll::Ready(self.get_results())
-            },
-            crate::langcompat::ASYNC_STATUS_STARTED => {
-                if self.get_completed().expect("get_completed failed").is_some() {
-                    return Poll::Pending;
-                }
-                let waker = cx.waker().clone();
-
-                let handler = AsyncOperationCompletedHandler::new(move |_op, _status| {
-                    waker.wake_by_ref();
-                    Ok(())
-                });
-
-                self.set_completed(&handler).expect("set_completed failed");
-                Poll::Pending
-            }
-            _ => unimplemented!()
-        }
-    }
-}
-
 impl<T: RtType + 'static> RtAsyncOperation for IAsyncOperation<T>
     where AsyncOperationCompletedHandler<T>: ComIid
 {
@@ -156,20 +123,67 @@ impl<T: RtType + 'static, P: RtType + 'static> RtAsyncOperation for IAsyncOperat
     }
 }
 
-// Make await syntax work with `ComPtr` directly
-/*impl<'a, T: RtType + 'static> Future for &'a crate::ComPtr<T>
-    where &'a T: Future,
-          //&'a crate::rt::gen::windows::foundation::IAsyncOperation<T> : futures::Future,
-          //&'a crate::ComPtr<T>: Unpin
-{
-    type Output = <&'a T as Future>::Output;
-    #[inline] fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        use std::ops::DerefMut;
-        //unsafe { self.map_unchecked(|ptr| ptr.deref().deref()) }.poll(self, cx)
-        let s: Pin<&mut &_>/*: Pin<&mut &IAsyncOperation<_>>*/ = unsafe { self.map_unchecked_mut(|mut ptr| &mut&**ptr) };
-        //let s: Pin<&mut &'a IAsyncOperation<T>> = Pin::new(&mut **self.get_mut().deref_mut().deref_mut());
-        //let p: crate::ComPtr<T>
-        s.poll(cx)
-        //unimplemented!()
+
+macro_rules! impl_poll {
+    ($handler:ident => $retexpr:tt) => {
+        fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+            let info = crate::comptr::query_interface::<_, IAsyncInfo>(self.deref().deref()).expect("query_interface failed");
+            let status = info.get_status().expect("get_status failed");
+            match status {
+                crate::windows::foundation::AsyncStatus::Completed => {
+                    Poll::Ready($retexpr(self))
+                },
+                crate::windows::foundation::AsyncStatus::Started => {
+                    // Calling poll multiple times must work correctly, so we have to check that we didn't already install the Completed handler
+                    if self.get_completed().expect("get_completed failed").is_some() {
+                        // TODO: We might have to check that the installed handler is actually
+                        //       the one with the waker (because the user could have installed one independently).
+                        //       Or we document that the user is not allowed to do that.
+                        return Poll::Pending;
+                    }
+                    let waker = cx.waker().clone();
+
+                    let handler = $handler::new(move |_op, _status| {
+                        waker.wake_by_ref();
+                        Ok(())
+                    });
+
+                    self.set_completed(&handler).expect("set_completed failed");
+                    Poll::Pending
+                }
+                _ => unimplemented!() // FIXME
+            }
+        }
     }
-}*/
+}
+
+
+impl Future for crate::ComPtr<IAsyncAction> {
+    type Output = ();
+
+    impl_poll!{ AsyncActionCompletedHandler => { |_: Pin<&mut Self>| () } }
+}
+
+impl<P: RtType + 'static> Future for crate::ComPtr<IAsyncActionWithProgress<P>>
+    where AsyncActionWithProgressCompletedHandler<P>: ComIid
+{
+    type Output = ();
+
+    impl_poll!{ AsyncActionWithProgressCompletedHandler => { |_: Pin<&mut Self>| () } }
+}
+
+impl<T: RtType + 'static> Future for crate::ComPtr<IAsyncOperation<T>>
+    where AsyncOperationCompletedHandler<T>: ComIid
+{
+    type Output = Result<<T as RtType>::Out>;
+
+    impl_poll!{ AsyncOperationCompletedHandler => { |s: Pin<&mut Self>| s.get_results() } }
+}
+
+impl<T: RtType + 'static, P: RtType + 'static> Future for crate::ComPtr<IAsyncOperationWithProgress<T, P>>
+    where AsyncOperationWithProgressCompletedHandler<T, P>: ComIid
+{
+    type Output = Result<<T as RtType>::Out>;
+
+    impl_poll!{ AsyncOperationWithProgressCompletedHandler => { |s: Pin<&mut Self>| s.get_results() } }
+}