This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10485

rust: Add a Timestamp struct instead of abusing Duration
ClosedPublic

Authored by SimonSapin on Apr 20 2021, 10:17 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG5d62243c7732: rust: Add a Timestamp struct instead of abusing Duration
rHG8dd49c9cd322: rust: Add a Timestamp struct instead of abusing Duration
Summary

SystemTime would be the standard library type semantically appropriate
instead of Duration.

But since the value is coming from Python as a plain integer and used in
dirstate packing code as an integer, let’s make a type that contains a single
integer instead of using one with sub-second precision.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Apr 20 2021, 10:17 AM
SimonSapin added a comment.Apr 20 2021, 10:19 AM

Oops, I forgot to connect them but this stack depends on the one at https://phab.mercurial-scm.org/D10370

baymax added a parent revision: D10370: dirstate-tree: Add tree traversal/iteration.Apr 20 2021, 1:03 PM
baymax updated this revision to Diff 27135.

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.Apr 22 2021, 4:22 AM
This revision is now accepted and ready to land.Apr 22 2021, 4:22 AM

Revision Contents
Changeset List

Diff 27646

rust/hg-core/src/dirstate/dirstate_map.rs

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::Timestamp;
use crate::errors::HgError; use crate::errors::HgError;
use crate::revlog::node::NULL_NODE; use crate::revlog::node::NULL_NODE;
use crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT}, dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT},
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::{ utils::{
files::normalize_case, files::normalize_case,
hg_path::{HgPath, HgPathBuf}, hg_path::{HgPath, HgPathBuf},
}, },
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError,
DirstateParents, FastHashMap, StateMap, DirstateParents, FastHashMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet; use std::collections::HashSet;
use std::convert::TryInto; use std::convert::TryInto;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
use std::time::Duration;
pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>; pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>;
const MTIME_UNSET: i32 = -1; const MTIME_UNSET: i32 = -1;
#[derive(Default)] #[derive(Default)]
pub struct DirstateMap { pub struct DirstateMap {
state_map: StateMap, state_map: StateMap,
} }
Ok(Some(parents)) Ok(Some(parents))
} }
pub fn pack( pub fn pack(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
let packed = let packed =
pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?; pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
self.dirty_parents = false; self.dirty_parents = false;
self.set_non_normal_other_parent_entries(true); self.set_non_normal_other_parent_entries(true);
Ok(packed) Ok(packed)

rust/hg-core/src/dirstate/parsers.rs

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{ use crate::{
dirstate::{CopyMap, EntryState, RawEntry, StateMap}, dirstate::{CopyMap, EntryState, RawEntry, StateMap},
DirstateEntry, DirstateParents, DirstateEntry, DirstateParents,
}; };
use byteorder::{BigEndian, WriteBytesExt}; use byteorder::{BigEndian, WriteBytesExt};
use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use micro_timer::timed; use micro_timer::timed;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::time::Duration;
/// Parents are stored in the dirstate as byte hashes. /// Parents are stored in the dirstate as byte hashes.
pub const PARENT_SIZE: usize = 20; pub const PARENT_SIZE: usize = 20;
/// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits.
const MIN_ENTRY_SIZE: usize = 17; const MIN_ENTRY_SIZE: usize = 17;
type ParseResult<'a> = ( type ParseResult<'a> = (
&'a DirstateParents, &'a DirstateParents,
let copy_source = iter.next().map(HgPath::new); let copy_source = iter.next().map(HgPath::new);
each_entry(path, &entry, copy_source); each_entry(path, &entry, copy_source);
contents = rest; contents = rest;
} }
Ok(parents) Ok(parents)
} }
/// `now` is the duration in seconds since the Unix epoch /// Seconds since the Unix epoch
pub struct Timestamp(pub u64);
pub fn pack_dirstate( pub fn pack_dirstate(
state_map: &mut StateMap, state_map: &mut StateMap,
copy_map: &CopyMap, copy_map: &CopyMap,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Timestamp,
) -> Result<Vec<u8>, HgError> { ) -> Result<Vec<u8>, HgError> {
// TODO move away from i32 before 2038. // TODO move away from i32 before 2038.
let now: i32 = now.as_secs().try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let expected_size: usize = state_map let expected_size: usize = state_map
.iter() .iter()
.map(|(filename, _)| { .map(|(filename, _)| {
let mut length = MIN_ENTRY_SIZE + filename.len(); let mut length = MIN_ENTRY_SIZE + filename.len();
if let Some(copy) = copy_map.get(filename) { if let Some(copy) = copy_map.get(filename) {
length += copy.len() + 1; length += copy.len() + 1;
} }
#[test] #[test]
fn test_pack_dirstate_empty() { fn test_pack_dirstate_empty() {
let mut state_map = StateMap::default(); let mut state_map = StateMap::default();
let copymap = FastHashMap::default(); let copymap = FastHashMap::default();
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let expected = b"1234567891011121314100000000000000000000".to_vec(); let expected = b"1234567891011121314100000000000000000000".to_vec();
assert_eq!( assert_eq!(
expected, expected,
pack_dirstate(&mut state_map, &copymap, parents, now).unwrap() pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
); );
assert!(state_map.is_empty()) assert!(state_map.is_empty())
.collect(); .collect();
let mut state_map = expected_state_map.clone(); let mut state_map = expected_state_map.clone();
let copymap = FastHashMap::default(); let copymap = FastHashMap::default();
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let expected = [ let expected = [
49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49, 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
41, 58, 244, 0, 0, 0, 2, 102, 49, 41, 58, 244, 0, 0, 0, 2, 102, 49,
] ]
.to_vec(); .to_vec();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
); );
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let expected = [ let expected = [
49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49, 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 112, 121, 110, 97, 41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 112, 121, 110, 97,
109, 101, 109, 101,
] ]
.to_vec(); .to_vec();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
); );
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let result = let result =
pack_dirstate(&mut state_map, &copymap, parents.clone(), now) pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap(); .unwrap();
let (new_parents, entries, copies) = let (new_parents, entries, copies) =
parse_dirstate(result.as_slice()).unwrap(); parse_dirstate(result.as_slice()).unwrap();
let new_state_map: StateMap = entries let new_state_map: StateMap = entries
.into_iter() .into_iter()
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f4\xF6"), HgPathBuf::from_bytes(b"f4\xF6"),
HgPathBuf::from_bytes(b"copyname2"), HgPathBuf::from_bytes(b"copyname2"),
); );
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let result = let result =
pack_dirstate(&mut state_map, &copymap, parents.clone(), now) pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap(); .unwrap();
let (new_parents, entries, copies) = let (new_parents, entries, copies) =
parse_dirstate(result.as_slice()).unwrap(); parse_dirstate(result.as_slice()).unwrap();
let new_state_map: StateMap = entries let new_state_map: StateMap = entries
.into_iter() .into_iter()
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
); );
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141".into(), p1: b"12345678910111213141".into(),
p2: b"00000000000000000000".into(), p2: b"00000000000000000000".into(),
}; };
let now = Duration::new(15000000, 0); let now = Timestamp(15000000);
let result = let result =
pack_dirstate(&mut state_map, &copymap, parents.clone(), now) pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap(); .unwrap();
let (new_parents, entries, copies) = let (new_parents, entries, copies) =
parse_dirstate(result.as_slice()).unwrap(); parse_dirstate(result.as_slice()).unwrap();
let new_state_map: StateMap = entries let new_state_map: StateMap = entries
.into_iter() .into_iter()

rust/hg-core/src/dirstate_tree/dirstate_map.rs

use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::path::PathBuf; use std::path::PathBuf;
use std::time::Duration;
use super::path_with_basename::WithBasename; use super::path_with_basename::WithBasename;
use crate::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate::parsers::parse_dirstate_parents; use crate::dirstate::parsers::parse_dirstate_parents;
use crate::dirstate::parsers::Timestamp;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::revlog::node::NULL_NODE; use crate::revlog::node::NULL_NODE;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateMapError; use crate::DirstateMapError;
} }
Ok(Some(parents)) Ok(Some(parents))
} }
fn pack( fn pack(
&mut self, &mut self,
_parents: DirstateParents, _parents: DirstateParents,
_now: Duration, _now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
let _ = self.iter_node_data_mut(); let _ = self.iter_node_data_mut();
todo!() todo!()
} }
fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> { fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> {
todo!() todo!()
} }

rust/hg-core/src/dirstate_tree/dispatch.rs

use std::path::PathBuf; use std::path::PathBuf;
use std::time::Duration;
use crate::dirstate::parsers::Timestamp;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateMap; use crate::DirstateMap;
use crate::DirstateMapError; use crate::DirstateMapError;
use crate::DirstateParents; use crate::DirstateParents;
fn read<'a>( fn read<'a>(
&mut self, &mut self,
file_contents: &'a [u8], file_contents: &'a [u8],
) -> Result<Option<&'a DirstateParents>, DirstateError>; ) -> Result<Option<&'a DirstateParents>, DirstateError>;
fn pack( fn pack(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf>; fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf>;
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>;
fn set_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_dirs(&mut self) -> Result<(), DirstateMapError>;
file_contents: &'a [u8], file_contents: &'a [u8],
) -> Result<Option<&'a DirstateParents>, DirstateError> { ) -> Result<Option<&'a DirstateParents>, DirstateError> {
self.read(file_contents) self.read(file_contents)
} }
fn pack( fn pack(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Duration, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.pack(parents, now) self.pack(parents, now)
} }
fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> { fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> {
self.build_file_fold_map() self.build_file_fold_map()
} }

rust/hg-core/src/lib.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
mod ancestors; mod ancestors;
pub mod dagops; pub mod dagops;
pub mod errors; pub mod errors;
pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors}; pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
mod dirstate; pub mod dirstate;
pub mod dirstate_tree; pub mod dirstate_tree;
pub mod discovery; pub mod discovery;
pub mod requirements; pub mod requirements;
pub mod testing; // unconditionally built, for use from integration tests pub mod testing; // unconditionally built, for use from integration tests
pub use dirstate::{ pub use dirstate::{
dirs_multiset::{DirsMultiset, DirsMultisetIter}, dirs_multiset::{DirsMultiset, DirsMultisetIter},
dirstate_map::DirstateMap, dirstate_map::DirstateMap,
parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE}, parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},

rust/hg-cpython/src/dirstate/dirstate_map.rs

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::dirstate_map` file provided by the //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::{Ref, RefCell}; use std::cell::{Ref, RefCell};
use std::convert::TryInto; use std::convert::TryInto;
use std::time::Duration;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, PyTuple, Python, PythonObject, PyObject, PyResult, PySet, PyString, PyTuple, Python, PythonObject,
ToPyObject, UnsafePyLeaked, ToPyObject, UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::{dirs_multiset::Dirs, make_dirstate_tuple}, dirstate::{dirs_multiset::Dirs, make_dirstate_tuple},
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
errors::HgError, errors::HgError,
revlog::Node, revlog::Node,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap, DirsMultiset, DirstateEntry, DirstateMap as RustDirstateMap,
DirstateMapError, DirstateParents, EntryState, StateMapIter, DirstateMapError, DirstateParents, EntryState, StateMapIter,
}; };
} }
} }
def write( def write(
&self, &self,
p1: PyObject, p1: PyObject,
p2: PyObject, p2: PyObject,
now: PyObject now: PyObject
) -> PyResult<PyBytes> { ) -> PyResult<PyBytes> {
let now = Duration::new(now.extract(py)?, 0); let now = Timestamp(now.extract(py)?);
let parents = DirstateParents { let parents = DirstateParents {
p1: extract_node_id(py, &p1)?, p1: extract_node_id(py, &p1)?,
p2: extract_node_id(py, &p2)?, p2: extract_node_id(py, &p2)?,
}; };
match self.inner(py).borrow_mut().pack(parents, now) { match self.inner(py).borrow_mut().pack(parents, now) {
Ok(packed) => Ok(PyBytes::new(py, &packed)), Ok(packed) => Ok(PyBytes::new(py, &packed)),
Err(_) => Err(PyErr::new::<exc::OSError, _>( Err(_) => Err(PyErr::new::<exc::OSError, _>(

rust/hg-cpython/src/parsers.rs

// parsers.rs // parsers.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::parsers` module provided by the //! Bindings for the `hg::dirstate::parsers` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.parsers` //! From Python, this will be seen as `mercurial.rustext.parsers`
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python, exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
PythonObject, ToPyObject, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
pack_dirstate, parse_dirstate, utils::hg_path::HgPathBuf, DirstateEntry, dirstate::parsers::Timestamp, pack_dirstate, parse_dirstate,
DirstateParents, FastHashMap, PARENT_SIZE, utils::hg_path::HgPathBuf, DirstateEntry, DirstateParents, FastHashMap,
PARENT_SIZE,
}; };
use std::convert::TryInto; use std::convert::TryInto;
use crate::dirstate::{extract_dirstate, make_dirstate_tuple}; use crate::dirstate::{extract_dirstate, make_dirstate_tuple};
use std::time::Duration;
fn parse_dirstate_wrapper( fn parse_dirstate_wrapper(
py: Python, py: Python,
dmap: PyDict, dmap: PyDict,
copymap: PyDict, copymap: PyDict,
st: PyBytes, st: PyBytes,
) -> PyResult<PyTuple> { ) -> PyResult<PyTuple> {
match parse_dirstate(st.data(py)) { match parse_dirstate(st.data(py)) {
match pack_dirstate( match pack_dirstate(
&mut dirstate_map, &mut dirstate_map,
&copies?, &copies?,
DirstateParents { DirstateParents {
p1: p1.try_into().unwrap(), p1: p1.try_into().unwrap(),
p2: p2.try_into().unwrap(), p2: p2.try_into().unwrap(),
}, },
Duration::from_secs(now.as_object().extract::<u64>(py)?), Timestamp(now.as_object().extract::<u64>(py)?),
) { ) {
Ok(packed) => { Ok(packed) => {
for (filename, entry) in dirstate_map.iter() { for (filename, entry) in dirstate_map.iter() {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_bytes()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_tuple(py, &entry)?,
)?; )?;