inc_complete/db/
serialize.rs

1use std::{collections::BTreeSet, sync::{
2    atomic::{AtomicU32, Ordering}, Arc
3}};
4
5use parking_lot::Mutex;
6use serde::{Deserialize, Serialize, ser::SerializeStruct};
7
8use crate::Cell;
9
10use super::Db;
11
12impl<Storage> serde::Serialize for Db<Storage>
13where
14    Storage: serde::Serialize,
15{
16    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
17    where
18        S: serde::Serializer,
19    {
20        let mut cells = Vec::with_capacity(self.cells.len());
21
22        for item in self.cells.iter() {
23            let value = item.value();
24            cells.push((
25                *item.key(),
26                CellDataDeserialize {
27                    computation_id: value.computation_id,
28                    last_updated_version: value.last_updated_version,
29                    last_verified_version: value.last_verified_version,
30                    dependencies: value.dependencies.clone(),
31                    input_dependencies: value.input_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    input_dependencies: BTreeSet<Cell>,
65}
66
67impl<'de, Storage> serde::Deserialize<'de> for Db<Storage>
68where
69    Storage: serde::Deserialize<'de>,
70{
71    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
72    where
73        D: serde::Deserializer<'de>,
74    {
75        let db = DbDeserialize::deserialize(deserializer)?;
76
77        let cells = dashmap::DashMap::with_capacity(db.cells.len());
78
79        for (cell, data) in db.cells {
80            cells.insert(
81                cell,
82                crate::cell::CellData {
83                    computation_id: data.computation_id,
84                    last_updated_version: data.last_updated_version,
85                    last_verified_version: data.last_verified_version,
86                    dependencies: data.dependencies,
87                    input_dependencies: data.input_dependencies,
88                    lock: Arc::new(Mutex::new(())),
89                },
90            );
91        }
92
93        Ok(Db {
94            cells,
95            version: AtomicU32::new(db.version),
96            next_cell: AtomicU32::new(db.next_cell),
97            storage: db.storage,
98        })
99    }
100}
inc_complete/db/serialize.rs

inc_complete/db/
serialize.rs
