Struct FilterApp 

pub struct FilterApp {
    pub pattern_editor: Editor,
    pub options: FilterOptions,
    pub lines: Vec<String>,
    pub json_extracted: Option<Vec<Option<String>>>,
    pub matched: Vec<usize>,
    pub match_spans: Vec<Vec<Range<usize>>>,
    pub selected: usize,
    pub scroll: usize,
    pub error: Option<String>,
    pub should_quit: bool,
    pub outcome: Outcome,
    /* private fields */
}

Fields

pattern_editor: Editor

options: FilterOptions

lines: Vec<String>

json_extracted: Option<Vec<Option<String>>>

Optional per-line extracted strings when the user passed --json. Same length as lines. None at index i means line i should be skipped (JSON parse failure, missing path, or non-string value). When json_extracted is None, matching runs against the raw lines.

matched: Vec<usize>

Indices of lines that currently match the pattern.

match_spans: Vec<Vec<Range<usize>>>

Byte ranges within each matched input that the pattern matched. In --json mode these are spans within the extracted string, not the raw line. Length equals matched.len(); empty per-line in invert mode.

selected: usize

Selected index into matched for the cursor in the match list.

scroll: usize

Scroll offset (first visible index into matched).

error: Option<String>

Compilation error from the last recompute, if any.

should_quit: bool

Whether to quit the event loop on next tick.

outcome: Outcome

Outcome decided by the user: emit the filtered output, or discard.

Implementations

impl FilterApp

pub fn new( lines: Vec<String>, initial_pattern: &str, options: FilterOptions, ) -> Self

pub fn with_json_extracted( lines: Vec<String>, extracted: Vec<Option<String>>, initial_pattern: &str, options: FilterOptions, ) -> Self

Construct a filter app whose matching runs against pre-extracted JSON field values (from the --json flag). extracted[i] is Some(s) when line i parsed and yielded a string value; None otherwise.

pub fn pattern(&self) -> &str

pub fn recompute(&mut self)

pub fn select_next(&mut self)

pub fn select_prev(&mut self)

pub fn toggle_case_insensitive(&mut self)

pub fn toggle_invert(&mut self)