Struct arrow_array::builder::BufferBuilder
source · pub struct BufferBuilder<T>where
T: ArrowNativeType,{ /* private fields */ }
Expand description
Builder for creating a Buffer object.
A Buffer is the underlying data structure of Arrow’s Arrays.
For all supported types, there are type definitions for the
generic version of BufferBuilder<T>
, e.g. BufferBuilder
.
§Example:
let mut builder = BufferBuilder::<u8>::new(100);
builder.append_slice(&[42, 43, 44]);
builder.append(45);
let buffer = builder.finish();
assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 43, 44, 45]);
Implementations§
source§impl<T> BufferBuilder<T>where
T: ArrowNativeType,
impl<T> BufferBuilder<T>where
T: ArrowNativeType,
sourcepub fn new(capacity: usize) -> BufferBuilder<T>
pub fn new(capacity: usize) -> BufferBuilder<T>
Creates a new builder with initial capacity for at least capacity
elements of type T
.
The capacity can later be manually adjusted with the
reserve()
method.
Also the
append()
,
append_slice()
and
advance()
methods automatically increase the capacity if needed.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
assert!(builder.capacity() >= 10);
sourcepub fn new_from_buffer(buffer: MutableBuffer) -> BufferBuilder<T>
pub fn new_from_buffer(buffer: MutableBuffer) -> BufferBuilder<T>
Creates a new builder from a MutableBuffer
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the current number of array elements in the internal buffer.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.append(42);
assert_eq!(builder.len(), 1);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns whether the internal buffer is empty.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.append(42);
assert_eq!(builder.is_empty(), false);
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the actual capacity (number of elements) of the internal buffer.
Note: the internal capacity returned by this method might be larger than
what you’d expect after setting the capacity in the new()
or reserve()
functions.
sourcepub fn advance(&mut self, i: usize)
pub fn advance(&mut self, i: usize)
Increases the number of elements in the internal buffer by n
and resizes the buffer as needed.
The values of the newly added elements are 0.
This method is usually used when appending NULL
values to the buffer
as they still require physical memory space.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.advance(2);
assert_eq!(builder.len(), 2);
sourcepub fn reserve(&mut self, n: usize)
pub fn reserve(&mut self, n: usize)
Reserves memory for at least n
more elements of type T
.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.reserve(10);
assert!(builder.capacity() >= 20);
sourcepub fn append(&mut self, v: T)
pub fn append(&mut self, v: T)
Appends a value of type T
into the builder,
growing the internal buffer as needed.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.append(42);
assert_eq!(builder.len(), 1);
sourcepub fn append_n(&mut self, n: usize, v: T)
pub fn append_n(&mut self, n: usize, v: T)
Appends a value of type T
into the builder N times,
growing the internal buffer as needed.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.append_n(10, 42);
assert_eq!(builder.len(), 10);
sourcepub fn append_n_zeroed(&mut self, n: usize)
pub fn append_n_zeroed(&mut self, n: usize)
Appends n
, zero-initialized values
§Example:
let mut builder = BufferBuilder::<u32>::new(10);
builder.append_n_zeroed(3);
assert_eq!(builder.len(), 3);
assert_eq!(builder.as_slice(), &[0, 0, 0])
sourcepub fn append_slice(&mut self, slice: &[T])
pub fn append_slice(&mut self, slice: &[T])
Appends a slice of type T
, growing the internal buffer as needed.
§Example:
let mut builder = BufferBuilder::<u8>::new(10);
builder.append_slice(&[42, 44, 46]);
assert_eq!(builder.len(), 3);
sourcepub fn as_slice(&self) -> &[T]
pub fn as_slice(&self) -> &[T]
View the contents of this buffer as a slice
let mut builder = BufferBuilder::<f64>::new(10);
builder.append(1.3);
builder.append_n(2, 2.3);
assert_eq!(builder.as_slice(), &[1.3, 2.3, 2.3]);
sourcepub fn as_slice_mut(&mut self) -> &mut [T]
pub fn as_slice_mut(&mut self) -> &mut [T]
View the contents of this buffer as a mutable slice
§Example:
let mut builder = BufferBuilder::<f32>::new(10);
builder.append_slice(&[1., 2., 3.4]);
assert_eq!(builder.as_slice(), &[1., 2., 3.4]);
builder.as_slice_mut()[1] = 4.2;
assert_eq!(builder.as_slice(), &[1., 4.2, 3.4]);
sourcepub fn truncate(&mut self, len: usize)
pub fn truncate(&mut self, len: usize)
Shorten this BufferBuilder to len
items
If len
is greater than the builder’s current length, this has no effect
§Example:
let mut builder = BufferBuilder::<u16>::new(10);
builder.append_slice(&[42, 44, 46]);
assert_eq!(builder.as_slice(), &[42, 44, 46]);
builder.truncate(2);
assert_eq!(builder.as_slice(), &[42, 44]);
builder.append(12);
assert_eq!(builder.as_slice(), &[42, 44, 12]);
sourcepub unsafe fn append_trusted_len_iter(
&mut self,
iter: impl IntoIterator<Item = T>,
)
pub unsafe fn append_trusted_len_iter( &mut self, iter: impl IntoIterator<Item = T>, )
§Safety
This requires the iterator be a trusted length. This could instead require
the iterator implement TrustedLen
once that is stabilized.
Trait Implementations§
source§impl<T> Debug for BufferBuilder<T>where
T: Debug + ArrowNativeType,
impl<T> Debug for BufferBuilder<T>where
T: Debug + ArrowNativeType,
source§impl<T> Default for BufferBuilder<T>where
T: ArrowNativeType,
impl<T> Default for BufferBuilder<T>where
T: ArrowNativeType,
source§fn default() -> BufferBuilder<T>
fn default() -> BufferBuilder<T>
source§impl<T> Extend<T> for BufferBuilder<T>where
T: ArrowNativeType,
impl<T> Extend<T> for BufferBuilder<T>where
T: ArrowNativeType,
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)