Struct harfbuzz_rs::Blob

#[repr(C)]
pub struct Blob<'a> { /* fields omitted */ }

A Blob manages raw data like e.g. file contents. It refers to a slice of bytes that can be either owned by the Blob or not.

It is used to provide access to memory for Face and Font. Typically it contains the raw font data (e.g. an entire font file or font tables). To enable shared usage of its data it uses a reference counting mechanism making the clone operation very cheap as no data is cloned.

Construction

A Blob implements Into for every type that satisfies the AsRef<[u8]> trait such as Vec<u8> and Box<[u8]> so owned blobs can be created easily from standard Rust objects.

You can also create Blobs that contain borrowed data using the constructors Blob::with_bytes and Blob::with_bytes_mut for immutable and mutable access respectively.

Methods

impl<'a> Blob<'a>

pub fn with_bytes(bytes: &'a [u8]) -> Owned<Blob<'a>>

Create a new Blob from the slice bytes. The blob will not own the slice's data.

pub fn with_bytes_mut(bytes: &'a mut [u8]) -> Owned<Blob<'a>>

Create a new Blob from the mutable slice bytes. The blob will not own the slice's data.

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Shared<Blob<'static>>>

Create a Blob from the contents of the file at path whose contents will be read into memory.

The result will be either a Blob that owns the file's contents or an error that happened while trying to read the file.

This can be a performance problem if the file is very big. If this turns out to be a problem consider mmaping the file or splitting it into smaller chunks before creating a Blob.

pub fn get_data(&self) -> &[u8]

Get a slice of the Blob's bytes.

pub fn create_sub_blob(&self, offset: usize, length: usize) -> Shared<Blob<'a>>

Creates an immutable Blob that contains part of the data of the parent Blob. The parent Blob will be immutable after this and the subBlob cannot outlive its parent.

Arguments

• offset: Byte-offset of sub-blob within parent.
• length: Length of the sub-blob.

pub fn is_immutable(&self) -> bool

Returns true if the blob is immutable.

HarfBuzz internally uses this value to make sure the blob is not mutated after being shared. In Rust this is not really necessary due to the borrow checker. This method is provided regardless for completeness.

pub fn make_immutable(&mut self)

Makes this blob immutable so the bytes it refers to will never change during its lifetime.

pub fn try_get_mut_data(&mut self) -> Option<&'a mut [u8]>

Try to get a mutable slice of the Blob's bytes, possibly copying them.

This returns None if the blob is immutable or memory allocation failed.

Trait Implementations

impl<'a> HarfbuzzObject for Blob<'a>

type Raw = hb_blob_t

Type of the raw harfbuzz object.

unsafe fn from_raw(raw: *const hb_blob_t) -> Self

Creates a reference from a harfbuzz object pointer.

fn as_raw(&self) -> *mut hb_blob_t

Returns the underlying harfbuzz object pointer.

unsafe fn reference(&self)

Increases the reference count of the HarfBuzz object.

unsafe fn dereference(&self)

Decreases the reference count of the HarfBuzz object and destroys it if the reference count reaches zero.

impl<'a> Send for Blob<'a>

impl<'a> Sync for Blob<'a>

impl<'a> AsRef<[u8]> for Blob<'a>

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

Performs the conversion.

impl<'a> Deref for Blob<'a>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &[u8]

Dereferences the value.

impl<'a> Debug for Blob<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.