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

pub mod item;

use std::collections::BTreeSet;
use educe::Educe;
use serde::Serialize;
use crate::index;
pub use item::Item;

#[derive(Educe)]
#[educe(Debug, PartialEq, Eq, Hash)]
#[derive(Serialize, Clone)]
pub struct Index {
    pub r#type: index::Type,
    pub name: String,
    pub items: Vec<Item>,
    #[serde(skip)]
    #[educe(PartialEq(ignore))] #[educe(Hash(ignore))]
    pub cache: Cache,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Cache {
    pub keys: Vec<String>,
}

impl Index {

    pub fn new(r#type: index::Type, name: String, items: Vec<Item>) -> Self {
        let keys = items.iter().map(|i| i.field.clone()).collect();
        Self {
            r#type,
            name,
            items,
            cache: Cache { keys }
        }
    }

    pub fn r#type(&self) -> index::Type {
        self.r#type
    }

    pub fn name(&self) -> &str {
        self.name.as_str()
    }

    pub fn items(&self) -> &Vec<Item> {
        &self.items
    }

    pub fn keys(&self) -> &Vec<String> {
        &self.cache.keys
    }
}