comparison rust/hg-cpython/src/revlog.rs @ 51219:8cb31833b486

rust-index: slicechunktodensity returns Rust result

Ready for removal of the scaffolding.

This time, we allow ourselves a minor optimization: we avoid
allocating for each chunk. Instead, we reuse the same vector,
and perform at most one allocation per chunk.
The `PyList` constructor will copy the buffer anyway.

51218:0112803e6c01

            args.get_item(py, 1).extract(py)?,
            args.get_item(py, 2).extract(py)?
        )?;

        let c_res = self.call_cindex(py, "slicechunktodensity", args, kw)?;
        assert_eq!(
            rust_res.len(),
            c_res.len(py)?,
            "chunks differ {:?} {}",
            rust_res, c_res
        );
        for (i, chunk) in rust_res.iter().enumerate() {
            let c_chunk = c_res.get_item(py, i)?;
            assert_eq!(
                chunk.len(),
                c_chunk.len(py)?,
                "chunk {} length differ {:?} {}",
                i,
                chunk,
                c_res
            );
            for (j, rev) in chunk.iter().enumerate() {
                let c_chunk: BaseRevision
                    = c_chunk.get_item(py, j)?.extract(py)?;
                assert_eq!(c_chunk, rev.0);
            }
        }
        Ok(c_res)
    }

    /// stats for the index
    def stats(&self, *args, **kw) -> PyResult<PyObject> {
        self.call_cindex(py, "stats", args, kw)

        &self,
        py: Python,
        revs: PyObject,
        target_density: f64,
        min_gap_size: usize,
    ) -> PyResult<Vec<Vec<Revision>>> {
        let index = &mut *self.index(py).borrow_mut();
        let revs: Vec<_> = rev_pyiter_collect(py, &revs, index)?;
        Ok(index.slice_chunk_to_density(&revs, target_density, min_gap_size))
    }
}

fn revlog_error(py: Python) -> PyErr {
    match py

51219:8cb31833b486

            args.get_item(py, 1).extract(py)?,
            args.get_item(py, 2).extract(py)?
        )?;

        let c_res = self.call_cindex(py, "slicechunktodensity", args, kw)?;
        assert_py_eq(py, "slicechunktodensity", &rust_res, &c_res)?;
        Ok(rust_res)
    }

    /// stats for the index
    def stats(&self, *args, **kw) -> PyResult<PyObject> {
        self.call_cindex(py, "stats", args, kw)

        &self,
        py: Python,
        revs: PyObject,
        target_density: f64,
        min_gap_size: usize,
    ) -> PyResult<PyObject> {
        let index = &mut *self.index(py).borrow_mut();
        let revs: Vec<_> = rev_pyiter_collect(py, &revs, index)?;
        let as_nested_vec =
            index.slice_chunk_to_density(&revs, target_density, min_gap_size);
        let mut res = Vec::with_capacity(as_nested_vec.len());
        let mut py_chunk = Vec::new();
        for chunk in as_nested_vec {
            py_chunk.clear();
            py_chunk.reserve_exact(chunk.len());
            for rev in chunk {
                py_chunk.push(
                    PyRevision::from(rev).into_py_object(py).into_object(),
                );
            }
            res.push(PyList::new(py, &py_chunk).into_object());
        }
        // This is just to do the same as C, not sure why it does this
        if res.len() == 1 {
            Ok(PyTuple::new(py, &res).into_object())
        } else {
            Ok(PyList::new(py, &res).into_object())
        }
    }
}

fn revlog_error(py: Python) -> PyErr {
    match py