Struct Shared 

pub struct Shared<T> { /* private fields */ }

A wrapper for data that can be shared across processes.

The data is owned, but the element of type T will not be dropped when the Shared<T> is dropped. Note that an element that has a meaningful Drop is likely not ProcSync anyway.

Implementations

impl<T> Shared<T>

pub fn new(val: T) -> Result<Shared<T>, Error>

Creates and initializes a Shared<T> to value val.

impl Shared<c_void>

pub fn new_sized(size: usize) -> Result<Shared<c_void>, Error>

Creates a Shared<c_void> that points to a memory region of size size, aligned to page boundary.

Proper handling of the returned value is left up to the user.

impl<T> Shared<T>

pub fn try_clone(data: &Shared<T>) -> Result<Shared<T>, Error>

Attempts to clone data.

This will remap data at another location in memory, in addition to keeping data alive.

pub fn as_mut_ptr(data: &Shared<T>) -> *mut T

Returns a mutable pointer to the data contained by data.

Note that using this pointer needs the caller to handle synchronization themselves.

pub fn size(data: &Shared<T>) -> usize

Returns the size in bytes of the data contained by data.

For a Shared<T> it is mem::size_of<T>() and for Shared<c_void> it is the size specified at creation.

impl<T: ProcSync> Shared<T>

pub unsafe fn from_raw_fd(fd: RawFd) -> Result<Shared<T>, Error>

Creates a Shared<T> from pre-existing fd.

Safety

This assumes that fd is a file descriptor that has been created by another instance of Shared<T>, and that it will never be used by anything else than Shared<T>. Note that not respecting this will at best do as bad as std::mem::transmute, and at worst end in tears.

This also assumes that fd is not shared with another Shared<T>, as the output of as_raw_fd() is only a borrow. Do not forget to call dup before passing the file descriptor to from_raw_fd if you are not using into_raw_fd and have not passed the RawFd over a socket.

Trait Implementations

impl<T> AsRawFd for Shared<T>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<T> Deref for Shared<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Drop for Shared<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> IntoRawFd for Shared<T>

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl<T: Sync> Send for Shared<T>

impl<T: Sync> Sync for Shared<T>