Crate scrolling_window_pattern_matcher

Scrolling Window Pattern Matcher

This crate provides a generic pattern matcher that operates over a scrolling window (queue) of items. Patterns can be defined as sequences of values, functions, or a mix of both. When a pattern matches, an optional user-defined callback is invoked. The matcher supports optional deduplication of matches and per-pattern overlap settings.

Features

• Match patterns using values, functions, or both
• Optional deduplication of matches
• Support for overlapping matches (per-pattern control)
• Callback invocation on match (per-pattern)
• No unnecessary trait bounds: PartialEq is only required for value-based patterns

Usage: Value/Mixed Patterns with Multiple Patterns

use scrolling_window_pattern_matcher::{ScrollingWindowPatternMatcherRef, PatternElem};
let window = vec![&1, &2, &1, &2, &1];
let patterns = vec![
    vec![PatternElem::Value(1), PatternElem::Value(2)],
    vec![PatternElem::Value(2), PatternElem::Value(1)],
    vec![PatternElem::Value(1)],
    vec![PatternElem::Value(2)],
];
let matcher = ScrollingWindowPatternMatcherRef::new(5);
let matches = matcher.find_matches(&window, &patterns, false, None::<fn(usize, usize)>);
assert!(matches.contains(&(0, 0))); // [1,2] at 0
assert!(matches.contains(&(1, 1))); // [2,1] at 1
assert!(matches.contains(&(2, 0))); // [1] at 0
assert!(matches.contains(&(3, 1))); // [2] at 1

Usage: Patterns with Callbacks and Overlap Settings

use scrolling_window_pattern_matcher::{ScrollingWindowPatternMatcherRef, PatternElem, PatternWithCallback};
use std::rc::Rc;
use std::cell::RefCell;
let window = vec![&1, &2, &1, &2, &1];
let results: Rc<RefCell<Vec<Vec<i32>>>> = Rc::new(RefCell::new(vec![]));
let results1 = results.clone();
let results2 = results.clone();
let patterns = vec![
    PatternWithCallback {
        pattern: vec![PatternElem::Value(1), PatternElem::Value(2)],
        callback: Box::new(move |matched| results1.borrow_mut().push(matched.iter().map(|x| **x).collect::<Vec<_>>())),
        allow_overlap_with_others: false,
        allow_others_to_overlap: true,
    },
    PatternWithCallback {
        pattern: vec![PatternElem::Value(2), PatternElem::Value(1)],
        callback: Box::new(move |matched| results2.borrow_mut().push(matched.iter().map(|x| **x).collect::<Vec<_>>())),
        allow_overlap_with_others: true,
        allow_others_to_overlap: true,
    },
];
let matcher = ScrollingWindowPatternMatcherRef::new(5);
matcher.find_matches_with_callbacks(&window, &patterns);
let results = results.borrow();
assert!(results.contains(&vec![1, 2]));
assert!(results.contains(&vec![2, 1]));

Edge Cases

• Empty window or patterns: returns no matches
• Patterns can be all values, all functions, or mixed
• Multiple patterns and multi-element patterns supported
• Deduplication and overlap settings can be combined

API

• find_matches: Use for value or mixed patterns (requires PartialEq for T), supports multiple patterns and multi-element patterns
• find_matches_with_callbacks: Use for value/mixed patterns with per-pattern callbacks and overlap settings
• find_matches_functions_only: Use for function-only patterns (no trait bound required)
• find_matches_with_callbacks (function matcher): Use for function-only patterns with per-pattern callbacks and overlap settings

See tests for more comprehensive examples and edge cases.

Structs

PatternWithCallback

Pattern with callback and overlap settings for value/mixed patterns

PatternWithCallbackFn

Pattern with callback and overlap settings for function-only patterns

ScrollingWindowFunctionPatternMatcherRef

ScrollingWindowPatternMatcherOwned

ScrollingWindowPatternMatcherRef

A generic pattern matcher that scrolls through a queue of items of type T.

Enums

PatternElem

A single element in a pattern: either an exact value or a matcher function.

Type Aliases

PatternId