Struct pasture_core::containers::HashMapBuffer

pub struct HashMapBuffer { /* private fields */ }

A point buffer that stores point data in columnar memory layout, using a HashMap<PointAttributeDefinition, Vec<u8>> as its underlying storage

Implementations

impl HashMapBuffer

pub fn with_capacity(capacity: usize, point_layout: PointLayout) -> Self

Creates a new HashMapBuffer with the given capacity and point_layout. It preallocates enough memory to store at least capacity points

pub fn begin_push_attributes(&mut self) -> HashMapBufferAttributePusher<'_>

Create a new helper object through which ranges of attribute data can be pushed into this buffer

pub fn filter<B: for<'a> OwningBuffer<'a> + for<'a> MakeBufferFromLayout<'a>, F: Fn(usize) -> bool>( &self, predicate: F ) -> B

Like Iterator::filter, but filters into a point buffer of type B

pub fn filter_into<B: for<'a> BorrowedMutBuffer<'a>, F: Fn(usize) -> bool>( &self, buffer: &mut B, predicate: F, num_matches_hint: Option<usize> )

Like filter, but writes the filtered points into the given buffer

panics

If buffer.len() is less than the number of matching points according to predicate If the PointLayout of buffer does not match the PointLayout of self

Trait Implementations

impl<'a> BorrowedBuffer<'a> for HashMapBuffer

where HashMapBuffer: 'a,

fn len(&self) -> usize

Returns the length of this buffer, i.e. the number of points

fn point_layout(&self) -> &PointLayout

Returns the PointLayout of this buffer. The PointLayout describes the structure of a single point at runtime.

fn get_point(&self, index: usize, data: &mut [u8])

Writes the data for the point at index from this buffer into data

fn get_point_range(&self, range: Range<usize>, data: &mut [u8])

Writes the data for the given range of points from this buffer into data

fn get_attribute( &self, attribute: &PointAttributeDefinition, index: usize, data: &mut [u8] )

Writes the data for the given attribute of the point at index into data

unsafe fn get_attribute_unchecked( &self, attribute_member: &PointAttributeMember, index: usize, data: &mut [u8] )

Like get_attribute, but performs no check whether the attribute actually is part of this buffers PointLayout or not. Because of this, this function accepts a PointAttributeMember instead of a PointAttributeDefinition, and this PointAttributeMember must come from the PointLayout of this buffer! The benefit over get_attribute is that this function skips the include checks and thus will be faster if you repeatedly want to get data for a single attribute

fn as_columnar(&self) -> Option<&dyn ColumnarBuffer<'a>>

Try to get a reference to self as a ColumnarBuffer. Returns None if self does not implement ColumnarBuffer

fn is_empty(&self) -> bool

Returns true if this buffer does not store any points

fn get_attribute_range( &self, attribute: &PointAttributeDefinition, point_range: Range<usize>, data: &mut [u8] )

Writes the data for the given attribute of the given range of points into data. The attribute data will be tightly packed in data, irregardless of the memory layout of this buffer. The attribute values might not be correctly aligned, if the alignment requirement of attribute.datatype() is larger than the size of the attribute. All of the built-in attributes in pasture have alignments that are less than or equal to their size, so for built-in attributes you can assume that the attributes in data are correctly aligned.

fn view<'b, T: PointType>(&'b self) -> PointView<'a, 'b, Self, T>

where Self: Sized, 'a: 'b,

Get a strongly typed view of the point data of this buffer

fn view_attribute<'b, T: PrimitiveType>( &'b self, attribute: &PointAttributeDefinition ) -> AttributeView<'a, 'b, Self, T>

where Self: Sized, 'a: 'b,

Gets a strongly typed view of the attribute of all points in this buffer

fn view_attribute_with_conversion<'b, T: PrimitiveType>( &'b self, attribute: &PointAttributeDefinition ) -> Result<AttributeViewConverting<'a, 'b, Self, T>>

where Self: Sized, 'a: 'b,

Like view_attribute, but allows T::data_type() to be different from the data type of
the attribute within this buffer.

fn as_interleaved(&self) -> Option<&dyn InterleavedBuffer<'a>>

Try to get a reference to self as an InterleavedBuffer. Returns None if self does not implement InterleavedBuffer

impl<'a> BorrowedMutBuffer<'a> for HashMapBuffer

where HashMapBuffer: 'a,

unsafe fn set_point(&mut self, index: usize, point_data: &[u8])

Sets the data for the point at the given index

unsafe fn set_attribute( &mut self, attribute: &PointAttributeDefinition, index: usize, attribute_data: &[u8] )

Sets the data for the given attribute of the point at index

fn swap(&mut self, from_index: usize, to_index: usize)

Swaps the two points at from_index and to_index. Implementations should allow the case where from_index == to_index

unsafe fn set_point_range( &mut self, point_range: Range<usize>, point_data: &[u8] )

Sets the data for the given range of points. This function will generally be more efficient than calling [set_point] multiple times, as [set_point] performs size and index checks on every call, whereas this function can perform them only once. Assumes that the point_data is tightly packed, i.e. stored in an interleaved format with point alignment of 1.

unsafe fn set_attribute_range( &mut self, attribute: &PointAttributeDefinition, point_range: Range<usize>, attribute_data: &[u8] )

Sets the data for the given attribute for all points in point_range. This function will generally be more efficient than calling [set_attribute] multiple times, as [set_attribute] has to perform type and bounds checks on each call.

fn as_columnar_mut(&mut self) -> Option<&mut dyn ColumnarBufferMut<'a>>

Try to get a mutable reference to self as a ColumnarBufferMut. Returns None if self does not implement ColumnarBufferMut

fn transform_attribute<'b, T: PrimitiveType, F: Fn(usize, T) -> T>( &'b mut self, attribute: &PointAttributeDefinition, func: F )

where Self: Sized, 'a: 'b,

Apply a transformation function to the given attribute of all points within this buffer. This function is helpful if you want to modify a single attribute of a buffer in-place and works for buffers of all memory layouts. For columnar buffers, prefer using get_attribute_range_mut to modify attribute data in-place.

fn view_mut<'b, T: PointType>(&'b mut self) -> PointViewMut<'a, 'b, Self, T>

where Self: Sized, 'a: 'b,

Get a strongly typed view of the point data of this buffer. This view allows mutating the point data!

fn view_attribute_mut<'b, T: PrimitiveType>( &'b mut self, attribute: &PointAttributeDefinition ) -> AttributeViewMut<'a, 'b, Self, T>

where Self: Sized, 'a: 'b,

Get a strongly typed view of the attribute of all points in this buffer. This view allows mutating the attribute data!

fn as_interleaved_mut(&mut self) -> Option<&mut dyn InterleavedBufferMut<'a>>

Try to get a mutable reference to self as an InterleavedBufferMut. Returns None if self does not implement InterleavedBufferMut

impl Clone for HashMapBuffer

fn clone(&self) -> HashMapBuffer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> ColumnarBuffer<'a> for HashMapBuffer

where HashMapBuffer: 'a,

fn get_attribute_ref<'b>( &'b self, attribute: &PointAttributeDefinition, index: usize ) -> &'b [u8]

where 'a: 'b,

Get an immutable slice to the memory of the given attribute for the point at index. See InterleavedBuffer::get_point_ref for an explanation of the lifetime bounds.

fn get_attribute_range_ref<'b>( &'b self, attribute: &PointAttributeDefinition, range: Range<usize> ) -> &'b [u8]

where 'a: 'b,

Get an immutable slice to the memory for the attribute of the given range of points

fn view_raw_attribute<'b>( &'b self, attribute: &PointAttributeMember ) -> RawAttributeView<'b>

where 'a: 'b,

Get a raw view over the given attribute from this point buffer. Unlike the typed view that view_attribute returns, this view dereferences to byte slices, but it is potentially more efficient to use than calling get_attribute repeatedly

impl<'a> ColumnarBufferMut<'a> for HashMapBuffer

where HashMapBuffer: 'a,

fn get_attribute_mut<'b>( &'b mut self, attribute: &PointAttributeDefinition, index: usize ) -> &'b mut [u8]

where 'a: 'b,

Get a mutable slice to the memory of the given attribute for the point at index. This is the mutable version of ColumnarBuffer::get_attribute_ref

fn get_attribute_range_mut<'b>( &'b mut self, attribute: &PointAttributeDefinition, range: Range<usize> ) -> &'b mut [u8]

where 'a: 'b,

Get a mutable slice to the memory for the attribute of the given range of points. This is the mutable version of ColumnarBuffer::get_attribute_range_ref

fn view_raw_attribute_mut<'b>( &'b mut self, attribute: &PointAttributeMember ) -> RawAttributeViewMut<'b>

where 'a: 'b,

Like view_raw_attribute, but returns mutable byte slices of the attribute data

impl Debug for HashMapBuffer

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

Formats the value using the given formatter.

impl<T: PointType> FromIterator<T> for HashMapBuffer

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> MakeBufferFromLayout<'a> for HashMapBuffer

fn new_from_layout(point_layout: PointLayout) -> Self

Creates a new empty buffer from the given PointLayout

impl<'a> OwningBuffer<'a> for HashMapBuffer

where HashMapBuffer: 'a,

unsafe fn push_points(&mut self, point_bytes: &[u8])

Push the raw memory for a range of points into this buffer. Works similar to Vec::push

fn resize(&mut self, count: usize)

Resize this buffer to contain exactly count points. If count is less than self.len(), point data is removed, if count is greater than self.len() new points are default-constructed (i.e. zero-initialized).

fn clear(&mut self)

Clears the contents of this buffer, removing all point data and setting the length to 0

fn append_interleaved<'b, B: InterleavedBuffer<'b>>(&mut self, other: &B)

Appends data from the given interleaved buffer to the end of this buffer

fn append_columnar<'b, B: ColumnarBuffer<'b>>(&mut self, other: &B)

Appends data from the given columnar buffer to the end of this buffer

fn append<'b, B: BorrowedBuffer<'b>>(&mut self, other: &B)

Appends data from the given buffer to the end of this buffer. Makes no assumptions about the memory layout of other. If you know the memory layout of other, consider using append_interleaved or append_columnarinstead, as these will give better performance.

impl PartialEq for HashMapBuffer

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

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

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

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

impl<'a> SliceBuffer<'a> for HashMapBuffer

where Self: 'a,

type SliceType = BufferSliceColumnar<'a, HashMapBuffer>

The slice type

fn slice(&'a self, range: Range<usize>) -> Self::SliceType

Take a immutable slice to this buffer using the given range of points

impl<'a> SliceBufferMut<'a> for HashMapBuffer

type SliceTypeMut = BufferSliceColumnarMut<'a, HashMapBuffer>

fn slice_mut(&'a mut self, range: Range<usize>) -> Self::SliceTypeMut

Take a mutable slice to this buffer using the given range of points

impl Eq for HashMapBuffer

impl StructuralEq for HashMapBuffer

impl StructuralPartialEq for HashMapBuffer