mercurial-scm/hg: rust/hg-core/src/revlog/index.rs annotate

annotate rust/hg-core/src/revlog/index.rs @ 52050:ea0467ed76aa

rust-dirstate-map: use a more precise identity This is closer to the behavior of what Python does. So far, we were checking only the inode, but this might not be good enough for the v1 case.

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Thu, 03 Oct 2024 16:35:31 +0200
parents	652149ed64f0
children	f2eab4967bfc

rev	line source
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1 use std::collections::{HashMap, HashSet};
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2 use std::fmt::Debug;
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	3 use std::ops::Deref;
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	4 use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	5
51257 c4f1a790bda8 rust-index: use a `BitVec` instead of plain `Vec` for heads computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51256 diff changeset	6 use bitvec::prelude::*;
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	7 use byteorder::{BigEndian, ByteOrder};
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	8 use bytes_cast::{unaligned, BytesCast};
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	9
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	10 use super::REVIDX_KNOWN_FLAGS;
46443 43d63979a75e rust: use HgError in RevlogError and Vfs Simon Sapin <simon.sapin@octobus.net> parents: 46090 diff changeset	11 use crate::errors::HgError;
51206 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	12 use crate::node::{NODE_BYTES_LENGTH, NULL_NODE, STORED_NODE_ID_BYTES};
46033 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45602 diff changeset	13 use crate::revlog::node::Node;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	14 use crate::revlog::{Revision, NULL_REVISION};
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	15 use crate::{
51212 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	16 dagops, BaseRevision, FastHashMap, Graph, GraphError, RevlogError,
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	17 RevlogIndex, UncheckedRevision,
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	18 };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	19
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	20 pub const INDEX_ENTRY_SIZE: usize = 64;
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	21 pub const INDEX_HEADER_SIZE: usize = 4;
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	22 pub const COMPRESSION_MODE_INLINE: u8 = 2;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	23
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	24 #[derive(Debug)]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	25 pub struct IndexHeader {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	26 pub(super) header_bytes: [u8; INDEX_HEADER_SIZE],
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	27 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	28
51849 4777378fc3bf rust-inner-revlog: derive Debug for IndexHeaderFlags Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51848 diff changeset	29 #[derive(Copy, Clone, Debug)]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	30 pub struct IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	31 flags: u16,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	32 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	33
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	34 /// Corresponds to the high bits of `_format_flags` in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	35 impl IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	36 /// Corresponds to FLAG_INLINE_DATA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	37 pub fn is_inline(self) -> bool {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	38 self.flags & 1 != 0
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	39 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	40 /// Corresponds to FLAG_GENERALDELTA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	41 pub fn uses_generaldelta(self) -> bool {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	42 self.flags & 2 != 0
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	43 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	44 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	45
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	46 /// Corresponds to the INDEX_HEADER structure,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	47 /// which is parsed as a `header` variable in `_loadindex` in `revlog.py`
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	48 impl IndexHeader {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	49 fn format_flags(&self) -> IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	50 // No "unknown flags" check here, unlike in python. Maybe there should
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	51 // be.
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	52 IndexHeaderFlags {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	53 flags: BigEndian::read_u16(&self.header_bytes[0..2]),
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	54 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	55 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	56
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	57 /// The only revlog version currently supported by rhg.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	58 const REVLOGV1: u16 = 1;
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	59
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	60 /// Corresponds to `_format_version` in Python.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	61 fn format_version(&self) -> u16 {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	62 BigEndian::read_u16(&self.header_bytes[2..4])
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	63 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	64
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	65 pub fn parse(index_bytes: &[u8]) -> Result<Option<IndexHeader>, HgError> {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	66 if index_bytes.is_empty() {
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	67 return Ok(None);
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	68 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	69 if index_bytes.len() < 4 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	70 return Err(HgError::corrupted(
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	71 "corrupted revlog: can't read the index format header",
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	72 ));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	73 }
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	74 Ok(Some(IndexHeader {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	75 header_bytes: {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	76 let bytes: [u8; 4] =
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	77 index_bytes[0..4].try_into().expect("impossible");
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	78 bytes
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	79 },
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	80 }))
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	81 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	82 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	83
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	84 /// Abstracts the access to the index bytes since they can be spread between
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	85 /// the immutable (bytes) part and the mutable (added) part if any appends
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	86 /// happened. This makes it transparent for the callers.
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	87 struct IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	88 /// Immutable bytes, most likely taken from disk
51230 ca81cd96000a rust-index: add Sync bound to all relevant mmap-derived values Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	89 bytes: Box<dyn Deref<Target = [u8]> + Send + Sync>,
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	90 /// Used when stripping index contents, keeps track of the start of the
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	91 /// first stripped revision, which is used to give a slice of the
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	92 /// `bytes` field.
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	93 truncation: Option<usize>,
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	94 /// Bytes that were added after reading the index
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	95 added: Vec<u8>,
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	96 first_entry: [u8; INDEX_ENTRY_SIZE],
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	97 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	98
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	99 impl IndexData {
51230 ca81cd96000a rust-index: add Sync bound to all relevant mmap-derived values Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	100 pub fn new(bytes: Box<dyn Deref<Target = [u8]> + Send + Sync>) -> Self {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	101 let mut first_entry = [0; INDEX_ENTRY_SIZE];
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	102 if bytes.len() >= INDEX_ENTRY_SIZE {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	103 first_entry[INDEX_HEADER_SIZE..]
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	104 .copy_from_slice(&bytes[INDEX_HEADER_SIZE..INDEX_ENTRY_SIZE])
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	105 }
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	106 Self {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	107 bytes,
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	108 truncation: None,
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	109 added: vec![],
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	110 first_entry,
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	111 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	112 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	113
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	114 pub fn len(&self) -> usize {
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	115 match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	116 Some(truncation) => truncation + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	117 None => self.bytes.len() + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	118 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	119 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	120
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	121 fn remove(
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	122 &mut self,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	123 rev: Revision,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	124 offsets: Option<&[usize]>,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	125 ) -> Result<(), RevlogError> {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	126 let rev = rev.0 as usize;
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	127 let truncation = if let Some(offsets) = offsets {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	128 offsets[rev]
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	129 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	130 rev * INDEX_ENTRY_SIZE
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	131 };
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	132 if truncation < self.bytes.len() {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	133 self.truncation = Some(truncation);
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	134 self.added.clear();
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	135 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	136 self.added.truncate(truncation - self.bytes.len());
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	137 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	138 Ok(())
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	139 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	140
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	141 fn is_new(&self) -> bool {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	142 self.bytes.is_empty()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	143 }
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	144 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	145
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	146 impl std::ops::Index<std::ops::Range<usize>> for IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	147 type Output = [u8];
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	148
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	149 fn index(&self, index: std::ops::Range<usize>) -> &Self::Output {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	150 let start = index.start;
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	151 let end = index.end;
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	152 let immutable_len = match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	153 Some(truncation) => truncation,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	154 None => self.bytes.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	155 };
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	156 if start < immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	157 if end > immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	158 panic!("index data cannot span existing and added ranges");
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	159 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	160 &self.bytes[index]
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	161 } else {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	162 &self.added[start - immutable_len..end - immutable_len]
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	163 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	164 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	165 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	166
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	167 #[derive(Debug, PartialEq, Eq)]
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	168 pub struct RevisionDataParams {
51189 65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	169 pub flags: u16,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	170 pub data_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	171 pub data_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	172 pub data_uncompressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	173 pub data_delta_base: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	174 pub link_rev: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	175 pub parent_rev_1: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	176 pub parent_rev_2: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	177 pub node_id: [u8; NODE_BYTES_LENGTH],
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	178 pub _sidedata_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	179 pub _sidedata_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	180 pub data_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	181 pub _sidedata_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	182 pub _rank: i32,
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	183 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	184
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	185 impl Default for RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	186 fn default() -> Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	187 Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	188 flags: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	189 data_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	190 data_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	191 data_uncompressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	192 data_delta_base: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	193 link_rev: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	194 parent_rev_1: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	195 parent_rev_2: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	196 node_id: [0; NODE_BYTES_LENGTH],
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	197 _sidedata_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	198 _sidedata_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	199 data_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	200 _sidedata_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	201 _rank: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	202 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	203 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	204 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	205
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	206 #[derive(BytesCast)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	207 #[repr(C)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	208 pub struct RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	209 data_offset_or_flags: unaligned::U64Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	210 data_compressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	211 data_uncompressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	212 data_delta_base: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	213 link_rev: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	214 parent_rev_1: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	215 parent_rev_2: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	216 node_id: [u8; STORED_NODE_ID_BYTES],
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	217 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	218
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	219 fn _static_assert_size_of_revision_data_v1() {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	220 let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	221 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	222
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	223 impl RevisionDataParams {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	224 pub fn validate(&self) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	225 if self.flags & !REVIDX_KNOWN_FLAGS != 0 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	226 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	227 "unknown revlog index flags: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	228 self.flags
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	229 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	230 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	231 if self.data_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	232 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	233 "invalid data compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	234 self.data_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	235 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	236 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	237 // FIXME isn't this only for v2 or changelog v2?
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	238 if self._sidedata_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	239 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	240 "invalid sidedata compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	241 self._sidedata_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	242 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	243 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	244 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	245 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	246
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	247 pub fn into_v1(self) -> RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	248 let data_offset_or_flags = self.data_offset << 16 \| self.flags as u64;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	249 let mut node_id = [0; STORED_NODE_ID_BYTES];
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	250 node_id[..NODE_BYTES_LENGTH].copy_from_slice(&self.node_id);
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	251 RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	252 data_offset_or_flags: data_offset_or_flags.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	253 data_compressed_length: self.data_compressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	254 data_uncompressed_length: self.data_uncompressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	255 data_delta_base: self.data_delta_base.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	256 link_rev: self.link_rev.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	257 parent_rev_1: self.parent_rev_1.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	258 parent_rev_2: self.parent_rev_2.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	259 node_id,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	260 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	261 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	262 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	263
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	264 /// A Revlog index
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	265 pub struct Index {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	266 bytes: IndexData,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	267 /// Offsets of starts of index blocks.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	268 /// Only needed when the index is interleaved with data.
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	269 offsets: RwLock<Option<Vec<usize>>>,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	270 uses_generaldelta: bool,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	271 is_inline: bool,
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	272 /// Cache of (head_revisions, filtered_revisions)
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	273 ///
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	274 /// The head revisions in this index, kept in sync. Should
51212 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	275 /// be accessed via the [`Self::head_revs`] method.
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	276 /// The last filtered revisions in this index, used to make sure
51213 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	277 /// we haven't changed filters when returning the cached `head_revs`.
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	278 head_revs: RwLock<(Vec<Revision>, HashSet<Revision>)>,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	279 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	280
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	281 impl Debug for Index {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	282 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	283 f.debug_struct("Index")
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	284 .field("offsets", &self.offsets)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	285 .field("uses_generaldelta", &self.uses_generaldelta)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	286 .finish()
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	287 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	288 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	289
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	290 impl Graph for Index {
51254 e74dd6d73cb5 rust-index: allow inlining `parents` across crates Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	291 #[inline(always)]
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	292 fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	293 let err = \|\| GraphError::ParentOutOfRange(rev);
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	294 match self.get_entry(rev) {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	295 Some(entry) => {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	296 // The C implementation checks that the parents are valid
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	297 // before returning
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	298 Ok([
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	299 self.check_revision(entry.p1()).ok_or_else(err)?,
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	300 self.check_revision(entry.p2()).ok_or_else(err)?,
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	301 ])
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	302 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	303 None => Ok([NULL_REVISION, NULL_REVISION]),
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	304 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	305 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	306 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	307
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	308 /// A cache suitable for find_snapshots
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	309 ///
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	310 /// Logically equivalent to a mapping whose keys are [`BaseRevision`] and
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	311 /// values sets of [`BaseRevision`]
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	312 ///
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	313 /// TODO the dubious part is insisting that errors must be RevlogError
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	314 /// we would probably need to sprinkle some magic here, such as an associated
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	315 /// type that would be Into<RevlogError> but even that would not be
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	316 /// satisfactory, as errors potentially have nothing to do with the revlog.
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	317 pub trait SnapshotsCache {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	318 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	319 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	320 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	321 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	322 ) -> Result<(), RevlogError>;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	323 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	324
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	325 impl SnapshotsCache for FastHashMap<BaseRevision, HashSet<BaseRevision>> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	326 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	327 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	328 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	329 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	330 ) -> Result<(), RevlogError> {
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	331 let all_values = self.entry(rev).or_default();
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	332 all_values.insert(value);
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	333 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	334 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	335 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	336
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	337 impl Index {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	338 /// Create an index from bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	339 /// Calculate the start of each entry when is_inline is true.
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	340 pub fn new(
51230 ca81cd96000a rust-index: add Sync bound to all relevant mmap-derived values Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	341 bytes: Box<dyn Deref<Target = [u8]> + Send + Sync>,
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	342 default_header: IndexHeader,
47963 001d747c2baf rust: Return HgError instead of RevlogError in revlog constructors Simon Sapin <simon.sapin@octobus.net> parents: 46887 diff changeset	343 ) -> Result<Self, HgError> {
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	344 let header =
13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	345 IndexHeader::parse(bytes.as_ref())?.unwrap_or(default_header);
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	346
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	347 if header.format_version() != IndexHeader::REVLOGV1 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	348 // A proper new version should have had a repo/store
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	349 // requirement.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	350 return Err(HgError::corrupted("unsupported revlog version"));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	351 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	352
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	353 let uses_generaldelta = header.format_flags().uses_generaldelta();
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	354
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	355 if header.format_flags().is_inline() {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	356 let mut offset: usize = 0;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	357 let mut offsets = Vec::new();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	358
45590 11f3c3f408fd hg-core: minor code style change (D8958#inline-14993 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45536 diff changeset	359 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	360 offsets.push(offset);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	361 let end = offset + INDEX_ENTRY_SIZE;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	362 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	363 bytes: &bytes[offset..end],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	364 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	365
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	366 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	367 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	368
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	369 if offset == bytes.len() {
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	370 Ok(Self {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	371 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	372 offsets: RwLock::new(Some(offsets)),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	373 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	374 is_inline: true,
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	375 head_revs: RwLock::new((vec![], HashSet::new())),
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	376 })
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	377 } else {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	378 Err(HgError::corrupted("unexpected inline revlog length"))
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	379 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	380 } else {
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	381 Ok(Self {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	382 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	383 offsets: RwLock::new(None),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	384 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	385 is_inline: false,
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	386 head_revs: RwLock::new((vec![], HashSet::new())),
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	387 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	388 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	389 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	390
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	391 pub fn uses_generaldelta(&self) -> bool {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	392 self.uses_generaldelta
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	393 }
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	394
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	395 /// Value of the inline flag.
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	396 pub fn is_inline(&self) -> bool {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	397 self.is_inline
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	398 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	399
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	400 /// Return a slice of bytes if `revlog` is inline. Panic if not.
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	401 pub fn data(&self, start: usize, end: usize) -> &[u8] {
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	402 if !self.is_inline() {
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	403 panic!("tried to access data in the index of a revlog that is not inline");
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	404 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	405 &self.bytes[start..end]
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	406 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	407
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	408 /// Return number of entries of the revlog index.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	409 pub fn len(&self) -> usize {
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	410 if self.is_inline() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	411 (*self.get_offsets())
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	412 .as_ref()
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	413 .expect("inline should have offsets")
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	414 .len()
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	415 } else {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	416 self.bytes.len() / INDEX_ENTRY_SIZE
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	417 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	418 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	419
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	420 pub fn get_offsets(&self) -> RwLockReadGuard<Option<Vec<usize>>> {
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	421 assert!(self.is_inline());
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	422 {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	423 // Wrap in a block to drop the read guard
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	424 let mut offsets = self.offsets.write().unwrap();
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	425 if offsets.is_none() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	426 offsets.replace(inline_scan(&self.bytes.bytes).1);
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	427 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	428 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	429 self.offsets.read().unwrap()
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	430 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	431
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	432 pub fn get_offsets_mut(&mut self) -> RwLockWriteGuard<Option<Vec<usize>>> {
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	433 assert!(self.is_inline());
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	434 let mut offsets = self.offsets.write().unwrap();
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	435 if offsets.is_none() {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	436 offsets.replace(inline_scan(&self.bytes.bytes).1);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	437 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	438 offsets
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	439 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	440
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	441 /// Returns `true` if the `Index` has zero `entries`.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	442 pub fn is_empty(&self) -> bool {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	443 self.len() == 0
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	444 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	445
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	446 /// Return the index entry corresponding to the given revision or `None`
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	447 /// for [`NULL_REVISION`]
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	448 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	449 /// The specified revision being of the checked type, it always exists
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	450 /// if it was validated by this index.
51850 5baa52ca4932 rust-inner-revlog: always inline `get_entry` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51849 diff changeset	451 #[inline(always)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	452 pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	453 if rev == NULL_REVISION {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	454 return None;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	455 }
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	456 if rev.0 == 0 {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	457 Some(IndexEntry {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	458 bytes: &self.bytes.first_entry[..],
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	459 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	460 } else {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	461 Some(if self.is_inline() {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	462 self.get_entry_inline(rev)
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	463 } else {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	464 self.get_entry_separated(rev)
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	465 })
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	466 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	467 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	468
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	469 /// Return the binary content of the index entry for the given revision
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	470 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	471 /// See [get_entry()](`Self::get_entry()`) for cases when `None` is
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	472 /// returned.
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	473 pub fn entry_binary(&self, rev: Revision) -> Option<&[u8]> {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	474 self.get_entry(rev).map(\|e\| {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	475 let bytes = e.as_bytes();
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	476 if rev.0 == 0 {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	477 &bytes[4..]
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	478 } else {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	479 bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	480 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	481 })
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	482 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	483
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	484 pub fn entry_as_params(
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	485 &self,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	486 rev: UncheckedRevision,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	487 ) -> Option<RevisionDataParams> {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	488 let rev = self.check_revision(rev)?;
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	489 self.get_entry(rev).map(\|e\| RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	490 flags: e.flags(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	491 data_offset: if rev.0 == 0 && !self.bytes.is_new() {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	492 e.flags() as u64
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	493 } else {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	494 e.raw_offset()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	495 },
51233 eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	496 data_compressed_length: e
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	497 .compressed_len()
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	498 .try_into()
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	499 .unwrap_or_else(\|_\| {
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	500 // Python's `unionrepo` sets the compressed length to be
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	501 // `-1` (or `u32::MAX` if transmuted to `u32`) because it
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	502 // cannot know the correct compressed length of a given
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	503 // revision. I'm not sure if this is true, but having this
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	504 // edge case won't hurt other use cases, let's handle it.
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	505 assert_eq!(e.compressed_len(), u32::MAX);
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	506 NULL_REVISION.0
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	507 }),
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	508 data_uncompressed_length: e.uncompressed_len(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	509 data_delta_base: e.base_revision_or_base_of_delta_chain().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	510 link_rev: e.link_revision().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	511 parent_rev_1: e.p1().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	512 parent_rev_2: e.p2().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	513 node_id: e.hash().as_bytes().try_into().unwrap(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	514 ..Default::default()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	515 })
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	516 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	517
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	518 fn get_entry_inline(&self, rev: Revision) -> IndexEntry {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	519 let offsets = &self.get_offsets();
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	520 let offsets = offsets.as_ref().expect("inline should have offsets");
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	521 let start = offsets[rev.0 as usize];
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	522 let end = start + INDEX_ENTRY_SIZE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	523 let bytes = &self.bytes[start..end];
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	524
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	525 IndexEntry { bytes }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	526 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	527
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	528 fn get_entry_separated(&self, rev: Revision) -> IndexEntry {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	529 let start = rev.0 as usize * INDEX_ENTRY_SIZE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	530 let end = start + INDEX_ENTRY_SIZE;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	531 let bytes = &self.bytes[start..end];
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	532
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	533 IndexEntry { bytes }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	534 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	535
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	536 fn null_entry(&self) -> IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	537 IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	538 bytes: &[0; INDEX_ENTRY_SIZE],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	539 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	540 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	541
51212 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	542 /// Return the head revisions of this index
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	543 pub fn head_revs(&self) -> Result<Vec<Revision>, GraphError> {
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	544 self.head_revs_advanced(&HashSet::new(), None, false)
51258 9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	545 .map(\|h\| h.unwrap())
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	546 }
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	547
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	548 /// Return the head revisions of this index
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	549 pub fn head_revs_advanced(
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	550 &self,
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	551 filtered_revs: &HashSet<Revision>,
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	552 stop_rev: Option<Revision>,
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	553 py_shortcut: bool,
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	554 ) -> Result<Option<Vec<Revision>>, GraphError> {
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	555 {
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	556 let guard = self
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	557 .head_revs
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	558 .read()
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	559 .expect("RwLock on Index.head_revs should not be poisoned");
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	560 let self_head_revs = &guard.0;
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	561 let self_filtered_revs = &guard.1;
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	562 if !self_head_revs.is_empty()
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	563 && filtered_revs == self_filtered_revs
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	564 && stop_rev.is_none()
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	565 {
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	566 if py_shortcut {
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	567 // Don't copy the revs since we've already cached them
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	568 // on the Python side.
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	569 return Ok(None);
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	570 } else {
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	571 return Ok(Some(self_head_revs.to_owned()));
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	572 }
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	573 }
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	574 }
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	575
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	576 let (as_vec, cachable) = if self.is_empty() {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	577 (vec![NULL_REVISION], true)
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	578 } else {
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	579 let length: usize = match stop_rev {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	580 Some(r) => r.0 as usize,
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	581 None => self.len(),
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	582 };
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	583 let cachable = self.len() == length;
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	584 let mut not_heads = bitvec![0; length];
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	585 dagops::retain_heads_fast(
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	586 self,
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	587 not_heads.as_mut_bitslice(),
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	588 filtered_revs,
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	589 )?;
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	590 (
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	591 not_heads
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	592 .into_iter()
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	593 .enumerate()
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	594 .filter_map(\|(idx, is_not_head)\| {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	595 if is_not_head {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	596 None
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	597 } else {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	598 Some(Revision(idx as BaseRevision))
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	599 }
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	600 })
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	601 .collect(),
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	602 cachable,
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	603 )
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	604 };
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	605 if cachable {
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	606 *self
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	607 .head_revs
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	608 .write()
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	609 .expect("RwLock on Index.head_revs should not be poisoned") =
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	610 (as_vec.to_owned(), filtered_revs.to_owned());
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	611 }
51974 5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	612 Ok(Some(as_vec))
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	613 }
5d1e6f447d2d head-revs: move hg-core's inner_headrevsfiltered closer to inner_headrevs Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51850 diff changeset	614
51258 9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	615 /// Python-specific shortcut to save on PyList creation
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	616 pub fn head_revs_shortcut(
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	617 &self,
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	618 ) -> Result<Option<Vec<Revision>>, GraphError> {
51975 609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	619 self.head_revs_advanced(&HashSet::new(), None, true)
51213 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	620 }
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	621
51394 b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	622 /// Return the heads removed and added by advancing from `begin` to `end`.
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	623 /// In revset language, we compute:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	624 /// - `heads(:begin)-heads(:end)`
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	625 /// - `heads(:end)-heads(:begin)`
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	626 pub fn head_revs_diff(
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	627 &self,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	628 begin: Revision,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	629 end: Revision,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	630 ) -> Result<(Vec<Revision>, Vec<Revision>), GraphError> {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	631 let mut heads_added = vec![];
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	632 let mut heads_removed = vec![];
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	633
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	634 let mut acc = HashSet::new();
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	635 let Revision(begin) = begin;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	636 let Revision(end) = end;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	637 let mut i = end;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	638
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	639 while i > begin {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	640 // acc invariant:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	641 // `j` is in the set iff `j <= i` and it has children
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	642 // among `i+1..end` (inclusive)
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	643 if !acc.remove(&i) {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	644 heads_added.push(Revision(i));
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	645 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	646 for Revision(parent) in self.parents(Revision(i))? {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	647 acc.insert(parent);
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	648 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	649 i -= 1;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	650 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	651
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	652 // At this point `acc` contains old revisions that gained new children.
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	653 // We need to check if they had any children before. If not, those
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	654 // revisions are the removed heads.
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	655 while !acc.is_empty() {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	656 // acc invariant:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	657 // `j` is in the set iff `j <= i` and it has children
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	658 // among `begin+1..end`, but not among `i+1..begin` (inclusive)
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	659
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	660 assert!(i >= -1); // yes, `-1` can also be a head if the repo is empty
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	661 if acc.remove(&i) {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	662 heads_removed.push(Revision(i));
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	663 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	664 for Revision(parent) in self.parents(Revision(i))? {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	665 acc.remove(&parent);
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	666 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	667 i -= 1;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	668 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	669
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	670 Ok((heads_removed, heads_added))
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	671 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	672
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	673 /// Obtain the delta chain for a revision.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	674 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	675 /// `stop_rev` specifies a revision to stop at. If not specified, we
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	676 /// stop at the base of the chain.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	677 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	678 /// Returns a 2-tuple of (chain, stopped) where `chain` is a vec of
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	679 /// revs in ascending order and `stopped` is a bool indicating whether
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	680 /// `stoprev` was hit.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	681 pub fn delta_chain(
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	682 &self,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	683 rev: Revision,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	684 stop_rev: Option<Revision>,
51232 456e0fe702e8 rust-index: honour incoming using_general_delta in `deltachain` Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51231 diff changeset	685 using_general_delta: Option<bool>,
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	686 ) -> Result<(Vec<Revision>, bool), HgError> {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	687 let mut current_rev = rev;
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	688 let mut entry = self.get_entry(rev).unwrap();
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	689 let mut chain = vec![];
51232 456e0fe702e8 rust-index: honour incoming using_general_delta in `deltachain` Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51231 diff changeset	690 let using_general_delta =
456e0fe702e8 rust-index: honour incoming using_general_delta in `deltachain` Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51231 diff changeset	691 using_general_delta.unwrap_or_else(\|\| self.uses_generaldelta());
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	692 while current_rev.0 != entry.base_revision_or_base_of_delta_chain().0
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	693 && stop_rev.map(\|r\| r != current_rev).unwrap_or(true)
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	694 {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	695 chain.push(current_rev);
51232 456e0fe702e8 rust-index: honour incoming using_general_delta in `deltachain` Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51231 diff changeset	696 let new_rev = if using_general_delta {
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	697 entry.base_revision_or_base_of_delta_chain()
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	698 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	699 UncheckedRevision(current_rev.0 - 1)
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	700 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	701 current_rev = self.check_revision(new_rev).ok_or_else(\|\| {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	702 HgError::corrupted(format!("Revision {new_rev} out of range"))
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	703 })?;
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	704 if current_rev.0 == NULL_REVISION.0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	705 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	706 }
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	707 entry = self.get_entry(current_rev).unwrap()
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	708 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	709
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	710 let stopped = if stop_rev.map(\|r\| current_rev == r).unwrap_or(false) {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	711 true
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	712 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	713 chain.push(current_rev);
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	714 false
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	715 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	716 chain.reverse();
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	717 Ok((chain, stopped))
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	718 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	719
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	720 pub fn find_snapshots(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	721 &self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	722 start_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	723 end_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	724 cache: &mut impl SnapshotsCache,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	725 ) -> Result<(), RevlogError> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	726 let mut start_rev = start_rev.0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	727 let mut end_rev = end_rev.0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	728 end_rev += 1;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	729 let len = self.len().try_into().unwrap();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	730 if end_rev > len {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	731 end_rev = len;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	732 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	733 if start_rev < 0 {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	734 start_rev = 0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	735 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	736 for rev in start_rev..end_rev {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	737 if !self.is_snapshot_unchecked(Revision(rev))? {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	738 continue;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	739 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	740 let mut base = self
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	741 .get_entry(Revision(rev))
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	742 .unwrap()
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	743 .base_revision_or_base_of_delta_chain();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	744 if base.0 == rev {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	745 base = NULL_REVISION.into();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	746 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	747 cache.insert_for(base.0, rev)?;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	748 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	749 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	750 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	751
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	752 fn clear_head_revs(&self) {
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	753 self.head_revs
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	754 .write()
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	755 .expect("RwLock on Index.head_revs should not be poisoined")
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	756 .0
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	757 .clear()
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	758 }
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	759
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	760 /// TODO move this to the trait probably, along with other things
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	761 pub fn append(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	762 &mut self,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	763 revision_data: RevisionDataParams,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	764 ) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	765 revision_data.validate()?;
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	766 let entry_v1 = revision_data.into_v1();
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	767 let entry_bytes = entry_v1.as_bytes();
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	768 if self.bytes.len() == 0 {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	769 self.bytes.first_entry[INDEX_HEADER_SIZE..].copy_from_slice(
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	770 &entry_bytes[INDEX_HEADER_SIZE..INDEX_ENTRY_SIZE],
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	771 )
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	772 }
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	773 if self.is_inline() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	774 let new_offset = self.bytes.len();
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	775 if let Some(offsets) = &mut *self.get_offsets_mut() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	776 offsets.push(new_offset)
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	777 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	778 }
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	779 self.bytes.added.extend(entry_bytes);
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	780 self.clear_head_revs();
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	781 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	782 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	783
51195 51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	784 pub fn pack_header(&self, header: i32) -> [u8; 4] {
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	785 header.to_be_bytes()
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	786 }
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	787
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	788 pub fn remove(&mut self, rev: Revision) -> Result<(), RevlogError> {
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	789 let offsets = if self.is_inline() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	790 self.get_offsets().clone()
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	791 } else {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	792 None
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	793 };
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	794 self.bytes.remove(rev, offsets.as_deref())?;
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	795 if self.is_inline() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	796 if let Some(offsets) = &mut *self.get_offsets_mut() {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	797 offsets.truncate(rev.0 as usize)
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	798 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	799 }
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	800 self.clear_head_revs();
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	801 Ok(())
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	802 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	803
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	804 pub fn clear_caches(&self) {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	805 // We need to get the 'inline' value from Python at init and use this
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	806 // instead of offsets to determine whether we're inline since we might
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	807 // clear caches. This implies re-populating the offsets on-demand.
51231 59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	808 *self
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	809 .offsets
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	810 .write()
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	811 .expect("RwLock on Index.offsets should not be poisoed") = None;
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	812 self.clear_head_revs();
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	813 }
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	814
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	815 /// Unchecked version of `is_snapshot`.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	816 /// Assumes the caller checked that `rev` is within a valid revision range.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	817 pub fn is_snapshot_unchecked(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	818 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	819 mut rev: Revision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	820 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	821 while rev.0 >= 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	822 let entry = self.get_entry(rev).unwrap();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	823 let mut base = entry.base_revision_or_base_of_delta_chain().0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	824 if base == rev.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	825 base = NULL_REVISION.0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	826 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	827 if base == NULL_REVISION.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	828 return Ok(true);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	829 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	830 let [mut p1, mut p2] = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	831 .parents(rev)
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	832 .map_err(\|e\| RevlogError::InvalidRevision(e.to_string()))?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	833 while let Some(p1_entry) = self.get_entry(p1) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	834 if p1_entry.compressed_len() != 0 \|\| p1.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	835 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	836 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	837 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	838 p1_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	839 if parent_base.0 == p1.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	840 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	841 }
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	842 p1 = self.check_revision(parent_base).ok_or(
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	843 RevlogError::InvalidRevision(parent_base.to_string()),
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	844 )?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	845 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	846 while let Some(p2_entry) = self.get_entry(p2) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	847 if p2_entry.compressed_len() != 0 \|\| p2.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	848 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	849 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	850 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	851 p2_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	852 if parent_base.0 == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	853 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	854 }
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	855 p2 = self.check_revision(parent_base).ok_or(
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	856 RevlogError::InvalidRevision(parent_base.to_string()),
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	857 )?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	858 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	859 if base == p1.0 \|\| base == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	860 return Ok(false);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	861 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	862 rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	863 .check_revision(base.into())
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	864 .ok_or(RevlogError::InvalidRevision(base.to_string()))?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	865 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	866 Ok(rev == NULL_REVISION)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	867 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	868
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	869 /// Return whether the given revision is a snapshot. Returns an error if
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	870 /// `rev` is not within a valid revision range.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	871 pub fn is_snapshot(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	872 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	873 rev: UncheckedRevision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	874 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	875 let rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	876 .check_revision(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	877 .ok_or_else(\|\| RevlogError::corrupted("test"))?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	878 self.is_snapshot_unchecked(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	879 }
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	880
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	881 /// Slice revs to reduce the amount of unrelated data to be read from disk.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	882 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	883 /// The index is sliced into groups that should be read in one time.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	884 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	885 /// The initial chunk is sliced until the overall density
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	886 /// (payload/chunks-span ratio) is above `target_density`.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	887 /// No gap smaller than `min_gap_size` is skipped.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	888 pub fn slice_chunk_to_density(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	889 &self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	890 revs: &[Revision],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	891 target_density: f64,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	892 min_gap_size: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	893 ) -> Vec<Vec<Revision>> {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	894 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	895 return vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	896 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	897 if revs.len() == 1 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	898 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	899 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	900 let delta_chain_span = self.segment_span(revs);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	901 if delta_chain_span < min_gap_size {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	902 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	903 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	904 let entries: Vec<_> = revs
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	905 .iter()
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	906 .map(\|r\| {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	907 (r, self.get_entry(r).unwrap_or_else(\|\| self.null_entry()))
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	908 })
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	909 .collect();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	910
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	911 let mut read_data = delta_chain_span;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	912 let chain_payload: u32 =
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	913 entries.iter().map(\|(_r, e)\| e.compressed_len()).sum();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	914 let mut density = if delta_chain_span > 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	915 chain_payload as f64 / delta_chain_span as f64
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	916 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	917 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	918 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	919
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	920 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	921 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	922 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	923
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	924 // Store the gaps in a heap to have them sorted by decreasing size
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	925 let mut gaps = Vec::new();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	926 let mut previous_end = None;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	927
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	928 for (i, (_rev, entry)) in entries.iter().enumerate() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	929 let start = entry.c_start() as usize;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	930 let length = entry.compressed_len();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	931
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	932 // Skip empty revisions to form larger holes
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	933 if length == 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	934 continue;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	935 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	936
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	937 if let Some(end) = previous_end {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	938 let gap_size = start - end;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	939 // Only consider holes that are large enough
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	940 if gap_size > min_gap_size {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	941 gaps.push((gap_size, i));
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	942 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	943 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	944 previous_end = Some(start + length as usize);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	945 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	946 if gaps.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	947 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	948 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	949 // sort the gaps to pop them from largest to small
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	950 gaps.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	951
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	952 // Collect the indices of the largest holes until
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	953 // the density is acceptable
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	954 let mut selected = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	955 while let Some((gap_size, gap_id)) = gaps.pop() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	956 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	957 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	958 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	959 selected.push(gap_id);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	960
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	961 // The gap sizes are stored as negatives to be sorted decreasingly
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	962 // by the heap
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	963 read_data -= gap_size;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	964 density = if read_data > 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	965 chain_payload as f64 / read_data as f64
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	966 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	967 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	968 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	969 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	970 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	971 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	972 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	973 selected.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	974 selected.push(revs.len());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	975
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	976 // Cut the revs at collected indices
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	977 let mut previous_idx = 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	978 let mut chunks = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	979 for idx in selected {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	980 let chunk = self.trim_chunk(&entries, previous_idx, idx);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	981 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	982 chunks.push(chunk.iter().map(\|(rev, _entry)\| *rev).collect());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	983 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	984 previous_idx = idx;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	985 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	986 let chunk = self.trim_chunk(&entries, previous_idx, entries.len());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	987 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	988 chunks.push(chunk.iter().map(\|(rev, _entry)\| *rev).collect());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	989 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	990
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	991 chunks
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	992 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	993
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	994 /// Get the byte span of a segment of sorted revisions.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	995 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	996 /// Occurrences of [`NULL_REVISION`] are ignored at the beginning of
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	997 /// the `revs` segment.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	998 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	999 /// panics:
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1000 /// - if `revs` is empty or only made of `NULL_REVISION`
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1001 /// - if cannot retrieve entry for the last or first not null element of
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1002 /// `revs`.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1003 fn segment_span(&self, revs: &[Revision]) -> usize {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1004 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1005 return 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1006 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1007 let last_entry = &self.get_entry(revs[revs.len() - 1]).unwrap();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1008 let end = last_entry.c_start() + last_entry.compressed_len() as u64;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1009 let first_rev = revs.iter().find(\|r\| r.0 != NULL_REVISION.0).unwrap();
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1010 let start = if first_rev.0 == 0 {
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1011 0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1012 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1013 self.get_entry(*first_rev).unwrap().c_start()
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1014 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1015 (end - start) as usize
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1016 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1017
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1018 /// Returns `&revs[startidx..endidx]` without empty trailing revs
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1019 fn trim_chunk<'a>(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1020 &'a self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1021 revs: &'a [(Revision, IndexEntry)],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1022 start: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1023 mut end: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1024 ) -> &'a [(Revision, IndexEntry)] {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1025 // Trim empty revs at the end, except the very first rev of a chain
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1026 let last_rev = revs[end - 1].0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1027 if last_rev.0 < self.len() as BaseRevision {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1028 while end > 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1029 && end > start
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1030 && revs[end - 1].1.compressed_len() == 0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1031 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1032 end -= 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1033 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1034 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1035 &revs[start..end]
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1036 }
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1037
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1038 /// Computes the set of revisions for each non-public phase from `roots`,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1039 /// which are the last known roots for each non-public phase.
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1040 pub fn compute_phases_map_sets(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1041 &self,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1042 roots: HashMap<Phase, Vec<Revision>>,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1043 ) -> Result<(usize, RootsPerPhase), GraphError> {
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1044 let mut phases = vec![Phase::Public; self.len()];
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1045 let mut min_phase_rev = NULL_REVISION;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1046
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1047 for phase in Phase::non_public_phases() {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1048 if let Some(phase_roots) = roots.get(phase) {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1049 let min_rev =
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1050 self.add_roots_get_min(phase_roots, &mut phases, *phase);
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1051 if min_rev != NULL_REVISION
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1052 && (min_phase_rev == NULL_REVISION
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1053 \|\| min_rev < min_phase_rev)
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1054 {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1055 min_phase_rev = min_rev;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1056 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1057 } else {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1058 continue;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1059 };
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1060 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1061 let mut phase_sets: RootsPerPhase = Default::default();
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1062
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1063 if min_phase_rev == NULL_REVISION {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1064 min_phase_rev = Revision(self.len() as BaseRevision);
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1065 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1066
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1067 for rev in min_phase_rev.0..self.len() as BaseRevision {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1068 let rev = Revision(rev);
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1069 let [p1, p2] = self.parents(rev)?;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1070
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1071 if p1.0 >= 0 && phases[p1.0 as usize] > phases[rev.0 as usize] {
7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1072 phases[rev.0 as usize] = phases[p1.0 as usize];
7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1073 }
7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1074 if p2.0 >= 0 && phases[p2.0 as usize] > phases[rev.0 as usize] {
7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1075 phases[rev.0 as usize] = phases[p2.0 as usize];
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1076 }
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1077 let set = match phases[rev.0 as usize] {
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1078 Phase::Public => continue,
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1079 phase => &mut phase_sets[phase as usize - 1],
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1080 };
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1081 set.push(rev);
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1082 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1083
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1084 Ok((self.len(), phase_sets))
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1085 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1086
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1087 fn add_roots_get_min(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1088 &self,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1089 phase_roots: &[Revision],
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1090 phases: &mut [Phase],
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1091 phase: Phase,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1092 ) -> Revision {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1093 let mut min_rev = NULL_REVISION;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1094
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1095 for root in phase_roots {
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1096 phases[root.0 as usize] = phase;
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1097 if min_rev == NULL_REVISION \|\| min_rev > *root {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1098 min_rev = *root;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1099 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1100 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1101 min_rev
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1102 }
51219 fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1103
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1104 /// Return `(heads(::(<roots> and <roots>::<heads>)))`
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1105 /// If `include_path` is `true`, return `(<roots>::<heads>)`."""
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1106 ///
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1107 /// `min_root` and `roots` are unchecked since they are just used as
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1108 /// a bound or for comparison and don't need to represent a valid revision.
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1109 /// In practice, the only invalid revision passed is the working directory
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1110 /// revision ([`i32::MAX`]).
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1111 pub fn reachable_roots(
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1112 &self,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1113 min_root: UncheckedRevision,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1114 mut heads: Vec<Revision>,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1115 roots: HashSet<UncheckedRevision>,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1116 include_path: bool,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1117 ) -> Result<HashSet<Revision>, GraphError> {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1118 if roots.is_empty() {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1119 return Ok(HashSet::new());
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1120 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1121 let mut reachable = HashSet::new();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1122 let mut seen = HashMap::new();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1123
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1124 while let Some(rev) = heads.pop() {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1125 if roots.contains(&rev.into()) {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1126 reachable.insert(rev);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1127 if !include_path {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1128 continue;
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1129 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1130 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1131 let parents = self.parents(rev)?;
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1132 seen.insert(rev, parents);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1133 for parent in parents {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1134 if parent.0 >= min_root.0 && !seen.contains_key(&parent) {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1135 heads.push(parent);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1136 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1137 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1138 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1139 if !include_path {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1140 return Ok(reachable);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1141 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1142 let mut revs: Vec<_> = seen.keys().collect();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1143 revs.sort_unstable();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1144 for rev in revs {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1145 for parent in seen[rev] {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1146 if reachable.contains(&parent) {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1147 reachable.insert(*rev);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1148 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1149 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1150 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1151 Ok(reachable)
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1152 }
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1153
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1154 /// Given a (possibly overlapping) set of revs, return all the
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1155 /// common ancestors heads: `heads(::args[0] and ::a[1] and ...)`
51222 89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1156 pub fn common_ancestor_heads(
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1157 &self,
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1158 revisions: &[Revision],
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1159 ) -> Result<Vec<Revision>, GraphError> {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1160 // given that revisions is expected to be small, we find this shortcut
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1161 // potentially acceptable, especially given that `hg-cpython` could
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1162 // very much bypass this, constructing a vector of unique values from
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1163 // the onset.
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1164 let as_set: HashSet<Revision> = revisions.iter().copied().collect();
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1165 // Besides deduplicating, the C version also implements the shortcut
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1166 // for `NULL_REVISION`:
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1167 if as_set.contains(&NULL_REVISION) {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1168 return Ok(vec![]);
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1169 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1170
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1171 let revisions: Vec<Revision> = as_set.into_iter().collect();
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1172
51226 1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1173 if revisions.len() < 8 {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1174 self.find_gca_candidates::<u8>(&revisions)
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1175 } else if revisions.len() < 64 {
51222 89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1176 self.find_gca_candidates::<u64>(&revisions)
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1177 } else {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1178 self.find_gca_candidates::<NonStaticPoisonableBitSet>(&revisions)
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1179 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1180 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1181
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1182 pub fn ancestors(
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1183 &self,
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1184 revisions: &[Revision],
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1185 ) -> Result<Vec<Revision>, GraphError> {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1186 self.find_deepest_revs(&self.common_ancestor_heads(revisions)?)
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1187 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1188
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1189 /// Given a disjoint set of revs, return all candidates for the
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1190 /// greatest common ancestor. In revset notation, this is the set
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1191 /// `heads(::a and ::b and ...)`
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1192 fn find_gca_candidates<BS: PoisonableBitSet + Clone>(
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1193 &self,
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1194 revs: &[Revision],
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1195 ) -> Result<Vec<Revision>, GraphError> {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1196 if revs.is_empty() {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1197 return Ok(vec![]);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1198 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1199 let revcount = revs.len();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1200 let mut candidates = vec![];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1201 let max_rev = revs.iter().max().unwrap();
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1202
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1203 let mut seen = BS::vec_of_empty(revs.len(), (max_rev.0 + 1) as usize);
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1204
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1205 for (idx, rev) in revs.iter().enumerate() {
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1206 seen[rev.0 as usize].add(idx);
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1207 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1208 let mut current_rev = *max_rev;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1209 // Number of revisions whose inspection in the main loop
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1210 // will give a result or trigger inspection of other revisions
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1211 let mut interesting = revcount;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1212
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1213 // The algorithm works on a vector of bit sets, indexed by revision
83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1214 // numbers and iterated on reverse order.
83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1215 // An entry in this vector is poisoned if and only if the corresponding
83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1216 // revision is a common, yet not maximal ancestor.
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1217
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1218 // The principle of the algorithm is as follows:
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1219 // For a revision `r`, when entering the loop, `seen[r]` is either
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1220 // poisoned or the sub set of `revs` of which `r` is an ancestor.
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1221 // In this sub set is full, then `r` is a solution and its parents
83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1222 // have to be poisoned.
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1223 //
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1224 // At each iteration, the bit sets of the parents are updated by
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1225 // union with `seen[r]`.
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1226 // As we walk the index from the end, we are sure we have encountered
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1227 // all children of `r` before `r`, hence we know that `seen[r]` is
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1228 // fully computed.
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1229 //
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1230 // On top of that there are several optimizations that make reading
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1231 // less obvious than the comment above:
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1232 // - The `interesting` counter allows to break early
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1233 // - The loop starts from `max(revs)`
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1234 // - Early return in case it is detected that one of the incoming revs
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1235 // is a common ancestor of all of them.
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1236 while current_rev.0 >= 0 && interesting > 0 {
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1237 let current_seen = seen[current_rev.0 as usize].clone();
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1238
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1239 if current_seen.is_empty() {
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1240 current_rev = Revision(current_rev.0 - 1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1241 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1242 }
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1243 let mut poison = current_seen.is_poisoned();
83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1244 if !poison {
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1245 interesting -= 1;
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1246 if current_seen.is_full_range(revcount) {
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1247 candidates.push(current_rev);
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1248 poison = true;
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1249
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1250 // Being a common ancestor, if `current_rev` is among
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1251 // the input revisions, it is the answer.
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1252 for rev in revs {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1253 if *rev == current_rev {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1254 return Ok(candidates);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1255 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1256 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1257 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1258 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1259 for parent in self.parents(current_rev)? {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1260 if parent == NULL_REVISION {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1261 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1262 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1263 let parent_seen = &mut seen[parent.0 as usize];
51224 e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1264 if poison {
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1265 // this block is logically equivalent to poisoning parent
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1266 // and counting it as non interesting if it
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1267 // has been seen before (hence counted then as interesting)
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1268 if !parent_seen.is_empty() && !parent_seen.is_poisoned() {
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1269 interesting -= 1;
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1270 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1271 parent_seen.poison();
51224 e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1272 } else {
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1273 if parent_seen.is_empty() {
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1274 interesting += 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1275 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1276 parent_seen.union(&current_seen);
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1277 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1278 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1279
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1280 current_rev = Revision(current_rev.0 - 1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1281 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1282
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1283 Ok(candidates)
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1284 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1285
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1286 /// Given a disjoint set of revs, return the subset with the longest path
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1287 /// to the root.
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1288 fn find_deepest_revs(
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1289 &self,
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1290 revs: &[Revision],
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1291 ) -> Result<Vec<Revision>, GraphError> {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1292 // TODO replace this all with just comparing rank?
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1293 // Also, the original implementations in C/Python are cryptic, not
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1294 // even sure we actually need this?
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1295 if revs.len() <= 1 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1296 return Ok(revs.to_owned());
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1297 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1298 let max_rev = revs.iter().max().unwrap().0;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1299 let mut interesting = HashMap::new();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1300 let mut seen = vec![0; max_rev as usize + 1];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1301 let mut depth = vec![0; max_rev as usize + 1];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1302 let mut mapping = vec![];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1303 let mut revs = revs.to_owned();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1304 revs.sort_unstable();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1305
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1306 for (idx, rev) in revs.iter().enumerate() {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1307 depth[rev.0 as usize] = 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1308 let shift = 1 << idx;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1309 seen[rev.0 as usize] = shift;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1310 interesting.insert(shift, 1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1311 mapping.push((shift, *rev));
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1312 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1313
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1314 let mut current_rev = Revision(max_rev);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1315 while current_rev.0 >= 0 && interesting.len() > 1 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1316 let current_depth = depth[current_rev.0 as usize];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1317 if current_depth == 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1318 current_rev = Revision(current_rev.0 - 1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1319 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1320 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1321
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1322 let current_seen = seen[current_rev.0 as usize];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1323 for parent in self.parents(current_rev)? {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1324 if parent == NULL_REVISION {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1325 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1326 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1327 let parent_seen = seen[parent.0 as usize];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1328 let parent_depth = depth[parent.0 as usize];
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1329 if parent_depth <= current_depth {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1330 depth[parent.0 as usize] = current_depth + 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1331 if parent_seen != current_seen {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1332 *interesting.get_mut(&current_seen).unwrap() += 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1333 seen[parent.0 as usize] = current_seen;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1334 if parent_seen != 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1335 let parent_interesting =
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1336 interesting.get_mut(&parent_seen).unwrap();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1337 *parent_interesting -= 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1338 if *parent_interesting == 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1339 interesting.remove(&parent_seen);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1340 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1341 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1342 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1343 } else if current_depth == parent_depth - 1 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1344 let either_seen = parent_seen \| current_seen;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1345 if either_seen == parent_seen {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1346 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1347 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1348 seen[parent.0 as usize] = either_seen;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1349 interesting
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1350 .entry(either_seen)
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1351 .and_modify(\|v\| *v += 1)
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1352 .or_insert(1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1353 *interesting.get_mut(&parent_seen).unwrap() -= 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1354 if interesting[&parent_seen] == 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1355 interesting.remove(&parent_seen);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1356 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1357 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1358 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1359 *interesting.get_mut(&current_seen).unwrap() -= 1;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1360 if interesting[&current_seen] == 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1361 interesting.remove(&current_seen);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1362 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1363
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1364 current_rev = Revision(current_rev.0 - 1);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1365 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1366
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1367 if interesting.len() != 1 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1368 return Ok(vec![]);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1369 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1370 let mask = interesting.keys().next().unwrap();
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1371
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1372 Ok(mapping
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1373 .into_iter()
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1374 .filter_map(\|(shift, rev)\| {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1375 if (mask & shift) != 0 {
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1376 return Some(rev);
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1377 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1378 None
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1379 })
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1380 .collect())
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1381 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1382 }
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1383
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1384 /// The kind of functionality needed by find_gca_candidates
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1385 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1386 /// This is a bit mask which can be declared to be "poisoned", which callers
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1387 /// interpret to break out of some loops.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1388 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1389 /// The maximum capacity of the bit mask is up to the actual implementation
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1390 trait PoisonableBitSet: Sized + PartialEq {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1391 /// Return a vector of exactly n elements, initialized to be empty.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1392 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1393 /// Optimization can vastly depend on implementation. Those being `Copy`
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1394 /// and having constant capacity typically can have a very simple
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1395 /// implementation.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1396 fn vec_of_empty(sets_size: usize, vec_len: usize) -> Vec<Self>;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1397
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1398 /// The size of the bit mask in memory
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1399 #[allow(unused)]
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1400 fn size(&self) -> usize;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1401
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1402 /// The number of elements that can be represented in the set.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1403 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1404 /// Another way to put it is that it is the highest integer `C` such that
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1405 /// the set is guaranteed to always be a subset of the integer range
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1406 /// `[0, C)`
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1407 #[allow(unused)]
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1408 fn capacity(&self) -> usize;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1409
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1410 /// Declare `n` to belong to the set
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1411 fn add(&mut self, n: usize);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1412
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1413 /// Declare `n` not to belong to the set
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1414 #[allow(unused)]
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1415 fn discard(&mut self, n: usize);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1416
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1417 /// Replace this bit set by its union with other
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1418 fn union(&mut self, other: &Self);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1419
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1420 /// Poison the bit set
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1421 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1422 /// Interpretation up to the caller
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1423 fn poison(&mut self);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1424
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1425 /// Is the bit set poisoned?
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1426 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1427 /// Interpretation is up to the caller
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1428 fn is_poisoned(&self) -> bool;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1429
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1430 /// Is the bit set empty?
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1431 fn is_empty(&self) -> bool;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1432
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1433 /// return `true` if and only if the bit is the full range `[0, n)`
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1434 /// of integers
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1435 fn is_full_range(&self, n: usize) -> bool;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1436 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1437
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1438 const U64_POISON: u64 = 1 << 63;
51226 1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1439 const U8_POISON: u8 = 1 << 7;
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1440
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1441 impl PoisonableBitSet for u64 {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1442 fn vec_of_empty(_sets_size: usize, vec_len: usize) -> Vec<Self> {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1443 vec![0u64; vec_len]
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1444 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1445
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1446 fn size(&self) -> usize {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1447 8
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1448 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1449
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1450 fn capacity(&self) -> usize {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1451 63
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1452 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1453
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1454 fn add(&mut self, n: usize) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1455 (*self) \|= 1u64 << n;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1456 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1457
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1458 fn discard(&mut self, n: usize) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1459 (*self) &= u64::MAX - (1u64 << n);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1460 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1461
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1462 fn union(&mut self, other: &Self) {
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1463 if self != other {
61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1464 (self) \|= other;
61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1465 }
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1466 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1467
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1468 fn is_full_range(&self, n: usize) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1469 *self + 1 == (1u64 << n)
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1470 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1471
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1472 fn is_empty(&self) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1473 *self == 0
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1474 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1475
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1476 fn poison(&mut self) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1477 *self = U64_POISON;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1478 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1479
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1480 fn is_poisoned(&self) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1481 // equality comparison would be tempting but would not resist
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1482 // operations after poisoning (even if these should be bogus).
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1483 *self >= U64_POISON
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1484 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1485 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1486
51226 1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1487 impl PoisonableBitSet for u8 {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1488 fn vec_of_empty(_sets_size: usize, vec_len: usize) -> Vec<Self> {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1489 vec![0; vec_len]
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1490 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1491
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1492 fn size(&self) -> usize {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1493 1
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1494 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1495
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1496 fn capacity(&self) -> usize {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1497 7
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1498 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1499
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1500 fn add(&mut self, n: usize) {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1501 (*self) \|= 1 << n;
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1502 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1503
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1504 fn discard(&mut self, n: usize) {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1505 (*self) &= u8::MAX - (1 << n);
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1506 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1507
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1508 fn union(&mut self, other: &Self) {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1509 if self != other {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1510 (self) \|= other;
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1511 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1512 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1513
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1514 fn is_full_range(&self, n: usize) -> bool {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1515 *self + 1 == (1 << n)
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1516 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1517
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1518 fn is_empty(&self) -> bool {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1519 *self == 0
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1520 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1521
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1522 fn poison(&mut self) {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1523 *self = U8_POISON;
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1524 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1525
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1526 fn is_poisoned(&self) -> bool {
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1527 // equality comparison would be tempting but would not resist
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1528 // operations after poisoning (even if these should be bogus).
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1529 *self >= U8_POISON
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1530 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1531 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1532
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1533 /// A poisonable bit set whose capacity is not known at compile time but
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1534 /// is constant after initial construction
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1535 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1536 /// This can be way further optimized if performance assessments (speed
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1537 /// and/or RAM) require it.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1538 /// As far as RAM is concerned, for large vectors of these, the main problem
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1539 /// would be the repetition of set_size in each item. We would need a trait
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1540 /// to abstract over the idea of a vector of such bit sets to do better.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1541 #[derive(Clone, PartialEq)]
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1542 struct NonStaticPoisonableBitSet {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1543 set_size: usize,
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1544 bit_set: Vec<u64>,
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1545 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1546
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1547 /// Number of `u64` needed for a [`NonStaticPoisonableBitSet`] of given size
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1548 fn non_static_poisonable_inner_len(set_size: usize) -> usize {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1549 1 + (set_size + 1) / 64
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1550 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1551
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1552 impl NonStaticPoisonableBitSet {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1553 /// The index of the sub-bit set for the given n, and the index inside
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1554 /// the latter
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1555 fn index(&self, n: usize) -> (usize, usize) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1556 (n / 64, n % 64)
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1557 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1558 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1559
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1560 /// Mock implementation to ensure that the trait makes sense
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1561 impl PoisonableBitSet for NonStaticPoisonableBitSet {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1562 fn vec_of_empty(set_size: usize, vec_len: usize) -> Vec<Self> {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1563 let tmpl = Self {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1564 set_size,
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1565 bit_set: vec![0u64; non_static_poisonable_inner_len(set_size)],
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1566 };
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1567 vec![tmpl; vec_len]
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1568 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1569
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1570 fn size(&self) -> usize {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1571 8 + self.bit_set.len() * 8
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1572 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1573
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1574 fn capacity(&self) -> usize {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1575 self.set_size
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1576 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1577
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1578 fn add(&mut self, n: usize) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1579 let (sub_bs, bit_pos) = self.index(n);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1580 self.bit_set[sub_bs] \|= 1 << bit_pos
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1581 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1582
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1583 fn discard(&mut self, n: usize) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1584 let (sub_bs, bit_pos) = self.index(n);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1585 self.bit_set[sub_bs] \|= u64::MAX - (1 << bit_pos)
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1586 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1587
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1588 fn union(&mut self, other: &Self) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1589 assert!(
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1590 self.set_size == other.set_size,
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1591 "Binary operations on bit sets can only be done on same size"
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1592 );
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1593 for i in 0..self.bit_set.len() - 1 {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1594 self.bit_set[i] \|= other.bit_set[i]
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1595 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1596 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1597
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1598 fn is_full_range(&self, n: usize) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1599 let (sub_bs, bit_pos) = self.index(n);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1600 self.bit_set[..sub_bs].iter().all(\|bs\| *bs == u64::MAX)
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1601 && self.bit_set[sub_bs] == (1 << (bit_pos + 1)) - 1
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1602 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1603
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1604 fn is_empty(&self) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1605 self.bit_set.iter().all(\|bs\| *bs == 0u64)
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1606 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1607
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1608 fn poison(&mut self) {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1609 let (sub_bs, bit_pos) = self.index(self.set_size);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1610 self.bit_set[sub_bs] = 1 << bit_pos;
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1611 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1612
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1613 fn is_poisoned(&self) -> bool {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1614 let (sub_bs, bit_pos) = self.index(self.set_size);
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1615 self.bit_set[sub_bs] >= 1 << bit_pos
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1616 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1617 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1618
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1619 /// Set of roots of all non-public phases
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1620 pub type RootsPerPhase = [Vec<Revision>; Phase::non_public_phases().len()];
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1621
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1622 #[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1623 pub enum Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1624 Public = 0,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1625 Draft = 1,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1626 Secret = 2,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1627 Archived = 3,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1628 Internal = 4,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1629 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1630
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1631 impl TryFrom<usize> for Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1632 type Error = RevlogError;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1633
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1634 fn try_from(value: usize) -> Result<Self, Self::Error> {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1635 Ok(match value {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1636 0 => Self::Public,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1637 1 => Self::Draft,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1638 2 => Self::Secret,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1639 32 => Self::Archived,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1640 96 => Self::Internal,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1641 v => {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1642 return Err(RevlogError::corrupted(format!(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1643 "invalid phase value {}",
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1644 v
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1645 )))
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1646 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1647 })
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1648 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1649 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1650
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1651 impl Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1652 pub const fn all_phases() -> &'static [Self] {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1653 &[
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1654 Self::Public,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1655 Self::Draft,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1656 Self::Secret,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1657 Self::Archived,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1658 Self::Internal,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1659 ]
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1660 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1661 pub const fn non_public_phases() -> &'static [Self] {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1662 &[Self::Draft, Self::Secret, Self::Archived, Self::Internal]
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1663 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1664 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1665
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1666 fn inline_scan(bytes: &[u8]) -> (usize, Vec<usize>) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1667 let mut offset: usize = 0;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1668 let mut offsets = Vec::new();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1669
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1670 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1671 offsets.push(offset);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1672 let end = offset + INDEX_ENTRY_SIZE;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1673 let entry = IndexEntry {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1674 bytes: &bytes[offset..end],
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1675 };
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1676
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1677 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1678 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1679 (offset, offsets)
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1680 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1681
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1682 impl super::RevlogIndex for Index {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1683 fn len(&self) -> usize {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1684 self.len()
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1685 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1686
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1687 fn node(&self, rev: Revision) -> Option<&Node> {
51206 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	1688 if rev == NULL_REVISION {
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	1689 return Some(&NULL_NODE);
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	1690 }
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1691 self.get_entry(rev).map(\|entry\| entry.hash())
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1692 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1693 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1694
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1695 #[derive(Debug)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1696 pub struct IndexEntry<'a> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1697 bytes: &'a [u8],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1698 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1699
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1700 impl<'a> IndexEntry<'a> {
45593 da30e4b553c3 hg-core: minor docstring update (D8958#inline-14991 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45592 diff changeset	1701 /// Return the offset of the data.
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1702 pub fn offset(&self) -> usize {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1703 let mut bytes = [0; 8];
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1704 bytes[2..8].copy_from_slice(&self.bytes[0..=5]);
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1705 BigEndian::read_u64(&bytes[..]) as usize
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1706 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1707 pub fn raw_offset(&self) -> u64 {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1708 BigEndian::read_u64(&self.bytes[0..8])
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1709 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1710
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1711 /// Same result (except potentially for rev 0) as C `index_get_start()`
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1712 fn c_start(&self) -> u64 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1713 self.raw_offset() >> 16
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1714 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1715
48546 e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1716 pub fn flags(&self) -> u16 {
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1717 BigEndian::read_u16(&self.bytes[6..=7])
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1718 }
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1719
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1720 /// Return the compressed length of the data.
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1721 pub fn compressed_len(&self) -> u32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1722 BigEndian::read_u32(&self.bytes[8..=11])
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1723 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1724
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1725 /// Return the uncompressed length of the data.
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1726 pub fn uncompressed_len(&self) -> i32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1727 BigEndian::read_i32(&self.bytes[12..=15])
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1728 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1729
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1730 /// Return the revision upon which the data has been derived.
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1731 pub fn base_revision_or_base_of_delta_chain(&self) -> UncheckedRevision {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1732 // TODO Maybe return an Option when base_revision == rev?
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1733 // Requires to add rev to IndexEntry
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1734
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1735 BigEndian::read_i32(&self.bytes[16..]).into()
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1736 }
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1737
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1738 pub fn link_revision(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1739 BigEndian::read_i32(&self.bytes[20..]).into()
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1740 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1741
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1742 pub fn p1(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1743 BigEndian::read_i32(&self.bytes[24..]).into()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1744 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1745
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1746 pub fn p2(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1747 BigEndian::read_i32(&self.bytes[28..]).into()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1748 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1749
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1750 /// Return the hash of revision's full text.
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1751 ///
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1752 /// Currently, SHA-1 is used and only the first 20 bytes of this field
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1753 /// are used.
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1754 pub fn hash(&self) -> &'a Node {
46033 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45602 diff changeset	1755 (&self.bytes[32..52]).try_into().unwrap()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1756 }
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	1757
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	1758 pub fn as_bytes(&self) -> &'a [u8] {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	1759 self.bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	1760 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1761 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1762
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1763 #[cfg(test)]
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1764 pub use tests::IndexEntryBuilder;
ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1765
ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1766 #[cfg(test)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1767 mod tests {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1768 use super::*;
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1769 use crate::node::NULL_NODE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1770
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1771 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1772 #[derive(Debug, Copy, Clone)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1773 pub struct IndexEntryBuilder {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1774 is_first: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1775 is_inline: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1776 is_general_delta: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1777 version: u16,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1778 offset: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1779 compressed_len: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1780 uncompressed_len: usize,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1781 base_revision_or_base_of_delta_chain: Revision,
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1782 link_revision: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1783 p1: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1784 p2: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1785 node: Node,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1786 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1787
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1788 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1789 impl IndexEntryBuilder {
49926 0780371d6b1e rust-clippy: tell `clippy` we don't need to declare a default here Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	1790 #[allow(clippy::new_without_default)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1791 pub fn new() -> Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1792 Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1793 is_first: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1794 is_inline: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1795 is_general_delta: true,
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	1796 version: 1,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1797 offset: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1798 compressed_len: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1799 uncompressed_len: 0,
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1800 base_revision_or_base_of_delta_chain: Revision(0),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1801 link_revision: Revision(0),
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1802 p1: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1803 p2: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1804 node: NULL_NODE,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1805 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1806 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1807
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1808 pub fn is_first(&mut self, value: bool) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1809 self.is_first = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1810 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1811 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1812
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1813 pub fn with_inline(&mut self, value: bool) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1814 self.is_inline = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1815 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1816 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1817
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1818 pub fn with_general_delta(&mut self, value: bool) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1819 self.is_general_delta = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1820 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1821 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1822
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1823 pub fn with_version(&mut self, value: u16) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1824 self.version = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1825 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1826 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1827
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1828 pub fn with_offset(&mut self, value: usize) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1829 self.offset = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1830 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1831 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1832
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1833 pub fn with_compressed_len(&mut self, value: usize) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1834 self.compressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1835 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1836 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1837
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1838 pub fn with_uncompressed_len(&mut self, value: usize) -> &mut Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1839 self.uncompressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1840 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1841 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1842
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1843 pub fn with_base_revision_or_base_of_delta_chain(
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1844 &mut self,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1845 value: Revision,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1846 ) -> &mut Self {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1847 self.base_revision_or_base_of_delta_chain = value;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1848 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1849 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1850
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1851 pub fn with_link_revision(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1852 self.link_revision = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1853 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1854 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1855
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1856 pub fn with_p1(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1857 self.p1 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1858 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1859 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1860
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1861 pub fn with_p2(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1862 self.p2 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1863 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1864 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1865
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1866 pub fn with_node(&mut self, value: Node) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1867 self.node = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1868 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1869 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1870
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1871 pub fn build(&self) -> Vec<u8> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1872 let mut bytes = Vec::with_capacity(INDEX_ENTRY_SIZE);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1873 if self.is_first {
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1874 bytes.extend(match (self.is_general_delta, self.is_inline) {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1875 (false, false) => [0u8, 0],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1876 (false, true) => [0u8, 1],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1877 (true, false) => [0u8, 2],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1878 (true, true) => [0u8, 3],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1879 });
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1880 bytes.extend(self.version.to_be_bytes());
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1881 // Remaining offset bytes.
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1882 bytes.extend([0u8; 2]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1883 } else {
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	1884 // Offset stored on 48 bits (6 bytes)
6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	1885 bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1886 }
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1887 bytes.extend([0u8; 2]); // Revision flags.
c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1888 bytes.extend((self.compressed_len as u32).to_be_bytes());
c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1889 bytes.extend((self.uncompressed_len as u32).to_be_bytes());
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1890 bytes.extend(
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1891 self.base_revision_or_base_of_delta_chain.0.to_be_bytes(),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1892 );
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1893 bytes.extend(self.link_revision.0.to_be_bytes());
c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1894 bytes.extend(self.p1.0.to_be_bytes());
c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1895 bytes.extend(self.p2.0.to_be_bytes());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1896 bytes.extend(self.node.as_bytes());
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1897 bytes.extend(vec![0u8; 12]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1898 bytes
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1899 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1900 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1901
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1902 pub fn is_inline(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1903 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1904 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	1905 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1906 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1907 .is_inline()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1908 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1909
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1910 pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1911 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1912 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	1913 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1914 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1915 .uses_generaldelta()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1916 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1917
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1918 pub fn get_version(index_bytes: &[u8]) -> u16 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1919 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1920 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	1921 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1922 .format_version()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1923 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1924
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1925 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1926 fn flags_when_no_inline_flag_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1927 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1928 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1929 .with_general_delta(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1930 .with_inline(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1931 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1932
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1933 assert!(!is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1934 assert!(!uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1935 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1936
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1937 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1938 fn flags_when_inline_flag_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1939 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1940 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1941 .with_general_delta(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1942 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1943 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1944
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1945 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1946 assert!(!uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1947 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1948
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1949 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1950 fn flags_when_inline_and_generaldelta_flags_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1951 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1952 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1953 .with_general_delta(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1954 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1955 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1956
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1957 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1958 assert!(uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1959 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1960
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1961 #[test]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1962 fn test_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1963 let bytes = IndexEntryBuilder::new().with_offset(1).build();
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1964 let entry = IndexEntry { bytes: &bytes };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1965
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1966 assert_eq!(entry.offset(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1967 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1968
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1969 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1970 fn test_compressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1971 let bytes = IndexEntryBuilder::new().with_compressed_len(1).build();
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1972 let entry = IndexEntry { bytes: &bytes };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1973
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1974 assert_eq!(entry.compressed_len(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1975 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1976
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1977 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1978 fn test_uncompressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1979 let bytes = IndexEntryBuilder::new().with_uncompressed_len(1).build();
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1980 let entry = IndexEntry { bytes: &bytes };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1981
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1982 assert_eq!(entry.uncompressed_len(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1983 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1984
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1985 #[test]
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1986 fn test_base_revision_or_base_of_delta_chain() {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1987 let bytes = IndexEntryBuilder::new()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1988 .with_base_revision_or_base_of_delta_chain(Revision(1))
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1989 .build();
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1990 let entry = IndexEntry { bytes: &bytes };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1991
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1992 assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1.into())
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1993 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1994
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1995 #[test]
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1996 fn link_revision_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1997 let bytes = IndexEntryBuilder::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1998 .with_link_revision(Revision(123))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1999 .build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2000
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2001 let entry = IndexEntry { bytes: &bytes };
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2002
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2003 assert_eq!(entry.link_revision(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2004 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2005
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2006 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2007 fn p1_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2008 let bytes = IndexEntryBuilder::new().with_p1(Revision(123)).build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2009
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2010 let entry = IndexEntry { bytes: &bytes };
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2011
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2012 assert_eq!(entry.p1(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2013 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2014
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2015 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2016 fn p2_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2017 let bytes = IndexEntryBuilder::new().with_p2(Revision(123)).build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2018
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2019 let entry = IndexEntry { bytes: &bytes };
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2020
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2021 assert_eq!(entry.p2(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2022 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2023
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2024 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2025 fn node_test() {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2026 let node = Node::from_hex("0123456789012345678901234567890123456789")
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2027 .unwrap();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2028 let bytes = IndexEntryBuilder::new().with_node(node).build();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2029
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2030 let entry = IndexEntry { bytes: &bytes };
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2031
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2032 assert_eq!(*entry.hash(), node);
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2033 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2034
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2035 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2036 fn version_test() {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2037 let bytes = IndexEntryBuilder::new()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2038 .is_first(true)
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	2039 .with_version(2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2040 .build();
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2041
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	2042 assert_eq!(get_version(&bytes), 2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2043 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2044 }

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/revlog/index.rs @ 52050:ea0467ed76aa