      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105

    //! Futures.

    use core::ops::DerefMut;
    use core::pin::Pin;
    use core::task::{Context, Poll};

    #[doc(no_inline)]
    pub use core::future::Future;

    /// An owned dynamically typed [`Future`] for use in cases where you can't
    /// statically type your result or need to add some indirection.
    #[cfg(feature = "alloc")]
    pub type BoxFuture<'a, T> = Pin<alloc::boxed::Box<dyn Future<Output = T> + Send + 'a>>;

    /// `BoxFuture`, but without the `Send` requirement.
    #[cfg(feature = "alloc")]
    pub type LocalBoxFuture<'a, T> = Pin<alloc::boxed::Box<dyn Future<Output = T> + 'a>>;

    /// A future which tracks whether or not the underlying future
    /// should no longer be polled.
    ///
    /// `is_terminated` will return `true` if a future should no longer be polled.
    /// Usually, this state occurs after `poll` (or `try_poll`) returned
    /// `Poll::Ready`. However, `is_terminated` may also return `true` if a future
    /// has become inactive and can no longer make progress and should be ignored
    /// or dropped rather than being `poll`ed again.
    pub trait FusedFuture: Future {
        /// Returns `true` if the underlying future should no longer be polled.
        fn is_terminated(&self) -> bool;
    }

    impl<F: FusedFuture + ?Sized + Unpin> FusedFuture for &mut F {
        fn is_terminated(&self) -> bool {
            <F as FusedFuture>::is_terminated(&**self)
        }
    }

    impl<P> FusedFuture for Pin<P>
    where
        P: DerefMut + Unpin,
        P::Target: FusedFuture,
    {
        fn is_terminated(&self) -> bool {
            <P::Target as FusedFuture>::is_terminated(&**self)
        }
    }

    mod private_try_future {
        use super::Future;

        pub trait Sealed {}

        impl<F, T, E> Sealed for F where F: ?Sized + Future<Output = Result<T, E>> {}
    }

    /// A convenience for futures that return `Result` values that includes
    /// a variety of adapters tailored to such futures.
    pub trait TryFuture: Future + private_try_future::Sealed {
        /// The type of successful values yielded by this future
        type Ok;

        /// The type of failures yielded by this future
        type Error;

        /// Poll this `TryFuture` as if it were a `Future`.
        ///
        /// This method is a stopgap for a compiler limitation that prevents us from
        /// directly inheriting from the `Future` trait; in the future it won't be
        /// needed.
        fn try_poll(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
        ) -> Poll<Result<Self::Ok, Self::Error>>;
    }

    impl<F, T, E> TryFuture for F
        where F: ?Sized + Future<Output = Result<T, E>>
    {
        type Ok = T;
        type Error = E;

        #[inline]
        fn try_poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
            self.poll(cx)
        }
    }

    #[cfg(feature = "alloc")]
    mod if_alloc {
        use alloc::boxed::Box;
        use super::*;

        impl<F: FusedFuture + ?Sized + Unpin> FusedFuture for Box<F> {
            fn is_terminated(&self) -> bool {
                <F as FusedFuture>::is_terminated(&**self)
            }
        }

        #[cfg(feature = "std")]
        impl<F: FusedFuture> FusedFuture for std::panic::AssertUnwindSafe<F> {
            fn is_terminated(&self) -> bool {
                <F as FusedFuture>::is_terminated(&**self)
            }
        }
    }