pagat 0.0.2

A library that helps you split the bill
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::{money::Money, person::Person};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Obligation {
    pub from: Person,
    pub to: Person,
    pub amount: Money,
}

impl Obligation {
    #[inline(always)]
    pub fn builder() -> ObligationBuilder {
        ObligationBuilder::default()
    }
}

#[derive(Default)]
pub struct ObligationBuilder {
    from: Person,
    to: Person,
    amount: Money,
}

impl ObligationBuilder {
    #[inline(always)]
    pub const fn new(from: Person, to: Person, amount: Money) -> Self {
        Self { from, to, amount }
    }

    #[inline(always)]
    pub fn from(mut self, from: Person) -> Self {
        self.from = from;
        self
    }

    #[inline(always)]
    pub fn to(mut self, to: Person) -> Self {
        self.to = to;
        self
    }

    #[inline(always)]
    pub const fn amount(mut self, amount: Money) -> Self {
        self.amount = amount;
        self
    }

    #[inline(always)]
    pub fn build(self) -> Obligation {
        Obligation {
            from: self.from,
            to: self.to,
            amount: self.amount,
        }
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct Obligations(Vec<Obligation>);

impl Obligations {
    #[inline(always)]
    pub fn new(obligations: &[Obligation]) -> Self {
        Self(obligations.to_vec())
    }

    #[inline(always)]
    pub fn builder() -> ObligationsBuilder {
        ObligationsBuilder::default()
    }

    #[inline(always)]
    pub const fn raw(&self) -> &Vec<Obligation> {
        &self.0
    }
}

#[derive(Debug, Default)]
pub struct ObligationsBuilder {
    obligations: Vec<Obligation>,
}

impl ObligationsBuilder {
    #[inline(always)]
    pub fn record(&mut self, o: Obligation) -> &mut Self {
        self.obligations.push(o);
        self
    }

    #[inline(always)]
    pub fn build(&mut self) -> Obligations {
        Obligations::new(&self.obligations)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_obligations() {
        let from_raw = "from";
        let to_raw = "to";
        let amount_raw = 10;

        let from = Person::new(from_raw.to_owned());
        let to = Person::new(to_raw.to_owned());
        let amount = Money::new(amount_raw);

        let obligation = Obligation::builder()
            .from(from)
            .to(to)
            .amount(amount)
            .build();

        assert_eq!(from_raw, obligation.from.raw());
        assert_eq!(to_raw, obligation.to.raw());
        assert_eq!(amount_raw, obligation.amount.raw());

        let obligations = Obligations::builder().record(obligation).build();
        assert_eq!(1, obligations.raw().len());
    }
}