Struct Predicate 

pub struct Predicate<P>(pub P)
where
    P: PredicateInner;

An Predicate is a logical condition that represents a header space.

Methods

• ! : logical NOT
• & : logical AND
• [|] : logical OR
• [-] : logical DIFF
• [==] : equality
• is_empty : check if the predicate is empty

Operations explained

Predicate hide reference counting inside, it is coherent with the Rust ownership model. When a predicate is moved, it is de-referenced automatically and the underlying data structure (like bdd nodes) may be garbage collected afterward. When a new predicate is produced, it is referenced automatically.

Unary operation has two forms

• let b = !a: a is moved
• let b = !&a: a is NOT moved

Binary operations have three forms

&, |, - have the same forms. Take & for example:

• let c = a & b: a and b are moved
• let c = a & &b: a is moved
• let c = &a & b: none is moved
• let a &= b: a is mutated and b is moved
• let a &= &b: a is mutated

Examples

This example demonstrates how to use the & and &= like methods.

use rapimt_core::fm_ipv4_from;
use rapimt_core::prelude::{
    ipv4_to_match,
    Predicate, MatchEncoder,
    RuddyPredicateEngine, FieldMatch
};

fn get_predicates<ME: for <'a> MatchEncoder<'a>>(engine: &ME)-> [Predicate<<ME as MatchEncoder<'_>>::P>;3] {
    [
        engine.encode_match(fm_ipv4_from!("dip", "192.168.1.0/24")).0,
        engine.encode_match(fm_ipv4_from!("dip", "192.168.1.0/25")).0,
        engine.encode_match(fm_ipv4_from!("dip", "192.168.1.0/26")).0,
    ]
}

let engine = RuddyPredicateEngine::init(1000, 100);

// p2, p3 are dropped and should no longer be used afterward
let [mut p1, p2, p3] = get_predicates(&engine);
let p123 = {
    p1 &= p2;
    p1 &= p3;
    p1
};

// get the cross product of [p1, p2, p3] and [p1, p2, p3]
// since iter() returns reference, the predicates are not moved
let pls = Vec::from(get_predicates(&engine));
let prs = Vec::from(get_predicates(&engine));
let mut res = vec![];
for pl in pls.iter() {
    for pr in prs.iter() {
        res.push(pl & pr);
   }
}

Tuple Fields

0: P

Implementations

impl<P> Predicate<P>

where P: PredicateInner,

pub fn is_empty(&self) -> bool

pub fn non_empty(&self) -> bool

Trait Implementations

impl<P> BitAnd<&Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &Predicate<P>, ) -> <&Predicate<P> as BitAnd<&Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &Predicate<P>, ) -> <&mut Predicate<P> as BitAnd<&Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &Predicate<P>, ) -> <Predicate<P> as BitAnd<&Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<&mut Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &mut Predicate<P>, ) -> <&Predicate<P> as BitAnd<&mut Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &mut Predicate<P>, ) -> <&mut Predicate<P> as BitAnd<&mut Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: &mut Predicate<P>, ) -> <Predicate<P> as BitAnd<&mut Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: Predicate<P>, ) -> <&Predicate<P> as BitAnd<Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand( self, rhs: Predicate<P>, ) -> <&mut Predicate<P> as BitAnd<Predicate<P>>>::Output

Performs the & operation.

impl<P> BitAnd for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the & operator.

fn bitand(self, rhs: Predicate<P>) -> <Predicate<P> as BitAnd>::Output

Performs the & operation.

impl<P> BitAndAssign<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: &Predicate<P>)

Performs the &= operation.

impl<P> BitAndAssign<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: &Predicate<P>)

Performs the &= operation.

impl<P> BitAndAssign<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: &mut Predicate<P>)

Performs the &= operation.

impl<P> BitAndAssign<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: &mut Predicate<P>)

Performs the &= operation.

impl<P> BitAndAssign<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: Predicate<P>)

Performs the &= operation.

impl<P> BitAndAssign for Predicate<P>

where P: PredicateInner,

fn bitand_assign(&mut self, rhs: Predicate<P>)

Performs the &= operation.

impl<P> BitOr<&Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &Predicate<P>, ) -> <&Predicate<P> as BitOr<&Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &Predicate<P>, ) -> <&mut Predicate<P> as BitOr<&Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &Predicate<P>, ) -> <Predicate<P> as BitOr<&Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<&mut Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &mut Predicate<P>, ) -> <&Predicate<P> as BitOr<&mut Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &mut Predicate<P>, ) -> <&mut Predicate<P> as BitOr<&mut Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: &mut Predicate<P>, ) -> <Predicate<P> as BitOr<&mut Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: Predicate<P>, ) -> <&Predicate<P> as BitOr<Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor( self, rhs: Predicate<P>, ) -> <&mut Predicate<P> as BitOr<Predicate<P>>>::Output

Performs the | operation.

impl<P> BitOr for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the | operator.

fn bitor(self, rhs: Predicate<P>) -> <Predicate<P> as BitOr>::Output

Performs the | operation.

impl<P> BitOrAssign<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: &Predicate<P>)

Performs the |= operation.

impl<P> BitOrAssign<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: &Predicate<P>)

Performs the |= operation.

impl<P> BitOrAssign<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: &mut Predicate<P>)

Performs the |= operation.

impl<P> BitOrAssign<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: &mut Predicate<P>)

Performs the |= operation.

impl<P> BitOrAssign<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: Predicate<P>)

Performs the |= operation.

impl<P> BitOrAssign for Predicate<P>

where P: PredicateInner,

fn bitor_assign(&mut self, rhs: Predicate<P>)

Performs the |= operation.

impl<P> Clone for Predicate<P>

where P: PredicateInner,

fn clone(&self) -> Predicate<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for Predicate<P>

where P: PredicateInner,

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

Formats the value using the given formatter.

impl<P> Display for Predicate<P>

where P: PredicateInner,

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

Formats the value using the given formatter.

impl<P> Drop for Predicate<P>

where P: PredicateInner,

fn drop(&mut self)

Executes the destructor for this type.

impl<P> From<P> for Predicate<P>

where P: PredicateInner,

fn from(value: P) -> Predicate<P>

Converts to this type from the input type.

impl<P> Hash for Predicate<P>

where P: Hash + PredicateInner,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P> Not for &Predicate<P>

where P: PredicateInner,

!(&predicate) consumes the predicate reference.

type Output = Predicate<P>

The resulting type after applying the ! operator.

fn not(self) -> <&Predicate<P> as Not>::Output

Performs the unary ! operation.

impl<P> Not for Predicate<P>

where P: PredicateInner,

!predicate consumes the predicate.

type Output = Predicate<P>

The resulting type after applying the ! operator.

fn not(self) -> <Predicate<P> as Not>::Output

Performs the unary ! operation.

impl<P> Ord for Predicate<P>

where P: Ord + PredicateInner,

fn cmp(&self, other: &Predicate<P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<P> PartialEq for Predicate<P>

where P: PartialEq + PredicateInner,

fn eq(&self, other: &Predicate<P>) -> 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<P> PartialOrd for Predicate<P>

where P: PartialOrd + PredicateInner,

fn partial_cmp(&self, other: &Predicate<P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P> Sub<&Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: &Predicate<P>, ) -> <&Predicate<P> as Sub<&Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: &Predicate<P>, ) -> <&mut Predicate<P> as Sub<&Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub(self, rhs: &Predicate<P>) -> <Predicate<P> as Sub<&Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<&mut Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: &mut Predicate<P>, ) -> <&Predicate<P> as Sub<&mut Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: &mut Predicate<P>, ) -> <&mut Predicate<P> as Sub<&mut Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: &mut Predicate<P>, ) -> <Predicate<P> as Sub<&mut Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<Predicate<P>> for &Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub(self, rhs: Predicate<P>) -> <&Predicate<P> as Sub<Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub( self, rhs: Predicate<P>, ) -> <&mut Predicate<P> as Sub<Predicate<P>>>::Output

Performs the - operation.

impl<P> Sub for Predicate<P>

where P: PredicateInner,

type Output = Predicate<P>

The resulting type after applying the - operator.

fn sub(self, rhs: Predicate<P>) -> <Predicate<P> as Sub>::Output

Performs the - operation.

impl<P> SubAssign<&Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: &Predicate<P>)

Performs the -= operation.

impl<P> SubAssign<&Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: &Predicate<P>)

Performs the -= operation.

impl<P> SubAssign<&mut Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: &mut Predicate<P>)

Performs the -= operation.

impl<P> SubAssign<&mut Predicate<P>> for Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: &mut Predicate<P>)

Performs the -= operation.

impl<P> SubAssign<Predicate<P>> for &mut Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: Predicate<P>)

Performs the -= operation.

impl<P> SubAssign for Predicate<P>

where P: PredicateInner,

fn sub_assign(&mut self, rhs: Predicate<P>)

Performs the -= operation.

impl<P> Eq for Predicate<P>

where P: Eq + PredicateInner,

impl<P> StructuralPartialEq for Predicate<P>

where P: PredicateInner,