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            let input_dependencies: Vec<_> = value.input_dependencies.iter().copied().collect();
26
27            cells.push((
28                *item.key(),
29                CellDataDeserialize {
30                    computation_id: value.computation_id,
31                    last_updated_version: value.last_updated_version,
32                    last_verified_version: value.last_verified_version,
33                    dependencies: value.dependencies.clone(),
34                    input_dependencies,
35                },
36            ));
37        }
38
39        let version = self.version.load(Ordering::SeqCst);
40        let next_cell = self.next_cell.load(Ordering::SeqCst);
41
42        let mut s = serializer.serialize_struct("Db", 4)?;
43        s.serialize_field("version", &version)?;
44        s.serialize_field("next_cell", &next_cell)?;
45        s.serialize_field("cells", &cells)?;
46        s.serialize_field("storage", &self.storage)?;
47        s.end()
48    }
49}
50
51#[derive(Deserialize)]
52#[serde(rename = "Db")]
53struct DbDeserialize<Storage> {
54    version: u32,
55    next_cell: u32,
56    cells: Vec<(Cell, CellDataDeserialize)>,
57    storage: Storage,
58}
59
60#[derive(Serialize, Deserialize)]
61#[serde(rename = "CellData")]
62struct CellDataDeserialize {
63    computation_id: u32,
64    last_updated_version: u32,
65    last_verified_version: u32,
66    dependencies: Vec<Cell>,
67    input_dependencies: Vec<Cell>,
68}
69
70impl<'de, Storage> serde::Deserialize<'de> for Db<Storage>
71where
72    Storage: serde::Deserialize<'de>,
73{
74    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
75    where
76        D: serde::Deserializer<'de>,
77    {
78        let db = DbDeserialize::deserialize(deserializer)?;
79
80        let cells = dashmap::DashMap::with_capacity(db.cells.len());
81
82        for (cell, data) in db.cells {
83            cells.insert(
84                cell,
85                crate::cell::CellData {
86                    computation_id: data.computation_id,
87                    last_updated_version: data.last_updated_version,
88                    last_verified_version: data.last_verified_version,
89                    dependencies: data.dependencies,
90                    input_dependencies: data.input_dependencies.into_iter().collect(),
91                    lock: Arc::new(Mutex::new(())),
92                },
93            );
94        }
95
96        Ok(Db {
97            cells,
98            version: AtomicU32::new(db.version),
99            next_cell: AtomicU32::new(db.next_cell),
100            cell_locks: Default::default(),
101            storage: db.storage,
102        })
103    }
104}
inc_complete/db/serialize.rs

inc_complete/db/
serialize.rs
