Enum Term 

pub enum Term {
    Default {
        value: Value,
    },
    Field {
        field: String,
        value: Value,
    },
    Negate {
        term: Box<Term>,
    },
    Combine {
        left: Box<Term>,
        right: Box<Term>,
        operator: Operator,
    },
}

An expression term.

Variants

Default

A term searching the default field set, see Value for more information on valid syntax.

Examples

• Phrase "boil 'em, mash 'em"
• Single Term potatoes
• Ranges [3 TO 5]

Fields

value: Value

Field

A term searching a specific field. The searched value can be anything supported by Value.

Fields

field: String

The field to be searched by this term.

value: Value

Negate

Searches for the opposite of the contained term.

Fields

term: Box<Term>

Combine

Applies a boolean operation to the two contained terms.

Fields

left: Box<Term>

right: Box<Term>

operator: Operator

Implementations

impl Term

pub const fn new_default(value: Value) -> Self

Constructs a Self::Default term.

Purely for the syntactic convenience.

pub const fn new_negate(term: Box<Term>) -> Self

Constructs a Self::Negate term.

Purely for the syntactic convenience.

pub fn visit<T>(self, visitor: impl Fn(Term, &dyn Fn(Box<Term>) -> T) -> T) -> T

Calls the provided visitor with this node, and a function to recurse into another nodes.

Allows for iteration or reduction of the term tree.

Example

use lucene_query_syntax::Term;

let root: Term = todo!("-name:Bob age:[20 TO 40]");
let complexity = root.visit(|term, recurse| match term {
    Term::Combine { left, right, .. } => 1 + recurse(left) + recurse(right),
    Term::Negate { term } => 1 + recurse(term),
    _ => 1,
});

assert_eq!(complexity, 3);

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl PartialEq for Term

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

impl StructuralPartialEq for Term