Struct zc::Zc

pub struct Zc<O: Owner, D> { /* fields omitted */ }

A zero-copy structure consisting of an Owner and a Dependant.

Implementations

impl<O, D> Zc<O, D> where
    O: Owner,
    D: Dependant<'static> + 'static, 

pub fn new<C>(owner: O, constructor: C) -> Self where
    C: for<'o> Construct<'o, <O::Storage as Deref>::Target, Dependant = D>, 

Construct a new zero-copied structure given an Owner and a function for constructing the Dependant.

Example

use zc::{Zc, Dependant};

#[derive(Dependant)]
struct MyStruct<'a>(&'a [u8]);

impl<'a> From<&'a [u8]> for MyStruct<'a> {
    fn from(bytes: &'a [u8]) -> Self {
        Self(&bytes[1..])
    }
}

let owner = vec![1, 2, 3];
let _ = zc::from!(owner, MyStruct, [u8]);

pub fn try_new<C, E>(owner: O, constructor: C) -> Result<Self, (E, O)> where
    E: 'static,
    C: for<'o> TryConstruct<'o, <O::Storage as Deref>::Target, Error = E, Dependant = D>, 

Construct a new zero-copied structure given an Owner and a function for constructing the Dependant.

Example

use zc::{Zc, Dependant};
use core::convert::TryFrom;

#[derive(Dependant)]
struct MyStruct<'a>(&'a [u8]);

impl<'a> TryFrom<&'a [u8]> for MyStruct<'a> {
    type Error = ();

    fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
        Ok(Self(&bytes[1..]))
    }
}

let owner = vec![1, 2, 3];
let _ = zc::try_from!(owner, MyStruct, [u8]);

pub fn dependant<'a, T>(&'a self) -> &T where
    T: Dependant<'a, Static = D>, 

Return a reference to the Dependant.

The dependant type T must be supplied (eg. Self::dependant::<MyStruct>(&self)).

Example

use zc::{Zc, Dependant};

#[derive(Debug, PartialEq, Dependant)]
struct MyStruct<'a>(&'a [u8]);

impl<'a> From<&'a [u8]> for MyStruct<'a> {
    fn from(bytes: &'a [u8]) -> Self {
        Self(&bytes[1..])
    }
}

let owner = vec![1, 2, 3];
let data = zc::from!(owner, MyStruct, [u8]);

assert_eq!(
    data.dependant::<MyStruct>(),
    &MyStruct(&[2, 3])
);

pub fn owned(&self) -> &<O::Storage as Deref>::Target

Return a reference to the data Owner provides.

Example

use zc::{Zc, Dependant};

#[derive(Debug, PartialEq, Dependant)]
struct MyStruct<'a>(&'a [u8]);

impl<'a> From<&'a [u8]> for MyStruct<'a> {
    fn from(bytes: &'a [u8]) -> Self {
        Self(&bytes[1..])
    }
}

let owner = vec![1, 2, 3];
let data = zc::from!(owner, MyStruct, [u8]);

assert_eq!(data.owned(), &[1, 2, 3]);

pub fn into_owner(self) -> O

Consumes self into the Owner.

Example

use zc::{Zc, Dependant};

#[derive(Debug, PartialEq, Dependant)]
struct MyStruct<'a>(&'a [u8]);

impl<'a> From<&'a [u8]> for MyStruct<'a> {
    fn from(bytes: &'a [u8]) -> Self {
        Self(&bytes[1..])
    }
}

let owner = vec![1, 2, 3];
let data = zc::from!(owner, MyStruct, [u8]);

assert_eq!(data.into_owner(), vec![1, 2, 3]);

Trait Implementations

impl<O, D> Debug for Zc<O, D> where
    O: Owner,
    O::Storage: Debug,
    D: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.