Struct varlen::tuple::Tup3

pub struct Tup3<A, B, C>(pub FieldMarker<A>, pub FieldMarker<B>, pub FieldMarker<C>);

Tuple of variable-length types.

Examples

use varlen::prelude::*;
use varlen::Layout;
let mut t: VBox<Tup3<Str, Str, Str>> = VBox::new(tup3::Init(
    Str::copy("hello"),
    Str::copy("brave"),
    Str::copy("world"),
));

assert_eq!(&t.refs().0[..], "hello");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");
t.as_mut().muts().0.mut_slice().make_ascii_uppercase();
assert_eq!(&t.refs().0[..], "HELLO");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");

assert_eq!(t.calculate_layout().size(), 
    core::mem::size_of::<usize>() * 3 + 8 /* hello */ + 8 /* brave */ + 5 /* world */);

Tuple Fields

0: FieldMarker<A>

1: FieldMarker<B>

2: FieldMarker<C>

Implementations

impl<A: VarLen, B: VarLen, C: VarLen> Tup3<A, B, C>

pub fn refs(&self) -> Refs<'_, A, B, C>

Immutable access to fields of a tuple.

Examples

use varlen::prelude::*;
use varlen::Layout;
let mut t: VBox<Tup3<Str, Str, Str>> = VBox::new(tup3::Init(
    Str::copy("hello"),
    Str::copy("brave"),
    Str::copy("world"),
));

assert_eq!(&t.refs().0[..], "hello");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");
t.as_mut().muts().0.mut_slice().make_ascii_uppercase();
assert_eq!(&t.refs().0[..], "HELLO");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");

assert_eq!(t.calculate_layout().size(), 
    core::mem::size_of::<usize>() * 3 + 8 /* hello */ + 8 /* brave */ + 5 /* world */);

pub fn muts(self: Pin<&mut Self>) -> Muts<'_, A, B, C>

Mutable access to fields of a tuple.

Examples

use varlen::prelude::*;
use varlen::Layout;
let mut t: VBox<Tup3<Str, Str, Str>> = VBox::new(tup3::Init(
    Str::copy("hello"),
    Str::copy("brave"),
    Str::copy("world"),
));

assert_eq!(&t.refs().0[..], "hello");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");
t.as_mut().muts().0.mut_slice().make_ascii_uppercase();
assert_eq!(&t.refs().0[..], "HELLO");
assert_eq!(&t.refs().1[..], "brave");
assert_eq!(&t.refs().2[..], "world");

assert_eq!(t.calculate_layout().size(), 
    core::mem::size_of::<usize>() * 3 + 8 /* hello */ + 8 /* brave */ + 5 /* world */);

Trait Implementations

impl<A, B, C> Drop for Tup3<A, B, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, A: VClone<'a>, B: VClone<'a>, C: VClone<'a>> Initializer<Tup3<A, B, C>> for Cloner<'a, A, B, C>

fn calculate_layout_cautious(&self) -> Option<<Tup3<A, B, C> as VarLen>::Layout>

Calculates the layout of the object, returning None if any of the calculated sizes or offsets would overflow usize.

unsafe fn initialize(
    self,
    dst: NonNull<Tup3<A, B, C>>,
    layout: <Tup3<A, B, C> as VarLen>::Layout
)

Populates the destination pointer.

impl<A: VarLen, AInit: Initializer<A>, B: VarLen, BInit: Initializer<B>, C: VarLen, CInit: Initializer<C>> Initializer<Tup3<A, B, C>> for Init<AInit, BInit, CInit>

fn calculate_layout_cautious(&self) -> Option<Layout<A, B, C>>

Calculates the layout of the object, returning None if any of the calculated sizes or offsets would overflow usize.

unsafe fn initialize(self, dst: NonNull<Tup3<A, B, C>>, layout: Layout<A, B, C>)

Populates the destination pointer.

impl<'a, A: VClone<'a>, B: VClone<'a>, C: VClone<'a>> VClone<'a> for Tup3<A, B, C>

type Cloner = Cloner<'a, A, B, C>

An initializer that can produce a clone of an object of type Self.

fn vclone(&'a self) -> Self::Cloner

Returns an initializer that will clone self when run.

impl<'a, A: VCopy<'a>, B: VCopy<'a>, C: VCopy<'a>> VCopy<'a> for Tup3<A, B, C>

fn vcopy(&'a self) -> VCopier<'a, Self>

Returns an initializer that does a bulk byte copy of self.

impl<A: VarLen, B: VarLen, C: VarLen> VarLen for Tup3<A, B, C>

type Layout = Layout<A, B, C>

This type’s internal dynamic calculations of where its tail fields are.

const ALIGN: usize

Alignment of this type, including its fixed-length header.

const NEEDS_VDROP: bool

If false, vdrop() is a noop, and may be skipped without changing behavior.

fn calculate_layout(&self) -> Layout<A, B, C>

Calculates the layout of the internal fields of this object.

unsafe fn vdrop(self: Pin<&mut Self>, layout: Layout<A, B, C>)

Drops self.