Struct ExecutionOptions

pub struct ExecutionOptions { /* private fields */ }

Operation policy with explicit tolerance, precision, and cancellation.

Deliberately not Copy: it carries a shared CancellationToken, and an implicitly copied cancellation handle is a footgun. Callers clone when they mean to share the token and construct fresh options when they do not.

Implementations

impl ExecutionOptions

pub const fn new(tolerance: Tolerance) -> ExecutionOptions

Start from the required model-aware tolerance.

pub fn with_tolerance(self, tolerance: Tolerance) -> ExecutionOptions

Replace the tolerance while preserving every other execution policy.

Compilers use this when evaluating geometry in a transformed local coordinate system. Cloning first keeps cancellation, budgets, determinism, residency, and provider preferences intact.

pub fn with_cancellation(self, token: CancellationToken) -> ExecutionOptions

Attach a cooperative cancellation token.

Absent a token, an operation runs to completion; there is no ambient cancellation source. Providers declare how finely they poll via crate::CancellationGranularity, so a caller can see the real latency.

pub fn cancellation(&self) -> Option<&CancellationToken>

The attached cancellation token, if any.

pub fn check_cancelled(&self) -> Result<(), GeomError>

Err(GeomError::Cancelled) if a token is attached and cancelled.

The call providers make at each poll point: options.check_cancelled()?. Cheap (one relaxed load) and a no-op when no token is attached.

pub fn with_precision(self, precision: Precision) -> ExecutionOptions

Set required precision.

pub fn with_determinism(self, value: Determinism) -> ExecutionOptions

Set determinism requirement.

pub fn with_parallelism(self, value: Parallelism) -> Option<ExecutionOptions>

Set scheduling preference. Returns None for zero explicit threads.

pub fn with_device(self, value: DevicePreference) -> ExecutionOptions

Set device preference.

pub fn with_residency(self, value: DataResidency) -> ExecutionOptions

Declare where inputs live and where outputs are wanted.

pub fn with_chord_error(self, value: f64) -> Option<ExecutionOptions>

Bound how far flattened curves may deviate from the exact curve.

Curved geometry that a provider approximates with straight chords (profile arcs, sweep directrices, curved B-rep faces) stays within this distance of the exact curve. Without it the chord budget is the linear tolerance, which is a coincidence tolerance and coarse for small radii: at Tolerance::MILLIMETRE a 5 mm arc gets four chords per half turn. Quantity take-off wants a tighter budget than display.

Returns None for a non-finite or non-positive value. A provider may still refuse a budget too fine to meet within its own work limits.

pub fn chord_error(&self) -> Option<f64>

The explicit chord budget, if one was set.

None means the provider uses its default, the linear tolerance.

pub fn with_memory_budget(self, bytes: usize) -> ExecutionOptions

Bound temporary allocation.

pub fn tolerance(&self) -> Tolerance

Tolerance.

pub fn precision(&self) -> Precision

Precision.

pub fn determinism(&self) -> Determinism

Determinism requirement.

pub fn parallelism(&self) -> Parallelism

Scheduling preference.

pub fn device(&self) -> DevicePreference

Device preference.

pub fn memory_budget_bytes(&self) -> Option<usize>

Optional temporary-memory budget.

pub fn residency(&self) -> DataResidency

Where inputs live and where outputs are wanted.

pub fn charge_scratch(&self, bytes: usize) -> Result<(), GeomError>

Charge bytes of scratch against the budget before allocating it.

The budget is only real if something checks it, so this is the single enforcement point every hot path routes through. Backends must call it before the allocation, not after: reporting an overrun once the allocation already succeeded defeats the purpose of a budget.

Trait Implementations

impl Clone for ExecutionOptions

fn clone(&self) -> ExecutionOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionOptions

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

Formats the value using the given formatter.

impl PartialEq for ExecutionOptions

fn eq(&self, other: &ExecutionOptions) -> 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 StructuralPartialEq for ExecutionOptions