dirstate_map.rs
590 lines
| 18.2 KiB
| application/rls-services+xml
|
RustLexer
|
r42999 | // dirstate_map.rs | ||
// | ||||
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | ||||
// | ||||
// This software may be used and distributed according to the terms of the | ||||
// GNU General Public License version 2 or any later version. | ||||
//! Bindings for the `hg::dirstate::dirstate_map` file provided by the | ||||
//! `hg-core` package. | ||||
|
r43567 | use std::cell::{Ref, RefCell}; | ||
|
r42999 | use std::convert::TryInto; | ||
use std::time::Duration; | ||||
use cpython::{ | ||||
|
r44836 | exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, | ||
PyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, | ||||
|
r44779 | UnsafePyLeaked, | ||
|
r42999 | }; | ||
use crate::{ | ||||
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, | ||||
|
r44903 | dirstate::non_normal_entries::{ | ||
NonNormalEntries, NonNormalEntriesIterator, | ||||
}, | ||||
|
r43479 | dirstate::{dirs_multiset::Dirs, make_dirstate_tuple}, | ||
|
r42999 | }; | ||
use hg::{ | ||||
|
r43227 | utils::hg_path::{HgPath, HgPathBuf}, | ||
|
r43070 | DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap, | ||
|
r44227 | DirstateMapError, DirstateParents, DirstateParseError, EntryState, | ||
StateMapIter, PARENT_SIZE, | ||||
|
r42999 | }; | ||
// TODO | ||||
// This object needs to share references to multiple members of its Rust | ||||
// inner struct, namely `copy_map`, `dirs` and `all_dirs`. | ||||
// Right now `CopyMap` is done, but it needs to have an explicit reference | ||||
// to `RustDirstateMap` which itself needs to have an encapsulation for | ||||
// every method in `CopyMap` (copymapcopy, etc.). | ||||
// This is ugly and hard to maintain. | ||||
// The same logic applies to `dirs` and `all_dirs`, however the `Dirs` | ||||
// `py_class!` is already implemented and does not mention | ||||
// `RustDirstateMap`, rightfully so. | ||||
// All attributes also have to have a separate refcount data attribute for | ||||
// leaks, with all methods that go along for reference sharing. | ||||
py_class!(pub class DirstateMap |py| { | ||||
|
r44703 | @shared data inner: RustDirstateMap; | ||
|
r42999 | |||
def __new__(_cls, _root: PyObject) -> PyResult<Self> { | ||||
let inner = RustDirstateMap::default(); | ||||
|
r44703 | Self::create_instance(py, inner) | ||
|
r42999 | } | ||
def clear(&self) -> PyResult<PyObject> { | ||||
|
r44702 | self.inner(py).borrow_mut().clear(); | ||
|
r42999 | Ok(py.None()) | ||
} | ||||
def get( | ||||
&self, | ||||
key: PyObject, | ||||
default: Option<PyObject> = None | ||||
) -> PyResult<Option<PyObject>> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r44702 | match self.inner(py).borrow().get(HgPath::new(key.data(py))) { | ||
|
r42999 | Some(entry) => { | ||
|
r43479 | Ok(Some(make_dirstate_tuple(py, entry)?)) | ||
|
r42999 | }, | ||
None => Ok(default) | ||||
} | ||||
} | ||||
def addfile( | ||||
&self, | ||||
f: PyObject, | ||||
oldstate: PyObject, | ||||
state: PyObject, | ||||
mode: PyObject, | ||||
size: PyObject, | ||||
mtime: PyObject | ||||
) -> PyResult<PyObject> { | ||||
|
r44702 | self.inner(py).borrow_mut().add_file( | ||
|
r43227 | HgPath::new(f.extract::<PyBytes>(py)?.data(py)), | ||
|
r42999 | oldstate.extract::<PyBytes>(py)?.data(py)[0] | ||
.try_into() | ||||
.map_err(|e: DirstateParseError| { | ||||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
DirstateEntry { | ||||
state: state.extract::<PyBytes>(py)?.data(py)[0] | ||||
.try_into() | ||||
.map_err(|e: DirstateParseError| { | ||||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
mode: mode.extract(py)?, | ||||
size: size.extract(py)?, | ||||
mtime: mtime.extract(py)?, | ||||
}, | ||||
|
r44227 | ).and(Ok(py.None())).or_else(|e: DirstateMapError| { | ||
Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())) | ||||
}) | ||||
|
r42999 | } | ||
def removefile( | ||||
&self, | ||||
f: PyObject, | ||||
oldstate: PyObject, | ||||
size: PyObject | ||||
) -> PyResult<PyObject> { | ||||
|
r44702 | self.inner(py).borrow_mut() | ||
|
r42999 | .remove_file( | ||
|
r43227 | HgPath::new(f.extract::<PyBytes>(py)?.data(py)), | ||
|
r42999 | oldstate.extract::<PyBytes>(py)?.data(py)[0] | ||
.try_into() | ||||
.map_err(|e: DirstateParseError| { | ||||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
size.extract(py)?, | ||||
) | ||||
.or_else(|_| { | ||||
Err(PyErr::new::<exc::OSError, _>( | ||||
py, | ||||
"Dirstate error".to_string(), | ||||
)) | ||||
})?; | ||||
Ok(py.None()) | ||||
} | ||||
def dropfile( | ||||
&self, | ||||
f: PyObject, | ||||
oldstate: PyObject | ||||
) -> PyResult<PyBool> { | ||||
|
r44702 | self.inner(py).borrow_mut() | ||
|
r42999 | .drop_file( | ||
|
r43227 | HgPath::new(f.extract::<PyBytes>(py)?.data(py)), | ||
|
r42999 | oldstate.extract::<PyBytes>(py)?.data(py)[0] | ||
.try_into() | ||||
.map_err(|e: DirstateParseError| { | ||||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
) | ||||
.and_then(|b| Ok(b.to_py_object(py))) | ||||
.or_else(|_| { | ||||
Err(PyErr::new::<exc::OSError, _>( | ||||
py, | ||||
"Dirstate error".to_string(), | ||||
)) | ||||
}) | ||||
} | ||||
def clearambiguoustimes( | ||||
&self, | ||||
files: PyObject, | ||||
now: PyObject | ||||
) -> PyResult<PyObject> { | ||||
|
r43227 | let files: PyResult<Vec<HgPathBuf>> = files | ||
|
r42999 | .iter(py)? | ||
.map(|filename| { | ||||
|
r43227 | Ok(HgPathBuf::from_bytes( | ||
filename?.extract::<PyBytes>(py)?.data(py), | ||||
)) | ||||
|
r42999 | }) | ||
.collect(); | ||||
|
r44702 | self.inner(py).borrow_mut() | ||
|
r42999 | .clear_ambiguous_times(files?, now.extract(py)?); | ||
Ok(py.None()) | ||||
} | ||||
|
r44836 | def other_parent_entries(&self) -> PyResult<PyObject> { | ||
|
r44779 | let mut inner_shared = self.inner(py).borrow_mut(); | ||
|
r44836 | let (_, other_parent) = | ||
inner_shared.get_non_normal_other_parent_entries(); | ||||
|
r42999 | |||
let locals = PyDict::new(py); | ||||
locals.set_item( | ||||
py, | ||||
"other_parent", | ||||
|
r44842 | other_parent | ||
|
r42999 | .iter() | ||
|
r45500 | .map(|v| PyBytes::new(py, v.as_bytes())) | ||
|
r42999 | .collect::<Vec<PyBytes>>() | ||
.to_py_object(py), | ||||
)?; | ||||
|
r44836 | py.eval("set(other_parent)", None, Some(&locals)) | ||
} | ||||
def non_normal_entries(&self) -> PyResult<NonNormalEntries> { | ||||
NonNormalEntries::from_inner(py, self.clone_ref(py)) | ||||
} | ||||
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
Ok(self | ||||
|
r44779 | .inner(py) | ||
.borrow_mut() | ||||
|
r44836 | .get_non_normal_other_parent_entries().0 | ||
.contains(HgPath::new(key.data(py)))) | ||||
} | ||||
def non_normal_entries_display(&self) -> PyResult<PyString> { | ||||
Ok( | ||||
PyString::new( | ||||
py, | ||||
&format!( | ||||
"NonNormalEntries: {:?}", | ||||
self | ||||
|
r44779 | .inner(py) | ||
.borrow_mut() | ||||
|
r44836 | .get_non_normal_other_parent_entries().0 | ||
|
r44842 | .iter().map(|o| o)) | ||
|
r44836 | ) | ||
) | ||||
} | ||||
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
self | ||||
|
r44779 | .inner(py) | ||
.borrow_mut() | ||||
|
r44836 | .non_normal_entries_remove(HgPath::new(key.data(py))); | ||
Ok(py.None()) | ||||
} | ||||
def non_normal_entries_union(&self, other: PyObject) -> PyResult<PyList> { | ||||
let other: PyResult<_> = other.iter(py)? | ||||
.map(|f| { | ||||
Ok(HgPathBuf::from_bytes( | ||||
f?.extract::<PyBytes>(py)?.data(py), | ||||
)) | ||||
}) | ||||
.collect(); | ||||
let res = self | ||||
|
r44779 | .inner(py) | ||
.borrow_mut() | ||||
|
r44836 | .non_normal_entries_union(other?); | ||
let ret = PyList::new(py, &[]); | ||||
|
r44779 | for filename in res.iter() { | ||
|
r44836 | let as_pystring = PyBytes::new(py, filename.as_bytes()); | ||
|
r44779 | ret.append(py, as_pystring.into_object()); | ||
|
r44836 | } | ||
Ok(ret) | ||||
|
r42999 | } | ||
|
r44903 | def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> { | ||
// Make sure the sets are defined before we no longer have a mutable | ||||
// reference to the dmap. | ||||
self.inner(py) | ||||
.borrow_mut() | ||||
.set_non_normal_other_parent_entries(false); | ||||
let leaked_ref = self.inner(py).leak_immutable(); | ||||
NonNormalEntriesIterator::from_inner(py, unsafe { | ||||
leaked_ref.map(py, |o| { | ||||
o.get_non_normal_other_parent_entries_panic().0.iter() | ||||
}) | ||||
}) | ||||
} | ||||
|
r42999 | def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> { | ||
let d = d.extract::<PyBytes>(py)?; | ||||
|
r44702 | Ok(self.inner(py).borrow_mut() | ||
|
r43227 | .has_tracked_dir(HgPath::new(d.data(py))) | ||
|
r44315 | .map_err(|e| { | ||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})? | ||||
|
r42999 | .to_py_object(py)) | ||
} | ||||
def hasdir(&self, d: PyObject) -> PyResult<PyBool> { | ||||
let d = d.extract::<PyBytes>(py)?; | ||||
|
r44702 | Ok(self.inner(py).borrow_mut() | ||
|
r43227 | .has_dir(HgPath::new(d.data(py))) | ||
|
r44315 | .map_err(|e| { | ||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})? | ||||
|
r42999 | .to_py_object(py)) | ||
} | ||||
def parents(&self, st: PyObject) -> PyResult<PyTuple> { | ||||
|
r44702 | self.inner(py).borrow_mut() | ||
|
r42999 | .parents(st.extract::<PyBytes>(py)?.data(py)) | ||
.and_then(|d| { | ||||
Ok((PyBytes::new(py, &d.p1), PyBytes::new(py, &d.p2)) | ||||
.to_py_object(py)) | ||||
}) | ||||
.or_else(|_| { | ||||
Err(PyErr::new::<exc::OSError, _>( | ||||
py, | ||||
"Dirstate error".to_string(), | ||||
)) | ||||
}) | ||||
} | ||||
def setparents(&self, p1: PyObject, p2: PyObject) -> PyResult<PyObject> { | ||||
|
r43068 | let p1 = extract_node_id(py, &p1)?; | ||
let p2 = extract_node_id(py, &p2)?; | ||||
|
r42999 | |||
|
r44702 | self.inner(py).borrow_mut() | ||
|
r43069 | .set_parents(&DirstateParents { p1, p2 }); | ||
|
r42999 | Ok(py.None()) | ||
} | ||||
def read(&self, st: PyObject) -> PyResult<Option<PyObject>> { | ||||
|
r44702 | match self.inner(py).borrow_mut() | ||
|
r42999 | .read(st.extract::<PyBytes>(py)?.data(py)) | ||
{ | ||||
Ok(Some(parents)) => Ok(Some( | ||||
(PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2)) | ||||
.to_py_object(py) | ||||
.into_object(), | ||||
)), | ||||
Ok(None) => Ok(Some(py.None())), | ||||
Err(_) => Err(PyErr::new::<exc::OSError, _>( | ||||
py, | ||||
"Dirstate error".to_string(), | ||||
)), | ||||
} | ||||
} | ||||
def write( | ||||
&self, | ||||
p1: PyObject, | ||||
p2: PyObject, | ||||
now: PyObject | ||||
) -> PyResult<PyBytes> { | ||||
let now = Duration::new(now.extract(py)?, 0); | ||||
let parents = DirstateParents { | ||||
|
r43068 | p1: extract_node_id(py, &p1)?, | ||
p2: extract_node_id(py, &p2)?, | ||||
|
r42999 | }; | ||
|
r44702 | match self.inner(py).borrow_mut().pack(parents, now) { | ||
|
r42999 | Ok(packed) => Ok(PyBytes::new(py, &packed)), | ||
Err(_) => Err(PyErr::new::<exc::OSError, _>( | ||||
py, | ||||
"Dirstate error".to_string(), | ||||
)), | ||||
} | ||||
} | ||||
def filefoldmapasdict(&self) -> PyResult<PyDict> { | ||||
let dict = PyDict::new(py); | ||||
|
r43450 | for (key, value) in | ||
|
r44702 | self.inner(py).borrow_mut().build_file_fold_map().iter() | ||
|
r43450 | { | ||
|
r45500 | dict.set_item( | ||
py, | ||||
key.as_bytes().to_vec(), | ||||
value.as_bytes().to_vec(), | ||||
)?; | ||||
|
r42999 | } | ||
Ok(dict) | ||||
} | ||||
def __len__(&self) -> PyResult<usize> { | ||||
|
r44702 | Ok(self.inner(py).borrow().len()) | ||
|
r42999 | } | ||
def __contains__(&self, key: PyObject) -> PyResult<bool> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r44702 | Ok(self.inner(py).borrow().contains_key(HgPath::new(key.data(py)))) | ||
|
r42999 | } | ||
def __getitem__(&self, key: PyObject) -> PyResult<PyObject> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r43227 | let key = HgPath::new(key.data(py)); | ||
|
r44702 | match self.inner(py).borrow().get(key) { | ||
|
r42999 | Some(entry) => { | ||
|
r43479 | Ok(make_dirstate_tuple(py, entry)?) | ||
|
r42999 | }, | ||
None => Err(PyErr::new::<exc::KeyError, _>( | ||||
py, | ||||
|
r43227 | String::from_utf8_lossy(key.as_bytes()), | ||
|
r42999 | )), | ||
} | ||||
} | ||||
def keys(&self) -> PyResult<DirstateMapKeysIterator> { | ||||
|
r44702 | let leaked_ref = self.inner(py).leak_immutable(); | ||
|
r42999 | DirstateMapKeysIterator::from_inner( | ||
py, | ||||
|
r43579 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | ||
|
r42999 | ) | ||
} | ||||
def items(&self) -> PyResult<DirstateMapItemsIterator> { | ||||
|
r44702 | let leaked_ref = self.inner(py).leak_immutable(); | ||
|
r42999 | DirstateMapItemsIterator::from_inner( | ||
py, | ||||
|
r43579 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | ||
|
r42999 | ) | ||
} | ||||
def __iter__(&self) -> PyResult<DirstateMapKeysIterator> { | ||||
|
r44702 | let leaked_ref = self.inner(py).leak_immutable(); | ||
|
r42999 | DirstateMapKeysIterator::from_inner( | ||
py, | ||||
|
r43579 | unsafe { leaked_ref.map(py, |o| o.iter()) }, | ||
|
r42999 | ) | ||
} | ||||
def getdirs(&self) -> PyResult<Dirs> { | ||||
// TODO don't copy, share the reference | ||||
|
r44702 | self.inner(py).borrow_mut().set_dirs() | ||
|
r44315 | .map_err(|e| { | ||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?; | ||||
|
r42999 | Dirs::from_inner( | ||
py, | ||||
|
r43070 | DirsMultiset::from_dirstate( | ||
|
r44702 | &self.inner(py).borrow(), | ||
|
r42999 | Some(EntryState::Removed), | ||
|
r44315 | ) | ||
.map_err(|e| { | ||||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
|
r42999 | ) | ||
} | ||||
def getalldirs(&self) -> PyResult<Dirs> { | ||||
// TODO don't copy, share the reference | ||||
|
r44702 | self.inner(py).borrow_mut().set_all_dirs() | ||
|
r44315 | .map_err(|e| { | ||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?; | ||||
|
r42999 | Dirs::from_inner( | ||
py, | ||||
|
r43070 | DirsMultiset::from_dirstate( | ||
|
r44702 | &self.inner(py).borrow(), | ||
|
r42999 | None, | ||
|
r44315 | ).map_err(|e| { | ||
PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
})?, | ||||
|
r42999 | ) | ||
} | ||||
// TODO all copymap* methods, see docstring above | ||||
def copymapcopy(&self) -> PyResult<PyDict> { | ||||
let dict = PyDict::new(py); | ||||
|
r44702 | for (key, value) in self.inner(py).borrow().copy_map.iter() { | ||
|
r43227 | dict.set_item( | ||
py, | ||||
|
r45500 | PyBytes::new(py, key.as_bytes()), | ||
PyBytes::new(py, value.as_bytes()), | ||||
|
r43227 | )?; | ||
|
r42999 | } | ||
Ok(dict) | ||||
} | ||||
def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r44702 | match self.inner(py).borrow().copy_map.get(HgPath::new(key.data(py))) { | ||
|
r45500 | Some(copy) => Ok(PyBytes::new(py, copy.as_bytes())), | ||
|
r42999 | None => Err(PyErr::new::<exc::KeyError, _>( | ||
py, | ||||
String::from_utf8_lossy(key.data(py)), | ||||
)), | ||||
} | ||||
} | ||||
def copymap(&self) -> PyResult<CopyMap> { | ||||
CopyMap::from_inner(py, self.clone_ref(py)) | ||||
} | ||||
def copymaplen(&self) -> PyResult<usize> { | ||||
|
r44702 | Ok(self.inner(py).borrow().copy_map.len()) | ||
|
r42999 | } | ||
def copymapcontains(&self, key: PyObject) -> PyResult<bool> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r43227 | Ok(self | ||
|
r44702 | .inner(py) | ||
|
r43227 | .borrow() | ||
.copy_map | ||||
.contains_key(HgPath::new(key.data(py)))) | ||||
|
r42999 | } | ||
def copymapget( | ||||
&self, | ||||
key: PyObject, | ||||
default: Option<PyObject> | ||||
) -> PyResult<Option<PyObject>> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r43227 | match self | ||
|
r44702 | .inner(py) | ||
|
r43227 | .borrow() | ||
.copy_map | ||||
.get(HgPath::new(key.data(py))) | ||||
{ | ||||
Some(copy) => Ok(Some( | ||||
|
r45500 | PyBytes::new(py, copy.as_bytes()).into_object(), | ||
|
r43227 | )), | ||
|
r42999 | None => Ok(default), | ||
} | ||||
} | ||||
def copymapsetitem( | ||||
&self, | ||||
key: PyObject, | ||||
value: PyObject | ||||
) -> PyResult<PyObject> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
let value = value.extract::<PyBytes>(py)?; | ||||
|
r44702 | self.inner(py).borrow_mut().copy_map.insert( | ||
|
r43227 | HgPathBuf::from_bytes(key.data(py)), | ||
HgPathBuf::from_bytes(value.data(py)), | ||||
); | ||||
|
r42999 | Ok(py.None()) | ||
} | ||||
def copymappop( | ||||
&self, | ||||
key: PyObject, | ||||
default: Option<PyObject> | ||||
) -> PyResult<Option<PyObject>> { | ||||
let key = key.extract::<PyBytes>(py)?; | ||||
|
r43227 | match self | ||
|
r44702 | .inner(py) | ||
|
r44685 | .borrow_mut() | ||
|
r43227 | .copy_map | ||
.remove(HgPath::new(key.data(py))) | ||||
{ | ||||
|
r42999 | Some(_) => Ok(None), | ||
None => Ok(default), | ||||
} | ||||
} | ||||
def copymapiter(&self) -> PyResult<CopyMapKeysIterator> { | ||||
|
r44702 | let leaked_ref = self.inner(py).leak_immutable(); | ||
|
r42999 | CopyMapKeysIterator::from_inner( | ||
py, | ||||
|
r43579 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, | ||
|
r42999 | ) | ||
} | ||||
def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> { | ||||
|
r44702 | let leaked_ref = self.inner(py).leak_immutable(); | ||
|
r42999 | CopyMapItemsIterator::from_inner( | ||
py, | ||||
|
r43579 | unsafe { leaked_ref.map(py, |o| o.copy_map.iter()) }, | ||
|
r42999 | ) | ||
} | ||||
}); | ||||
impl DirstateMap { | ||||
|
r43567 | pub fn get_inner<'a>( | ||
&'a self, | ||||
py: Python<'a>, | ||||
) -> Ref<'a, RustDirstateMap> { | ||||
|
r44702 | self.inner(py).borrow() | ||
|
r43567 | } | ||
|
r42999 | fn translate_key( | ||
py: Python, | ||||
|
r43227 | res: (&HgPathBuf, &DirstateEntry), | ||
|
r42999 | ) -> PyResult<Option<PyBytes>> { | ||
|
r45500 | Ok(Some(PyBytes::new(py, res.0.as_bytes()))) | ||
|
r42999 | } | ||
fn translate_key_value( | ||||
py: Python, | ||||
|
r43227 | res: (&HgPathBuf, &DirstateEntry), | ||
|
r42999 | ) -> PyResult<Option<(PyBytes, PyObject)>> { | ||
let (f, entry) = res; | ||||
Ok(Some(( | ||||
|
r45500 | PyBytes::new(py, f.as_bytes()), | ||
|
r43479 | make_dirstate_tuple(py, entry)?, | ||
|
r42999 | ))) | ||
} | ||||
} | ||||
|
r43159 | py_shared_iterator!( | ||
|
r42999 | DirstateMapKeysIterator, | ||
|
r44703 | UnsafePyLeaked<StateMapIter<'static>>, | ||
|
r42999 | DirstateMap::translate_key, | ||
Option<PyBytes> | ||||
); | ||||
|
r43159 | py_shared_iterator!( | ||
|
r42999 | DirstateMapItemsIterator, | ||
|
r44703 | UnsafePyLeaked<StateMapIter<'static>>, | ||
|
r42999 | DirstateMap::translate_key_value, | ||
Option<(PyBytes, PyObject)> | ||||
); | ||||
|
r43068 | |||
fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<[u8; PARENT_SIZE]> { | ||||
let bytes = obj.extract::<PyBytes>(py)?; | ||||
match bytes.data(py).try_into() { | ||||
Ok(s) => Ok(s), | ||||
Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())), | ||||
} | ||||
} | ||||