rust/hg-cpython/src/dirstate/item.rs
changeset 48260 269ff8978086
parent 48258 c591944f42c1
child 48378 3d6eb119200d
equal deleted inserted replaced
48259:84f6b0c41b90 48260:269ff8978086
     7 use cpython::PyResult;
     7 use cpython::PyResult;
     8 use cpython::Python;
     8 use cpython::Python;
     9 use cpython::PythonObject;
     9 use cpython::PythonObject;
    10 use hg::dirstate::DirstateEntry;
    10 use hg::dirstate::DirstateEntry;
    11 use hg::dirstate::EntryState;
    11 use hg::dirstate::EntryState;
       
    12 use hg::dirstate::TruncatedTimestamp;
    12 use std::cell::Cell;
    13 use std::cell::Cell;
    13 use std::convert::TryFrom;
    14 use std::convert::TryFrom;
    14 
    15 
    15 py_class!(pub class DirstateItem |py| {
    16 py_class!(pub class DirstateItem |py| {
    16     data entry: Cell<DirstateEntry>;
    17     data entry: Cell<DirstateEntry>;
    20         wc_tracked: bool = false,
    21         wc_tracked: bool = false,
    21         p1_tracked: bool = false,
    22         p1_tracked: bool = false,
    22         p2_info: bool = false,
    23         p2_info: bool = false,
    23         has_meaningful_data: bool = true,
    24         has_meaningful_data: bool = true,
    24         has_meaningful_mtime: bool = true,
    25         has_meaningful_mtime: bool = true,
    25         parentfiledata: Option<(u32, u32, u32)> = None,
    26         parentfiledata: Option<(u32, u32, (u32, u32))> = None,
    26         fallback_exec: Option<bool> = None,
    27         fallback_exec: Option<bool> = None,
    27         fallback_symlink: Option<bool> = None,
    28         fallback_symlink: Option<bool> = None,
    28 
    29 
    29     ) -> PyResult<DirstateItem> {
    30     ) -> PyResult<DirstateItem> {
    30         let mut mode_size_opt = None;
    31         let mut mode_size_opt = None;
    32         if let Some((mode, size, mtime)) = parentfiledata {
    33         if let Some((mode, size, mtime)) = parentfiledata {
    33             if has_meaningful_data {
    34             if has_meaningful_data {
    34                 mode_size_opt = Some((mode, size))
    35                 mode_size_opt = Some((mode, size))
    35             }
    36             }
    36             if has_meaningful_mtime {
    37             if has_meaningful_mtime {
    37                 mtime_opt = Some(mtime)
    38                 mtime_opt = Some(timestamp(py, mtime)?)
    38             }
    39             }
    39         }
    40         }
    40         let entry = DirstateEntry::from_v2_data(
    41         let entry = DirstateEntry::from_v2_data(
    41             wc_tracked,
    42             wc_tracked,
    42             p1_tracked,
    43             p1_tracked,
   189     def v1_mtime(&self) -> PyResult<i32> {
   190     def v1_mtime(&self) -> PyResult<i32> {
   190         let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
   191         let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
   191         Ok(mtime)
   192         Ok(mtime)
   192     }
   193     }
   193 
   194 
   194     def need_delay(&self, now: i32) -> PyResult<bool> {
   195     def need_delay(&self, now: (u32, u32)) -> PyResult<bool> {
       
   196         let now = timestamp(py, now)?;
   195         Ok(self.entry(py).get().need_delay(now))
   197         Ok(self.entry(py).get().need_delay(now))
       
   198     }
       
   199 
       
   200     def mtime_likely_equal_to(&self, other: (u32, u32)) -> PyResult<bool> {
       
   201         if let Some(mtime) = self.entry(py).get().truncated_mtime() {
       
   202             Ok(mtime.likely_equal(timestamp(py, other)?))
       
   203         } else {
       
   204             Ok(false)
       
   205         }
   196     }
   206     }
   197 
   207 
   198     @classmethod
   208     @classmethod
   199     def from_v1_data(
   209     def from_v1_data(
   200         _cls,
   210         _cls,
   218 
   228 
   219     def set_clean(
   229     def set_clean(
   220         &self,
   230         &self,
   221         mode: u32,
   231         mode: u32,
   222         size: u32,
   232         size: u32,
   223         mtime: u32,
   233         mtime: (u32, u32),
   224     ) -> PyResult<PyNone> {
   234     ) -> PyResult<PyNone> {
       
   235         let mtime = timestamp(py, mtime)?;
   225         self.update(py, |entry| entry.set_clean(mode, size, mtime));
   236         self.update(py, |entry| entry.set_clean(mode, size, mtime));
   226         Ok(PyNone)
   237         Ok(PyNone)
   227     }
   238     }
   228 
   239 
   229     def set_possibly_dirty(&self) -> PyResult<PyNone> {
   240     def set_possibly_dirty(&self) -> PyResult<PyNone> {
   259         let mut entry = self.entry(py).get();
   270         let mut entry = self.entry(py).get();
   260         f(&mut entry);
   271         f(&mut entry);
   261         self.entry(py).set(entry)
   272         self.entry(py).set(entry)
   262     }
   273     }
   263 }
   274 }
       
   275 
       
   276 pub(crate) fn timestamp(
       
   277     py: Python<'_>,
       
   278     (s, ns): (u32, u32),
       
   279 ) -> PyResult<TruncatedTimestamp> {
       
   280     TruncatedTimestamp::from_already_truncated(s, ns).map_err(|_| {
       
   281         PyErr::new::<exc::ValueError, _>(
       
   282             py,
       
   283             "expected mtime truncated to 31 bits",
       
   284         )
       
   285     })
       
   286 }