Enum OutputBound

#[non_exhaustive]
pub enum OutputBound {
    OneToOne,
    AtMost {
        max: usize,
    },
    Unbounded,
}

Upper bound on how many outputs an operation produces per input element.

Declared so a caller can size a destination buffer before the operation runs. That is what makes a scan-then-scatter implementation possible: with a per-element bound, exclusive-prefix-summing the per-element counts gives every worker a disjoint write offset, so no lock, no atomic counter, and no dynamically growing vector is needed on the hot path.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

OneToOne

Exactly one output per input. The output index equals the input index.

AtMost

At most max outputs per input element.

Fields

max: usize

Inclusive upper bound per element.

Unbounded

The output count cannot be bounded before running.

Callers must fall back to a growable collection. Kept representable and deliberately unpleasant so an operation that could declare a bound is not tempted to shrug.

Implementations

impl OutputBound

pub const fn upper_bound(self, elements: usize) -> Option<usize>

Worst-case total outputs for elements inputs, or None if unbounded or the product would overflow.

pub const fn is_preallocatable(self, elements: usize) -> bool

Whether a caller can preallocate an exact destination for elements.

pub fn write_offsets(self, counts: &[usize]) -> Option<(Vec<usize>, usize)>

Exclusive prefix sum of counts, plus the total.

This is the scan that turns “how many outputs does each element make?” into “where does each element write?”. Returns None if any count exceeds this bound (a provider contract violation) or the total overflows. Allocation is the caller’s single result buffer; the scan itself is a running total with no per-element allocation.

Trait Implementations

impl Clone for OutputBound

fn clone(&self) -> OutputBound

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OutputBound

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

Formats the value using the given formatter.

impl Hash for OutputBound

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for OutputBound

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for OutputBound

impl Eq for OutputBound

impl StructuralPartialEq for OutputBound