solverforge-scoring 0.15.0

Incremental constraint scoring for SolverForge
Documentation 
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

/* Zero-erasure sum collector for summing values.

All type information is preserved at compile time - no Arc, no dyn, no Clone.
*/

use std::marker::PhantomData;
use std::ops::{AddAssign, SubAssign};

use super::{Accumulator, Collector};

/* Creates a zero-erasure collector that sums values extracted from stream matches.

# Example

```
use solverforge_scoring::stream::collector::{sum, Accumulator, Collector};

struct Item { value: i64 }

let collector = sum(|item: &Item| item.value);
let mut acc = collector.create_accumulator();

acc.accumulate(collector.extract(&Item { value: 5 }));
let middle = acc.accumulate(collector.extract(&Item { value: 3 }));
acc.accumulate(collector.extract(&Item { value: 7 }));
assert_eq!(acc.finish(), 15);

acc.retract(middle);
assert_eq!(acc.finish(), 12);
```
*/
pub fn sum<T, F>(mapper: F) -> SumCollector<T, F>
where
    T: Default + Copy + AddAssign + SubAssign + Send + Sync + 'static,
    F: Send + Sync + 'static,
{
    SumCollector {
        mapper,
        _phantom: PhantomData,
    }
}

/* Zero-erasure collector that sums values extracted from stream matches.

Created by the [`sum()`] function.
The mapper function is stored once in the collector, not cloned into accumulators.
*/
pub struct SumCollector<T, F> {
    mapper: F,
    _phantom: PhantomData<fn() -> T>,
}

impl<Input, T, F> Collector<Input> for SumCollector<T, F>
where
    Input: Send + Sync,
    T: Default + Copy + AddAssign + SubAssign + Send + Sync + 'static,
    F: Fn(Input) -> T + Send + Sync + 'static,
{
    type Value = T;
    type Result = T;
    type Accumulator = SumAccumulator<T>;

    #[inline]
    fn extract(&self, input: Input) -> T {
        (self.mapper)(input)
    }

    fn create_accumulator(&self) -> Self::Accumulator {
        SumAccumulator { sum: T::default() }
    }
}

/* Zero-erasure accumulator for summing values.

Works with pre-extracted values, not entities directly.
*/
pub struct SumAccumulator<T> {
    sum: T,
}

impl<T> Accumulator<T, T> for SumAccumulator<T>
where
    T: Default + Copy + AddAssign + SubAssign + Send + Sync,
{
    type Retraction = T;

    #[inline]
    fn accumulate(&mut self, value: T) -> Self::Retraction {
        self.sum += value;
        value
    }

    #[inline]
    fn retract(&mut self, value: Self::Retraction) {
        self.sum -= value;
    }

    #[inline]
    fn with_result<R>(&self, f: impl FnOnce(&T) -> R) -> R {
        f(&self.sum)
    }

    #[inline]
    fn reset(&mut self) {
        self.sum = T::default();
    }
}