inc_complete/storage/
singleton.rs

1use serde::{Deserialize, ser::SerializeStruct};
2
3use super::{Computation, StorageFor};
4use crate::Cell;
5
6/// Helper to store a simple computation type which has no fields and thus
7/// does not require a map to cache each possible value.
8///
9/// Examples include `struct SourceFile;` or `struct Time;`
10pub struct SingletonStorage<K: Computation> {
11    cell: std::sync::OnceLock<Cell>,
12    key: std::sync::OnceLock<K>,
13    value: std::sync::Mutex<Option<K::Output>>,
14}
15
16impl<K: Computation> Default for SingletonStorage<K> {
17    fn default() -> Self {
18        Self {
19            cell: Default::default(),
20            value: Default::default(),
21            key: Default::default(),
22        }
23    }
24}
25
26impl<K> StorageFor<K> for SingletonStorage<K>
27where
28    K: Computation + Clone,
29    K::Output: Eq + Clone,
30{
31    fn get_cell_for_computation(&self, _: &K) -> Option<Cell> {
32        self.cell.get().copied()
33    }
34
35    fn insert_new_cell(&self, cell: Cell, key: K) {
36        // self.cell must be written last to avoid data races
37        let result = self.key.set(key);
38        result.unwrap_or_else(|_| panic!("insert_new_cell: cell already initialized"));
39        assert!(
40            self.cell.set(cell).is_ok(),
41            "Overwriting previous singleton value - are you using SingleStorage<{}> with a non-singleton type?",
42            std::any::type_name::<K>()
43        );
44    }
45
46    fn try_get_input(&self, cell: Cell) -> Option<K> {
47        if cell == self.cell.get().cloned()? {
48            self.key.get().cloned()
49        } else {
50            None
51        }
52    }
53
54    fn get_input(&self, _: Cell) -> K {
55        self.key.get().cloned().unwrap()
56    }
57
58    fn get_output(&self, _: Cell) -> Option<K::Output> {
59        self.value.lock().unwrap().clone()
60    }
61
62    fn update_output(&self, _: Cell, new_value: K::Output) -> bool {
63        let mut guard = self.value.lock().unwrap();
64        let changed = K::ASSUME_CHANGED || guard.as_ref().is_none_or(|value| *value != new_value);
65        *guard = Some(new_value);
66        changed
67    }
68
69    fn gc(&mut self, used_cells: &std::collections::HashSet<Cell>) {
70        if let Some(this_cell) = self.cell.get() {
71            if !used_cells.contains(this_cell) {
72                if let Ok(val) = self.value.get_mut() {
73                    *val = None;
74                }
75            }
76        }
77    }
78}
79
80impl<K> serde::Serialize for SingletonStorage<K>
81where
82    K: serde::Serialize + Computation,
83    K::Output: serde::Serialize,
84{
85    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
86    where
87        S: serde::Serializer,
88    {
89        let mut s = serializer.serialize_struct("SingletonStorage", 3)?;
90        s.serialize_field("cell", &self.cell.get())?;
91        s.serialize_field("key", &self.key.get())?;
92        let guard = self.value.lock().unwrap();
93
94        // When users store unit values in a singleton, this leads to `self.value`
95        // being `Some(())` or `None` which tagless encodings can't differentiate.
96        // So we wrap in a single element tuple to tell them apart.
97        s.serialize_field("value", &guard.as_ref().map(|value| (value,)))?;
98        s.end()
99    }
100}
101
102impl<'de, K> serde::Deserialize<'de> for SingletonStorage<K>
103where
104    K: serde::Deserialize<'de> + Computation,
105    K::Output: serde::Deserialize<'de>,
106{
107    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
108    where
109        D: serde::Deserializer<'de>,
110    {
111        let wrapper: SerializeWrapper<K> = Deserialize::deserialize(deserializer)?;
112        Ok(wrapper.into_storage())
113    }
114}
115
116#[derive(Deserialize)]
117struct SerializeWrapper<K: Computation> {
118    #[serde(default)]
119    cell: Option<Cell>,
120
121    // Serde complains we need a `K: Default` without this, but that shouldn't be necessary.
122    #[serde(default = "none")]
123    key: Option<K>,
124
125    #[serde(default)]
126    #[serde(bound = "K::Output: Deserialize<'de>")]
127    value: Option<(K::Output,)>,
128}
129
130fn none<T>() -> Option<T> {
131    None
132}
133
134impl<K: Computation> SerializeWrapper<K> {
135    fn into_storage(self) -> SingletonStorage<K> {
136        let cell = match self.cell {
137            Some(cell) => std::sync::OnceLock::from(cell),
138            None => std::sync::OnceLock::new(),
139        };
140        let key = match self.key {
141            Some(key) => std::sync::OnceLock::from(key),
142            None => std::sync::OnceLock::new(),
143        };
144        let value = std::sync::Mutex::new(self.value.map(|(value,)| value));
145        SingletonStorage { cell, key, value }
146    }
147}
inc_complete/storage/singleton.rs

inc_complete/storage/
singleton.rs
