Struct Blob 

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

Shared data with an associated unique identifier.

Implementations

impl<T> Blob<T>

pub fn new(data: Arc<dyn AsRef<[T]> + Send + Sync>) -> Blob<T>

Creates a new blob from the given data and generates a unique identifier.

pub fn from_raw_parts( data: Arc<dyn AsRef<[T]> + Send + Sync>, id: u64, ) -> Blob<T>

Creates a new blob from the given data and identifier.

Note that while this function is not unsafe, usage of this in combination with new (or with identifiers that are not uniquely associated with the given data) can lead to inconsistencies.

pub fn into_raw_parts(self) -> (Arc<dyn AsRef<[T]> + Send + Sync>, u64)

Consumes self and returns the inner components of the blob.

pub fn len(&self) -> usize

Returns the length of the data.

pub fn is_empty(&self) -> bool

Returns true if the blob is empty.

pub fn data(&self) -> &[T]

Returns a reference to the underlying data.

pub fn id(&self) -> u64

Returns the unique identifier associated with the data.

pub fn strong_count(&self) -> usize

Returns the number of existing strong pointers to this blob.

pub fn downgrade(&self) -> WeakBlob<T>

Downgrades the shared blob to a weak reference.

Trait Implementations

impl<T> AsRef<[T]> for Blob<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Blob<T>

fn clone(&self) -> Blob<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Blob<T>

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

Formats the value using the given formatter.

impl<T> From<Vec<T>> for Blob<T>

where T: 'static + Send + Sync,

fn from(vec: Vec<T>) -> Blob<T>

Converts to this type from the input type.

impl<T> PartialEq for Blob<T>

fn eq(&self, other: &Blob<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.