1 use super::Filter;
2
3 pub trait WrapSealed<F: Filter> {
4 type Wrapped: Filter;
5
wrap(&self, filter: F) -> Self::Wrapped6 fn wrap(&self, filter: F) -> Self::Wrapped;
7 }
8
9 impl<'a, T, F> WrapSealed<F> for &'a T
10 where
11 T: WrapSealed<F>,
12 F: Filter,
13 {
14 type Wrapped = T::Wrapped;
wrap(&self, filter: F) -> Self::Wrapped15 fn wrap(&self, filter: F) -> Self::Wrapped {
16 (*self).wrap(filter)
17 }
18 }
19
20 pub trait Wrap<F: Filter>: WrapSealed<F> {}
21
22 impl<T, F> Wrap<F> for T
23 where
24 T: WrapSealed<F>,
25 F: Filter,
26 {
27 }
28
29 /// Function that receives a filter to be combined with pre and after filters
wrap_fn<F, T, U>(func: F) -> WrapFn<F> where F: Fn(T) -> U, T: Filter, U: Filter,30 pub fn wrap_fn<F, T, U>(func: F) -> WrapFn<F>
31 where
32 F: Fn(T) -> U,
33 T: Filter,
34 U: Filter,
35 {
36 WrapFn { func }
37 }
38
39 #[derive(Debug)]
40 pub struct WrapFn<F> {
41 func: F,
42 }
43
44 impl<F, T, U> WrapSealed<T> for WrapFn<F>
45 where
46 F: Fn(T) -> U,
47 T: Filter,
48 U: Filter,
49 {
50 type Wrapped = U;
51
wrap(&self, filter: T) -> Self::Wrapped52 fn wrap(&self, filter: T) -> Self::Wrapped {
53 (self.func)(filter)
54 }
55 }
56