selene-core 0.5.0

selene-core is the backend for Selene, a local-first music player
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

use serde::{Deserialize, Serialize};

mod track_rules;
pub use track_rules::*;

mod album_rules;
pub use album_rules::*;

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum GroupOp {
    Any,
    All,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum EqOp {
    EqAny,
    EqAll,
    NeqAny,
    NeqAll,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum OrdOp {
    Eq,
    Neq,
    Greater,
    GreaterEq,
    Lesser,
    LesserEq,
}

pub trait Rule {
    type Item;
    fn matches(&self, item: &Self::Item) -> bool;
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuleGroup<R: Rule> {
    pub rules: Vec<R>,
    pub op: GroupOp,
}

impl<R: Rule> Default for RuleGroup<R> {
    fn default() -> Self {
        Self::new()
    }
}

impl<R: Rule> RuleGroup<R> {
    #[must_use] 
    pub const fn new() -> Self {
        Self {
            rules: Vec::new(),
            op: GroupOp::Any,
        }
    }

    pub fn filter<'a>(&self, candidates: &'a [R::Item]) -> impl Iterator<Item = &'a R::Item> {
        candidates.iter().filter(|c| {
            if self.rules.is_empty() {
                return true;
            }

            match self.op {
                GroupOp::Any => self.rules.iter().any(|rule| rule.matches(c)),
                GroupOp::All => self.rules.iter().all(|rule| rule.matches(c)),
            }
        })
    }
}

pub(crate) fn eq_single<T: PartialEq>(item: &T, cmp: &[T], op: EqOp) -> bool {
    match op {
        EqOp::EqAny | EqOp::EqAll => cmp.contains(item),
        EqOp::NeqAny => !cmp.contains(item),
        EqOp::NeqAll => cmp.iter().any(|c| c != item),
    }
}

pub(crate) fn eq_many<T: PartialEq>(values: &[T], cmp: &[T], op: EqOp) -> bool {
    match op {
        EqOp::EqAny => cmp.iter().any(|c| values.contains(c)),
        EqOp::EqAll => cmp.iter().all(|c| values.contains(c)),
        EqOp::NeqAny => cmp.iter().any(|c| !values.contains(c)),
        EqOp::NeqAll => cmp.iter().all(|c| !values.contains(c)),
    }
}

pub(crate) fn ord_single<T: PartialOrd>(value: T, cmp: T, op: OrdOp) -> bool {
    match op {
        OrdOp::Eq => value == cmp,
        OrdOp::Neq => value != cmp,
        OrdOp::Greater => value > cmp,
        OrdOp::GreaterEq => value >= cmp,
        OrdOp::Lesser => value < cmp,
        OrdOp::LesserEq => value <= cmp,
    }
}