darkfi_serial/types/
sled_overlay.rs

1/* This file is part of DarkFi (https://dark.fi)
2 *
3 * Copyright (C) 2020-2026 Dyne.org foundation
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Affero General Public License as
7 * published by the Free Software Foundation, either version 3 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU Affero General Public License for more details.
14 *
15 * You should have received a copy of the GNU Affero General Public License
16 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
17 */
18
19use std::{
20    collections::BTreeMap,
21    io::{Read, Result, Write},
22};
23
24use sled_overlay::{SledDbOverlayStateDiff, SledTreeOverlayStateDiff};
25
26#[cfg(feature = "async")]
27use crate::{AsyncDecodable, AsyncEncodable};
28#[cfg(feature = "async")]
29use async_trait::async_trait;
30#[cfg(feature = "async")]
31use futures_lite::{AsyncRead, AsyncWrite};
32
33use crate::{Decodable, Encodable, VarInt};
34
35impl Encodable for SledTreeOverlayStateDiff {
36    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
37        let mut len = 0;
38
39        len += VarInt(self.cache.len() as u64).encode(s)?;
40        for (key, (previous, current)) in self.cache.iter() {
41            len += key.to_vec().encode(s)?;
42            let previous = previous.as_ref().map(|p| p.to_vec());
43            len += previous.encode(s)?;
44            len += current.to_vec().encode(s)?;
45        }
46
47        len += VarInt(self.removed.len() as u64).encode(s)?;
48        for (key, value) in self.removed.iter() {
49            len += key.to_vec().encode(s)?;
50            len += value.to_vec().encode(s)?;
51        }
52
53        Ok(len)
54    }
55}
56
57#[cfg(feature = "async")]
58#[async_trait]
59impl AsyncEncodable for SledTreeOverlayStateDiff {
60    async fn encode_async<S: AsyncWrite + Unpin + Send>(&self, s: &mut S) -> Result<usize> {
61        let mut len = 0;
62
63        len += VarInt(self.cache.len() as u64).encode_async(s).await?;
64        for (key, (previous, current)) in self.cache.iter() {
65            len += key.to_vec().encode_async(s).await?;
66            let previous = previous.as_ref().map(|p| p.to_vec());
67            len += previous.encode_async(s).await?;
68            len += current.to_vec().encode_async(s).await?;
69        }
70
71        len += VarInt(self.removed.len() as u64).encode_async(s).await?;
72        for (key, value) in self.removed.iter() {
73            len += key.to_vec().encode_async(s).await?;
74            len += value.to_vec().encode_async(s).await?;
75        }
76
77        Ok(len)
78    }
79}
80
81impl Decodable for SledTreeOverlayStateDiff {
82    fn decode<D: Read>(d: &mut D) -> Result<Self> {
83        let len = VarInt::decode(d)?.0;
84        let mut cache = BTreeMap::new();
85        for _ in 0..len {
86            let key: Vec<u8> = Decodable::decode(d)?;
87            let (previous, current): (Option<Vec<u8>>, Vec<u8>) = Decodable::decode(d)?;
88            let previous = previous.as_ref().map(|p| p.clone().into());
89            cache.insert(key.into(), (previous, current.into()));
90        }
91
92        let len = VarInt::decode(d)?.0;
93        let mut removed = BTreeMap::new();
94        for _ in 0..len {
95            let key: Vec<u8> = Decodable::decode(d)?;
96            let entry: Vec<u8> = Decodable::decode(d)?;
97            removed.insert(key.into(), entry.into());
98        }
99
100        Ok(Self { cache, removed })
101    }
102}
103
104#[cfg(feature = "async")]
105#[async_trait]
106impl AsyncDecodable for SledTreeOverlayStateDiff {
107    async fn decode_async<D: AsyncRead + Unpin + Send>(d: &mut D) -> Result<Self> {
108        let len = VarInt::decode_async(d).await?.0;
109        let mut cache = BTreeMap::new();
110        for _ in 0..len {
111            let key: Vec<u8> = AsyncDecodable::decode_async(d).await?;
112            let (previous, current): (Option<Vec<u8>>, Vec<u8>) =
113                AsyncDecodable::decode_async(d).await?;
114            let previous = previous.as_ref().map(|p| p.clone().into());
115            cache.insert(key.into(), (previous, current.into()));
116        }
117
118        let len = VarInt::decode_async(d).await?.0;
119        let mut removed = BTreeMap::new();
120        for _ in 0..len {
121            let key: Vec<u8> = AsyncDecodable::decode_async(d).await?;
122            let entry: Vec<u8> = AsyncDecodable::decode_async(d).await?;
123            removed.insert(key.into(), entry.into());
124        }
125
126        Ok(Self { cache, removed })
127    }
128}
129
130impl Encodable for SledDbOverlayStateDiff {
131    fn encode<S: Write>(&self, s: &mut S) -> Result<usize> {
132        let mut len = 0;
133
134        len += VarInt(self.initial_tree_names.len() as u64).encode(s)?;
135        for tree_name in &self.initial_tree_names {
136            len += tree_name.to_vec().encode(s)?;
137        }
138
139        len += VarInt(self.caches.len() as u64).encode(s)?;
140        for (key, (cache, drop)) in self.caches.iter() {
141            len += key.to_vec().encode(s)?;
142            len += cache.encode(s)?;
143            len += drop.encode(s)?;
144        }
145
146        len += VarInt(self.dropped_trees.len() as u64).encode(s)?;
147        for (key, (cache, restore)) in self.dropped_trees.iter() {
148            len += key.to_vec().encode(s)?;
149            len += cache.encode(s)?;
150            len += restore.encode(s)?;
151        }
152
153        Ok(len)
154    }
155}
156
157#[cfg(feature = "async")]
158#[async_trait]
159impl AsyncEncodable for SledDbOverlayStateDiff {
160    async fn encode_async<S: AsyncWrite + Unpin + Send>(&self, s: &mut S) -> Result<usize> {
161        let mut len = 0;
162
163        len += VarInt(self.initial_tree_names.len() as u64).encode_async(s).await?;
164        for tree_name in &self.initial_tree_names {
165            len += tree_name.to_vec().encode_async(s).await?;
166        }
167
168        len += VarInt(self.caches.len() as u64).encode_async(s).await?;
169        for (key, (cache, drop)) in self.caches.iter() {
170            len += key.to_vec().encode_async(s).await?;
171            len += cache.encode_async(s).await?;
172            len += drop.encode_async(s).await?;
173        }
174
175        len += VarInt(self.dropped_trees.len() as u64).encode_async(s).await?;
176        for (key, (cache, restore)) in self.dropped_trees.iter() {
177            len += key.to_vec().encode_async(s).await?;
178            len += cache.encode_async(s).await?;
179            len += restore.encode_async(s).await?;
180        }
181
182        Ok(len)
183    }
184}
185
186impl Decodable for SledDbOverlayStateDiff {
187    fn decode<D: Read>(d: &mut D) -> Result<Self> {
188        let len = VarInt::decode(d)?.0;
189        let mut initial_tree_names = vec![];
190        for _ in 0..len {
191            let initial_tree_name: Vec<u8> = Decodable::decode(d)?;
192            initial_tree_names.push(initial_tree_name.into());
193        }
194
195        let len = VarInt::decode(d)?.0;
196        let mut caches = BTreeMap::new();
197        for _ in 0..len {
198            let key: Vec<u8> = Decodable::decode(d)?;
199            let cache = Decodable::decode(d)?;
200            let drop = Decodable::decode(d)?;
201            caches.insert(key.into(), (cache, drop));
202        }
203
204        let len = VarInt::decode(d)?.0;
205        let mut dropped_trees = BTreeMap::new();
206        for _ in 0..len {
207            let key: Vec<u8> = Decodable::decode(d)?;
208            let cache = Decodable::decode(d)?;
209            let restore = Decodable::decode(d)?;
210            dropped_trees.insert(key.into(), (cache, restore));
211        }
212
213        Ok(Self { initial_tree_names, caches, dropped_trees })
214    }
215}
216
217#[cfg(feature = "async")]
218#[async_trait]
219impl AsyncDecodable for SledDbOverlayStateDiff {
220    async fn decode_async<D: AsyncRead + Unpin + Send>(d: &mut D) -> Result<Self> {
221        let len = VarInt::decode_async(d).await?.0;
222        let mut initial_tree_names = vec![];
223        for _ in 0..len {
224            let initial_tree_name: Vec<u8> = AsyncDecodable::decode_async(d).await?;
225            initial_tree_names.push(initial_tree_name.into());
226        }
227
228        let len = VarInt::decode_async(d).await?.0;
229        let mut caches = BTreeMap::new();
230        for _ in 0..len {
231            let key: Vec<u8> = AsyncDecodable::decode_async(d).await?;
232            let cache = AsyncDecodable::decode_async(d).await?;
233            let drop = AsyncDecodable::decode_async(d).await?;
234            caches.insert(key.into(), (cache, drop));
235        }
236
237        let len = VarInt::decode_async(d).await?.0;
238        let mut dropped_trees = BTreeMap::new();
239        for _ in 0..len {
240            let key: Vec<u8> = AsyncDecodable::decode_async(d).await?;
241            let cache = AsyncDecodable::decode_async(d).await?;
242            let restore = AsyncDecodable::decode_async(d).await?;
243            dropped_trees.insert(key.into(), (cache, restore));
244        }
245
246        Ok(Self { initial_tree_names, caches, dropped_trees })
247    }
248}
darkfi_serial/types/sled_overlay.rs

darkfi_serial/types/
sled_overlay.rs
