[−][src]Struct goods::Handle
Handle for an asset of type A that eventually
resolves to the asset instance or an error.
Handle implements Future which helps with compound asset loading.
Unlike many Futures Handle semantically is just a pointer
to the place where asset isntance will be.
So polling Handle isn't necessary for asset to be loaded.
When asset is finally loaded any task that polled Handle will be notified.
Implementations
impl<A> Handle<A> where
A: Asset, [src]
A: Asset,
pub fn query(&self) -> Poll<&Result<A, Error<A>>>[src]
Queries for the asset state.
Returns Poll::Ready(Ok(asset)) if asset was successfully loaded.
Returns Poll::Ready(Err(error)) if error occured.
Otherwise returns Poll::Pending as asset wasn't yet loaded.
pub fn is_pending(&self) -> bool[src]
Checks if asset referenced by this handle is not loaded yet.
pub fn is_ready(&self) -> bool[src]
Checks if loading of the asset referenced by this handle is complete.
pub fn is_err(&self) -> bool[src]
Checks if loading of the asset referenced by this handle failed.
pub fn is_ok(&self) -> bool[src]
Checks if loading of the asset referenced by this handle succeeded.
pub fn get(&self) -> Option<&A>[src]
Returns asset instance if it's loaded.
Trait Implementations
impl<A: Clone + Asset> Clone for Handle<A>[src]
impl<A> Eq for Handle<A> where
A: Asset, [src]
A: Asset,
impl<A> Future for Handle<A> where
A: Asset, [src]
A: Asset,
type Output = Result<A, Error<A>>
The type of value produced on completion.
fn poll(
self: Pin<&mut Self>,
context: &mut Context
) -> Poll<Result<A, Error<A>>>[src]
self: Pin<&mut Self>,
context: &mut Context
) -> Poll<Result<A, Error<A>>>
impl<A> Hash for Handle<A> where
A: Asset, [src]
A: Asset,
fn hash<H>(&self, state: &mut H) where
H: Hasher, [src]
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]
H: Hasher,
impl<A> PartialEq<Handle<A>> for Handle<A> where
A: Asset, [src]
A: Asset,
Auto Trait Implementations
impl<A> !RefUnwindSafe for Handle<A>
impl<A> !Send for Handle<A>
impl<A> !Sync for Handle<A>
impl<A> Unpin for Handle<A>
impl<A> !UnwindSafe for Handle<A>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
fn equivalent(&self, key: &K) -> bool[src]
impl<T> From<T> for T[src]
impl<T> FutureExt for T where
T: Future + ?Sized, [src]
T: Future + ?Sized,
fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U, [src]
F: FnOnce(Self::Output) -> U,
fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>, [src]
Self::Output: Into<U>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future, [src]
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>, [src]
B: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>, [src]
A: Future<Output = Self::Output>,
fn into_stream(self) -> IntoStream<Self>[src]
fn flatten(self) -> Flatten<Self> where
Self::Output: Future, [src]
Self::Output: Future,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream, [src]
Self::Output: Stream,
fn fuse(self) -> Fuse<Self>[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output), [src]
F: FnOnce(&Self::Output),
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe, [src]
Self: UnwindSafe,
fn shared(self) -> Shared<Self> where
Self::Output: Clone, [src]
Self::Output: Clone,
fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send>> where
Self: Send + 'a, [src]
Self: Send + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> where
Self: 'a, [src]
Self: 'a,
fn unit_error(self) -> UnitError<Self>[src]
fn never_error(self) -> NeverError<Self>[src]
fn poll_unpin(&mut self, cx: &mut Context) -> Poll<Self::Output> where
Self: Unpin, [src]
Self: Unpin,
fn now_or_never(self) -> Option<Self::Output>[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<F> IntoFuture for F where
F: Future, [src]
F: Future,
type Output = <F as Future>::Output
🔬 This is a nightly-only experimental API. (
into_future)The output that the future will produce on completion.
type Future = F
🔬 This is a nightly-only experimental API. (
into_future)Which kind of future are we turning this into?
fn into_future(self) -> <F as IntoFuture>::Future[src]
impl<T> Key for T where
T: Eq + Hash + Clone + MaybeSend + MaybeSync + 'static, [src]
T: Eq + Hash + Clone + MaybeSend + MaybeSync + 'static,
impl<T> MaybeSend for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> MaybeSync for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> ToOwned for T where
T: Clone, [src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
fn clone_into(&self, target: &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized, [src]
F: Future<Output = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll(self: Pin<&mut F>, cx: &mut Context) -> Poll<<F as Future>::Output>[src]
impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized, [src]
Fut: TryFuture + ?Sized,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnOnce(Self::Ok) -> T, [src]
F: FnOnce(Self::Ok) -> T,
fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> where
E: FnOnce(Self::Error) -> T,
F: FnOnce(Self::Ok) -> T, [src]
E: FnOnce(Self::Error) -> T,
F: FnOnce(Self::Ok) -> T,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E, [src]
F: FnOnce(Self::Error) -> E,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn ok_into<U>(self) -> OkInto<Self, U> where
Self::Ok: Into<U>, [src]
Self::Ok: Into<U>,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>, [src]
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>, [src]
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnOnce(&Self::Ok), [src]
F: FnOnce(&Self::Ok),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnOnce(&Self::Error), [src]
F: FnOnce(&Self::Error),
fn try_flatten(self) -> TryFlatten<Self, Self::Ok> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error, [src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where
F: FnOnce(Self::Error) -> Self::Ok, [src]
F: FnOnce(Self::Error) -> Self::Ok,
fn into_future(self) -> IntoFuture<Self>[src]
fn try_poll_unpin(
&mut self,
cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,