Struct FrameAdapter 

pub struct FrameAdapter { /* private fields */ }

Converts a point buffer (frame) into a continuous stream.

The adapter cycles through the frame’s points, filling buffers via the fill_chunk() method for use with Stream::run().

Update semantics

• update() sets the pending frame (latest-wins if called multiple times)
• When the current frame ends, any pending frame becomes current immediately (even mid-chunk), ensuring clean frame-to-frame transitions

Example

use laser_dac::{Frame, FrameAdapter, LaserPoint};

let mut adapter = FrameAdapter::new();
adapter.update(Frame::new(vec![
    LaserPoint::new(0.5, 0.0, 65535, 0, 0, 65535),
]));
let shared = adapter.shared();

stream.run(
    |req, buffer| shared.fill_chunk(req, buffer),
    |err| eprintln!("Error: {}", err),
)?;

Implementations

impl FrameAdapter

pub fn new() -> Self

Creates a new adapter with an empty frame.

Call update() to set the initial frame before streaming.

pub fn update(&mut self, frame: Frame)

Sets the pending frame.

The frame becomes current when the current frame ends (all points output). If called multiple times before a swap, only the most recent frame is kept (latest-wins).

pub fn fill_chunk( &mut self, req: &ChunkRequest, buffer: &mut [LaserPoint], ) -> ChunkResult

Fill the provided buffer with points from the current frame.

This is the new zero-allocation API that fills a library-owned buffer instead of allocating a new Vec on each call.

Cycles through the current frame. When the frame ends and a pending frame is available, switches immediately (even mid-chunk).

Returns

• ChunkResult::Filled(n) - Wrote n points (always req.target_points)
• ChunkResult::Starved - Never returned (adapter always has points to output)
• ChunkResult::End - Never returned (adapter cycles indefinitely)

pub fn shared(self) -> SharedFrameAdapter

Returns a thread-safe handle for updating frames from another thread.

Trait Implementations

impl Default for FrameAdapter

fn default() -> Self

Returns the “default value” for a type.