Enum pica_record::matcher::field::FieldMatcher

pub enum FieldMatcher {
    Singleton(SingletonMatcher),
    Cardinality(CardinalityMatcher),
    Group(Box<FieldMatcher>),
    Not(Box<FieldMatcher>),
    Composite {
        lhs: Box<FieldMatcher>,
        op: BooleanOp,
        rhs: Box<FieldMatcher>,
    },
}

A matcher that allows grouping, negation and connecting of SingletonMatcher.

Variants

Singleton(SingletonMatcher)

Cardinality(CardinalityMatcher)

Group(Box<FieldMatcher>)

Not(Box<FieldMatcher>)

Composite

Fields

lhs: Box<FieldMatcher>

op: BooleanOp

rhs: Box<FieldMatcher>

Implementations

impl FieldMatcher

pub fn new(matcher: &str) -> Result<Self, ParseMatcherError>

Creates a new FieldMatcher.

Errors

This function fails if the given expression is not a valid field matcher.

Example

use pica_record::matcher::field::FieldMatcher;

let _matcher = FieldMatcher::new("#003@ > 1")?;
let _matcher = FieldMatcher::new("010@.a == 'ger'")?;
let _matcher = FieldMatcher::new("(010@.a == 'ger')")?;

pub fn is_match<'a>( &self, fields: impl IntoIterator<Item = &'a FieldRef<'a>> + Clone, options: &MatcherOptions, ) -> bool

Returns true if the given field(s) matches against the field matcher.

Example

use pica_record::matcher::field::FieldMatcher;
use pica_record::matcher::MatcherOptions;
use pica_record::primitives::FieldRef;

let field =
    FieldRef::new("003@", None, vec![('0', "0123456789X")])?;

let options = MatcherOptions::default();
let matcher = FieldMatcher::new("#003@ == 1")?;
assert!(matcher.is_match(&field, &options));

Trait Implementations

impl BitAnd for FieldMatcher

fn bitand(self, rhs: Self) -> Self::Output

The bitwise AND operator & of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let lhs = FieldMatcher::new("012A.a == 'A'")?;
let rhs = FieldMatcher::new("012A.b == 'B'")?;
let matcher = lhs & rhs;

assert!(matcher.is_match(&field, &options));

type Output = FieldMatcher

The resulting type after applying the & operator.

impl BitAndAssign for FieldMatcher

fn bitand_assign(&mut self, rhs: Self)

The bitwise AND assignment operator &= of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let mut matcher = FieldMatcher::new("012A.a == 'A'")?;
matcher &= FieldMatcher::new("012A.b == 'B'")?;
assert!(matcher.is_match(&field, &options));

impl BitOr for FieldMatcher

fn bitor(self, rhs: Self) -> Self::Output

The bitwise OR operator | of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let lhs = FieldMatcher::new("012A.a == 'X'")?;
let rhs = FieldMatcher::new("012A.b == 'B'")?;
let matcher = lhs | rhs;

assert!(matcher.is_match(&field, &options));

type Output = FieldMatcher

The resulting type after applying the | operator.

impl BitOrAssign for FieldMatcher

fn bitor_assign(&mut self, rhs: Self)

The bitwise OR assignment operator |= of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let mut matcher = FieldMatcher::new("012A.a == 'X'")?;
matcher |= FieldMatcher::new("012A.b == 'B'")?;
assert!(matcher.is_match(&field, &options));

impl BitXor for FieldMatcher

fn bitxor(self, rhs: Self) -> Self::Output

The bitwise XOR operator ^ of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let lhs = FieldMatcher::new("012A.a == 'X'")?;
let rhs = FieldMatcher::new("012A.b == 'B'")?;
let matcher = lhs ^ rhs;

assert!(matcher.is_match(&field, &options));

type Output = FieldMatcher

The resulting type after applying the ^ operator.

impl BitXorAssign for FieldMatcher

fn bitxor_assign(&mut self, rhs: Self)

The bitwise XOR assignment operator ^= of two FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let mut matcher = FieldMatcher::new("012A.a == 'X'")?;
matcher ^= FieldMatcher::new("012A.b == 'B'")?;
assert!(matcher.is_match(&field, &options));

impl Clone for FieldMatcher

fn clone(&self) -> FieldMatcher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FieldMatcher

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

Formats the value using the given formatter.

impl Display for FieldMatcher

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

Format the subfield-matcher as a human-readable string.

Example

use pica_record::matcher::field::FieldMatcher;

let matcher = FieldMatcher::new("#012A > 3")?;
assert_eq!(matcher.to_string(), "#012A > 3");

let mut matcher =
    FieldMatcher::new("012A.a == 'foo' || 012A.a == 'bar'")?;
matcher &= FieldMatcher::new("012A.c == 'baz'")?;
assert_eq!(
    matcher.to_string(),
    "(012A.a == 'foo' || 012A.a == 'bar') && 012A.c == 'baz'"
);

impl Not for FieldMatcher

fn not(self) -> Self::Output

The unary logical negation operator ! applied to a FieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::FieldRef;

let options = MatcherOptions::default();
let field =
    FieldRef::new("012A", None, vec![('a', "A"), ('b', "B")])?;

let matcher = FieldMatcher::new("012A.a == 'X'")?;
let matcher = !matcher;

assert!(matcher.is_match(&field, &options));

type Output = FieldMatcher

The resulting type after applying the ! operator.

impl PartialEq for FieldMatcher

fn eq(&self, other: &FieldMatcher) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for FieldMatcher