inc_complete/db/
serialize.rs

1use std::sync::{
2    Arc,
3    atomic::{AtomicU32, Ordering},
4};
5
6use parking_lot::Mutex;
7use serde::{Deserialize, Serialize, ser::SerializeStruct};
8
9use crate::Cell;
10
11use super::Db;
12
13impl<Storage> serde::Serialize for Db<Storage>
14where
15    Storage: serde::Serialize,
16{
17    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
18    where
19        S: serde::Serializer,
20    {
21        let mut cells = Vec::with_capacity(self.cells.len());
22
23        for item in self.cells.iter() {
24            let value = item.value();
25            cells.push((
26                *item.key(),
27                CellDataDeserialize {
28                    computation_id: value.computation_id,
29                    last_updated_version: value.last_updated_version,
30                    last_verified_version: value.last_verified_version,
31                    dependencies: value.dependencies.clone(),
32                },
33            ));
34        }
35
36        let version = self.version.load(Ordering::SeqCst);
37        let next_cell = self.next_cell.load(Ordering::SeqCst);
38
39        let mut s = serializer.serialize_struct("Db", 4)?;
40        s.serialize_field("version", &version)?;
41        s.serialize_field("next_cell", &next_cell)?;
42        s.serialize_field("cells", &cells)?;
43        s.serialize_field("storage", &self.storage)?;
44        s.end()
45    }
46}
47
48#[derive(Deserialize)]
49#[serde(rename = "Db")]
50struct DbDeserialize<Storage> {
51    version: u32,
52    next_cell: u32,
53    cells: Vec<(Cell, CellDataDeserialize)>,
54    storage: Storage,
55}
56
57#[derive(Serialize, Deserialize)]
58#[serde(rename = "CellData")]
59struct CellDataDeserialize {
60    computation_id: u32,
61    last_updated_version: u32,
62    last_verified_version: u32,
63    dependencies: Vec<Cell>,
64}
65
66impl<'de, Storage> serde::Deserialize<'de> for Db<Storage>
67where
68    Storage: serde::Deserialize<'de>,
69{
70    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71    where
72        D: serde::Deserializer<'de>,
73    {
74        let db = DbDeserialize::deserialize(deserializer)?;
75
76        let cells = dashmap::DashMap::with_capacity(db.cells.len());
77
78        for (cell, data) in db.cells {
79            cells.insert(
80                cell,
81                crate::cell::CellData {
82                    computation_id: data.computation_id,
83                    last_updated_version: data.last_updated_version,
84                    last_verified_version: data.last_verified_version,
85                    dependencies: data.dependencies,
86                    lock: Arc::new(Mutex::new(())),
87                },
88            );
89        }
90
91        Ok(Db {
92            cells,
93            version: AtomicU32::new(db.version),
94            next_cell: AtomicU32::new(db.next_cell),
95            storage: db.storage,
96        })
97    }
98}
inc_complete/db/serialize.rs

inc_complete/db/
serialize.rs
