Enum pica_record::matcher::subfield::SubfieldMatcher

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

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

Variants

Singleton(SingletonMatcher)

Group(Box<SubfieldMatcher>)

Not(Box<SubfieldMatcher>)

Composite

Fields

lhs: Box<SubfieldMatcher>

op: BooleanOp

rhs: Box<SubfieldMatcher>

Implementations

impl SubfieldMatcher

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

Creates a new SubfieldMatcher.

Errors

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

Example

use pica_record::matcher::subfield::SubfieldMatcher;

let _matcher = SubfieldMatcher::new("a == 'foo'")?;

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

Returns true if the underlying matcher returns true.

Example

use pica_record::matcher::subfield::SubfieldMatcher;
use pica_record::matcher::MatcherOptions;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foo")?;

let matcher = SubfieldMatcher::new("a =^ 'f' && (a =$ 'o')")?;
assert!(matcher.is_match(&subfield, &options));

Trait Implementations

impl BitAnd for SubfieldMatcher

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

The bitwise AND operator & of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foobar")?;

let lhs = SubfieldMatcher::new("a =^ 'foo'")?;
let rhs = SubfieldMatcher::new("a =$ 'bar'")?;
let matcher = lhs & rhs;

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

type Output = SubfieldMatcher

The resulting type after applying the & operator.

impl BitAndAssign for SubfieldMatcher

fn bitand_assign(&mut self, rhs: Self)

The bitwise AND assignment operator &= of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foobar")?;

let mut matcher = SubfieldMatcher::new("a =^ 'foo'")?;
matcher &= SubfieldMatcher::new("a =$ 'bar'")?;
assert!(matcher.is_match(&subfield, &options));

impl BitOr for SubfieldMatcher

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

The bitwise OR operator | of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "bar")?;

let lhs = SubfieldMatcher::new("a == 'foo'")?;
let rhs = SubfieldMatcher::new("a == 'bar'")?;
let matcher = lhs | rhs;
assert!(matcher.is_match(&subfield, &options));

type Output = SubfieldMatcher

The resulting type after applying the | operator.

impl BitOrAssign for SubfieldMatcher

fn bitor_assign(&mut self, rhs: Self)

The bitwise OR assignment operator |= of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foo")?;

let mut matcher = SubfieldMatcher::new("a == 'foo'")?;
matcher |= SubfieldMatcher::new("a == 'bar'")?;
assert!(matcher.is_match(&subfield, &options));

impl BitXor for SubfieldMatcher

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

The bitwise XOR operator ^ of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "bar")?;

let lhs = SubfieldMatcher::new("a == 'foo'")?;
let rhs = SubfieldMatcher::new("a == 'bar'")?;
let matcher = lhs ^ rhs;
assert!(matcher.is_match(&subfield, &options));

type Output = SubfieldMatcher

The resulting type after applying the ^ operator.

impl BitXorAssign for SubfieldMatcher

fn bitxor_assign(&mut self, rhs: Self)

The bitwise XOR assignment operator ^= of two SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foo")?;

let mut matcher = SubfieldMatcher::new("a == 'foo'")?;
matcher ^= SubfieldMatcher::new("a == 'bar'")?;
assert!(matcher.is_match(&subfield, &options));

impl Clone for SubfieldMatcher

fn clone(&self) -> SubfieldMatcher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubfieldMatcher

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

Formats the value using the given formatter.

impl Display for SubfieldMatcher

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

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

Example

use pica_record::matcher::subfield::SubfieldMatcher;

let matcher = SubfieldMatcher::new("#a >= 3")?;
assert_eq!(matcher.to_string(), "#a >= 3");

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

let mut matcher = SubfieldMatcher::new("a == 'foo'")?;
matcher &= SubfieldMatcher::new("b == 'bar' ^ b == 'baz'")?;
assert_eq!(
    matcher.to_string(),
    "a == 'foo' && (b == 'bar' ^ b == 'baz')"
);

impl Not for SubfieldMatcher

fn not(self) -> Self::Output

The unary logical negation operator ! applied to a SubfieldMatcher.

Example

use pica_record::prelude::*;
use pica_record::primitives::SubfieldRef;

let options = MatcherOptions::default();
let subfield = SubfieldRef::new('a', "foo")?;

let matcher = !SubfieldMatcher::new("a == 'bar'")?;
assert!(matcher.is_match(&subfield, &options));

let matcher = !SubfieldMatcher::new("a == 'foo'")?;
assert!(!matcher.is_match(&subfield, &options));

type Output = SubfieldMatcher

The resulting type after applying the ! operator.

impl PartialEq for SubfieldMatcher

fn eq(&self, other: &SubfieldMatcher) -> 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 SubfieldMatcher