Trait Container

pub trait Container<C: Columnar + ?Sized> {
    type Borrowed<'a>: Copy + Len + AsBytes<'a> + FromBytes<'a> + Index<Ref = C::Ref<'a>>
       where Self: 'a;

    // Required methods
    fn borrow<'a>(&'a self) -> Self::Borrowed<'a>;
    fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>
       where Self: 'a;
}

A container that can hold C, and provide its preferred references.

As an example, (Vec<A>, Vecs<Vec<B>>).

Required Associated Types

type Borrowed<'a>: Copy + Len + AsBytes<'a> + FromBytes<'a> + Index<Ref = C::Ref<'a>> where Self: 'a

The type of a borrowed container.

Corresponding to our example, (&'a [A], Vecs<&'a [B], &'a [u64]>).

Required Methods

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

Converts a reference to the type to a borrowed variant.

fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where Self: 'a,

Reborrows the borrowed type to a shorter lifetime. See Columnar::reborrow for details.

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 Container<f32> for Vec<f32>

type Borrowed<'a> = &'a [f32]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [f32]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<f64> for Vec<f64>

type Borrowed<'a> = &'a [f64]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [f64]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<i8> for Vec<i8>

type Borrowed<'a> = &'a [i8]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [i8]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<i16> for Vec<i16>

type Borrowed<'a> = &'a [i16]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [i16]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<i32> for Vec<i32>

type Borrowed<'a> = &'a [i32]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [i32]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<i64> for Vec<i64>

type Borrowed<'a> = &'a [i64]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [i64]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<i128> for Vec<i128>

type Borrowed<'a> = &'a [i128]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [i128]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<u8> for Vec<u8>

type Borrowed<'a> = &'a [u8]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [u8]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<u16> for Vec<u16>

type Borrowed<'a> = &'a [u16]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [u16]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<u32> for Vec<u32>

type Borrowed<'a> = &'a [u32]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [u32]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<u64> for Vec<u64>

type Borrowed<'a> = &'a [u64]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [u64]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<u128> for Vec<u128>

type Borrowed<'a> = &'a [u128]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [u128]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<i8>> for Vec<Wrapping<i8>>

type Borrowed<'a> = &'a [Wrapping<i8>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<i8>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<i16>> for Vec<Wrapping<i16>>

type Borrowed<'a> = &'a [Wrapping<i16>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<i16>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<i32>> for Vec<Wrapping<i32>>

type Borrowed<'a> = &'a [Wrapping<i32>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<i32>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<i64>> for Vec<Wrapping<i64>>

type Borrowed<'a> = &'a [Wrapping<i64>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<i64>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<i128>> for Vec<Wrapping<i128>>

type Borrowed<'a> = &'a [Wrapping<i128>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<i128>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<u8>> for Vec<Wrapping<u8>>

type Borrowed<'a> = &'a [Wrapping<u8>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<u8>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<u16>> for Vec<Wrapping<u16>>

type Borrowed<'a> = &'a [Wrapping<u16>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<u16>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<u32>> for Vec<Wrapping<u32>>

type Borrowed<'a> = &'a [Wrapping<u32>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<u32>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<u64>> for Vec<Wrapping<u64>>

type Borrowed<'a> = &'a [Wrapping<u64>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<u64>]) -> Self::Borrowed<'b>

where Self: 'a,

impl Container<Wrapping<u128>> for Vec<Wrapping<u128>>

type Borrowed<'a> = &'a [Wrapping<u128>]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: &'a [Wrapping<u128>]) -> Self::Borrowed<'b>

where Self: 'a,

impl<A: Columnar, AA: Container<A>> Container<(A,)> for (AA,)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>,) where A: 'a, AA: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>> Container<(A, B)> for (AA, BB)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>> Container<(A, B, C)> for (AA, BB, CC)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>> Container<(A, B, C, D)> for (AA, BB, CC, DD)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>> Container<(A, B, C, D, E)> for (AA, BB, CC, DD, EE)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>, F: Columnar, FF: Container<F>> Container<(A, B, C, D, E, F)> for (AA, BB, CC, DD, EE, FF)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>, <FF as Container<F>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a, F: 'a, FF: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>, F: Columnar, FF: Container<F>, G: Columnar, GG: Container<G>> Container<(A, B, C, D, E, F, G)> for (AA, BB, CC, DD, EE, FF, GG)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>, <FF as Container<F>>::Borrowed<'a>, <GG as Container<G>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a, F: 'a, FF: 'a, G: 'a, GG: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>, F: Columnar, FF: Container<F>, G: Columnar, GG: Container<G>, H: Columnar, HH: Container<H>> Container<(A, B, C, D, E, F, G, H)> for (AA, BB, CC, DD, EE, FF, GG, HH)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>, <FF as Container<F>>::Borrowed<'a>, <GG as Container<G>>::Borrowed<'a>, <HH as Container<H>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a, F: 'a, FF: 'a, G: 'a, GG: 'a, H: 'a, HH: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>, F: Columnar, FF: Container<F>, G: Columnar, GG: Container<G>, H: Columnar, HH: Container<H>, I: Columnar, II: Container<I>> Container<(A, B, C, D, E, F, G, H, I)> for (AA, BB, CC, DD, EE, FF, GG, HH, II)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>, <FF as Container<F>>::Borrowed<'a>, <GG as Container<G>>::Borrowed<'a>, <HH as Container<H>>::Borrowed<'a>, <II as Container<I>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a, F: 'a, FF: 'a, G: 'a, GG: 'a, H: 'a, HH: 'a, I: 'a, II: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a,

impl<A: Columnar, AA: Container<A>, B: Columnar, BB: Container<B>, C: Columnar, CC: Container<C>, D: Columnar, DD: Container<D>, E: Columnar, EE: Container<E>, F: Columnar, FF: Container<F>, G: Columnar, GG: Container<G>, H: Columnar, HH: Container<H>, I: Columnar, II: Container<I>, J: Columnar, JJ: Container<J>> Container<(A, B, C, D, E, F, G, H, I, J)> for (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ)

type Borrowed<'a> = (<AA as Container<A>>::Borrowed<'a>, <BB as Container<B>>::Borrowed<'a>, <CC as Container<C>>::Borrowed<'a>, <DD as Container<D>>::Borrowed<'a>, <EE as Container<E>>::Borrowed<'a>, <FF as Container<F>>::Borrowed<'a>, <GG as Container<G>>::Borrowed<'a>, <HH as Container<H>>::Borrowed<'a>, <II as Container<I>>::Borrowed<'a>, <JJ as Container<J>>::Borrowed<'a>) where A: 'a, AA: 'a, B: 'a, BB: 'a, C: 'a, CC: 'a, D: 'a, DD: 'a, E: 'a, EE: 'a, F: 'a, FF: 'a, G: 'a, GG: 'a, H: 'a, HH: 'a, I: 'a, II: 'a, J: 'a, JJ: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a, JJ: 'a,

Implementors

impl Container<()> for Empties

type Borrowed<'a> = Empties<&'a u64>

impl<'b, BC: Container<u64>> Container<String> for Strings<BC, &'b [u8]>

type Borrowed<'a> = Strings<<BC as Container<u64>>::Borrowed<'a>, &'a [u8]> where BC: 'a, 'b: 'a

impl<BC: Container<u64>> Container<String> for Strings<BC, Vec<u8>>

type Borrowed<'a> = Strings<<BC as Container<u64>>::Borrowed<'a>, &'a [u8]> where BC: 'a

impl<CV: Container<i64>> Container<isize> for Isizes<CV>

type Borrowed<'a> = Isizes<<CV as Container<i64>>::Borrowed<'a>> where CV: 'a

impl<CV: Container<u64>> Container<usize> for Usizes<CV>

type Borrowed<'a> = Usizes<<CV as Container<u64>>::Borrowed<'a>> where CV: 'a

impl<S: Columnar, T: Columnar, SC: Container<S>, TC: Container<T>> Container<Result<S, T>> for Results<SC, TC>

type Borrowed<'a> = Results<<SC as Container<S>>::Borrowed<'a>, <TC as Container<T>>::Borrowed<'a>, &'a [u64], &'a [u64], &'a u64> where SC: 'a, TC: 'a, S: 'a, T: 'a

impl<SC: Container<u64>, NC: Container<u32>> Container<Duration> for Durations<SC, NC>

type Borrowed<'a> = Durations<<SC as Container<u64>>::Borrowed<'a>, <NC as Container<u32>>::Borrowed<'a>> where SC: 'a, NC: 'a

impl<T: Columnar<Container = TC>, BC: Container<u64>, TC: Container<T>> Container<Vec<T>> for Vecs<TC, BC>

type Borrowed<'a> = Vecs<<TC as Container<T>>::Borrowed<'a>, <BC as Container<u64>>::Borrowed<'a>> where BC: 'a, TC: 'a, T: 'a

impl<T: Columnar<Container = TC>, BC: Container<u64>, TC: Container<T>, const N: usize> Container<[T; N]> for Vecs<TC, BC>

type Borrowed<'a> = Vecs<<TC as Container<T>>::Borrowed<'a>, <BC as Container<u64>>::Borrowed<'a>> where BC: 'a, TC: 'a, T: 'a

impl<T: Columnar<Container = TC>, BC: Container<u64>, TC: Container<T>, const N: usize> Container<SmallVec<[T; N]>> for Vecs<TC, BC>

type Borrowed<'a> = Vecs<<TC as Container<T>>::Borrowed<'a>, <BC as Container<u64>>::Borrowed<'a>> where BC: 'a, TC: 'a, T: 'a

impl<T: Columnar, TC: Container<T>> Container<Option<T>> for Options<TC>

type Borrowed<'a> = Options<<TC as Container<T>>::Borrowed<'a>, &'a [u64], &'a [u64], &'a u64> where TC: 'a, T: 'a

impl<VC: Container<u64>> Container<bool> for Bools<VC>

type Borrowed<'a> = Bools<<VC as Container<u64>>::Borrowed<'a>, &'a u64> where VC: 'a