Struct varlen::tuple::Tup2

pub struct Tup2<A, B>(pub FieldMarker<A>, pub FieldMarker<B>);

Tuple of variable-length types.

Examples

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

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

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

Tuple Fields

0: FieldMarker<A>

1: FieldMarker<B>

Implementations

impl<A: VarLen, B: VarLen> Tup2<A, B>

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

Immutable access to fields of a tuple.

Examples

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

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

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

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

Mutable access to fields of a tuple.

Examples

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

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

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

Trait Implementations

impl<A, B> Drop for Tup2<A, B>

fn drop(&mut self)

Executes the destructor for this type.

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

fn calculate_layout_cautious(&self) -> Option<<Tup2<A, B> 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<Tup2<A, B>>,
    layout: <Tup2<A, B> as VarLen>::Layout
)

Populates the destination pointer.

impl<A: VarLen, AInit: Initializer<A>, B: VarLen, BInit: Initializer<B>> Initializer<Tup2<A, B>> for Init<AInit, BInit>

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

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<Tup2<A, B>>, layout: Layout<A, B>)

Populates the destination pointer.

impl<'a, A: VClone<'a>, B: VClone<'a>> VClone<'a> for Tup2<A, B>

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

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>> VCopy<'a> for Tup2<A, B>

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

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

impl<A: VarLen, B: VarLen> VarLen for Tup2<A, B>

type Layout = Layout<A, B>

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>

Calculates the layout of the internal fields of this object.

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

Drops self.