vdf_reader/entry/
array.rs

1use super::{Entry, Table};
2use crate::entry::Value;
3use crate::error::{ParseStringError, UnknownError};
4use crate::VdfError;
5use serde_core::de::{DeserializeSeed, SeqAccess};
6use serde_core::{Deserialize, Deserializer, Serialize, Serializer};
7use std::ops::{Deref, DerefMut};
8
9/// An array of entries (items that have the same key).
10#[derive(Clone, PartialEq, Eq, Debug, Default)]
11pub struct Array(Vec<Entry>);
12
13impl Array {
14    pub(crate) fn from_space_separated(str: &str) -> Self {
15        let items = str
16            .split(' ')
17            .filter(|part| !part.is_empty())
18            .map(Value::from)
19            .map(Entry::from)
20            .collect();
21        Array(items)
22    }
23}
24
25impl<'de> Deserialize<'de> for Array {
26    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
27    where
28        D: Deserializer<'de>,
29    {
30        <Vec<Entry>>::deserialize(deserializer).map(Array)
31    }
32}
33
34impl Serialize for Array {
35    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
36    where
37        S: Serializer,
38    {
39        self.0.serialize(serializer)
40    }
41}
42
43impl From<Vec<Entry>> for Array {
44    fn from(value: Vec<Entry>) -> Self {
45        Array(value)
46    }
47}
48impl From<Entry> for Array {
49    fn from(value: Entry) -> Self {
50        Array(vec![value])
51    }
52}
53
54impl From<Array> for Entry {
55    fn from(array: Array) -> Self {
56        Entry::Array(array)
57    }
58}
59
60impl Deref for Array {
61    type Target = Vec<Entry>;
62
63    fn deref(&self) -> &Self::Target {
64        &self.0
65    }
66}
67
68impl DerefMut for Array {
69    fn deref_mut(&mut self) -> &mut Self::Target {
70        &mut self.0
71    }
72}
73
74pub(crate) struct ArraySeq {
75    iter: std::vec::IntoIter<Entry>,
76}
77
78impl ArraySeq {
79    pub(crate) fn new(array: Array) -> Self {
80        ArraySeq {
81            iter: array.0.into_iter(),
82        }
83    }
84}
85
86impl<'de> SeqAccess<'de> for ArraySeq {
87    type Error = VdfError;
88
89    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
90    where
91        T: DeserializeSeed<'de>,
92    {
93        let next = match self.iter.next() {
94            Some(next) => next,
95            None => return Ok(None),
96        };
97
98        seed.deserialize(next).map(Some)
99    }
100}
101
102pub(crate) struct TableArraySeq {
103    iter: std::vec::IntoIter<(String, Entry)>,
104    last_key: Option<u64>,
105}
106
107impl TableArraySeq {
108    pub(crate) fn new(table: Table) -> Self {
109        // since the tables map doesn't have a stable order, we need to re-sort them to have the keys in order
110        let mut items: Vec<_> = table.into_iter().collect();
111        items.sort_by(|(key_a, _), (key_b, _)| key_a.cmp(key_b));
112        TableArraySeq {
113            iter: items.into_iter(),
114            last_key: None,
115        }
116    }
117}
118
119impl<'de> SeqAccess<'de> for TableArraySeq {
120    type Error = VdfError;
121
122    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
123    where
124        T: DeserializeSeed<'de>,
125    {
126        let (key, next) = match self.iter.next() {
127            Some(next) => next,
128            None => return Ok(None),
129        };
130
131        let key: u64 = key.parse().map_err(|_| {
132            VdfError::ParseString(ParseStringError {
133                ty: "u64",
134                value: key,
135            })
136        })?;
137
138        if let Some(last_key) = self.last_key {
139            let expected_key = last_key + 1;
140            if expected_key != key {
141                return Err(VdfError::Other(UnknownError::from(format!(
142                    "Invalid array key {key}, expected {expected_key}"
143                ))));
144            }
145        }
146        self.last_key = Some(key);
147
148        seed.deserialize(next).map(Some)
149    }
150}
vdf_reader/entry/array.rs

vdf_reader/entry/
array.rs
