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

use serde::{de::*, ser::*};
use std::{collections::BTreeMap, hash::Hash, ops::Deref};

pub trait Key {
    type Key: Eq + Ord + Hash;

    fn key(&self) -> Self::Key;
}

#[derive(Debug, Clone, PartialEq)]
pub struct KeyList<T: Key>(BTreeMap<T::Key, T>);

impl<T: Key> Default for KeyList<T> {
    fn default() -> Self {
        Self(Default::default())
    }
}

impl<T: Key> Deref for KeyList<T> {
    type Target = BTreeMap<T::Key, T>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[derive(thiserror::Error, Debug)]
pub enum FromError {
    #[error("duplicate keys")]
    DuplicateKeys,
}

impl<T: Key, const SIZE: usize> TryFrom<[T; SIZE]> for KeyList<T> {
    type Error = FromError;

    fn try_from(input: [T; SIZE]) -> Result<Self, Self::Error> {
        let mut list = Self::default();
        for i in input.into_iter() {
            if let Some(value) = list.insert(i) {
                return Err(FromError::DuplicateKeys);
            }
        }
        Ok(list)
    }
}

impl<T: Key> KeyList<T> {
    pub fn insert(&mut self, version: T) -> Option<T> {
        self.0.insert(version.key(), version)
    }

    pub fn iter(&self) -> impl Iterator<Item = &T> {
        self.0.values()
    }

    pub fn into_iter(self) -> impl Iterator<Item = T> {
        self.0.into_values()
    }

    pub fn clear(&mut self) {
        self.0.clear()
    }
}

impl<T: Key> Serialize for KeyList<T>
where
    T: Serialize,
    T::Key: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
        for value in self.iter() {
            seq.serialize_element(value)?;
        }
        seq.end()
    }
}

impl<'de, T: Key> Deserialize<'de> for KeyList<T>
where
    T: DeserializeOwned,
    T::Key: DeserializeOwned,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let versions = Vec::<T>::deserialize(deserializer)?;
        //let mut versions = KeyList::default();
        todo!()
    }
}