Trait timely_container::flatcontainer::IntoOwned

pub trait IntoOwned<'a> {
    type Owned;

    // Required methods
    fn into_owned(self) -> Self::Owned;
    fn clone_onto(self, other: &mut Self::Owned);
    fn borrow_as(owned: &'a Self::Owned) -> Self;
}

A reference type corresponding to an owned type, supporting conversion in each direction.

This trait can be implemented by a GAT, and enables owned types to be borrowed as a GAT. This trait is analogous to ToOwned, but not as prescriptive. Specifically, it avoids the requirement that the other trait implement Borrow, for which a borrow must result in a &'self Borrowed, which cannot move the lifetime into a GAT borrowed type.

Required Associated Types

type Owned

Owned type into which this type can be converted.

Required Methods

fn into_owned(self) -> Self::Owned

Conversion from an instance of this type to the owned type.

fn clone_onto(self, other: &mut Self::Owned)

Clones self onto an existing instance of the owned type.

fn borrow_as(owned: &'a Self::Owned) -> Self

Borrows an owned instance as oneself.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a> IntoOwned<'a> for bool

type Owned = bool

fn into_owned(self) -> <bool as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <bool as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <bool as IntoOwned<'a>>::Owned) -> bool

impl<'a> IntoOwned<'a> for char

type Owned = char

fn into_owned(self) -> <char as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <char as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <char as IntoOwned<'a>>::Owned) -> char

impl<'a> IntoOwned<'a> for f32

type Owned = f32

fn into_owned(self) -> <f32 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <f32 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <f32 as IntoOwned<'a>>::Owned) -> f32

impl<'a> IntoOwned<'a> for f64

type Owned = f64

fn into_owned(self) -> <f64 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <f64 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <f64 as IntoOwned<'a>>::Owned) -> f64

impl<'a> IntoOwned<'a> for i8

type Owned = i8

fn into_owned(self) -> <i8 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <i8 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <i8 as IntoOwned<'a>>::Owned) -> i8

impl<'a> IntoOwned<'a> for i16

type Owned = i16

fn into_owned(self) -> <i16 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <i16 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <i16 as IntoOwned<'a>>::Owned) -> i16

impl<'a> IntoOwned<'a> for i32

type Owned = i32

fn into_owned(self) -> <i32 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <i32 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <i32 as IntoOwned<'a>>::Owned) -> i32

impl<'a> IntoOwned<'a> for i64

type Owned = i64

fn into_owned(self) -> <i64 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <i64 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <i64 as IntoOwned<'a>>::Owned) -> i64

impl<'a> IntoOwned<'a> for i128

type Owned = i128

fn into_owned(self) -> <i128 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <i128 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <i128 as IntoOwned<'a>>::Owned) -> i128

impl<'a> IntoOwned<'a> for isize

type Owned = isize

fn into_owned(self) -> <isize as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <isize as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <isize as IntoOwned<'a>>::Owned) -> isize

impl<'a> IntoOwned<'a> for u8

type Owned = u8

fn into_owned(self) -> <u8 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <u8 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <u8 as IntoOwned<'a>>::Owned) -> u8

impl<'a> IntoOwned<'a> for u16

type Owned = u16

fn into_owned(self) -> <u16 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <u16 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <u16 as IntoOwned<'a>>::Owned) -> u16

impl<'a> IntoOwned<'a> for u32

type Owned = u32

fn into_owned(self) -> <u32 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <u32 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <u32 as IntoOwned<'a>>::Owned) -> u32

impl<'a> IntoOwned<'a> for u64

type Owned = u64

fn into_owned(self) -> <u64 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <u64 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <u64 as IntoOwned<'a>>::Owned) -> u64

impl<'a> IntoOwned<'a> for u128

type Owned = u128

fn into_owned(self) -> <u128 as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <u128 as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <u128 as IntoOwned<'a>>::Owned) -> u128

impl<'a> IntoOwned<'a> for ()

type Owned = ()

fn into_owned(self) -> <() as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <() as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <() as IntoOwned<'a>>::Owned)

impl<'a> IntoOwned<'a> for usize

type Owned = usize

fn into_owned(self) -> <usize as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <usize as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <usize as IntoOwned<'a>>::Owned) -> usize

impl<'a> IntoOwned<'a> for Wrapping<i8>

type Owned = Wrapping<i8>

fn into_owned(self) -> <Wrapping<i8> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<i8> as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <Wrapping<i8> as IntoOwned<'a>>::Owned) -> Wrapping<i8>

impl<'a> IntoOwned<'a> for Wrapping<i16>

type Owned = Wrapping<i16>

fn into_owned(self) -> <Wrapping<i16> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<i16> as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <Wrapping<i16> as IntoOwned<'a>>::Owned, ) -> Wrapping<i16>

impl<'a> IntoOwned<'a> for Wrapping<i32>

type Owned = Wrapping<i32>

fn into_owned(self) -> <Wrapping<i32> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<i32> as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <Wrapping<i32> as IntoOwned<'a>>::Owned, ) -> Wrapping<i32>

impl<'a> IntoOwned<'a> for Wrapping<i64>

type Owned = Wrapping<i64>

fn into_owned(self) -> <Wrapping<i64> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<i64> as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <Wrapping<i64> as IntoOwned<'a>>::Owned, ) -> Wrapping<i64>

impl<'a> IntoOwned<'a> for Wrapping<i128>

type Owned = Wrapping<i128>

fn into_owned(self) -> <Wrapping<i128> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<i128> as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <Wrapping<i128> as IntoOwned<'a>>::Owned, ) -> Wrapping<i128>

impl<'a> IntoOwned<'a> for Wrapping<isize>

type Owned = Wrapping<isize>

fn into_owned(self) -> <Wrapping<isize> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Wrapping<isize> as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <Wrapping<isize> as IntoOwned<'a>>::Owned, ) -> Wrapping<isize>

impl<'a> IntoOwned<'a> for Duration

type Owned = Duration

fn into_owned(self) -> <Duration as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Duration as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <Duration as IntoOwned<'a>>::Owned) -> Duration

impl<'a, A> IntoOwned<'a> for (A,)

where A: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned,)

fn into_owned(self) -> <(A,) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A,) as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <(A,) as IntoOwned<'a>>::Owned) -> (A,)

impl<'a, A, B> IntoOwned<'a> for (A, B)

where A: IntoOwned<'a>, B: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B) as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <(A, B) as IntoOwned<'a>>::Owned) -> (A, B)

impl<'a, A, B, C> IntoOwned<'a> for (A, B, C)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B, C) as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <(A, B, C) as IntoOwned<'a>>::Owned) -> (A, B, C)

impl<'a, A, B, C, D> IntoOwned<'a> for (A, B, C, D)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B, C, D) as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <(A, B, C, D) as IntoOwned<'a>>::Owned) -> (A, B, C, D)

impl<'a, A, B, C, D, E> IntoOwned<'a> for (A, B, C, D, E)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B, C, D, E) as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <(A, B, C, D, E) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E)

impl<'a, A, B, C, D, E, F> IntoOwned<'a> for (A, B, C, D, E, F)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E, F) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B, C, D, E, F) as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <(A, B, C, D, E, F) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F)

impl<'a, A, B, C, D, E, F, G> IntoOwned<'a> for (A, B, C, D, E, F, G)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E, F, G) as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <(A, B, C, D, E, F, G) as IntoOwned<'a>>::Owned)

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G)

impl<'a, A, B, C, D, E, F, G, H> IntoOwned<'a> for (A, B, C, D, E, F, G, H)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E, F, G, H) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H)

impl<'a, A, B, C, D, E, F, G, H, I> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E, F, G, H, I) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I)

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned)

fn into_owned(self) -> <(A, B, C, D, E, F, G, H, I, J) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J)

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>,

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

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K)

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>, L: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned, <K as IntoOwned<'a>>::Owned, <L as IntoOwned<'a>>::Owned)

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K, L) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K, L)

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>, L: IntoOwned<'a>, M: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned, <K as IntoOwned<'a>>::Owned, <L as IntoOwned<'a>>::Owned, <M as IntoOwned<'a>>::Owned)

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K, L, M) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M)

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>, L: IntoOwned<'a>, M: IntoOwned<'a>, N: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned, <K as IntoOwned<'a>>::Owned, <L as IntoOwned<'a>>::Owned, <M as IntoOwned<'a>>::Owned, <N as IntoOwned<'a>>::Owned)

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>, L: IntoOwned<'a>, M: IntoOwned<'a>, N: IntoOwned<'a>, O: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned, <K as IntoOwned<'a>>::Owned, <L as IntoOwned<'a>>::Owned, <M as IntoOwned<'a>>::Owned, <N as IntoOwned<'a>>::Owned, <O as IntoOwned<'a>>::Owned)

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> IntoOwned<'a> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: IntoOwned<'a>, B: IntoOwned<'a>, C: IntoOwned<'a>, D: IntoOwned<'a>, E: IntoOwned<'a>, F: IntoOwned<'a>, G: IntoOwned<'a>, H: IntoOwned<'a>, I: IntoOwned<'a>, J: IntoOwned<'a>, K: IntoOwned<'a>, L: IntoOwned<'a>, M: IntoOwned<'a>, N: IntoOwned<'a>, O: IntoOwned<'a>, P: IntoOwned<'a>,

type Owned = (<A as IntoOwned<'a>>::Owned, <B as IntoOwned<'a>>::Owned, <C as IntoOwned<'a>>::Owned, <D as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned, <F as IntoOwned<'a>>::Owned, <G as IntoOwned<'a>>::Owned, <H as IntoOwned<'a>>::Owned, <I as IntoOwned<'a>>::Owned, <J as IntoOwned<'a>>::Owned, <K as IntoOwned<'a>>::Owned, <L as IntoOwned<'a>>::Owned, <M as IntoOwned<'a>>::Owned, <N as IntoOwned<'a>>::Owned, <O as IntoOwned<'a>>::Owned, <P as IntoOwned<'a>>::Owned)

fn into_owned( self, ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as IntoOwned<'a>>::Owned

fn clone_onto( self, other: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as IntoOwned<'a>>::Owned, )

fn borrow_as( owned: &'a <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as IntoOwned<'a>>::Owned, ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

impl<'a, T> IntoOwned<'a> for Option<T>

where T: IntoOwned<'a>,

type Owned = Option<<T as IntoOwned<'a>>::Owned>

fn into_owned(self) -> <Option<T> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Option<T> as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <Option<T> as IntoOwned<'a>>::Owned) -> Option<T>

impl<'a, T> IntoOwned<'a> for &'a T

where T: ToOwned + ?Sized,

type Owned = <T as ToOwned>::Owned

fn into_owned(self) -> <&'a T as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <&'a T as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <&'a T as IntoOwned<'a>>::Owned) -> &'a T

impl<'a, T, E> IntoOwned<'a> for Result<T, E>

where T: IntoOwned<'a>, E: IntoOwned<'a>,

type Owned = Result<<T as IntoOwned<'a>>::Owned, <E as IntoOwned<'a>>::Owned>

fn into_owned(self) -> <Result<T, E> as IntoOwned<'a>>::Owned

fn clone_onto(self, other: &mut <Result<T, E> as IntoOwned<'a>>::Owned)

fn borrow_as(owned: &'a <Result<T, E> as IntoOwned<'a>>::Owned) -> Result<T, E>

Implementors

impl<'a, R> IntoOwned<'a> for ReadColumns<'a, R>

where R: Region,

type Owned = Vec<<R as Region>::Owned>

impl<'a, R, O> IntoOwned<'a> for ReadSlice<'a, R, O>

where R: Region, O: OffsetContainer<<R as Region>::Index>,

type Owned = Vec<<R as Region>::Owned>