Struct rustler::resource::ResourceArc

pub struct ResourceArc<T>where
    T: ResourceTypeProvider,{ /* private fields */ }

A reference to a resource of type T.

This type is like std::sync::Arc: it provides thread-safe, reference-counted storage for Rust data that can be shared across threads. Data stored this way is immutable by default. If you need to modify data in a resource, use a std::sync::Mutex or RwLock.

Rust code and Erlang code can both have references to the same resource at the same time. Rust code uses ResourceArc; in Erlang, a reference to a resource is a kind of term. You can convert back and forth between the two using Encoder and Decoder.

Implementations

impl<T> ResourceArc<T>where
    T: ResourceTypeProvider,

pub fn new(data: T) -> Self

Makes a new ResourceArc from the given type. Note that the type must have ResourceTypeProvider implemented for it. See module documentation for info on this.

pub fn make_binary<'env, 'a, F>(&self, env: Env<'env>, f: F) -> Binary<'env>where
    F: FnOnce(&'a T) -> &'a [u8],

Make a resource binary associated with the given resource

The closure f is called with the referenced object and must return a slice with the same lifetime as the object. This means that the slice either has to be derived directly from the instance or that it has to have static lifetime.

pub unsafe fn make_binary_unsafe<'env, 'a, 'b, F>(
    &self,
    env: Env<'env>,
    f: F
) -> Binary<'env>where
    F: FnOnce(&'a T) -> &'b [u8],

Make a resource binary without strict lifetime checking

The user must ensure that the lifetime of the returned slice is at least as long as the lifetime of the referenced instance.

Safety

This function is only safe if the slice that is returned from the closure is guaranteed to live at least as long as the ResourceArc instance. If in doubt, use the safe version ResourceArc::make_binary which enforces this bound through its signature.

Trait Implementations

impl<T> Clone for ResourceArc<T>where
    T: ResourceTypeProvider,

fn clone(&self) -> Self

Cloning a ResourceArc simply increments the reference count for the resource. The T value is not cloned.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T> Decoder<'a> for ResourceArc<T>where
    T: ResourceTypeProvider + 'a,

fn decode(term: Term<'a>) -> NifResult<Self>

impl<T> Deref for ResourceArc<T>where
    T: ResourceTypeProvider,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Drop for ResourceArc<T>where
    T: ResourceTypeProvider,

fn drop(&mut self)

When a ResourceArc is dropped, the reference count is decremented. If there are no other references to the resource, the T value is dropped.

However, note that in general, the Rust value in a resource is dropped at an unpredictable time: whenever the VM decides to do garbage collection.

impl<T> Encoder for ResourceArc<T>where
    T: ResourceTypeProvider,

fn encode<'a>(&self, env: Env<'a>) -> Term<'a>

impl<T> Send for ResourceArc<T>where
    T: ResourceTypeProvider,

impl<T> Sync for ResourceArc<T>where
    T: ResourceTypeProvider,