Struct symbolic_common::ByteView

pub struct ByteView<'a> { /* fields omitted */ }

A smart pointer for byte data.

This type can be used to uniformly access bytes that were created either from mmapping in a path, a vector or a borrowed slice. A ByteView dereferences into a &[u8] and guarantees random access to the underlying buffer or file.

A ByteView can be constructed from borrowed slices, vectors or memory mapped from the file system directly.

Example

The most common way to use ByteView is to construct it from a file handle. This will own the underlying file handle until the ByteView is dropped:

use std::io::Write;
use symbolic_common::ByteView;

fn main() -> Result<(), std::io::Error> {
    let mut file = tempfile::tempfile()?;
    file.write_all(b"1234");

    let view = ByteView::map_file(file)?;
    assert_eq!(view.as_slice(), b"1234");
Ok(())
}

Implementations

impl<'a> ByteView<'a>

pub fn from_cow(cow: Cow<'a, [u8]>) -> Self

Constructs a ByteView from a Cow.

Example

use std::borrow::Cow;
use symbolic_common::ByteView;

let cow = Cow::Borrowed(&b"1234"[..]);
let view = ByteView::from_cow(cow);

pub fn from_slice(buffer: &'a [u8]) -> Self

Constructs a ByteView from a byte slice.

Example

use symbolic_common::ByteView;

let view = ByteView::from_slice(b"1234");

pub fn from_vec(buffer: Vec<u8>) -> Self

Constructs a ByteView from a vector of bytes.

Example

use symbolic_common::ByteView;

let vec = b"1234".to_vec();
let view = ByteView::from_vec(vec);

pub fn map_file(file: File) -> Result<Self, Error>

Constructs a ByteView from an open file handle by memory mapping the file.

Example

use std::io::Write;
use symbolic_common::ByteView;

fn main() -> Result<(), std::io::Error> {
    let mut file = tempfile::tempfile()?;
    let view = ByteView::map_file(file)?;
    Ok(())
}

pub fn read<R: Read>(reader: R) -> Result<Self, Error>

Constructs a ByteView from any std::io::Reader.

Note: This currently consumes the entire reader and stores its data in an internal buffer. Prefer open when reading from the file system or from_slice / from_vec for in-memory operations. This behavior might change in the future.

Example

use std::io::Cursor;
use symbolic_common::ByteView;

fn main() -> Result<(), std::io::Error> {
    let reader = Cursor::new(b"1234");
    let view = ByteView::read(reader)?;
    Ok(())
}

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, Error>

Constructs a ByteView from a file path by memory mapping the file.

Example

use symbolic_common::ByteView;

fn main() -> Result<(), std::io::Error> {
    let view = ByteView::open("test.txt")?;
    Ok(())
}

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

Returns a slice of the underlying data.

Example

use symbolic_common::ByteView;

let view = ByteView::from_slice(b"1234");
let data = view.as_slice();

Trait Implementations

impl<'_> AsRef<[u8]> for ByteView<'_>

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

Performs the conversion.

impl<'a> Clone for ByteView<'a>

fn clone(&self) -> ByteView<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ByteView<'a>

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

Formats the value using the given formatter.

impl<'_> Deref for ByteView<'_>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'_> StableDeref for ByteView<'_>