Trait Borrow 

pub trait Borrow:
    Len
    + Clone
    + 'static {
    type Ref<'a>: Copy;
    type Borrowed<'a>: Copy + Len + Index<Ref = Self::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;
    fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>
       where Self: 'a;
}

A type that can be borrowed into a preferred reference type.

Required Associated Types

type Ref<'a>: Copy

For each lifetime, a reference with that lifetime.

As an example, (&'a A, &'a [B]).

type Borrowed<'a>: Copy + Len + Index<Ref = Self::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.

Implementations should most likely be marked #[inline(always)].

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.

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'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".

Implementations on Foreign Types

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow, II: Borrow, JJ: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>, <II as Borrow>::Ref<'a>, <JJ as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a, JJ: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>, <II as Borrow>::Borrowed<'a>, <JJ as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow, II: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH, II)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>, <II as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>, <II as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow> Borrow for (AA, BB, CC, DD, EE, FF)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow> Borrow for (AA, BB, CC, DD, EE)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow> Borrow for (AA, BB, CC, DD)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow> Borrow for (AA, BB, CC)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>) where AA: 'a, BB: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow> Borrow for (AA, BB)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>) where AA: 'a, BB: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>) where AA: '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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow> Borrow for (AA,)

type Ref<'a> = (<AA as Borrow>::Ref<'a>,) where AA: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>,) where 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,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Borrow> Borrow for Arc<T>

type Ref<'a> = <T as Borrow>::Ref<'a> where T: 'a

type Borrowed<'a> = <T as Borrow>::Borrowed<'a>

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

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

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Borrow> Borrow for Rc<T>

type Ref<'a> = <T as Borrow>::Ref<'a> where T: 'a

type Borrowed<'a> = <T as Borrow>::Borrowed<'a>

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

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

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Clone + 'static> Borrow for Vec<T>

type Ref<'a> = &'a T

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

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

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

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

Implementors

impl Borrow for Discriminant

type Ref<'a> = (u8, u64)

type Borrowed<'a> = Discriminant<&'a [u8], &'a [u64]>

impl Borrow for Empties

type Ref<'a> = ()

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

impl Borrow for Strides

type Ref<'a> = u64

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

impl<BC: BorrowIndexAs<u64>, TC: Container> Borrow for Vecs<TC, BC>

type Ref<'a> = Slice<<TC as Borrow>::Borrowed<'a>> where TC: 'a

type Borrowed<'a> = Vecs<<TC as Borrow>::Borrowed<'a>, <BC as Borrow>::Borrowed<'a>> where BC: 'a, TC: 'a

impl<BC: BorrowIndexAs<u64>> Borrow for Strings<BC, Vec<u8>>

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

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

impl<C: Borrow> Borrow for Boxed<C>

type Ref<'a> = Boxed<<C as Borrow>::Ref<'a>>

type Borrowed<'a> = Boxed<<C as Borrow>::Borrowed<'a>>

impl<C: ContainerBytes, B: Deref<Target = [u8]> + Clone + 'static> Borrow for Stash<C, B>

type Ref<'a> = <C as Borrow>::Ref<'a>

type Borrowed<'a> = <C as Borrow>::Borrowed<'a>

impl<CV: BorrowIndexAs<[u8; 16]>> Borrow for I128s<CV>

type Ref<'a> = i128

type Borrowed<'a> = I128s<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<[u8; 16]>> Borrow for U128s<CV>

type Ref<'a> = u128

type Borrowed<'a> = U128s<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<i64>> Borrow for Isizes<CV>

type Ref<'a> = isize

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

impl<CV: BorrowIndexAs<u32>> Borrow for Chars<CV>

type Ref<'a> = char

type Borrowed<'a> = Chars<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<u64> + Len> Borrow for Usizes<CV>

type Ref<'a> = usize

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

impl<SC: Borrow, TC: Borrow> Borrow for Results<SC, TC>

type Ref<'a> = Result<<SC as Borrow>::Ref<'a>, <TC as Borrow>::Ref<'a>> where SC: 'a, TC: 'a

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

impl<SC: BorrowIndexAs<u64>, NC: BorrowIndexAs<u32>> Borrow for Durations<SC, NC>

type Ref<'a> = Duration

type Borrowed<'a> = Durations<<SC as Borrow>::Borrowed<'a>, <NC as Borrow>::Borrowed<'a>> where SC: 'a, NC: 'a

impl<TC: Borrow, const N: u8> Borrow for Lookbacks<TC, Vec<u8>, Vec<u64>, Vec<u64>, [u64; 2], N>

type Ref<'a> = <TC as Borrow>::Ref<'a> where TC: 'a

type Borrowed<'a> = Lookbacks<<TC as Borrow>::Borrowed<'a>, &'a [u8], &'a [u64], &'a [u64], &'a [u64], N> where TC: 'a

impl<TC: Borrow> Borrow for Options<TC>

type Ref<'a> = Option<<TC as Borrow>::Ref<'a>> where TC: 'a

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

impl<TC: Borrow> Borrow for Repeats<TC>

type Ref<'a> = <TC as Borrow>::Ref<'a> where TC: 'a

type Borrowed<'a> = Repeats<<TC as Borrow>::Borrowed<'a>, &'a [u64], &'a [u64], &'a [u64]> where TC: 'a

impl<TC: Borrow> Borrow for Trees<TC>

type Ref<'a> = TreesRef<<TC as Borrow>::Borrowed<'a>, &'a [u64]> where TC: 'a

type Borrowed<'a> = Trees<<TC as Borrow>::Borrowed<'a>, &'a [u64]> where TC: 'a

impl<VC: BorrowIndexAs<u64>> Borrow for Bools<VC>

type Ref<'a> = bool

type Borrowed<'a> = Bools<<VC as Borrow>::Borrowed<'a>, &'a [u64]> where VC: 'a

impl<const K: u64> Borrow for Fixeds<K>

type Ref<'a> = u64

type Borrowed<'a> = Fixeds<K, &'a u64>