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

inc_complete/db/
serialize.rs
