vdf_reader/entry/
array.rs1use 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#[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 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}