Struct MapTypedPredicate

Source

pub struct MapTypedPredicate<T: ValueLike, C: IntoIterator<Item = (String, T)> + ValueLike>(/* private fields */);

Expand description

Represents a typed Predicate specifically for maps such as std::collections::HashMap, ensuring that only valid conditions are used for a given type.

This is required due to limitations in Rust’s blanket impl functionality, which will be resolved once specialization is available.

Implementations§

Source §

impl<T: ValueLike, C: IntoIterator<Item = (String, T)> + ValueLike> MapTypedPredicate<T, C>

Source

pub fn new(predicate: Predicate) -> Self

Creates a new map typed predicate from an untyped predicate

Source

pub fn as_untyped(&self) -> &Predicate

Returns a reference to the untyped Predicate wrapped by this typed instance

Source

pub fn check(&self, value: C) -> bool

Checks if the typed predicate is satisfied by the given value

NOTE: This consumes the value instead of the untyped version that merely references the value

Source §

impl<T: ValueLike, C: IntoIterator<Item = (String, T)> + ValueLike> MapTypedPredicate<T, C>

Source

pub fn any<P: Into<TypedPredicate<T>>>(p: P) -> Self

Creates a new typed predicate for Predicate::Any

§Examples

use entity::{TypedPredicate as P, MapTypedPredicate as MP};
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(String::from("a"), 1);
map.insert(String::from("b"), 2);
map.insert(String::from("c"), 3);

let p = MP::any(P::equals(3));
assert_eq!(p.check(map.clone()), true);

let p = MP::any(P::equals(4));
assert_eq!(p.check(map), false);

Source

pub fn contains(value: T) -> Self

Creates a new typed predicate for Predicate::Contains

§Examples

use entity::{TypedPredicate as P, MapTypedPredicate as MP};
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(String::from("a"), 1);
map.insert(String::from("b"), 2);
map.insert(String::from("c"), 3);

let p = MP::contains(3);
assert_eq!(p.check(map.clone()), true);

let p = MP::contains(4);
assert_eq!(p.check(map), false);

Source

pub fn contains_all<I: IntoIterator<Item = T>>(i: I) -> Self

Creates a new typed predicate for Predicate::ContainsAll

§Examples

use entity::{TypedPredicate as P, MapTypedPredicate as MP};
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(String::from("a"), 1);
map.insert(String::from("b"), 2);
map.insert(String::from("c"), 3);

let p = MP::contains_all(vec![1, 3]);
assert_eq!(p.check(map.clone()), true);

let p = MP::contains_all(vec![1, 4]);
assert_eq!(p.check(map), false);

Source

pub fn contains_any<I: IntoIterator<Item = T>>(i: I) -> Self

Creates a new typed predicate for Predicate::ContainsAny

§Examples

use entity::{TypedPredicate as P, MapTypedPredicate as MP};
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(String::from("a"), 1);
map.insert(String::from("b"), 2);
map.insert(String::from("c"), 3);

let p = MP::contains_any(vec![1, 4]);
assert_eq!(p.check(map.clone()), true);

let p = MP::contains_any(vec![4, 5]);
assert_eq!(p.check(map), false);