Debian Codegraph @

rust/hg-pyo3/src/dirstate/item.rs

raw
1 // dirstate/item.rs
2 //
3 // Copyright 2019 Raphaël Gomès <[email protected]>
4 // 2025 Georges Racinet <[email protected]>
5 //
6 // This software may be used and distributed according to the terms of the
7 // GNU General Public License version 2 or any later version.
8 //! Bindings for the `hg::dirstate::entry` module of the `hg-core` package.
9
10 use std::sync::RwLock;
11 use std::sync::RwLockReadGuard;
12 use std::sync::RwLockWriteGuard;
13
14 use hg::dirstate::entry::DirstateEntry;
15 use hg::dirstate::entry::DirstateV2Data;
16 use hg::dirstate::entry::TruncatedTimestamp;
17 use pyo3::exceptions::PyValueError;
18 use pyo3::prelude::*;
19 use pyo3::types::PyBytes;
20
21 use crate::exceptions::map_lock_error;
22
23 #[pyclass]
24 pub struct DirstateItem {
25 entry: RwLock<DirstateEntry>,
26 }
27
28 /// Type alias to satisfy Clippy in `DirstateItem::new()`
29 type UncheckedTruncatedTimeStamp = Option<(u32, u32, bool)>;
30
31 #[pymethods]
32 impl DirstateItem {
33 #[new]
34 #[allow(clippy::too_many_arguments)]
35 #[pyo3(signature = (wc_tracked=false,
36 p1_tracked=false,
37 p2_info=false,
38 has_meaningful_data=true,
39 has_meaningful_mtime=true,
40 parentfiledata=None,
41 fallback_exec=None,
42 fallback_symlink=None))]
43 fn new(
44 wc_tracked: bool,
45 p1_tracked: bool,
46 p2_info: bool,
47 has_meaningful_data: bool,
48 has_meaningful_mtime: bool,
49 parentfiledata: Option<(u32, u32, UncheckedTruncatedTimeStamp)>,
50 fallback_exec: Option<bool>,
51 fallback_symlink: Option<bool>,
52 ) -> PyResult<Self> {
53 let mut mode_size_opt = None;
54 let mut mtime_opt = None;
55 if let Some((mode, size, mtime)) = parentfiledata {
56 if has_meaningful_data {
57 mode_size_opt = Some((mode, size))
58 }
59 if has_meaningful_mtime {
60 if let Some(m) = mtime {
61 mtime_opt = Some(timestamp(m)?);
62 }
63 }
64 }
65 Ok(Self {
66 entry: DirstateEntry::from_v2_data(DirstateV2Data {
67 wc_tracked,
68 p1_tracked,
69 p2_info,
70 mode_size: mode_size_opt,
71 mtime: mtime_opt,
72 fallback_exec,
73 fallback_symlink,
74 })
75 .into(),
76 })
77 }
78
79 #[getter]
80 fn state(&self, py: Python) -> PyResult<Py<PyBytes>> {
81 let state_byte = self.read()?.state();
82 Ok(PyBytes::new(py, &[state_byte.into()]).unbind())
83 }
84
85 #[getter]
86 fn mode(&self) -> PyResult<i32> {
87 Ok(self.read()?.mode())
88 }
89
90 #[getter]
91 fn size(&self) -> PyResult<i32> {
92 Ok(self.read()?.size())
93 }
94
95 #[getter]
96 fn mtime(&self) -> PyResult<i32> {
97 Ok(self.read()?.mtime())
98 }
99
100 #[getter]
101 fn has_fallback_exec(&self) -> PyResult<bool> {
102 Ok(self.read()?.get_fallback_exec().is_some())
103 }
104
105 #[getter]
106 fn fallback_exec(&self) -> PyResult<Option<bool>> {
107 Ok(self.read()?.get_fallback_exec())
108 }
109
110 #[setter]
111 fn set_fallback_exec(
112 &self,
113 value: Option<Bound<'_, PyAny>>,
114 ) -> PyResult<()> {
115 let mut writable = self.write()?;
116 match value {
117 None => {
118 writable.set_fallback_exec(None);
119 }
120 Some(value) => {
121 if value.is_none() {
122 // gracinet: this case probably cannot happen,
123 // because PyO3 setters have a fixed signature, that
124 // is not defaulting to kwargs, hence there is no
125 // difference between an explicit None and a default
126 // (kwarg) None. Still keeping it for safety, it could
127 // be cleaned up afterwards.
128 writable.set_fallback_exec(None);
129 } else {
130 writable.set_fallback_exec(Some(value.is_truthy()?));
131 }
132 }
133 }
134 Ok(())
135 }
136
137 #[getter]
138 fn has_fallback_symlink(&self) -> PyResult<bool> {
139 Ok(self.read()?.get_fallback_symlink().is_some())
140 }
141
142 #[getter]
143 fn fallback_symlink(&self) -> PyResult<Option<bool>> {
144 Ok(self.read()?.get_fallback_symlink())
145 }
146
147 #[getter]
148 fn tracked(&self) -> PyResult<bool> {
149 Ok(self.read()?.tracked())
150 }
151
152 #[getter]
153 fn p1_tracked(&self) -> PyResult<bool> {
154 Ok(self.read()?.p1_tracked())
155 }
156
157 #[getter]
158 fn added(&self) -> PyResult<bool> {
159 Ok(self.read()?.added())
160 }
161
162 #[getter]
163 fn modified(&self) -> PyResult<bool> {
164 Ok(self.read()?.modified())
165 }
166
167 #[getter]
168 fn p2_info(&self) -> PyResult<bool> {
169 Ok(self.read()?.p2_info())
170 }
171
172 #[getter]
173 fn removed(&self) -> PyResult<bool> {
174 Ok(self.read()?.removed())
175 }
176
177 #[getter]
178 fn maybe_clean(&self) -> PyResult<bool> {
179 Ok(self.read()?.maybe_clean())
180 }
181
182 #[getter]
183 fn any_tracked(&self) -> PyResult<bool> {
184 Ok(self.read()?.any_tracked())
185 }
186
187 fn mtime_likely_equal_to(&self, other: (u32, u32, bool)) -> PyResult<bool> {
188 if let Some(mtime) = self.read()?.truncated_mtime() {
189 Ok(mtime.likely_equal(timestamp(other)?))
190 } else {
191 Ok(false)
192 }
193 }
194
195 fn drop_merge_data(&self) -> PyResult<()> {
196 self.write()?.drop_merge_data();
197 Ok(())
198 }
199
200 fn set_clean(
201 &self,
202 mode: u32,
203 size: u32,
204 mtime: (u32, u32, bool),
205 ) -> PyResult<()> {
206 self.write()?.set_clean(mode, size, timestamp(mtime)?);
207 Ok(())
208 }
209
210 fn set_possibly_dirty(&self) -> PyResult<()> {
211 self.write()?.set_possibly_dirty();
212 Ok(())
213 }
214
215 fn set_tracked(&self) -> PyResult<()> {
216 self.write()?.set_tracked();
217 Ok(())
218 }
219
220 fn set_untracked(&self) -> PyResult<()> {
221 self.write()?.set_untracked();
222 Ok(())
223 }
224 }
225
226 impl DirstateItem {
227 pub fn new_as_py(py: Python, entry: DirstateEntry) -> PyResult<Py<Self>> {
228 Ok(Self { entry: entry.into() }.into_pyobject(py)?.unbind())
229 }
230
231 fn read(&self) -> PyResult<RwLockReadGuard<DirstateEntry>> {
232 self.entry.read().map_err(map_lock_error)
233 }
234
235 fn write(&self) -> PyResult<RwLockWriteGuard<DirstateEntry>> {
236 self.entry.write().map_err(map_lock_error)
237 }
238 }
239
240 pub(crate) fn timestamp(
241 (s, ns, second_ambiguous): (u32, u32, bool),
242 ) -> PyResult<TruncatedTimestamp> {
243 TruncatedTimestamp::from_already_truncated(s, ns, second_ambiguous).map_err(
244 |_| PyValueError::new_err("expected mtime truncated to 31 bits"),
245 )
246 }