tokio_timer/
deadline.rs

1#![allow(deprecated)]
2
3use Delay;
4
5use futures::{Async, Future, Poll};
6
7use std::error;
8use std::fmt;
9use std::time::Instant;
10
11#[deprecated(since = "0.2.6", note = "use Timeout instead")]
12#[doc(hidden)]
13#[derive(Debug)]
14pub struct Deadline<T> {
15    future: T,
16    delay: Delay,
17}
18
19#[deprecated(since = "0.2.6", note = "use Timeout instead")]
20#[doc(hidden)]
21#[derive(Debug)]
22pub struct DeadlineError<T>(Kind<T>);
23
24/// Deadline error variants
25#[derive(Debug)]
26enum Kind<T> {
27    /// Inner future returned an error
28    Inner(T),
29
30    /// The deadline elapsed.
31    Elapsed,
32
33    /// Timer returned an error.
34    Timer(::Error),
35}
36
37impl<T> Deadline<T> {
38    /// Create a new `Deadline` that completes when `future` completes or when
39    /// `deadline` is reached.
40    pub fn new(future: T, deadline: Instant) -> Deadline<T> {
41        Deadline::new_with_delay(future, Delay::new(deadline))
42    }
43
44    pub(crate) fn new_with_delay(future: T, delay: Delay) -> Deadline<T> {
45        Deadline { future, delay }
46    }
47
48    /// Gets a reference to the underlying future in this deadline.
49    pub fn get_ref(&self) -> &T {
50        &self.future
51    }
52
53    /// Gets a mutable reference to the underlying future in this deadline.
54    pub fn get_mut(&mut self) -> &mut T {
55        &mut self.future
56    }
57
58    /// Consumes this deadline, returning the underlying future.
59    pub fn into_inner(self) -> T {
60        self.future
61    }
62}
63
64impl<T> Future for Deadline<T>
65where
66    T: Future,
67{
68    type Item = T::Item;
69    type Error = DeadlineError<T::Error>;
70
71    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
72        // First, try polling the future
73        match self.future.poll() {
74            Ok(Async::Ready(v)) => return Ok(Async::Ready(v)),
75            Ok(Async::NotReady) => {}
76            Err(e) => return Err(DeadlineError::inner(e)),
77        }
78
79        // Now check the timer
80        match self.delay.poll() {
81            Ok(Async::NotReady) => Ok(Async::NotReady),
82            Ok(Async::Ready(_)) => Err(DeadlineError::elapsed()),
83            Err(e) => Err(DeadlineError::timer(e)),
84        }
85    }
86}
87
88// ===== impl DeadlineError =====
89
90impl<T> DeadlineError<T> {
91    /// Create a new `DeadlineError` representing the inner future completing
92    /// with `Err`.
93    pub fn inner(err: T) -> DeadlineError<T> {
94        DeadlineError(Kind::Inner(err))
95    }
96
97    /// Returns `true` if the error was caused by the inner future completing
98    /// with `Err`.
99    pub fn is_inner(&self) -> bool {
100        match self.0 {
101            Kind::Inner(_) => true,
102            _ => false,
103        }
104    }
105
106    /// Consumes `self`, returning the inner future error.
107    pub fn into_inner(self) -> Option<T> {
108        match self.0 {
109            Kind::Inner(err) => Some(err),
110            _ => None,
111        }
112    }
113
114    /// Create a new `DeadlineError` representing the inner future not
115    /// completing before the deadline is reached.
116    pub fn elapsed() -> DeadlineError<T> {
117        DeadlineError(Kind::Elapsed)
118    }
119
120    /// Returns `true` if the error was caused by the inner future not
121    /// completing before the deadline is reached.
122    pub fn is_elapsed(&self) -> bool {
123        match self.0 {
124            Kind::Elapsed => true,
125            _ => false,
126        }
127    }
128
129    /// Creates a new `DeadlineError` representing an error encountered by the
130    /// timer implementation
131    pub fn timer(err: ::Error) -> DeadlineError<T> {
132        DeadlineError(Kind::Timer(err))
133    }
134
135    /// Returns `true` if the error was caused by the timer.
136    pub fn is_timer(&self) -> bool {
137        match self.0 {
138            Kind::Timer(_) => true,
139            _ => false,
140        }
141    }
142
143    /// Consumes `self`, returning the error raised by the timer implementation.
144    pub fn into_timer(self) -> Option<::Error> {
145        match self.0 {
146            Kind::Timer(err) => Some(err),
147            _ => None,
148        }
149    }
150}
151
152impl<T: error::Error> error::Error for DeadlineError<T> {
153    fn description(&self) -> &str {
154        use self::Kind::*;
155
156        match self.0 {
157            Inner(ref e) => e.description(),
158            Elapsed => "deadline has elapsed",
159            Timer(ref e) => e.description(),
160        }
161    }
162}
163
164impl<T: fmt::Display> fmt::Display for DeadlineError<T> {
165    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
166        use self::Kind::*;
167
168        match self.0 {
169            Inner(ref e) => e.fmt(fmt),
170            Elapsed => "deadline has elapsed".fmt(fmt),
171            Timer(ref e) => e.fmt(fmt),
172        }
173    }
174}
tokio_timer/deadline.rs

tokio_timer/
deadline.rs
