Struct Section

Source

pub struct Section<V, S: Storage<V>> { /* private fields */ }

Implementations§

Source §

impl<V, S> Section<V, S>
where S: Storage<V>,

Source

pub fn try_restrict(&self, p: PointId) -> Result<&[V], MeshSieveError>

Read-only view of the data slice for a given point p.

§Errors

Returns Err(PointNotInAtlas(p)) if the point is not registered in the atlas, or Err(MissingSectionPoint(p)) if the data buffer is inconsistent.

Source

pub fn try_restrict_mut( &mut self, p: PointId, ) -> Result<&mut [V], MeshSieveError>

Mutable view of the data slice for a given point p.

§Errors

Returns Err(PointNotInAtlas(p)) if the point is not registered in the atlas, or Err(MissingSectionPoint(p)) if the data buffer is inconsistent.

Source

pub fn atlas(&self) -> &Atlas

Read-only handle to the backing atlas.

Mutations must go through with_atlas_mut to keep Section and its data buffer consistent.

§Complexity

O(1).

Source

pub fn iter(&self) -> impl Iterator<Item = (PointId, &[V])> + '_

Iterate over (PointId, &[V]) for all points in atlas order.

Source

pub fn as_flat_slice(&self) -> &[V]

Read-only view of the entire flat buffer in insertion order.

Source

pub fn for_each_in_order_mut<F>(&mut self, f: F)
where F: FnMut(PointId, &mut [V]),

Apply a closure to every (PointId, &mut [V]) in insertion order.

Source

pub fn for_each_in_order<F>(&self, f: F)
where F: FnMut(PointId, &[V]),

Read-only variant of [for_each_in_order_mut].

Source §

impl<V: Clone + Default, S: Storage<V>> Section<V, S>

Source

pub fn gather_in_order(&self) -> Vec<V>

Gather the entire section into a flat buffer in insertion order.

Source

pub fn try_set(&mut self, p: PointId, val: &[V]) -> Result<(), MeshSieveError>

Overwrite the data slice at point p with the values in val.

§Errors

Returns Err(PointNotInAtlas(p)) if the point is not registered in the atlas, or Err(SliceLengthMismatch) if the input slice length does not match the expected length.

Source

pub fn try_remove_point(&mut self, p: PointId) -> Result<(), MeshSieveError>

Remove a point from the section, rebuilding data to keep slices contiguous.

§Errors

Returns Err(MissingSectionPoint) if a point is missing from the old atlas or data.

§Complexity

O(n) atlas reindex + O(total_len_new) data rebuild.

§Determinism

Deterministic rebuild in insertion order with no gaps.

Source

pub fn try_apply_delta_between_points<D: SliceDelta<V>>( &mut self, src_point: PointId, dst_point: PointId, delta: &D, ) -> Result<(), MeshSieveError>

Apply a delta from src_point → dst_point directly within the section buffer.

In debug builds or when the strict-invariants feature (or alias check-invariants) is enabled, section invariants are validated before and after applying the delta. Violations panic prior to any slicing.

If the underlying slices do not overlap, the delta is applied without any additional allocation. Otherwise, the source slice is first copied into a temporary buffer to maintain aliasing safety.

§Errors

MeshSieveError::PointNotInAtlas if either point is missing.
MeshSieveError::SliceLengthMismatch if the slice lengths differ.
MeshSieveError::MissingSectionPoint if either slice is out of bounds.
MeshSieveError::ScatterChunkMismatch if an offset/length overflows.

Source

pub fn try_scatter_from( &mut self, other: &[V], atlas_map: &[(usize, usize)], ) -> Result<(), MeshSieveError>

Scatter values from an external buffer other into this section.

§Errors

Returns Err(ScatterLengthMismatch) if the input length does not match expected, or Err(ScatterChunkMismatch) if a chunk is out of bounds.

§Complexity

O(total_len) to copy slices; validates bounds in O(n) where n is points.

§Determinism

Deterministic copy; *_with_plan additionally validates the plan version for safety.

Source

pub fn try_scatter_with_plan( &mut self, buf: &[V], plan: &ScatterPlan, ) -> Result<(), MeshSieveError>

Scatter using a precomputed plan; fails if the atlas has changed.

§Complexity

O(total_len) to copy slices; validates bounds in O(n) where n is points.

§Determinism

Deterministic copy; *_with_plan additionally validates the plan version for safety.

Source §

impl<V: Clone + Default, S: Storage<V> + Clone> Section<V, S>

Source

pub fn new(atlas: Atlas) -> Self

Construct a new Section given an existing Atlas.

Initializes the data buffer with V::default() repeated for each degree of freedom in the atlas.

§Complexity

O(total_len) to fill with V::default().

§Determinism

Initial layout matches the atlas’ insertion order deterministically.

Source

pub fn try_add_point( &mut self, p: PointId, len: usize, ) -> Result<(), MeshSieveError>

Add a new point to the section, resizing data as needed.

§Errors

Returns Err(AtlasInsertionFailed) if the atlas insertion fails.

§Complexity

O(n) atlas insertion (reindex) + O(total_len_new) data resize.

§Determinism

Data remains contiguous in insertion order; the new point is appended.

Source

pub fn with_atlas_mut<F>(&mut self, f: F) -> Result<(), MeshSieveError>
where F: FnOnce(&mut Atlas),

Safely mutate the atlas and rebuild data to remain consistent.

New points get len default-initialized values.
Removed points drop data.
Reordered/retuned points keep their old values (by PointId), copied into the new contiguous layout.
Length changes for existing points are rejected. Use with_atlas_resize to allow slice length changes with an explicit policy.

§Errors

Returns MeshSieveError::AtlasPointLengthChanged if any existing point’s slice length differs after mutation.

§Complexity

O(n) mapping + O(total_len_new) copy/initialize.

§Determinism

Rebuild order follows atlas insertion order deterministically.

Source

pub fn with_atlas_resize<F>( &mut self, policy: ResizePolicy<V>, f: F, ) -> Result<(), MeshSieveError>
where F: FnOnce(&mut Atlas),

Mutate the atlas, allowing slice length changes per policy.

Existing points preserve or initialize values according to policy. New points are initialized per policy as well. Removed points drop their data. On error, the atlas and data are rolled back to their original state.

Source