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

inc_complete/db/
serialize.rs
