Struct arrow::buffer::MutableBuffer

pub struct MutableBuffer { /* fields omitted */ }

Similar to Buffer, but is growable and can be mutated. A mutable buffer can be converted into a immutable buffer via the freeze method.

Implementations

impl MutableBuffer

pub fn new(capacity: usize) -> Self

Allocate a new mutable buffer with initial capacity to be capacity.

pub fn with_bitset(self, end: usize, val: bool) -> Self

Set the bits in the range of [0, end) to 0 (if val is false), or 1 (if val is true). Also extend the length of this buffer to be end.

This is useful when one wants to clear (or set) the bits and then manipulate the buffer directly (e.g., modifying the buffer by holding a mutable reference from data_mut()).

pub fn set_null_bits(&mut self, start: usize, count: usize)

Ensure that count bytes from start contain zero bits

This is used to initialize the bits in a buffer, however, it has no impact on the len of the buffer and so can be used to initialize the memory region from len to capacity.

pub fn reserve(&mut self, capacity: usize) -> Result<usize>

Ensures that this buffer has at least capacity slots in this buffer. This will also ensure the new capacity will be a multiple of 64 bytes.

Returns the new capacity for this buffer.

pub fn resize(&mut self, new_len: usize) -> Result<()>

Resizes the buffer so that the len will equal to the new_len.

If new_len is greater than len, the buffer's length is simply adjusted to be the former, optionally extending the capacity. The data between len and new_len will be zeroed out.

If new_len is less than len, the buffer will be truncated.

pub fn is_empty(&self) -> bool

Returns whether this buffer is empty or not.

pub fn len(&self) -> usize

Returns the length (the number of bytes written) in this buffer.

pub fn capacity(&self) -> usize

Returns the total capacity in this buffer.

pub fn clear(&mut self)

Clear all existing data from this buffer.

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

Returns the data stored in this buffer as a slice.

pub fn data_mut(&mut self) -> &mut [u8]

Returns the data stored in this buffer as a mutable slice.

pub fn raw_data(&self) -> *const u8

Returns a raw pointer for this buffer.

Note that this should be used cautiously, and the returned pointer should not be stored anywhere, to avoid dangling pointers.

pub fn raw_data_mut(&mut self) -> *mut u8

pub fn freeze(self) -> Buffer

Freezes this buffer and return an immutable version of it.

pub fn typed_data_mut<T: ArrowNativeType + Num>(&mut self) -> &mut [T]

View buffer as typed slice.

pub fn write_bytes(&mut self, bytes: &[u8], len_added: usize) -> Result<()>

Writes a byte slice to the underlying buffer and updates the len, i.e. the number array elements in the buffer. Also, converts the io::Result required by the Write trait to the Arrow Result type.

Trait Implementations

impl Debug for MutableBuffer

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

Formats the value using the given formatter.

impl Drop for MutableBuffer

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<MutableBuffer> for MutableBuffer

fn eq(&self, other: &MutableBuffer) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Send for MutableBuffer

impl Sync for MutableBuffer

impl Write for MutableBuffer

fn write(&mut self, buf: &[u8]) -> IoResult<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> IoResult<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

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

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.