rust/hg-cpython/src/dirstate/dirstate_map.rs
changeset 47280 1766130fe9ba
parent 47124 cd8ca38fccff
child 47332 4ee9f419c52e
equal deleted inserted replaced
47279:40b51c28b242 47280:1766130fe9ba
    53 py_class!(pub class DirstateMap |py| {
    53 py_class!(pub class DirstateMap |py| {
    54     @shared data inner: Box<dyn DirstateMapMethods + Send>;
    54     @shared data inner: Box<dyn DirstateMapMethods + Send>;
    55 
    55 
    56     /// Returns a `(dirstate_map, parents)` tuple
    56     /// Returns a `(dirstate_map, parents)` tuple
    57     @staticmethod
    57     @staticmethod
    58     def new(use_dirstate_tree: bool, on_disk: PyBytes) -> PyResult<PyObject> {
    58     def new(
    59         let dirstate_error = |_: DirstateError| {
    59         use_dirstate_tree: bool,
    60             PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string())
    60         use_dirstate_v2: bool,
       
    61         on_disk: PyBytes,
       
    62     ) -> PyResult<PyObject> {
       
    63         let dirstate_error = |e: DirstateError| {
       
    64             PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
    61         };
    65         };
    62         let (inner, parents) = if use_dirstate_tree {
    66         let (inner, parents) = if use_dirstate_tree || use_dirstate_v2 {
    63             let (map, parents) =
    67             let (map, parents) =
    64                 OwningDirstateMap::new(py, on_disk)
    68                 OwningDirstateMap::new(py, on_disk, use_dirstate_v2)
    65                 .map_err(dirstate_error)?;
    69                 .map_err(dirstate_error)?;
    66             (Box::new(map) as _, parents)
    70             (Box::new(map) as _, parents)
    67         } else {
    71         } else {
    68             let bytes = on_disk.data(py);
    72             let bytes = on_disk.data(py);
    69             let mut map = RustDirstateMap::default();
    73             let mut map = RustDirstateMap::default();
   286             .to_py_object(py))
   290             .to_py_object(py))
   287     }
   291     }
   288 
   292 
   289     def write(
   293     def write(
   290         &self,
   294         &self,
       
   295         use_dirstate_v2: bool,
   291         p1: PyObject,
   296         p1: PyObject,
   292         p2: PyObject,
   297         p2: PyObject,
   293         now: PyObject
   298         now: PyObject
   294     ) -> PyResult<PyBytes> {
   299     ) -> PyResult<PyBytes> {
   295         let now = Timestamp(now.extract(py)?);
   300         let now = Timestamp(now.extract(py)?);
   296         let parents = DirstateParents {
   301         let parents = DirstateParents {
   297             p1: extract_node_id(py, &p1)?,
   302             p1: extract_node_id(py, &p1)?,
   298             p2: extract_node_id(py, &p2)?,
   303             p2: extract_node_id(py, &p2)?,
   299         };
   304         };
   300 
   305 
   301         match self.inner(py).borrow_mut().pack(parents, now) {
   306         let mut inner = self.inner(py).borrow_mut();
       
   307         let result = if use_dirstate_v2 {
       
   308             inner.pack_v2(parents, now)
       
   309         } else {
       
   310             inner.pack_v1(parents, now)
       
   311         };
       
   312         match result {
   302             Ok(packed) => Ok(PyBytes::new(py, &packed)),
   313             Ok(packed) => Ok(PyBytes::new(py, &packed)),
   303             Err(_) => Err(PyErr::new::<exc::OSError, _>(
   314             Err(_) => Err(PyErr::new::<exc::OSError, _>(
   304                 py,
   315                 py,
   305                 "Dirstate error".to_string(),
   316                 "Dirstate error".to_string(),
   306             )),
   317             )),