vdf_reader/entry/
array.rs

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