predicates/boxed.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
// Copyright (c) 2018 The predicates-rs Project Developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/license/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Predicate that can wrap other dynamically-called predicates in an
//! easy-to-manage type.
use std::fmt;
use crate::reflection;
use crate::utils;
use crate::Predicate;
/// `Predicate` that wraps another `Predicate` as a trait object, allowing
/// sized storage of predicate types.
pub struct BoxPredicate<Item: ?Sized>(Box<dyn Predicate<Item> + Send + Sync>);
impl<Item> BoxPredicate<Item>
where
Item: ?Sized,
{
/// Creates a new `BoxPredicate`, a wrapper around a dynamically-dispatched
/// `Predicate` type with useful trait impls.
pub fn new<P: Predicate<Item>>(inner: P) -> BoxPredicate<Item>
where
P: Send + Sync + 'static,
{
BoxPredicate(Box::new(inner))
}
}
impl<Item> fmt::Debug for BoxPredicate<Item>
where
Item: ?Sized,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BoxPredicate").finish()
}
}
impl<Item> reflection::PredicateReflection for BoxPredicate<Item>
where
Item: ?Sized,
{
fn parameters<'a>(&'a self) -> Box<dyn Iterator<Item = reflection::Parameter<'a>> + 'a> {
self.0.parameters()
}
fn children<'a>(&'a self) -> Box<dyn Iterator<Item = reflection::Child<'a>> + 'a> {
self.0.children()
}
}
impl<Item> fmt::Display for BoxPredicate<Item>
where
Item: ?Sized,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl<Item> Predicate<Item> for BoxPredicate<Item>
where
Item: ?Sized,
{
fn eval(&self, variable: &Item) -> bool {
self.0.eval(variable)
}
fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {
utils::default_find_case(self, expected, variable)
}
}
/// `Predicate` extension for boxing a `Predicate`.
pub trait PredicateBoxExt<Item: ?Sized>
where
Self: Predicate<Item>,
{
/// Returns a `BoxPredicate` wrapper around this `Predicate` type.
///
/// Returns a `BoxPredicate` wrapper around this `Predicate type. The
/// `BoxPredicate` type has a number of useful properties:
///
/// - It stores the inner predicate as a trait object, so the type of
/// `BoxPredicate` will always be the same even if steps are added or
/// removed from the predicate.
/// - It is a common type, allowing it to be stored in vectors or other
/// collection types.
/// - It implements `Debug` and `Display`.
///
/// # Examples
///
/// ```
/// use predicates::prelude::*;
///
/// let predicates = vec![
/// predicate::always().boxed(),
/// predicate::never().boxed(),
/// ];
/// assert_eq!(true, predicates[0].eval(&4));
/// assert_eq!(false, predicates[1].eval(&4));
/// ```
fn boxed(self) -> BoxPredicate<Item>
where
Self: Sized + Send + Sync + 'static,
{
BoxPredicate::new(self)
}
}
impl<P, Item> PredicateBoxExt<Item> for P where P: Predicate<Item> {}