Merge pull request #36 from async-rs/minimal

Minimal

Author: yoshuawuyts

README.md

@@ -7,58 +7,6 @@
 A library for working with timers, timeouts, and intervals with the `futures`
 crate.
 
-```toml
-# Cargo.toml
-[dependencies]
-futures-timer = "0.3"
-```
-
-An example of using a `Delay` is:
-
-```rust
-use std::time::Duration;
-
-use futures::prelude::*;
-use futures_timer::Delay;
-
-async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    Delay::new(Duration::from_secs(3))
-        .map(|()| println!("printed after three seconds"))
-        .await?;
-}
-```
-
-And using an `Interval`:
-
-```rust
-use std::time::Duration;
-
-use futures::prelude::*;
-use futures_timer::Interval;
-
-#[runtime::main]
-async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    Interval::new(Duration::from_secs(4))
-        .take(4)
-        .for_each(|()| Ok(println!("printed after three seconds")))
-        .await?;
-}
-```
-
-Or timing out a future
-
-```rust
-use std::time::Duration;
-
-use futures_timer::FutureExt;
-
-async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    // create a future that will take at most 3 seconds to resolve
-    let future = long_running_future()
-      .timeout(Duration::from_secs(3));
-}
-```
-
 # License
 
 This project is licensed under either of

src/delay.rs

@@ -38,22 +38,20 @@ impl Delay {
     /// The default timer will be spun up in a helper thread on first use.
     #[inline]
     pub fn new(dur: Duration) -> Delay {
-        Delay::new_at(Instant::now() + dur)
+        Delay::new_handle(Instant::now() + dur, Default::default())
     }
 
-    /// Creates a new future which will fire at the time specified by `at`.
-    ///
-    /// The returned object will be bound to the default timer for this thread.
-    /// The default timer will be spun up in a helper thread on first use.
+    /// Return the `Instant` when this delay will fire.
     #[inline]
-    pub fn new_at(at: Instant) -> Delay {
-        Delay::new_handle(at, Default::default())
+    pub fn when(&self, timeout: &Delay) -> Instant {
+        timeout.when
     }
 
     /// Creates a new future which will fire at the time specified by `at`.
     ///
     /// The returned instance of `Delay` will be bound to the timer specified by
     /// the `handle` argument.
+    #[doc(hidden)]
     pub fn new_handle(at: Instant, handle: TimerHandle) -> Delay {
         let inner = match handle.inner.upgrade() {
             Some(i) => i,
@@ -89,15 +87,6 @@ impl Delay {
         }
     }
 
-    /// Resets this timeout to an new timeout which will fire at the time
-    /// specified by `dur`.
-    ///
-    /// This is equivalent to calling `reset_at` with `Instant::now() + dur`
-    #[inline]
-    pub fn reset(&mut self, dur: Duration) {
-        self.reset_at(Instant::now() + dur)
-    }
-
     /// Resets this timeout to an new timeout which will fire at the time
     /// specified by `at`.
     ///
@@ -112,9 +101,9 @@ impl Delay {
     /// will be dropped. It is required to call `poll` again after this method
     /// has been called to ensure tha ta task is blocked on this future.
     #[inline]
-    pub fn reset_at(&mut self, at: Instant) {
-        self.when = at;
-        if self._reset(at).is_err() {
+    pub fn reset(&mut self, dur: Duration) {
+        self.when = Instant::now() + dur;
+        if self._reset(self.when).is_err() {
             self.state = None
         }
     }
@@ -148,11 +137,6 @@ impl Delay {
     }
 }
 
-#[inline]
-pub fn fires_at(timeout: &Delay) -> Instant {
-    timeout.when
-}
-
 impl Future for Delay {
     type Output = io::Result<()>;
 

src/ext.rs

@@ -0,0 +1,33 @@
+use std::cmp::Ordering;
+use std::sync::Arc;
+use std::time::Instant;
+
+use crate::{Node, ScheduledTimer};
+
+/// Entries in the timer heap, sorted by the instant they're firing at and then
+/// also containing some payload data.
+pub(crate) struct HeapTimer {
+    pub(crate) at: Instant,
+    pub(crate) gen: usize,
+    pub(crate) node: Arc<Node<ScheduledTimer>>,
+}
+
+impl PartialEq for HeapTimer {
+    fn eq(&self, other: &HeapTimer) -> bool {
+        self.at == other.at
+    }
+}
+
+impl Eq for HeapTimer {}
+
+impl PartialOrd for HeapTimer {
+    fn partial_cmp(&self, other: &HeapTimer) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for HeapTimer {
+    fn cmp(&self, other: &HeapTimer) -> Ordering {
+        self.at.cmp(&other.at)
+    }
+}