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

annotate rust/hg-core/src/revlog/index.rs @ 52760:94e2547e6f3d

rust: move code from utils to utils::strings This moves string-related functions in hg::utils into the recently added hg::utils::strings module.

author	Mitchell Kember <mkember@janestreet.com>
date	Thu, 16 Jan 2025 13:15:02 -0500
parents	393ad2685fb4
children	8de68446a5bd

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
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	10 use super::{NodePrefix, RevlogError, RevlogIndex, 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;
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	12 use crate::revlog::node::{
bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	13 Node, NODE_BYTES_LENGTH, NULL_NODE, STORED_NODE_ID_BYTES,
bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	14 };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	15 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	16 use crate::{
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	17 dagops, BaseRevision, FastHashMap, Graph, GraphError, 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
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	65 pub fn parse(index_bytes: &[u8]) -> Result<IndexHeader, HgError> {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	66 if index_bytes.len() < 4 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	67 return Err(HgError::corrupted(
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	68 "corrupted revlog: can't read the index format header",
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	69 ));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	70 }
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	71 Ok(IndexHeader {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	72 header_bytes: {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	73 let bytes: [u8; 4] =
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	74 index_bytes[0..4].try_into().expect("impossible");
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	75 bytes
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	76 },
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	77 })
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	78 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	79 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	80
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	81 /// 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	82 /// 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	83 /// 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	84 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	85 /// 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	86 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	87 /// 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	88 /// 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	89 /// `bytes` field.
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	90 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	91 /// 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	92 added: Vec<u8>,
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	93 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	94 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	95
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	96 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	97 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	98 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	99 if bytes.len() >= INDEX_ENTRY_SIZE {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	100 first_entry[INDEX_HEADER_SIZE..]
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	101 .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	102 }
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	103 Self {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	104 bytes,
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	105 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	106 added: vec![],
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	107 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	108 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	109 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	110
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	111 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	112 match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	113 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	114 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	115 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	116 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	117
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	118 fn remove(
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	119 &mut self,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	120 rev: Revision,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	121 offsets: Option<&[usize]>,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	122 ) -> Result<(), RevlogError> {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	123 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	124 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	125 offsets[rev]
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	126 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	127 rev * INDEX_ENTRY_SIZE
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	128 };
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	129 if truncation < self.bytes.len() {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	130 self.truncation = Some(truncation);
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	131 self.added.clear();
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	132 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	133 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	134 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	135 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	136 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	137
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	138 fn is_new(&self) -> bool {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	139 self.bytes.is_empty()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	140 }
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	141 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	142
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	143 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	144 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	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 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	147 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	148 let end = index.end;
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	149 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	150 Some(truncation) => truncation,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	151 None => self.bytes.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	152 };
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	153 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	154 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	155 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	156 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	157 &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	158 } else {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	159 &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	160 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	161 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	162 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	163
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	164 #[derive(Debug, PartialEq, Eq)]
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	165 pub struct RevisionDataParams {
51189 65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	166 pub flags: u16,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	167 pub data_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	168 pub data_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	169 pub data_uncompressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	170 pub data_delta_base: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	171 pub link_rev: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	172 pub parent_rev_1: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	173 pub parent_rev_2: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	174 pub node_id: [u8; NODE_BYTES_LENGTH],
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	175 pub _sidedata_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	176 pub _sidedata_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	177 pub data_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	178 pub _sidedata_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	179 pub _rank: i32,
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	180 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	181
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	182 impl Default for RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	183 fn default() -> Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	184 Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	185 flags: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	186 data_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	187 data_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	188 data_uncompressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	189 data_delta_base: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	190 link_rev: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	191 parent_rev_1: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	192 parent_rev_2: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	193 node_id: [0; NODE_BYTES_LENGTH],
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	194 _sidedata_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	195 _sidedata_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	196 data_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	197 _sidedata_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	198 _rank: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	199 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	200 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	201 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	202
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	203 #[derive(BytesCast)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	204 #[repr(C)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	205 pub struct RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	206 data_offset_or_flags: unaligned::U64Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	207 data_compressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	208 data_uncompressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	209 data_delta_base: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	210 link_rev: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	211 parent_rev_1: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	212 parent_rev_2: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	213 node_id: [u8; STORED_NODE_ID_BYTES],
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	214 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	215
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	216 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	217 let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;
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
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	220 impl RevisionDataParams {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	221 pub fn validate(&self) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	222 if self.flags & !REVIDX_KNOWN_FLAGS != 0 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	223 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	224 "unknown revlog index flags: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	225 self.flags
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	226 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	227 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	228 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	229 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	230 "invalid data compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	231 self.data_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	232 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	233 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	234 // 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	235 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	236 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	237 "invalid sidedata compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	238 self._sidedata_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	239 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	240 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	241 Ok(())
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 pub fn into_v1(self) -> RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	245 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	246 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	247 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	248 RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	249 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	250 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	251 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	252 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	253 link_rev: self.link_rev.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	254 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	255 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	256 node_id,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	257 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	258 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	259 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	260
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	261 /// 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	262 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	263 bytes: IndexData,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	264 /// 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	265 /// 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	266 offsets: RwLock<Option<Vec<usize>>>,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	267 uses_generaldelta: bool,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	268 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	269 /// 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	270 ///
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	271 /// 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	272 /// 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	273 /// 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	274 /// we haven't changed filters when returning the cached `head_revs`.
52160 e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	275 pub(super) 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	276 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	277
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	278 impl Debug for Index {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	279 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	280 f.debug_struct("Index")
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	281 .field("offsets", &self.offsets)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	282 .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	283 .finish()
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	284 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	285 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	286
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	287 impl Graph for Index {
51254 e74dd6d73cb5 rust-index: allow inlining `parents` across crates Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	288 #[inline(always)]
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	289 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	290 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	291 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	292 Some(entry) => {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	293 // 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	294 // before returning
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	295 Ok([
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	296 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	297 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	298 ])
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	299 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	300 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	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 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	304
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	305 /// 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	306 ///
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	307 /// 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	308 /// values sets of [`BaseRevision`]
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 /// 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	311 /// we would probably need to sprinkle some magic here, such as an associated
52306 a876ab6c3fd5 rust: fix `cargo doc` warnings Rapha?l Gom?s <rgomes@octobus.net> parents: 52290 diff changeset	312 /// type that would be `Into<RevlogError>` but even that would not be
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	313 /// 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	314 pub trait SnapshotsCache {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	315 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	316 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	317 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	318 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	319 ) -> Result<(), RevlogError>;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	320 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	321
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	322 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	323 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	324 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	325 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	326 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	327 ) -> Result<(), RevlogError> {
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	328 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	329 all_values.insert(value);
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	330 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	331 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	332 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	333
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	334 impl Index {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	335 /// Create an index from bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	336 /// 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	337 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	338 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	339 default_header: IndexHeader,
47963 001d747c2baf rust: Return HgError instead of RevlogError in revlog constructors Simon Sapin <simon.sapin@octobus.net> parents: 46887 diff changeset	340 ) -> Result<Self, HgError> {
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	341 let header = if bytes.len() < INDEX_ENTRY_SIZE {
f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	342 default_header
f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	343 } else {
f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	344 IndexHeader::parse(bytes.as_ref())?
f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	345 };
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
52173 1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	420 /// Same as `rev_from_node`, without using a persistent nodemap
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	421 ///
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	422 /// This is used as fallback when a persistent nodemap is not present.
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	423 /// This happens when the persistent-nodemap experimental feature is not
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	424 /// enabled, or for small revlogs.
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	425 pub fn rev_from_node_no_persistent_nodemap(
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	426 &self,
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	427 node: NodePrefix,
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	428 ) -> Result<Revision, RevlogError> {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	429 // Linear scan of the revlog
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	430 // TODO: consider building a non-persistent nodemap in memory to
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	431 // optimize these cases.
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	432 let mut found_by_prefix = None;
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	433 for rev in (-1..self.len() as BaseRevision).rev() {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	434 let rev = Revision(rev as BaseRevision);
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	435 let candidate_node = if rev == Revision(-1) {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	436 NULL_NODE
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	437 } else {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	438 let index_entry = self.get_entry(rev).ok_or_else(\|\| {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	439 HgError::corrupted(
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	440 "revlog references a revision not in the index",
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	441 )
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	442 })?;
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	443 *index_entry.hash()
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	444 };
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	445 if node == candidate_node {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	446 return Ok(rev);
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	447 }
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	448 if node.is_prefix_of(&candidate_node) {
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	449 if found_by_prefix.is_some() {
52343 393ad2685fb4 rust: make RevlogError AmbiguousPrefix case contain the actual prefix Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 52306 diff changeset	450 return Err(RevlogError::AmbiguousPrefix(format!(
393ad2685fb4 rust: make RevlogError AmbiguousPrefix case contain the actual prefix Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 52306 diff changeset	451 "{:x}",
393ad2685fb4 rust: make RevlogError AmbiguousPrefix case contain the actual prefix Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 52306 diff changeset	452 node
393ad2685fb4 rust: make RevlogError AmbiguousPrefix case contain the actual prefix Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 52306 diff changeset	453 )));
52173 1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	454 }
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	455 found_by_prefix = Some(rev)
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	456 }
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	457 }
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	458 found_by_prefix
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	459 .ok_or_else(\|\| RevlogError::InvalidRevision(format!("{:x}", node)))
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	460 }
1da6995835b4 rust-revlog: move non-persistent-nodemap rev lookup to the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52161 diff changeset	461
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	462 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	463 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	464 {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	465 // 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	466 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	467 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	468 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	469 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	470 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	471 self.offsets.read().unwrap()
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	472 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	473
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	474 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	475 assert!(self.is_inline());
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	476 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	477 if offsets.is_none() {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	478 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	479 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	480 offsets
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	481 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	482
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	483 /// 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	484 pub fn is_empty(&self) -> bool {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	485 self.len() == 0
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	486 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	487
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	488 /// 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	489 /// 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	490 ///
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	491 /// 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	492 /// 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	493 #[inline(always)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	494 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	495 if rev == NULL_REVISION {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	496 return None;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	497 }
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	498 if rev.0 == 0 {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	499 Some(IndexEntry {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	500 bytes: &self.bytes.first_entry[..],
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	501 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	502 } else {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	503 Some(if self.is_inline() {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	504 self.get_entry_inline(rev)
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	505 } else {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	506 self.get_entry_separated(rev)
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	507 })
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	508 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	509 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	510
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	511 /// 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	512 ///
52290 a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	513 /// See [`Self::get_entry`] for cases when `None` is returned.
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	514 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	515 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	516 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	517 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	518 &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	519 } 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	520 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	521 }
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	522 })
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	523 }
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	524
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	525 pub fn entry_as_params(
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	526 &self,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	527 rev: UncheckedRevision,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	528 ) -> Option<RevisionDataParams> {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	529 let rev = self.check_revision(rev)?;
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	530 self.get_entry(rev).map(\|e\| RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	531 flags: e.flags(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	532 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	533 e.flags() as u64
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	534 } else {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	535 e.raw_offset()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	536 },
51233 eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	537 data_compressed_length: e
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	538 .compressed_len()
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	539 .try_into()
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	540 .unwrap_or_else(\|_\| {
52290 a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	541 // Python's `unionrepo` sets the compressed length to
a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	542 // be `-1` (or `u32::MAX` if
a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	543 // transmuted to `u32`) because it
51233 eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	544 // cannot know the correct compressed length of a given
52290 a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	545 // revision. I'm not sure if this is true, but having
a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	546 // this edge case won't hurt
a3fa37bdb7ec rust: normalize `_for_unchecked_rev` naming among revlogs and the index Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 diff changeset	547 // other use cases, let's handle it.
51233 eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	548 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	549 NULL_REVISION.0
eb676c35a29b rust-index: support `unionrepo`'s compressed length hack Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	550 }),
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	551 data_uncompressed_length: e.uncompressed_len(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	552 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	553 link_rev: e.link_revision().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	554 parent_rev_1: e.p1().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	555 parent_rev_2: e.p2().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	556 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	557 ..Default::default()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	558 })
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	559 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	560
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	561 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	562 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	563 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	564 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	565 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	566 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	567
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	568 IndexEntry { bytes }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	569 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	570
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	571 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	572 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	573 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	574 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	575
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	576 IndexEntry { bytes }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	577 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	578
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	579 fn null_entry(&self) -> IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	580 IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	581 bytes: &[0; INDEX_ENTRY_SIZE],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	582 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	583 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	584
51212 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	585 /// 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	586 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	587 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	588 .map(\|h\| h.unwrap())
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	589 }
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	590
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	591 /// 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	592 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	593 &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	594 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	595 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	596 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	597 ) -> 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	598 {
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	599 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	600 .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	601 .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	602 .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	603 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	604 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	605 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	606 && 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	607 && 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	608 {
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	609 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	610 // 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	611 // 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	612 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	613 } 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	614 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	615 }
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	616 }
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	617 }
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	618
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 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	620 (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	621 } 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	622 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	623 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	624 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	625 };
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	626 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	627 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	628 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	629 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	630 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	631 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	632 )?;
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	633 (
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	634 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	635 .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	636 .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	637 .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	638 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	639 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	640 } 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	641 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	642 }
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	643 })
609700e5d8df head-revs: add a native implementation of the `stop_rev` parameter Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51974 diff changeset	644 .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	645 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	646 )
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	647 };
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	648 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	649 *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	650 .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	651 .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	652 .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	653 (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	654 }
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	655 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	656 }
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	657
51258 9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	658 /// 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	659 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	660 &self,
9088c6d65ef6 rust-index-cpython: cache the heads' PyList representation Rapha?l Gom?s <rgomes@octobus.net> parents: 51257 diff changeset	661 ) -> 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	662 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	663 }
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	664
51394 b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	665 /// 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	666 /// In revset language, we compute:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	667 /// - `heads(:begin)-heads(:end)`
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	668 /// - `heads(:end)-heads(:begin)`
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	669 pub fn head_revs_diff(
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	670 &self,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	671 begin: Revision,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	672 end: Revision,
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	673 ) -> Result<(Vec<Revision>, Vec<Revision>), GraphError> {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	674 let mut heads_added = vec![];
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	675 let mut heads_removed = vec![];
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	676
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	677 let mut acc = HashSet::new();
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	678 let Revision(begin) = begin;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	679 let Revision(end) = end;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	680 let mut i = end;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	681
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	682 while i > begin {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	683 // acc invariant:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	684 // `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	685 // among `i+1..end` (inclusive)
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	686 if !acc.remove(&i) {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	687 heads_added.push(Revision(i));
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	688 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	689 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	690 acc.insert(parent);
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	691 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	692 i -= 1;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	693 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	694
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	695 // 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	696 // 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	697 // revisions are the removed heads.
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	698 while !acc.is_empty() {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	699 // acc invariant:
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	700 // `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	701 // 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	702
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	703 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	704 if acc.remove(&i) {
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	705 heads_removed.push(Revision(i));
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	706 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	707 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	708 acc.remove(&parent);
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	709 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	710 i -= 1;
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	711 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	712
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	713 Ok((heads_removed, heads_added))
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	714 }
b01e7d97e167 revlog: add a Rust implementation of `headrevsdiff` Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51269 diff changeset	715
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	716 /// 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	717 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	718 /// `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	719 /// 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	720 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	721 /// 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	722 /// 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	723 /// `stoprev` was hit.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	724 pub fn delta_chain(
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	725 &self,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	726 rev: Revision,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	727 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	728 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	729 ) -> 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	730 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	731 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	732 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	733 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	734 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	735 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	736 && 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	737 {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	738 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	739 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	740 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	741 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	742 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	743 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	744 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	745 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	746 })?;
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	747 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	748 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	749 }
51210 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	750 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	751 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	752
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	753 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	754 true
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	755 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	756 chain.push(current_rev);
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	757 false
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	758 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	759 chain.reverse();
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	760 Ok((chain, stopped))
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	761 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	762
51209 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	763 pub fn find_snapshots(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	764 &self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	765 start_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	766 end_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	767 cache: &mut impl SnapshotsCache,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	768 ) -> Result<(), RevlogError> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	769 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	770 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	771 end_rev += 1;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	772 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	773 if end_rev > len {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	774 end_rev = len;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	775 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	776 if start_rev < 0 {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	777 start_rev = 0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	778 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	779 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	780 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	781 continue;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	782 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	783 let mut base = self
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	784 .get_entry(Revision(rev))
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	785 .unwrap()
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	786 .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	787 if base.0 == rev {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	788 base = NULL_REVISION.into();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	789 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	790 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	791 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	792 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	793 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51208 diff changeset	794
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	795 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	796 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	797 .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	798 .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	799 .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	800 .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	801 }
59183a19954e rust-index: use interior mutability in head revs and caches Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51230 diff changeset	802
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	803 /// 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	804 pub fn append(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	805 &mut self,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	806 revision_data: RevisionDataParams,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	807 ) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	808 revision_data.validate()?;
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	809 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	810 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	811 if self.bytes.len() == 0 {
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	812 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	813 &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	814 )
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	815 }
51261 47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	816 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	817 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	818 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	819 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	820 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	821 }
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	822 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	823 self.clear_head_revs();
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	824 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	825 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	826
51195 51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	827 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	828 header.to_be_bytes()
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	829 }
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	830
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	831 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	832 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	833 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	834 } else {
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	835 None
47a34afda7ad rust-index: only access offsets if revlog is inline Rapha?l Gom?s <rgomes@octobus.net> parents: 51258 diff changeset	836 };
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	837 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	838 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	839 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	840 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	841 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	842 }
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	843 self.clear_head_revs();
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	844 Ok(())
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	845 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	846
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	847 pub fn clear_caches(&self) {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	848 // 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	849 // 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	850 // 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	851 *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	852 .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	853 .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	854 .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	855 self.clear_head_revs();
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	856 }
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	857
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	858 /// Unchecked version of `is_snapshot`.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	859 /// 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	860 pub fn is_snapshot_unchecked(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	861 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	862 mut rev: Revision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	863 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	864 while rev.0 >= 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	865 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	866 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	867 if base == rev.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	868 base = NULL_REVISION.0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	869 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	870 if base == NULL_REVISION.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	871 return Ok(true);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	872 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	873 let [mut p1, mut p2] = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	874 .parents(rev)
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	875 .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	876 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	877 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	878 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	879 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	880 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	881 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	882 if parent_base.0 == p1.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	883 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	884 }
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	885 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	886 RevlogError::InvalidRevision(parent_base.to_string()),
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	887 )?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	888 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	889 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	890 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	891 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	892 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	893 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	894 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	895 if parent_base.0 == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	896 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	897 }
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	898 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	899 RevlogError::InvalidRevision(parent_base.to_string()),
652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	900 )?;
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	901 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	902 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	903 return Ok(false);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	904 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	905 rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	906 .check_revision(base.into())
52041 652149ed64f0 rust: improve `InvalidRevision` error message Rapha?l Gom?s <rgomes@octobus.net> parents: 51975 diff changeset	907 .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	908 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	909 Ok(rev == NULL_REVISION)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	910 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	911
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	912 /// 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	913 /// `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	914 pub fn is_snapshot(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	915 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	916 rev: UncheckedRevision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	917 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	918 let rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	919 .check_revision(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	920 .ok_or_else(\|\| RevlogError::corrupted("test"))?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	921 self.is_snapshot_unchecked(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	922 }
51215 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 /// 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	925 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	926 /// 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	927 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	928 /// 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	929 /// (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	930 /// 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	931 pub fn slice_chunk_to_density(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	932 &self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	933 revs: &[Revision],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	934 target_density: f64,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	935 min_gap_size: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	936 ) -> Vec<Vec<Revision>> {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	937 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	938 return vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	939 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	940 if revs.len() == 1 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	941 return vec![revs.to_owned()];
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 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	944 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	945 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	946 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	947 let entries: Vec<_> = revs
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	948 .iter()
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	949 .map(\|r\| {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	950 (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	951 })
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	952 .collect();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	953
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	954 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	955 let chain_payload: u32 =
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	956 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	957 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	958 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	959 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	960 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	961 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	962
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	963 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	964 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	965 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	966
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	967 // 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	968 let mut gaps = Vec::new();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	969 let mut previous_end = None;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	970
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	971 for (i, (rev, entry)) in entries.iter().enumerate() {
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	972 let start = self.start(*rev, entry);
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	973 let length = entry.compressed_len();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	974
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	975 // 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	976 if length == 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	977 continue;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	978 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	979
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	980 if let Some(end) = previous_end {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	981 let gap_size = start - end;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	982 // 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	983 if gap_size > min_gap_size {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	984 gaps.push((gap_size, i));
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 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	987 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	988 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	989 if gaps.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	990 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	991 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	992 // 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	993 gaps.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	994
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	995 // 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	996 // the density is acceptable
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	997 let mut selected = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	998 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	999 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1000 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1001 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1002 selected.push(gap_id);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1003
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1004 // 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	1005 // by the heap
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1006 read_data -= gap_size;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1007 density = if read_data > 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1008 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	1009 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1010 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1011 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1012 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1013 break;
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 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1016 selected.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1017 selected.push(revs.len());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1018
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1019 // Cut the revs at collected indices
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1020 let mut previous_idx = 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1021 let mut chunks = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1022 for idx in selected {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1023 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	1024 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1025 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	1026 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1027 previous_idx = idx;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1028 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1029 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	1030 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1031 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	1032 }
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 chunks
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1035 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1036
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1037 /// 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	1038 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1039 /// 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	1040 /// the `revs` segment.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1041 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1042 /// panics:
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1043 /// - 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	1044 /// - 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	1045 /// `revs`.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1046 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	1047 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1048 return 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1049 }
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1050 let last_rev = revs[revs.len() - 1];
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1051 let last_entry = &self.get_entry(last_rev).unwrap();
52161 6f94dc3cf8cf rust-index: use `IndexEntry::offset` to compute read segments Rapha?l Gom?s <rgomes@octobus.net> parents: 52160 diff changeset	1052 let end = last_entry.offset() + last_entry.compressed_len() as usize;
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1053 let first_rev = revs.iter().find(\|r\| r.0 != NULL_REVISION.0).unwrap();
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1054 let first_entry = self.get_entry(*first_rev).unwrap();
52161 6f94dc3cf8cf rust-index: use `IndexEntry::offset` to compute read segments Rapha?l Gom?s <rgomes@octobus.net> parents: 52160 diff changeset	1055 let start = first_entry.offset();
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1056 end - start
51215 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1057 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1058
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1059 /// 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	1060 fn trim_chunk<'a>(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1061 &'a self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1062 revs: &'a [(Revision, IndexEntry)],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1063 start: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1064 mut end: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1065 ) -> &'a [(Revision, IndexEntry)] {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1066 // 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	1067 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	1068 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	1069 while end > 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1070 && end > start
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1071 && 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	1072 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1073 end -= 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1074 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1075 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1076 &revs[start..end]
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	1077 }
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1078
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1079 /// 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	1080 /// 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	1081 pub fn compute_phases_map_sets(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1082 &self,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1083 roots: HashMap<Phase, Vec<Revision>>,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1084 ) -> Result<(usize, RootsPerPhase), GraphError> {
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1085 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	1086 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	1087
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1088 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	1089 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	1090 let min_rev =
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1091 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	1092 if min_rev != NULL_REVISION
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1093 && (min_phase_rev == NULL_REVISION
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1094 \|\| min_rev < min_phase_rev)
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1095 {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1096 min_phase_rev = min_rev;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1097 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1098 } else {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1099 continue;
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 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1102 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	1103
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1104 if min_phase_rev == NULL_REVISION {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1105 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	1106 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1107
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1108 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	1109 let rev = Revision(rev);
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1110 let [p1, p2] = self.parents(rev)?;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1111
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1112 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	1113 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	1114 }
7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1115 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	1116 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	1117 }
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1118 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	1119 Phase::Public => continue,
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1120 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	1121 };
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1122 set.push(rev);
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1123 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1124
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1125 Ok((self.len(), phase_sets))
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1126 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1127
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1128 fn add_roots_get_min(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1129 &self,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1130 phase_roots: &[Revision],
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1131 phases: &mut [Phase],
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1132 phase: Phase,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1133 ) -> Revision {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1134 let mut min_rev = NULL_REVISION;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1135
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1136 for root in phase_roots {
51422 7c6d0b9dde37 rust-index: improve phase computation speed Rapha?l Gom?s <rgomes@octobus.net> parents: 51394 diff changeset	1137 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	1138 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	1139 min_rev = *root;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1140 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1141 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1142 min_rev
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1143 }
51219 fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1144
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1145 /// Return `(heads(::(<roots> and <roots>::<heads>)))`
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1146 /// 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	1147 ///
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1148 /// `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	1149 /// 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	1150 /// 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	1151 /// revision ([`i32::MAX`]).
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1152 pub fn reachable_roots(
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1153 &self,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1154 min_root: UncheckedRevision,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1155 mut heads: Vec<Revision>,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1156 roots: HashSet<UncheckedRevision>,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1157 include_path: bool,
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1158 ) -> Result<HashSet<Revision>, GraphError> {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1159 if roots.is_empty() {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1160 return Ok(HashSet::new());
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1161 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1162 let mut reachable = HashSet::new();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1163 let mut seen = HashMap::new();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1164
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1165 while let Some(rev) = heads.pop() {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1166 if roots.contains(&rev.into()) {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1167 reachable.insert(rev);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1168 if !include_path {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1169 continue;
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1170 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1171 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1172 let parents = self.parents(rev)?;
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1173 seen.insert(rev, parents);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1174 for parent in parents {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1175 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	1176 heads.push(parent);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1177 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1178 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1179 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1180 if !include_path {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1181 return Ok(reachable);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1182 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1183 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	1184 revs.sort_unstable();
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1185 for rev in revs {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1186 for parent in seen[rev] {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1187 if reachable.contains(&parent) {
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1188 reachable.insert(*rev);
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1189 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1190 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1191 }
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1192 Ok(reachable)
fc05dd74e907 rust-index: add support for `reachableroots2` Rapha?l Gom?s <rgomes@octobus.net> parents: 51217 diff changeset	1193 }
51220 42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1194
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1195 /// 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	1196 /// 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	1197 pub fn common_ancestor_heads(
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1198 &self,
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1199 revisions: &[Revision],
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1200 ) -> Result<Vec<Revision>, GraphError> {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1201 // 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	1202 // 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	1203 // 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	1204 // the onset.
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1205 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	1206 // 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	1207 // for `NULL_REVISION`:
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1208 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	1209 return Ok(vec![]);
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1210 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1211
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1212 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	1213
51226 1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1214 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	1215 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	1216 } 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	1217 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	1218 } else {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1219 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	1220 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1221 }
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1222
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1223 pub fn ancestors(
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1224 &self,
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1225 revisions: &[Revision],
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1226 ) -> Result<Vec<Revision>, GraphError> {
89ce6a49bfeb rust-index: implement common_ancestors_heads() and ancestors() Georges Racinet <georges.racinet@octobus.net> parents: 51221 diff changeset	1227 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	1228 }
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 /// 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	1231 /// 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	1232 /// `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	1233 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	1234 &self,
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1235 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	1236 ) -> 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	1237 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	1238 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	1239 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1240 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	1241 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	1242 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	1243
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1244 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	1245
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1246 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	1247 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	1248 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1249 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	1250 // 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	1251 // 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	1252 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	1253
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1254 // 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	1255 // 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	1256 // 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	1257 // 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	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 // 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	1260 // 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	1261 // 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	1262 // 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	1263 // 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	1264 //
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1265 // 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	1266 // 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	1267 // 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	1268 // 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	1269 // 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	1270 //
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1271 // 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	1272 // 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	1273 // - 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	1274 // - 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	1275 // - 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	1276 // 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	1277 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	1278 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	1279
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1280 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	1281 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	1282 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1283 }
51223 83091c14058c rust-index: avoid some cloning in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51222 diff changeset	1284 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	1285 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	1286 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	1287 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	1288 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	1289 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	1290
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1291 // 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	1292 // 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	1293 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	1294 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	1295 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	1296 }
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 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1299 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1300 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	1301 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	1302 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1303 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1304 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	1305 if poison {
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1306 // 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	1307 // 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	1308 // 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	1309 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	1310 interesting -= 1;
e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1311 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1312 parent_seen.poison();
51224 e553cd209215 rust-index: avoid double negation in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51223 diff changeset	1313 } else {
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1314 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	1315 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	1316 }
51225 61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1317 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	1318 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1319 }
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 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	1322 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1323
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1324 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	1325 }
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 /// 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	1328 /// 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	1329 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	1330 &self,
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1331 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	1332 ) -> 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	1333 // 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	1334 // 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	1335 // 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	1336 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	1337 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	1338 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1339 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	1340 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	1341 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	1342 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	1343 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	1344 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	1345 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	1346
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1347 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	1348 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	1349 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	1350 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	1351 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	1352 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	1353 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1354
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1355 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	1356 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	1357 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	1358 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	1359 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	1360 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1361 }
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 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	1364 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	1365 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	1366 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1367 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1368 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	1369 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	1370 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	1371 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	1372 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	1373 *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	1374 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	1375 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	1376 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	1377 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	1378 *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	1379 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	1380 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	1381 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1382 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1383 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1384 } 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	1385 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	1386 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	1387 continue;
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1388 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1389 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	1390 interesting
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1391 .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	1392 .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	1393 .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	1394 *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	1395 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	1396 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	1397 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1398 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1399 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1400 *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	1401 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	1402 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	1403 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1404
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1405 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	1406 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1407
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1408 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	1409 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	1410 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1411 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	1412
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1413 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	1414 .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	1415 .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	1416 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	1417 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	1418 }
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1419 None
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1420 })
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1421 .collect())
42c8dbdb88ad rust-index: core impl for find_gca_candidates and find_deepest Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1422 }
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1423
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1424 /// Return the offset into the data corresponding to `rev` (in the index
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1425 /// file if inline, in the data file otherwise). `entry` must be the entry
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1426 /// for `rev`: the API is done this way to reduce the number of lookups
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1427 /// since we sometimes already have the entry, and because very few places
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1428 /// actually use this function.
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1429 #[inline(always)]
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1430 pub fn start(&self, rev: Revision, entry: &IndexEntry<'_>) -> usize {
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1431 #[cfg(debug_assertions)]
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1432 {
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1433 assert_eq!(&self.get_entry(rev).unwrap(), entry);
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1434 }
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1435 let offset = entry.offset();
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1436 if self.is_inline() {
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1437 offset + ((rev.0 as usize + 1) * INDEX_ENTRY_SIZE)
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1438 } else {
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1439 offset
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1440 }
44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1441 }
52160 e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1442
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1443 pub(crate) fn make_null_entry(&self) -> IndexEntry<'_> {
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1444 IndexEntry {
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1445 bytes: b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1446 \xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff \
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1447 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1448 }
e01e84e5e426 rust-revlog: add a Rust-only `InnerRevlog` Rapha?l Gom?s <rgomes@octobus.net> parents: 52159 diff changeset	1449 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1450 }
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1451
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1452 /// 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	1453 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1454 /// 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	1455 /// 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	1456 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1457 /// 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	1458 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	1459 /// 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	1460 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1461 /// 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	1462 /// 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	1463 /// implementation.
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1464 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	1465
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1466 /// 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	1467 #[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	1468 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	1469
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1470 /// 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	1471 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1472 /// 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	1473 /// 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	1474 /// `[0, C)`
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1475 #[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	1476 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	1477
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1478 /// 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	1479 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	1480
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1481 /// 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	1482 #[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	1483 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	1484
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1485 /// 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	1486 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	1487
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1488 /// 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	1489 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1490 /// 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	1491 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	1492
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1493 /// 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	1494 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1495 /// 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	1496 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	1497
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1498 /// 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	1499 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	1500
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1501 /// 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	1502 /// of integers
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1503 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	1504 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1505
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1506 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	1507 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	1508
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1509 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	1510 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	1511 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	1512 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1513
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1514 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	1515 8
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1516 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1517
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1518 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	1519 63
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1520 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1521
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1522 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	1523 (*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	1524 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1525
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1526 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	1527 (*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	1528 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1529
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1530 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	1531 if self != other {
61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1532 (self) \|= other;
61a6ef876efd rust-index: simplification in find_gca_candidates() Georges Racinet <georges.racinet@octobus.net> parents: 51224 diff changeset	1533 }
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1534 }
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 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	1537 *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	1538 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1539
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1540 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	1541 *self == 0
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1542 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1543
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1544 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	1545 *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	1546 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1547
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1548 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	1549 // 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	1550 // 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	1551 *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	1552 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1553 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1554
51226 1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1555 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	1556 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	1557 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	1558 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1559
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1560 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	1561 1
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1562 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1563
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1564 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	1565 7
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1566 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1567
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1568 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	1569 (*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	1570 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1571
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1572 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	1573 (*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	1574 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1575
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1576 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	1577 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	1578 (self) \|= other;
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1579 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1580 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1581
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1582 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	1583 *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	1584 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1585
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1586 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	1587 *self == 0
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1588 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1589
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1590 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	1591 *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	1592 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1593
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1594 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	1595 // 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	1596 // 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	1597 *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	1598 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1599 }
1b23aaf5eb7b rust-index: optimize find_gca_candidates() on less than 8 revisions Georges Racinet <georges.racinet@octobus.net> parents: 51225 diff changeset	1600
51221 43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1601 /// 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	1602 /// 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	1603 ///
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1604 /// 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	1605 /// 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	1606 /// 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	1607 /// 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	1608 /// 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	1609 #[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	1610 struct NonStaticPoisonableBitSet {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1611 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	1612 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	1613 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1614
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1615 /// 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	1616 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	1617 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	1618 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1619
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1620 impl NonStaticPoisonableBitSet {
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1621 /// 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	1622 /// the latter
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1623 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	1624 (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	1625 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1626 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1627
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1628 /// 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	1629 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	1630 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	1631 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	1632 set_size,
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1633 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	1634 };
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1635 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	1636 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1637
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1638 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	1639 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	1640 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1641
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1642 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	1643 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	1644 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1645
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1646 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	1647 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	1648 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	1649 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1650
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1651 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	1652 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	1653 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	1654 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1655
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1656 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	1657 assert!(
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1658 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	1659 "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	1660 );
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1661 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	1662 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	1663 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1664 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1665
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1666 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	1667 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	1668 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	1669 && 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	1670 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1671
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1672 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	1673 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	1674 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1675
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1676 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	1677 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	1678 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	1679 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1680
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1681 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	1682 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	1683 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	1684 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1685 }
43241f31cf5b rust-index: find_gca_candidates bit sets genericization Georges Racinet on incendie.racinet.fr <georges@racinet.fr> parents: 51220 diff changeset	1686
51217 c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1687 /// 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	1688 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	1689
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1690 #[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	1691 pub enum Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1692 Public = 0,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1693 Draft = 1,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1694 Secret = 2,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1695 Archived = 3,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1696 Internal = 4,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1697 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1698
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1699 impl TryFrom<usize> for Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1700 type Error = RevlogError;
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1701
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1702 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	1703 Ok(match value {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1704 0 => Self::Public,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1705 1 => Self::Draft,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1706 2 => Self::Secret,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1707 32 => Self::Archived,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1708 96 => Self::Internal,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1709 v => {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1710 return Err(RevlogError::corrupted(format!(
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1711 "invalid phase value {}",
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1712 v
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1713 )))
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1714 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1715 })
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1716 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1717 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1718
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1719 impl Phase {
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1720 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	1721 &[
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1722 Self::Public,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1723 Self::Draft,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1724 Self::Secret,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1725 Self::Archived,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1726 Self::Internal,
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1727 ]
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1728 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1729 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	1730 &[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	1731 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1732 }
c817d9f626d3 rust-index: add support for `computephasesmapsets` Rapha?l Gom?s <rgomes@octobus.net> parents: 51215 diff changeset	1733
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1734 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	1735 let mut offset: usize = 0;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1736 let mut offsets = Vec::new();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1737
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1738 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1739 offsets.push(offset);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1740 let end = offset + INDEX_ENTRY_SIZE;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1741 let entry = IndexEntry {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1742 bytes: &bytes[offset..end],
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1743 };
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1744
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1745 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	1746 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	1747 (offset, offsets)
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1748 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1749
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1750 impl super::RevlogIndex for Index {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1751 fn len(&self) -> usize {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1752 self.len()
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1753 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1754
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1755 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	1756 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	1757 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	1758 }
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1759 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	1760 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1761 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1762
52159 44823c5011fe rust-index: fix the computation of data start Rapha?l Gom?s <rgomes@octobus.net> parents: 52158 diff changeset	1763 #[derive(Debug, PartialEq, Eq)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1764 pub struct IndexEntry<'a> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1765 bytes: &'a [u8],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1766 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1767
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1768 impl<'a> IndexEntry<'a> {
45593 da30e4b553c3 hg-core: minor docstring update (D8958#inline-14991 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45592 diff changeset	1769 /// 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	1770 pub fn offset(&self) -> usize {
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1771 let mut bytes = [0; 8];
d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	1772 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	1773 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	1774 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1775 pub fn raw_offset(&self) -> u64 {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1776 BigEndian::read_u64(&self.bytes[0..8])
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	1777 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1778
48546 e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1779 pub fn flags(&self) -> u16 {
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1780 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	1781 }
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	1782
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1783 /// 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	1784 pub fn compressed_len(&self) -> u32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1785 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	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 /// 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	1789 pub fn uncompressed_len(&self) -> i32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	1790 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	1791 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1792
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1793 /// 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	1794 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	1795 // 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	1796 // 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	1797
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1798 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	1799 }
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1800
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1801 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	1802 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	1803 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1804
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1805 pub fn p1(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1806 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	1807 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1808
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1809 pub fn p2(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1810 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	1811 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1812
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1813 /// 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	1814 ///
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	1815 /// 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	1816 /// are used.
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	1817 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	1818 (&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	1819 }
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	1820
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	1821 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	1822 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	1823 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1824 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1825
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1826 #[cfg(test)]
51703 ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1827 pub use tests::IndexEntryBuilder;
ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1828
ec7171748350 rust: apply clippy lints Rapha?l Gom?s <rgomes@octobus.net> parents: 51696 diff changeset	1829 #[cfg(test)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1830 mod tests {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1831 use super::*;
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52173 diff changeset	1832 use crate::NULL_NODE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1833
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1834 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1835 #[derive(Debug, Copy, Clone)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1836 pub struct IndexEntryBuilder {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1837 is_first: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1838 is_inline: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1839 is_general_delta: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1840 version: u16,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1841 offset: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1842 compressed_len: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1843 uncompressed_len: usize,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1844 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	1845 link_revision: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1846 p1: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1847 p2: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1848 node: Node,
45526 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
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1851 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1852 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	1853 #[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	1854 pub fn new() -> Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1855 Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1856 is_first: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1857 is_inline: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1858 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	1859 version: 1,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1860 offset: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1861 compressed_len: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1862 uncompressed_len: 0,
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	1863 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	1864 link_revision: Revision(0),
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1865 p1: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1866 p2: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1867 node: NULL_NODE,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1868 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1869 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1870
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1871 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	1872 self.is_first = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1873 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1874 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1875
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1876 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	1877 self.is_inline = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1878 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1879 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1880
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1881 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	1882 self.is_general_delta = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1883 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1884 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1885
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1886 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	1887 self.version = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1888 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1889 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1890
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1891 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	1892 self.offset = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1893 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1894 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1895
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1896 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	1897 self.compressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1898 self
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 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	1902 self.uncompressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1903 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1904 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1905
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1906 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	1907 &mut self,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1908 value: Revision,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1909 ) -> &mut Self {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	1910 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	1911 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1912 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1913
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1914 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	1915 self.link_revision = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1916 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1917 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1918
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1919 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	1920 self.p1 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1921 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1922 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1923
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1924 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	1925 self.p2 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1926 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1927 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1928
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1929 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	1930 self.node = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1931 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1932 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	1933
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1934 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	1935 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	1936 if self.is_first {
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1937 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	1938 (false, false) => [0u8, 0],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1939 (false, true) => [0u8, 1],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1940 (true, false) => [0u8, 2],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1941 (true, true) => [0u8, 3],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1942 });
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1943 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	1944 // Remaining offset bytes.
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1945 bytes.extend([0u8; 2]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1946 } else {
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	1947 // 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	1948 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	1949 }
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1950 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	1951 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	1952 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	1953 bytes.extend(
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1954 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	1955 );
51269 c4cbb515b006 rust-clippy: apply some more trivial fixes Rapha?l Gom?s <rgomes@octobus.net> parents: 51261 diff changeset	1956 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	1957 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	1958 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	1959 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	1960 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	1961 bytes
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1962 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1963 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1964
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1965 pub fn is_inline(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1966 IndexHeader::parse(index_bytes)
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	1967 .expect("invalid header")
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1968 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1969 .is_inline()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1970 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1971
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1972 pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1973 IndexHeader::parse(index_bytes)
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	1974 .expect("invalid header")
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1975 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1976 .uses_generaldelta()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1977 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1978
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1979 pub fn get_version(index_bytes: &[u8]) -> u16 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1980 IndexHeader::parse(index_bytes)
52158 f2eab4967bfc rust-index: return an error on a bad index header Rapha?l Gom?s <rgomes@octobus.net> parents: 52041 diff changeset	1981 .expect("invalid header")
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1982 .format_version()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1983 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1984
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1985 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1986 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	1987 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	1988 .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	1989 .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	1990 .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	1991 .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	1992
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1993 assert!(!is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	1994 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	1995 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1996
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	1997 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1998 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	1999 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	2000 .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	2001 .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	2002 .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	2003 .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	2004
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	2005 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	2006 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	2007 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	2008
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	2009 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2010 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	2011 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	2012 .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	2013 .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	2014 .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	2015 .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	2016
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	2017 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	2018 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	2019 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	2020
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	2021 #[test]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2022 fn test_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2023 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	2024 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	2025
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2026 assert_eq!(entry.offset(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2027 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2028
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2029 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2030 fn test_compressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2031 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	2032 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	2033
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2034 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	2035 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2036
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2037 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2038 fn test_uncompressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2039 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	2040 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	2041
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2042 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	2043 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2044
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2045 #[test]
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	2046 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	2047 let bytes = IndexEntryBuilder::new()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2048 .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	2049 .build();
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2050 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	2051
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2052 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	2053 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2054
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2055 #[test]
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2056 fn link_revision_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2057 let bytes = IndexEntryBuilder::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2058 .with_link_revision(Revision(123))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2059 .build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2060
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2061 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	2062
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2063 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	2064 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2065
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2066 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2067 fn p1_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2068 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	2069
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2070 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	2071
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2072 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	2073 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2074
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2075 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2076 fn p2_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	2077 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	2078
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2079 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	2080
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	2081 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	2082 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2083
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2084 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2085 fn node_test() {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2086 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	2087 .unwrap();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2088 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	2089
51442 d2858d97af6c rust-index: drop offset_override Pierre-Yves David <pierre-yves.david@octobus.net> parents: 51422 diff changeset	2090 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	2091
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2092 assert_eq!(*entry.hash(), node);
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2093 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2094
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	2095 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2096 fn version_test() {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2097 let bytes = IndexEntryBuilder::new()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2098 .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	2099 .with_version(2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2100 .build();
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2101
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	2102 assert_eq!(get_version(&bytes), 2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	2103 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	2104 }

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/revlog/index.rs @ 52760:94e2547e6f3d