solverforge_scoring/stream/joiner/
comparison.rs

1//! Comparison joiners for less than / greater than matching.
2
3use std::marker::PhantomData;
4
5use super::Joiner;
6
7/// Creates a joiner that matches when `left(a) < right(b)`.
8///
9/// # Example
10///
11/// ```
12/// use solverforge_scoring::stream::joiner::{Joiner, less_than};
13///
14/// #[derive(Clone)]
15/// struct Task { end: i64, start: i64 }
16///
17/// // Task A must end before Task B starts
18/// let sequential = less_than(|t: &Task| t.end, |t: &Task| t.start);
19///
20/// assert!(sequential.matches(
21///     &Task { end: 10, start: 0 },
22///     &Task { end: 20, start: 15 }
23/// ));
24///
25/// assert!(!sequential.matches(
26///     &Task { end: 10, start: 0 },
27///     &Task { end: 20, start: 5 }
28/// ));
29/// ```
30pub fn less_than<A, B, T, Fa, Fb>(left: Fa, right: Fb) -> LessThanJoiner<Fa, Fb, T>
31where
32    T: Ord,
33    Fa: Fn(&A) -> T + Send + Sync,
34    Fb: Fn(&B) -> T + Send + Sync,
35{
36    LessThanJoiner {
37        left,
38        right,
39        _phantom: PhantomData,
40    }
41}
42
43/// A joiner that matches when `left(a) < right(b)`.
44pub struct LessThanJoiner<Fa, Fb, T> {
45    left: Fa,
46    right: Fb,
47    _phantom: PhantomData<fn() -> T>,
48}
49
50impl<A, B, T, Fa, Fb> Joiner<A, B> for LessThanJoiner<Fa, Fb, T>
51where
52    T: Ord,
53    Fa: Fn(&A) -> T + Send + Sync,
54    Fb: Fn(&B) -> T + Send + Sync,
55{
56    #[inline]
57    fn matches(&self, a: &A, b: &B) -> bool {
58        (self.left)(a) < (self.right)(b)
59    }
60}
61
62/// Creates a joiner that matches when `left(a) <= right(b)`.
63///
64/// # Example
65///
66/// ```
67/// use solverforge_scoring::stream::joiner::{Joiner, less_than_or_equal};
68///
69/// let joiner = less_than_or_equal(|x: &i32| *x, |y: &i32| *y);
70///
71/// assert!(joiner.matches(&5, &10));
72/// assert!(joiner.matches(&5, &5));
73/// assert!(!joiner.matches(&10, &5));
74/// ```
75pub fn less_than_or_equal<A, B, T, Fa, Fb>(left: Fa, right: Fb) -> LessThanOrEqualJoiner<Fa, Fb, T>
76where
77    T: Ord,
78    Fa: Fn(&A) -> T + Send + Sync,
79    Fb: Fn(&B) -> T + Send + Sync,
80{
81    LessThanOrEqualJoiner {
82        left,
83        right,
84        _phantom: PhantomData,
85    }
86}
87
88/// A joiner that matches when `left(a) <= right(b)`.
89pub struct LessThanOrEqualJoiner<Fa, Fb, T> {
90    left: Fa,
91    right: Fb,
92    _phantom: PhantomData<fn() -> T>,
93}
94
95impl<A, B, T, Fa, Fb> Joiner<A, B> for LessThanOrEqualJoiner<Fa, Fb, T>
96where
97    T: Ord,
98    Fa: Fn(&A) -> T + Send + Sync,
99    Fb: Fn(&B) -> T + Send + Sync,
100{
101    #[inline]
102    fn matches(&self, a: &A, b: &B) -> bool {
103        (self.left)(a) <= (self.right)(b)
104    }
105}
106
107/// Creates a joiner that matches when `left(a) > right(b)`.
108///
109/// # Example
110///
111/// ```
112/// use solverforge_scoring::stream::joiner::{Joiner, greater_than};
113///
114/// let joiner = greater_than(|x: &i32| *x, |y: &i32| *y);
115///
116/// assert!(joiner.matches(&10, &5));
117/// assert!(!joiner.matches(&5, &10));
118/// assert!(!joiner.matches(&5, &5));
119/// ```
120pub fn greater_than<A, B, T, Fa, Fb>(left: Fa, right: Fb) -> GreaterThanJoiner<Fa, Fb, T>
121where
122    T: Ord,
123    Fa: Fn(&A) -> T + Send + Sync,
124    Fb: Fn(&B) -> T + Send + Sync,
125{
126    GreaterThanJoiner {
127        left,
128        right,
129        _phantom: PhantomData,
130    }
131}
132
133/// A joiner that matches when `left(a) > right(b)`.
134pub struct GreaterThanJoiner<Fa, Fb, T> {
135    left: Fa,
136    right: Fb,
137    _phantom: PhantomData<fn() -> T>,
138}
139
140impl<A, B, T, Fa, Fb> Joiner<A, B> for GreaterThanJoiner<Fa, Fb, T>
141where
142    T: Ord,
143    Fa: Fn(&A) -> T + Send + Sync,
144    Fb: Fn(&B) -> T + Send + Sync,
145{
146    #[inline]
147    fn matches(&self, a: &A, b: &B) -> bool {
148        (self.left)(a) > (self.right)(b)
149    }
150}
151
152/// Creates a joiner that matches when `left(a) >= right(b)`.
153///
154/// # Example
155///
156/// ```
157/// use solverforge_scoring::stream::joiner::{Joiner, greater_than_or_equal};
158///
159/// let joiner = greater_than_or_equal(|x: &i32| *x, |y: &i32| *y);
160///
161/// assert!(joiner.matches(&10, &5));
162/// assert!(joiner.matches(&5, &5));
163/// assert!(!joiner.matches(&5, &10));
164/// ```
165pub fn greater_than_or_equal<A, B, T, Fa, Fb>(
166    left: Fa,
167    right: Fb,
168) -> GreaterThanOrEqualJoiner<Fa, Fb, T>
169where
170    T: Ord,
171    Fa: Fn(&A) -> T + Send + Sync,
172    Fb: Fn(&B) -> T + Send + Sync,
173{
174    GreaterThanOrEqualJoiner {
175        left,
176        right,
177        _phantom: PhantomData,
178    }
179}
180
181/// A joiner that matches when `left(a) >= right(b)`.
182pub struct GreaterThanOrEqualJoiner<Fa, Fb, T> {
183    left: Fa,
184    right: Fb,
185    _phantom: PhantomData<fn() -> T>,
186}
187
188impl<A, B, T, Fa, Fb> Joiner<A, B> for GreaterThanOrEqualJoiner<Fa, Fb, T>
189where
190    T: Ord,
191    Fa: Fn(&A) -> T + Send + Sync,
192    Fb: Fn(&B) -> T + Send + Sync,
193{
194    #[inline]
195    fn matches(&self, a: &A, b: &B) -> bool {
196        (self.left)(a) >= (self.right)(b)
197    }
198}
solverforge_scoring/stream/joiner/comparison.rs

solverforge_scoring/stream/joiner/
comparison.rs
