Struct IndexEmitter 

pub struct IndexEmitter<'a> { /* private fields */ }

Helper to build correct range_extractor implementations without allocations.

It enforces the extractor contract:

• Out-of-bounds indexes are ignored (and debug-asserted).
• Duplicates are ignored.
• Out-of-order indexes are ignored (and debug-asserted).

Example

use virtualizer::{IndexEmitter, Range};

let extractor = |range: Range, emit: &mut dyn FnMut(usize)| {
    let mut e = IndexEmitter::new(range, emit);
    e.emit_pinned(0);
    e.emit_overscanned();
};

Implementations

impl<'a> IndexEmitter<'a>

pub fn new(range: Range, emit: &'a mut dyn FnMut(usize)) -> Self

Examples found in repository

examples/pinned_headers.rs (line 15)

fn main() {
    // Example: pinned/sticky "headers" at fixed indexes.
    let mut opts = VirtualizerOptions::new(1_000, |_| 1);
    opts.overscan = 2;

    let pinned: Arc<[usize]> = Arc::from([0usize, 10, 20, 30, 40, 999]);
    opts.range_extractor = Some(Arc::new({
        let pinned = Arc::clone(&pinned);
        move |r: Range, emit: &mut dyn FnMut(usize)| {
            let mut e = IndexEmitter::new(r, emit);
            // IMPORTANT: indexes must be emitted in ascending order.
            //
            // We want pinned rows both before and after the overscanned range. To keep the output
            // sorted, emit:
            // 1) pinned indexes before the overscanned range
            // 2) the overscanned contiguous range
            // 3) pinned indexes after the overscanned range
            let overscanned_start = r.start_index.saturating_sub(r.overscan);
            let overscanned_end = r.end_index.saturating_add(r.overscan).min(r.count);

            for &idx in pinned.iter() {
                if idx < overscanned_start {
                    e.emit_pinned(idx);
                }
            }

            e.emit_overscanned();

            for &idx in pinned.iter() {
                if idx >= overscanned_end {
                    e.emit_pinned(idx);
                }
            }
        }
    }));

    let mut v = Virtualizer::new(opts);
    v.set_viewport_and_scroll_clamped(10, 500);

    let mut collected = Vec::new();
    v.for_each_virtual_index(|i| collected.push(i));

    println!("visible_range={:?}", v.visible_range());
    println!("virtual_range={:?}", v.virtual_range());
    println!(
        "indexes_len={} first_20={:?}",
        collected.len(),
        &collected[..20.min(collected.len())]
    );

    // A real UI would typically iterate items:
    let mut headers = 0usize;
    v.for_each_virtual_item(|it| {
        if pinned.binary_search(&it.index).is_ok() {
            headers += 1;
        }
    });
    println!("pinned_headers_in_output={headers}");
}

examples/adapter_sim.rs (line 23)

fn main() {
    // Simulate a framework adapter that owns the scroll state.
    let saved_scroll = Arc::new(AtomicU64::new(120));

    let opts = VirtualizerOptions::new(1000, |_| 1)
        .with_initial_rect(Some(Rect {
            main: 10,
            cross: 80,
        }))
        .with_initial_offset_provider({
            let saved_scroll = Arc::clone(&saved_scroll);
            move || saved_scroll.load(Ordering::Relaxed)
        })
        .with_scroll_margin(5)
        .with_range_extractor(Some(|r: Range, emit: &mut dyn FnMut(usize)| {
            // Pin a "sticky header" at index 0, regardless of scroll position.
            let mut e = virtualizer::IndexEmitter::new(r, emit);
            e.emit_pinned(0);
            e.emit_visible();
        }));

    let mut v = Virtualizer::new(opts);

    // First render: scroll offset comes from the provider.
    println!("initial scroll_offset={}", v.scroll_offset());
    println!("initial scroll_rect={:?}", v.scroll_rect());

    // Adapter updates rect + scroll offset on events.
    v.apply_scroll_frame(
        Rect {
            main: 12,
            cross: 80,
        },
        200,
        0,
    );

    let mut items = Vec::new();
    v.for_each_virtual_item_keyed(|it| items.push(it));
    println!(
        "is_scrolling={}, visible_range={:?}, items_len={}",
        v.is_scrolling(),
        v.visible_range(),
        items.len()
    );
    println!("first_item={:?}", items.first());

    // Demonstrate scroll-to helpers.
    let target = v.scroll_to_index_offset(500, Align::Start);
    v.set_scroll_offset_clamped(target);
    println!("after scroll_to_index: scroll_offset={}", v.scroll_offset());

    // Demonstrate dynamic measurement + scroll adjustment.
    let applied = v.resize_item(0, 20);
    println!("resize_item applied_scroll_adjustment={applied}");

    // Simulate reorder: change key mapping. This automatically rebuilds per-index sizes from the
    // key-based measurement cache. In real apps, you usually keep `get_item_key` stable and call
    // `sync_item_keys()` when your dataset is reordered while `count` stays the same.
    v.set_get_item_key(|i| if i == 0 { 1 } else { i as u64 });

    // Debounced scrolling reset without relying on a native scrollend event.
    v.update_scrolling(200);
    println!("after update_scrolling: is_scrolling={}", v.is_scrolling());

    // Toggle enabled to disable all queries.
    v.set_enabled(false);
    let mut disabled_len = 0usize;
    v.for_each_virtual_item(|_| disabled_len += 1);
    println!(
        "disabled total_size={}, items_len={}",
        v.total_size(),
        disabled_len
    );
}

pub fn range(&self) -> Range

pub fn emit(&mut self, index: usize)

pub fn emit_pinned(&mut self, index: usize)

Examples found in repository

examples/pinned_headers.rs (line 28)

fn main() {
    // Example: pinned/sticky "headers" at fixed indexes.
    let mut opts = VirtualizerOptions::new(1_000, |_| 1);
    opts.overscan = 2;

    let pinned: Arc<[usize]> = Arc::from([0usize, 10, 20, 30, 40, 999]);
    opts.range_extractor = Some(Arc::new({
        let pinned = Arc::clone(&pinned);
        move |r: Range, emit: &mut dyn FnMut(usize)| {
            let mut e = IndexEmitter::new(r, emit);
            // IMPORTANT: indexes must be emitted in ascending order.
            //
            // We want pinned rows both before and after the overscanned range. To keep the output
            // sorted, emit:
            // 1) pinned indexes before the overscanned range
            // 2) the overscanned contiguous range
            // 3) pinned indexes after the overscanned range
            let overscanned_start = r.start_index.saturating_sub(r.overscan);
            let overscanned_end = r.end_index.saturating_add(r.overscan).min(r.count);

            for &idx in pinned.iter() {
                if idx < overscanned_start {
                    e.emit_pinned(idx);
                }
            }

            e.emit_overscanned();

            for &idx in pinned.iter() {
                if idx >= overscanned_end {
                    e.emit_pinned(idx);
                }
            }
        }
    }));

    let mut v = Virtualizer::new(opts);
    v.set_viewport_and_scroll_clamped(10, 500);

    let mut collected = Vec::new();
    v.for_each_virtual_index(|i| collected.push(i));

    println!("visible_range={:?}", v.visible_range());
    println!("virtual_range={:?}", v.virtual_range());
    println!(
        "indexes_len={} first_20={:?}",
        collected.len(),
        &collected[..20.min(collected.len())]
    );

    // A real UI would typically iterate items:
    let mut headers = 0usize;
    v.for_each_virtual_item(|it| {
        if pinned.binary_search(&it.index).is_ok() {
            headers += 1;
        }
    });
    println!("pinned_headers_in_output={headers}");
}

examples/adapter_sim.rs (line 24)

fn main() {
    // Simulate a framework adapter that owns the scroll state.
    let saved_scroll = Arc::new(AtomicU64::new(120));

    let opts = VirtualizerOptions::new(1000, |_| 1)
        .with_initial_rect(Some(Rect {
            main: 10,
            cross: 80,
        }))
        .with_initial_offset_provider({
            let saved_scroll = Arc::clone(&saved_scroll);
            move || saved_scroll.load(Ordering::Relaxed)
        })
        .with_scroll_margin(5)
        .with_range_extractor(Some(|r: Range, emit: &mut dyn FnMut(usize)| {
            // Pin a "sticky header" at index 0, regardless of scroll position.
            let mut e = virtualizer::IndexEmitter::new(r, emit);
            e.emit_pinned(0);
            e.emit_visible();
        }));

    let mut v = Virtualizer::new(opts);

    // First render: scroll offset comes from the provider.
    println!("initial scroll_offset={}", v.scroll_offset());
    println!("initial scroll_rect={:?}", v.scroll_rect());

    // Adapter updates rect + scroll offset on events.
    v.apply_scroll_frame(
        Rect {
            main: 12,
            cross: 80,
        },
        200,
        0,
    );

    let mut items = Vec::new();
    v.for_each_virtual_item_keyed(|it| items.push(it));
    println!(
        "is_scrolling={}, visible_range={:?}, items_len={}",
        v.is_scrolling(),
        v.visible_range(),
        items.len()
    );
    println!("first_item={:?}", items.first());

    // Demonstrate scroll-to helpers.
    let target = v.scroll_to_index_offset(500, Align::Start);
    v.set_scroll_offset_clamped(target);
    println!("after scroll_to_index: scroll_offset={}", v.scroll_offset());

    // Demonstrate dynamic measurement + scroll adjustment.
    let applied = v.resize_item(0, 20);
    println!("resize_item applied_scroll_adjustment={applied}");

    // Simulate reorder: change key mapping. This automatically rebuilds per-index sizes from the
    // key-based measurement cache. In real apps, you usually keep `get_item_key` stable and call
    // `sync_item_keys()` when your dataset is reordered while `count` stays the same.
    v.set_get_item_key(|i| if i == 0 { 1 } else { i as u64 });

    // Debounced scrolling reset without relying on a native scrollend event.
    v.update_scrolling(200);
    println!("after update_scrolling: is_scrolling={}", v.is_scrolling());

    // Toggle enabled to disable all queries.
    v.set_enabled(false);
    let mut disabled_len = 0usize;
    v.for_each_virtual_item(|_| disabled_len += 1);
    println!(
        "disabled total_size={}, items_len={}",
        v.total_size(),
        disabled_len
    );
}

pub fn emit_range(&mut self, start_index: usize, end_index: usize)

pub fn emit_visible(&mut self)

Examples found in repository

examples/adapter_sim.rs (line 25)

fn main() {
    // Simulate a framework adapter that owns the scroll state.
    let saved_scroll = Arc::new(AtomicU64::new(120));

    let opts = VirtualizerOptions::new(1000, |_| 1)
        .with_initial_rect(Some(Rect {
            main: 10,
            cross: 80,
        }))
        .with_initial_offset_provider({
            let saved_scroll = Arc::clone(&saved_scroll);
            move || saved_scroll.load(Ordering::Relaxed)
        })
        .with_scroll_margin(5)
        .with_range_extractor(Some(|r: Range, emit: &mut dyn FnMut(usize)| {
            // Pin a "sticky header" at index 0, regardless of scroll position.
            let mut e = virtualizer::IndexEmitter::new(r, emit);
            e.emit_pinned(0);
            e.emit_visible();
        }));

    let mut v = Virtualizer::new(opts);

    // First render: scroll offset comes from the provider.
    println!("initial scroll_offset={}", v.scroll_offset());
    println!("initial scroll_rect={:?}", v.scroll_rect());

    // Adapter updates rect + scroll offset on events.
    v.apply_scroll_frame(
        Rect {
            main: 12,
            cross: 80,
        },
        200,
        0,
    );

    let mut items = Vec::new();
    v.for_each_virtual_item_keyed(|it| items.push(it));
    println!(
        "is_scrolling={}, visible_range={:?}, items_len={}",
        v.is_scrolling(),
        v.visible_range(),
        items.len()
    );
    println!("first_item={:?}", items.first());

    // Demonstrate scroll-to helpers.
    let target = v.scroll_to_index_offset(500, Align::Start);
    v.set_scroll_offset_clamped(target);
    println!("after scroll_to_index: scroll_offset={}", v.scroll_offset());

    // Demonstrate dynamic measurement + scroll adjustment.
    let applied = v.resize_item(0, 20);
    println!("resize_item applied_scroll_adjustment={applied}");

    // Simulate reorder: change key mapping. This automatically rebuilds per-index sizes from the
    // key-based measurement cache. In real apps, you usually keep `get_item_key` stable and call
    // `sync_item_keys()` when your dataset is reordered while `count` stays the same.
    v.set_get_item_key(|i| if i == 0 { 1 } else { i as u64 });

    // Debounced scrolling reset without relying on a native scrollend event.
    v.update_scrolling(200);
    println!("after update_scrolling: is_scrolling={}", v.is_scrolling());

    // Toggle enabled to disable all queries.
    v.set_enabled(false);
    let mut disabled_len = 0usize;
    v.for_each_virtual_item(|_| disabled_len += 1);
    println!(
        "disabled total_size={}, items_len={}",
        v.total_size(),
        disabled_len
    );
}

pub fn emit_overscanned(&mut self)

Examples found in repository

examples/pinned_headers.rs (line 32)

fn main() {
    // Example: pinned/sticky "headers" at fixed indexes.
    let mut opts = VirtualizerOptions::new(1_000, |_| 1);
    opts.overscan = 2;

    let pinned: Arc<[usize]> = Arc::from([0usize, 10, 20, 30, 40, 999]);
    opts.range_extractor = Some(Arc::new({
        let pinned = Arc::clone(&pinned);
        move |r: Range, emit: &mut dyn FnMut(usize)| {
            let mut e = IndexEmitter::new(r, emit);
            // IMPORTANT: indexes must be emitted in ascending order.
            //
            // We want pinned rows both before and after the overscanned range. To keep the output
            // sorted, emit:
            // 1) pinned indexes before the overscanned range
            // 2) the overscanned contiguous range
            // 3) pinned indexes after the overscanned range
            let overscanned_start = r.start_index.saturating_sub(r.overscan);
            let overscanned_end = r.end_index.saturating_add(r.overscan).min(r.count);

            for &idx in pinned.iter() {
                if idx < overscanned_start {
                    e.emit_pinned(idx);
                }
            }

            e.emit_overscanned();

            for &idx in pinned.iter() {
                if idx >= overscanned_end {
                    e.emit_pinned(idx);
                }
            }
        }
    }));

    let mut v = Virtualizer::new(opts);
    v.set_viewport_and_scroll_clamped(10, 500);

    let mut collected = Vec::new();
    v.for_each_virtual_index(|i| collected.push(i));

    println!("visible_range={:?}", v.visible_range());
    println!("virtual_range={:?}", v.virtual_range());
    println!(
        "indexes_len={} first_20={:?}",
        collected.len(),
        &collected[..20.min(collected.len())]
    );

    // A real UI would typically iterate items:
    let mut headers = 0usize;
    v.for_each_virtual_item(|it| {
        if pinned.binary_search(&it.index).is_ok() {
            headers += 1;
        }
    });
    println!("pinned_headers_in_output={headers}");
}