Trait FetchMultiple

pub trait FetchMultiple<'a, U: ?Sized + Unit<'a>> {
    type Output: 'a;
    type Actual;

    // 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;
}

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.

Required Associated Types

type Output: 'a

type Actual

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,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, U, 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> + ?Sized,

type Output = (<A as Fetch<'a, U>>::Output, <B as Fetch<'a, U>>::Output, <C as Fetch<'a, U>>::Output, <D as Fetch<'a, U>>::Output, <E as Fetch<'a, U>>::Output, <F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<A as Fetch<'a, U>>::Actual, <B as Fetch<'a, U>>::Actual, <C as Fetch<'a, U>>::Actual, <D as Fetch<'a, U>>::Actual, <E as Fetch<'a, U>>::Actual, <F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<B as Fetch<'a, U>>::Output, <C as Fetch<'a, U>>::Output, <D as Fetch<'a, U>>::Output, <E as Fetch<'a, U>>::Output, <F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<B as Fetch<'a, U>>::Actual, <C as Fetch<'a, U>>::Actual, <D as Fetch<'a, U>>::Actual, <E as Fetch<'a, U>>::Actual, <F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<C as Fetch<'a, U>>::Output, <D as Fetch<'a, U>>::Output, <E as Fetch<'a, U>>::Output, <F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<C as Fetch<'a, U>>::Actual, <D as Fetch<'a, U>>::Actual, <E as Fetch<'a, U>>::Actual, <F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<D as Fetch<'a, U>>::Output, <E as Fetch<'a, U>>::Output, <F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<D as Fetch<'a, U>>::Actual, <E as Fetch<'a, U>>::Actual, <F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<E as Fetch<'a, U>>::Output, <F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<E as Fetch<'a, U>>::Actual, <F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<F as Fetch<'a, U>>::Output, <G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<F as Fetch<'a, U>>::Actual, <G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<G as Fetch<'a, U>>::Output, <H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<G as Fetch<'a, U>>::Actual, <H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<H as Fetch<'a, U>>::Output, <I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<H as Fetch<'a, U>>::Actual, <I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, 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> + ?Sized,

type Output = (<I as Fetch<'a, U>>::Output, <J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<I as Fetch<'a, U>>::Actual, <J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, J, K> FetchMultiple<'a, U> for (J, K)

where K: Fetch<'a, U>, J: Fetch<'a, U>, U: Unit<'a> + ?Sized,

type Output = (<J as Fetch<'a, U>>::Output, <K as Fetch<'a, U>>::Output)

type Actual = (<J as Fetch<'a, U>>::Actual, <K as Fetch<'a, U>>::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,

impl<'a, U, K> FetchMultiple<'a, U> for (K,)

where K: Fetch<'a, U>, U: Unit<'a> + ?Sized,

type Output = (<K as Fetch<'a, U>>::Output,)

type Actual = (<K as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a [T]

where U: for<'b> Unit<'b> + ?Sized, <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>,

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

type Actual = <&'a [T] as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a mut [T]

where U: for<'b> Unit<'b> + ?Sized, <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>,

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

type Actual = <&'a mut [T] as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a T

where U: for<'b> Unit<'b> + ?Sized, <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>,

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

type Actual = <&'a T as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for &'a mut T

where U: for<'b> Unit<'b> + ?Sized, <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>,

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

type Actual = <&'a mut T as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for Box<T>

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

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

type Actual = <Box<T> as Fetch<'a, U>>::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,

impl<'a, U, T: Sized + Any + 'static> FetchMultiple<'a, U> for Vec<T>

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

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

type Actual = <Vec<T> as Fetch<'a, U>>::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,

Implementors