Enum CompositeFilter 

pub enum CompositeFilter {
    Byte(ByteFilter),
    Ngram(NgramFilter),
    Combine {
        left: Box<CompositeFilter>,
        right: Box<CompositeFilter>,
        op: FilterOp,
    },
}

A composite filter that combines byte and n-gram filters with logical operators.

Example

use flashsieve::{ByteFilter, NgramFilter};
use flashsieve::filter::{CompositeFilter, FilterOp};

let a = ByteFilter::from_patterns(&[b"secret".as_slice()]);
let b = ByteFilter::from_patterns(&[b"token".as_slice()]);
let combined = CompositeFilter::combine_byte(a, b, FilterOp::Or);

Variants

Byte(ByteFilter)

A leaf byte filter.

Ngram(NgramFilter)

A leaf n-gram filter.

Combine

Logical combination of two composite filters.

Fields

left: Box<CompositeFilter>

Left operand.

right: Box<CompositeFilter>

Right operand.

op: FilterOp

The logical operator.

Implementations

impl CompositeFilter

pub fn combine_byte(a: ByteFilter, b: ByteFilter, op: FilterOp) -> Self

Combine two byte filters under a logical operator.

Example

use flashsieve::{ByteFilter, filter::{CompositeFilter, FilterOp}};

let a = ByteFilter::from_patterns(&[b"secret".as_slice()]);
let b = ByteFilter::from_patterns(&[b"token".as_slice()]);
let combined = CompositeFilter::combine_byte(a, b, FilterOp::Or);

pub fn combine_ngram(a: NgramFilter, b: NgramFilter, op: FilterOp) -> Self

Combine two ngram filters under a logical operator.

Example

use flashsieve::{NgramFilter, filter::{CompositeFilter, FilterOp}};

let a = NgramFilter::from_patterns(&[b"secret".as_slice()]);
let b = NgramFilter::from_patterns(&[b"token".as_slice()]);
let combined = CompositeFilter::combine_ngram(a, b, FilterOp::Or);

pub fn combine(a: Self, b: Self, op: FilterOp) -> Self

Combine two composite filters under an arbitrary logical operator.

Example

use flashsieve::{ByteFilter, filter::{CompositeFilter, FilterOp}};

let left = CompositeFilter::Byte(ByteFilter::from_patterns(&[b"a".as_slice()]));
let right = CompositeFilter::Byte(ByteFilter::from_patterns(&[b"b".as_slice()]));
let combined = CompositeFilter::combine(left, right, FilterOp::And);

pub fn matches(&self, histogram: &ByteHistogram, bloom: &NgramBloom) -> bool

Evaluate against a histogram and bloom pair.

Example

use flashsieve::{ByteFilter, NgramBloom, filter::{CompositeFilter, FilterOp}};

let filter = CompositeFilter::Byte(ByteFilter::from_patterns(&[b"ab".as_slice()]));
let hist = flashsieve::ByteHistogram::from_block(b"ab");
let bloom = NgramBloom::from_block(b"ab", 1024).unwrap();
assert!(filter.matches(&hist, &bloom));

Trait Implementations

impl Clone for CompositeFilter

fn clone(&self) -> CompositeFilter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompositeFilter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.