Struct RealtimePipeline 

pub struct RealtimePipeline<T: Send + 'static, O: Send + 'static> { /* private fields */ }

Real-time streaming pipeline with backpressure.

Wraps any StreamingPipeline with a bounded input queue and drives it from a background worker thread. Flow control works as follows:

• send blocks the caller when the queue is full — the producer is naturally throttled without any explicit rate-limiter code.
• try_send never blocks; it drops the item and increments RealtimeMetrics::items_dropped when the queue is full.
• Call finish to close the input, drain remaining items, join the worker, and retrieve the pipeline’s final output.
• Dropping the pipeline without calling finish is safe: the channel is closed and the worker is joined in the Drop impl (result discarded).

Example

use threecrate_algorithms::streaming::{
    StreamingCollector, BackpressureConfig, RealtimePipeline,
};
use threecrate_core::Point3f;

let config = BackpressureConfig { max_queue_depth: 64, chunk_size: 16, ..Default::default() };
let rt = RealtimePipeline::new(StreamingCollector::new(), config);
for i in 0..50_u32 {
    rt.send(Point3f::new(i as f32, 0.0, 0.0)).unwrap();
}
let cloud = rt.finish().unwrap();
assert_eq!(cloud.len(), 50);

Implementations

impl<T: Send + 'static, O: Send + 'static> RealtimePipeline<T, O>

pub fn new<P>(pipeline: P, config: BackpressureConfig) -> Self

where P: StreamingPipeline<T, Output = O> + Send + 'static,

Create a new real-time pipeline backed by pipeline.

The worker thread starts immediately and is ready to receive items.

pub fn send(&self, item: T) -> Result<()>

Send an item, blocking until queue space is available (backpressure).

Returns Err if the worker thread has unexpectedly terminated.

pub fn try_send(&self, item: T) -> Result<bool>

Try to send without blocking.

Returns Ok(true) when the item was queued, Ok(false) when the queue was full and the item was dropped (counted in RealtimeMetrics::items_dropped). Returns Err if the worker has terminated unexpectedly.

pub fn metrics(&self) -> RealtimeMetrics

Snapshot current pipeline metrics.

pub fn finish(self) -> Result<O>

Close the input queue, wait for the worker to drain all buffered items, and return the pipeline’s final output.

Trait Implementations

impl<T: Send + 'static, O: Send + 'static> Drop for RealtimePipeline<T, O>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.