Struct entity::MapTypedPredicate

pub struct MapTypedPredicate<T: ValueLike, C: IntoIterator<Item = (String, T)> + ValueLike>(_, _, _);

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

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

pub fn new(predicate: Predicate) -> Self

Creates a new map typed predicate from an untyped predicate

pub fn as_untyped(&self) -> &Predicate

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

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

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

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);

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);

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);

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);

Trait Implementations

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

type Output = Self

The resulting type after applying the & operator.

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

Shorthand to produce Predicate::And

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

type Output = Self

The resulting type after applying the | operator.

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

Shorthand to produce Predicate::Or

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

type Output = Self

The resulting type after applying the ^ operator.

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

Shorthand to produce Predicate::Xor

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

fn clone(&self) -> MapTypedPredicate<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn from(map_typed_predicate: MapTypedPredicate<T, C>) -> Self

Performs the conversion.

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

fn from(map_typed_predicate: MapTypedPredicate<T, C>) -> Self

Performs the conversion.

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

fn from(predicate: Predicate) -> Self

Performs the conversion.

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

fn from(typed_predicate: TypedPredicate<C>) -> Self

Performs the conversion.

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

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Shorthand to produce Predicate::Not

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

fn eq(&self, other: &MapTypedPredicate<T, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &MapTypedPredicate<T, C>) -> bool

This method tests for !=.

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

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

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