use core::mem::{self, PinMut};
use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState};
use core::ptr::{self, NonNull, Unique};
-use core::task::{Context, Poll, UnsafePoll, TaskObj};
+use core::task::{Context, Poll, UnsafeTask, TaskObj};
use core::convert::From;
use raw_vec::RawVec;
}
#[unstable(feature = "futures_api", issue = "50547")]
-unsafe impl<F: Future<Output = ()> + Send + 'static> UnsafePoll for PinBox<F> {
+unsafe impl<F: Future<Output = ()> + Send + 'static> UnsafeTask for PinBox<F> {
fn into_raw(self) -> *mut () {
PinBox::into_raw(self) as *mut ()
}
#[unstable(feature = "futures_api", issue = "50547")]
impl<F: Future<Output = ()> + Send + 'static> From<PinBox<F>> for TaskObj {
fn from(boxed: PinBox<F>) -> Self {
- TaskObj::from_poll_task(boxed)
+ TaskObj::new(boxed)
}
}
#[unstable(feature = "futures_api", issue = "50547")]
impl<F: Future<Output = ()> + Send + 'static> From<Box<F>> for TaskObj {
fn from(boxed: Box<F>) -> Self {
- TaskObj::from_poll_task(PinBox::from(boxed))
+ TaskObj::new(PinBox::from(boxed))
}
}
use fmt;
use ptr::NonNull;
+use future::Future;
+use mem::PinMut;
/// Indicates whether a value is available or if the current task has been
/// scheduled to receive a wakeup instead.
/// `Box<Future<Output = ()> + Send>`.
pub struct TaskObj {
ptr: *mut (),
- poll: unsafe fn(*mut (), &mut Context) -> Poll<()>,
- drop: unsafe fn(*mut ()),
+ poll_fn: unsafe fn(*mut (), &mut Context) -> Poll<()>,
+ drop_fn: unsafe fn(*mut ()),
}
impl fmt::Debug for TaskObj {
}
unsafe impl Send for TaskObj {}
-unsafe impl Sync for TaskObj {}
/// A custom implementation of a task trait object for `TaskObj`, providing
/// a hand-rolled vtable.
/// The implementor must guarantee that it is safe to call `poll` repeatedly (in
/// a non-concurrent fashion) with the result of `into_raw` until `drop` is
/// called.
-pub unsafe trait UnsafePoll: Send + 'static {
+pub unsafe trait UnsafeTask: Send + 'static {
/// Convert a owned instance into a (conceptually owned) void pointer.
fn into_raw(self) -> *mut ();
impl TaskObj {
/// Create a `TaskObj` from a custom trait object representation.
#[inline]
- pub fn from_poll_task<T: UnsafePoll>(t: T) -> TaskObj {
+ pub fn new<T: UnsafeTask>(t: T) -> TaskObj {
TaskObj {
ptr: t.into_raw(),
- poll: T::poll,
- drop: T::drop,
+ poll_fn: T::poll,
+ drop_fn: T::drop,
}
}
+}
+
+impl Future for TaskObj {
+ type Output = ();
- /// Poll the task.
- ///
- /// The semantics here are identical to that for futures, but unlike
- /// futures only an `&mut self` reference is needed here.
#[inline]
- pub fn poll_task(&mut self, cx: &mut Context) -> Poll<()> {
+ fn poll(self: PinMut<Self>, cx: &mut Context) -> Poll<()> {
unsafe {
- (self.poll)(self.ptr, cx)
+ (self.poll_fn)(self.ptr, cx)
}
}
}
impl Drop for TaskObj {
fn drop(&mut self) {
unsafe {
- (self.drop)(self.ptr)
+ (self.drop_fn)(self.ptr)
}
}
}