[−][src]Trait restor::FetchMultiple

pub trait FetchMultiple<'a, U: ?Sized + Unit<'a>> {
    type Output: 'a;
    type Actual;
    fn get_many(boxed: &'a BlackBox<U>) -> Result<Self::Output, ErrorDesc>;

    fn waiting_get_many(
        boxed: &'a BlackBox<U>
    ) -> Result<Self::Output, ErrorDesc>
    where
        <U as Unit<'a>>::Borrowed: Waitable,
        <U as Unit<'a>>::MutBorrowed: Waitable;
}

An abstraction over Fetch which works over multiple types, and the six types which have Fetch pre-implemented. This is therefore implemented for the following types:

  • &T
  • &mut T
  • &[T]
  • &mut [T]
  • Box<T>
  • Vec<T>
  • (A,)
  • (A, B)
  • (A, B, C)
  • (A, B, C, D)
  • ...
  • (A, B, C, D, E, F, G, H, I, J, K)

Where each one of the type parameters in the tuple versions must implement Fetch.

Associated Types

type Output: 'a

type Actual

Loading content...

Required methods

fn get_many(boxed: &'a BlackBox<U>) -> Result<Self::Output, ErrorDesc>

fn waiting_get_many(boxed: &'a BlackBox<U>) -> Result<Self::Output, ErrorDesc> where
    <U as Unit<'a>>::Borrowed: Waitable,
    <U as Unit<'a>>::MutBorrowed: Waitable, 

Loading content...

Implementations on Foreign Types

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a T where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::Borrowed: Map<dyn Any, StorageUnit<T>, Func = dyn Fn(&dyn Any) -> &StorageUnit<T>>,
    <<U as Unit<'a>>::Borrowed as Map<dyn Any, StorageUnit<T>>>::Output: Map<StorageUnit<T>, T, Func = dyn Fn(&StorageUnit<T>) -> &T>,
    &'a T: Fetch<'a, U>, [src]

type Output = <&'a T as Fetch<'a, U>>::Output

type Actual = <&'a T as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a mut T where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::MutBorrowed: MapMut<dyn Any, StorageUnit<T>, Func = dyn Fn(&mut dyn Any) -> &mut StorageUnit<T>>,
    <<U as Unit<'a>>::MutBorrowed as MapMut<dyn Any, StorageUnit<T>>>::Output: MapMut<StorageUnit<T>, T, Func = dyn Fn(&mut StorageUnit<T>) -> &mut T>,
    &'a mut T: Fetch<'a, U>, [src]

type Output = <&'a mut T as Fetch<'a, U>>::Output

type Actual = <&'a mut T as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a [T] where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::Borrowed: Map<dyn Any, StorageUnit<T>, Func = dyn Fn(&dyn Any) -> &StorageUnit<T>>,
    <<U as Unit<'a>>::Borrowed as Map<dyn Any, StorageUnit<T>>>::Output: Map<StorageUnit<T>, [T], Func = dyn Fn(&StorageUnit<T>) -> &[T]>,
    &'a [T]: Fetch<'a, U>, [src]

type Output = <&'a [T] as Fetch<'a, U>>::Output

type Actual = <&'a [T] as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a mut [T] where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::MutBorrowed: MapMut<dyn Any, StorageUnit<T>, Func = dyn Fn(&mut dyn Any) -> &mut StorageUnit<T>>,
    <<U as Unit<'a>>::MutBorrowed as MapMut<dyn Any, StorageUnit<T>>>::Output: MapMut<StorageUnit<T>, [T], Func = dyn Fn(&mut StorageUnit<T>) -> &mut [T]>,
    &'a mut [T]: Fetch<'a, U>, [src]

type Output = <&'a mut [T] as Fetch<'a, U>>::Output

type Actual = <&'a mut [T] as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for Box<T> where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::MutBorrowed: MapMut<dyn Any, StorageUnit<T>, Func = dyn Fn(&mut dyn Any) -> &mut StorageUnit<T>>,
    Box<T>: Fetch<'a, U>, [src]

type Output = <Box<T> as Fetch<'a, U>>::Output

type Actual = <Box<T> as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, T: Sized + Any + 'static> FetchMultiple<'a, U> for Vec<T> where
    U: for<'b> Unit<'b>,
    <U as Unit<'a>>::MutBorrowed: MapMut<dyn Any, StorageUnit<T>, Func = dyn Fn(&mut dyn Any) -> &mut StorageUnit<T>>,
    Vec<T>: Fetch<'a, U>, [src]

type Output = <Vec<T> as Fetch<'a, U>>::Output

type Actual = <Vec<T> as Fetch<'a, U>>::Actual

impl<'a, U: ?Sized, A, B, C, D, E, F, G, H, I, J, K> FetchMultiple<'a, U> for (A, B, C, D, E, F, G, H, I, J, K) where
    B: Fetch<'a, U>,
    C: Fetch<'a, U>,
    D: Fetch<'a, U>,
    E: Fetch<'a, U>,
    F: Fetch<'a, U>,
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    A: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (A::Actual, B::Actual, C::Actual, D::Actual, E::Actual, F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, B, C, D, E, F, G, H, I, J, K> FetchMultiple<'a, U> for (B, C, D, E, F, G, H, I, J, K) where
    C: Fetch<'a, U>,
    D: Fetch<'a, U>,
    E: Fetch<'a, U>,
    F: Fetch<'a, U>,
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    B: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (B::Actual, C::Actual, D::Actual, E::Actual, F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, C, D, E, F, G, H, I, J, K> FetchMultiple<'a, U> for (C, D, E, F, G, H, I, J, K) where
    D: Fetch<'a, U>,
    E: Fetch<'a, U>,
    F: Fetch<'a, U>,
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    C: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (C::Actual, D::Actual, E::Actual, F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, D, E, F, G, H, I, J, K> FetchMultiple<'a, U> for (D, E, F, G, H, I, J, K) where
    E: Fetch<'a, U>,
    F: Fetch<'a, U>,
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    D: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (D::Actual, E::Actual, F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, E, F, G, H, I, J, K> FetchMultiple<'a, U> for (E, F, G, H, I, J, K) where
    F: Fetch<'a, U>,
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    E: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (E::Actual, F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, F, G, H, I, J, K> FetchMultiple<'a, U> for (F, G, H, I, J, K) where
    G: Fetch<'a, U>,
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    F: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (F::Actual, G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, G, H, I, J, K> FetchMultiple<'a, U> for (G, H, I, J, K) where
    H: Fetch<'a, U>,
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    G: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (G::Output, H::Output, I::Output, J::Output, K::Output)

type Actual = (G::Actual, H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, H, I, J, K> FetchMultiple<'a, U> for (H, I, J, K) where
    I: Fetch<'a, U>,
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    H: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (H::Output, I::Output, J::Output, K::Output)

type Actual = (H::Actual, I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, I, J, K> FetchMultiple<'a, U> for (I, J, K) where
    J: Fetch<'a, U>,
    K: Fetch<'a, U>,
    I: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (I::Output, J::Output, K::Output)

type Actual = (I::Actual, J::Actual, K::Actual)

impl<'a, U: ?Sized, J, K> FetchMultiple<'a, U> for (J, K) where
    K: Fetch<'a, U>,
    J: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (J::Output, K::Output)

type Actual = (J::Actual, K::Actual)

impl<'a, U: ?Sized, K> FetchMultiple<'a, U> for (K,) where
    K: Fetch<'a, U>,
    U: Unit<'a>, [src]

type Output = (K::Output,)

type Actual = (K::Actual,)

Loading content...

Implementors

Loading content...