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

annotate rust/hg-core/src/revlog/index.rs @ 51239:0112803e6c01

rust-index: add support for `_slicechunktodensity`

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Thu, 02 Nov 2023 11:40:23 +0100
parents	9f876765cbe2
children	c817d9f626d3

rev	line source
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	1 use std::collections::hash_map::RandomState;
51233 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	2 use std::collections::HashSet;
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	3 use std::fmt::Debug;
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	4 use std::ops::Deref;
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	5 use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	6
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	7 use byteorder::{BigEndian, ByteOrder};
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	8 use bytes_cast::{unaligned, BytesCast};
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	9
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	10 use super::REVIDX_KNOWN_FLAGS;
46511 43d63979a75e rust: use HgError in RevlogError and Vfs Simon Sapin <simon.sapin@octobus.net> parents: 46091 diff changeset	11 use crate::errors::HgError;
51230 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	12 use crate::node::{NODE_BYTES_LENGTH, NULL_NODE, STORED_NODE_ID_BYTES};
46037 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45605 diff changeset	13 use crate::revlog::node::Node;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	14 use crate::revlog::{Revision, NULL_REVISION};
51233 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	15 use crate::{
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	16 dagops, BaseRevision, FastHashMap, Graph, GraphError, RevlogError,
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	17 RevlogIndex, UncheckedRevision,
51233 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	18 };
45532 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;
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	21 pub const COMPRESSION_MODE_INLINE: u8 = 2;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	22
51239 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	23 #[derive(Debug)]
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	24 pub struct IndexHeader {
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	25 pub(super) header_bytes: [u8; 4],
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	26 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	27
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	28 #[derive(Copy, Clone)]
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	29 pub struct IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	30 flags: u16,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	31 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	32
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	33 /// Corresponds to the high bits of `_format_flags` in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	34 impl IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	35 /// Corresponds to FLAG_INLINE_DATA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	36 pub fn is_inline(self) -> bool {
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	37 self.flags & 1 != 0
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	38 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	39 /// Corresponds to FLAG_GENERALDELTA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	40 pub fn uses_generaldelta(self) -> bool {
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	41 self.flags & 2 != 0
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	42 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	43 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	44
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	45 /// Corresponds to the INDEX_HEADER structure,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	46 /// which is parsed as a `header` variable in `_loadindex` in `revlog.py`
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	47 impl IndexHeader {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	48 fn format_flags(&self) -> IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	49 // No "unknown flags" check here, unlike in python. Maybe there should
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	50 // be.
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	51 IndexHeaderFlags {
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	52 flags: BigEndian::read_u16(&self.header_bytes[0..2]),
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	53 }
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	54 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	55
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	56 /// The only revlog version currently supported by rhg.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	57 const REVLOGV1: u16 = 1;
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	58
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	59 /// Corresponds to `_format_version` in Python.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	60 fn format_version(&self) -> u16 {
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	61 BigEndian::read_u16(&self.header_bytes[2..4])
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	62 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	63
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	64 pub fn parse(index_bytes: &[u8]) -> Result<Option<IndexHeader>, HgError> {
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	65 if index_bytes.is_empty() {
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	66 return Ok(None);
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	67 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	68 if index_bytes.len() < 4 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	69 return Err(HgError::corrupted(
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	70 "corrupted revlog: can't read the index format header",
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	71 ));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	72 }
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	73 Ok(Some(IndexHeader {
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	74 header_bytes: {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	75 let bytes: [u8; 4] =
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	76 index_bytes[0..4].try_into().expect("impossible");
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	77 bytes
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	78 },
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	79 }))
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	80 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	81 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	82
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	83 /// 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: 50990 diff changeset	84 /// 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: 50990 diff changeset	85 /// 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: 50990 diff changeset	86 struct IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	87 /// Immutable bytes, most likely taken from disk
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	88 bytes: Box<dyn Deref<Target = [u8]> + Send>,
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	89 /// 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: 51213 diff changeset	90 /// 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: 51213 diff changeset	91 /// `bytes` field.
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	92 truncation: Option<usize>,
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	93 /// 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: 50990 diff changeset	94 added: Vec<u8>,
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	95 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	96
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	97 impl IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	98 pub fn new(bytes: Box<dyn Deref<Target = [u8]> + Send>) -> Self {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	99 Self {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	100 bytes,
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	101 truncation: None,
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	102 added: vec![],
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	103 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	104 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	105
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	106 pub fn len(&self) -> usize {
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	107 match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	108 Some(truncation) => truncation + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	109 None => self.bytes.len() + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	110 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	111 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	112
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	113 fn remove(
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	114 &mut self,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	115 rev: Revision,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	116 offsets: Option<&[usize]>,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	117 ) -> Result<(), RevlogError> {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	118 let rev = rev.0 as usize;
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	119 let truncation = if let Some(offsets) = offsets {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	120 offsets[rev]
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	121 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	122 rev * INDEX_ENTRY_SIZE
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	123 };
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	124 if truncation < self.bytes.len() {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	125 self.truncation = Some(truncation);
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	126 self.added.clear();
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	127 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	128 self.added.truncate(truncation - self.bytes.len());
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	129 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	130 Ok(())
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	131 }
51226 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	132
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	133 fn is_new(&self) -> bool {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	134 self.bytes.is_empty()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	135 }
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	136 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	137
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	138 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: 50990 diff changeset	139 type Output = [u8];
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	140
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	141 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: 50990 diff changeset	142 let start = index.start;
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	143 let end = index.end;
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	144 let immutable_len = match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	145 Some(truncation) => truncation,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	146 None => self.bytes.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	147 };
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	148 if start < immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	149 if end > immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	150 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: 50990 diff changeset	151 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	152 &self.bytes[index]
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	153 } else {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	154 &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: 50990 diff changeset	155 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	156 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	157 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	158
51226 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	159 #[derive(Debug, PartialEq, Eq)]
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	160 pub struct RevisionDataParams {
51213 65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	161 pub flags: u16,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	162 pub data_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	163 pub data_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	164 pub data_uncompressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	165 pub data_delta_base: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	166 pub link_rev: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	167 pub parent_rev_1: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	168 pub parent_rev_2: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	169 pub node_id: [u8; NODE_BYTES_LENGTH],
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	170 pub _sidedata_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	171 pub _sidedata_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	172 pub data_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	173 pub _sidedata_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51212 diff changeset	174 pub _rank: i32,
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	175 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	176
51226 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	177 impl Default for RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	178 fn default() -> Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	179 Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	180 flags: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	181 data_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	182 data_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	183 data_uncompressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	184 data_delta_base: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	185 link_rev: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	186 parent_rev_1: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	187 parent_rev_2: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	188 node_id: [0; NODE_BYTES_LENGTH],
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	189 _sidedata_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	190 _sidedata_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	191 data_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	192 _sidedata_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	193 _rank: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	194 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	195 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	196 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	197
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	198 #[derive(BytesCast)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	199 #[repr(C)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	200 pub struct RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	201 data_offset_or_flags: unaligned::U64Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	202 data_compressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	203 data_uncompressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	204 data_delta_base: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	205 link_rev: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	206 parent_rev_1: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	207 parent_rev_2: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	208 node_id: [u8; STORED_NODE_ID_BYTES],
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	209 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	210
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	211 fn _static_assert_size_of_revision_data_v1() {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	212 let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	213 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	214
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	215 impl RevisionDataParams {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	216 pub fn validate(&self) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	217 if self.flags & !REVIDX_KNOWN_FLAGS != 0 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	218 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	219 "unknown revlog index flags: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	220 self.flags
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	221 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	222 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	223 if self.data_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	224 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	225 "invalid data compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	226 self.data_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	227 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	228 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	229 // FIXME isn't this only for v2 or changelog v2?
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	230 if self._sidedata_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	231 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	232 "invalid sidedata compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	233 self._sidedata_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	234 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	235 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	236 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	237 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	238
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	239 pub fn into_v1(self) -> RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	240 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: 51209 diff changeset	241 let mut node_id = [0; STORED_NODE_ID_BYTES];
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	242 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: 51209 diff changeset	243 RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	244 data_offset_or_flags: data_offset_or_flags.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	245 data_compressed_length: self.data_compressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	246 data_uncompressed_length: self.data_uncompressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	247 data_delta_base: self.data_delta_base.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	248 link_rev: self.link_rev.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	249 parent_rev_1: self.parent_rev_1.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	250 parent_rev_2: self.parent_rev_2.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	251 node_id,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	252 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	253 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	254 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	255
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	256 /// A Revlog index
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	257 pub struct Index {
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	258 bytes: IndexData,
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	259 /// 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	260 /// Only needed when the index is interleaved with data.
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	261 offsets: RwLock<Option<Vec<usize>>>,
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	262 uses_generaldelta: bool,
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	263 is_inline: bool,
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	264 /// Cache of the head revisions in this index, kept in sync. Should
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	265 /// be accessed via the [`Self::head_revs`] method.
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	266 head_revs: Vec<Revision>,
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	267 /// Cache of the last filtered revisions in this index, used to make sure
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	268 /// we haven't changed filters when returning the cached `head_revs`.
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	269 filtered_revs: HashSet<Revision>,
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	270 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	271
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	272 impl Debug for Index {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	273 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: 50003 diff changeset	274 f.debug_struct("Index")
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	275 .field("offsets", &self.offsets)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	276 .field("uses_generaldelta", &self.uses_generaldelta)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	277 .finish()
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	278 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	279 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	280
50989 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	281 impl Graph for Index {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	282 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: 50988 diff changeset	283 let err = \|\| GraphError::ParentOutOfRange(rev);
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	284 match self.get_entry(rev) {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	285 Some(entry) => {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	286 // 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: 50988 diff changeset	287 // before returning
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	288 Ok([
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	289 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: 50988 diff changeset	290 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: 50988 diff changeset	291 ])
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	292 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	293 None => Ok([NULL_REVISION, NULL_REVISION]),
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	294 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	295 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	296 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50988 diff changeset	297
51233 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	298 /// A cache suitable for find_snapshots
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	299 ///
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	300 /// 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: 51232 diff changeset	301 /// values sets of [`BaseRevision`]
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	302 ///
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	303 /// 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: 51232 diff changeset	304 /// we would probably need to sprinkle some magic here, such as an associated
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	305 /// type that would be Into<RevlogError> but even that would not be
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	306 /// 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: 51232 diff changeset	307 pub trait SnapshotsCache {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	308 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	309 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	310 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	311 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	312 ) -> Result<(), RevlogError>;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	313 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	314
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	315 impl SnapshotsCache for FastHashMap<BaseRevision, HashSet<BaseRevision>> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	316 fn insert_for(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	317 &mut self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	318 rev: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	319 value: BaseRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	320 ) -> Result<(), RevlogError> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	321 let all_values = self.entry(rev).or_insert_with(HashSet::new);
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	322 all_values.insert(value);
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	323 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	324 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	325 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	326
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	327 impl Index {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	328 /// Create an index from bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	329 /// Calculate the start of each entry when is_inline is true.
45605 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	330 pub fn new(
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	331 bytes: Box<dyn Deref<Target = [u8]> + Send>,
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	332 default_header: IndexHeader,
47991 001d747c2baf rust: Return HgError instead of RevlogError in revlog constructors Simon Sapin <simon.sapin@octobus.net> parents: 46887 diff changeset	333 ) -> Result<Self, HgError> {
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	334 let header =
13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	335 IndexHeader::parse(bytes.as_ref())?.unwrap_or(default_header);
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	336
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	337 if header.format_version() != IndexHeader::REVLOGV1 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	338 // A proper new version should have had a repo/store
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	339 // requirement.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	340 return Err(HgError::corrupted("unsupported revlog version"));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	341 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	342
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	343 // This is only correct because we know version is REVLOGV1.
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	344 // In v2 we always use generaldelta, while in v0 we never use
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	345 // generaldelta. Similar for [is_inline] (it's only used in v1).
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	346 let uses_generaldelta = header.format_flags().uses_generaldelta();
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	347
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	348 if header.format_flags().is_inline() {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	349 let mut offset: usize = 0;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	350 let mut offsets = Vec::new();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	351
45593 11f3c3f408fd hg-core: minor code style change (D8958#inline-14993 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45542 diff changeset	352 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	353 offsets.push(offset);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	354 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	355 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	356 bytes: &bytes[offset..end],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	357 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	358 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	359
48572 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48497 diff changeset	360 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	361 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	362
45605 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	363 if offset == bytes.len() {
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	364 Ok(Self {
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	365 bytes: IndexData::new(bytes),
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	366 offsets: RwLock::new(Some(offsets)),
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	367 uses_generaldelta,
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	368 is_inline: true,
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	369 head_revs: vec![],
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	370 filtered_revs: HashSet::new(),
45605 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	371 })
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	372 } else {
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	373 Err(HgError::corrupted("unexpected inline revlog length"))
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	374 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	375 } else {
45605 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	376 Ok(Self {
51209 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50990 diff changeset	377 bytes: IndexData::new(bytes),
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	378 offsets: RwLock::new(None),
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	379 uses_generaldelta,
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	380 is_inline: false,
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	381 head_revs: vec![],
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	382 filtered_revs: HashSet::new(),
45605 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45604 diff changeset	383 })
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	384 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	385 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	386
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	387 pub fn uses_generaldelta(&self) -> bool {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	388 self.uses_generaldelta
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	389 }
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	390
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	391 /// 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: 45596 diff changeset	392 pub fn is_inline(&self) -> bool {
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	393 self.is_inline
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	394 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	395
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	396 /// 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: 45596 diff changeset	397 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: 45596 diff changeset	398 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: 45596 diff changeset	399 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: 45596 diff changeset	400 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	401 &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: 45596 diff changeset	402 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	403
45542 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	404 /// Return number of entries of the revlog index.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	405 pub fn len(&self) -> usize {
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	406 if let Some(offsets) = &*self.get_offsets() {
45542 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	407 offsets.len()
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	408 } else {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	409 self.bytes.len() / INDEX_ENTRY_SIZE
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	410 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	411 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	412
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	413 pub fn get_offsets(&self) -> RwLockReadGuard<Option<Vec<usize>>> {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	414 if self.is_inline() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	415 {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	416 // Wrap in a block to drop the read guard
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	417 // TODO perf?
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	418 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	419 if offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	420 offsets.replace(inline_scan(&self.bytes.bytes).1);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	421 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	422 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	423 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	424 self.offsets.read().unwrap()
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	425 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	426
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	427 pub fn get_offsets_mut(&mut self) -> RwLockWriteGuard<Option<Vec<usize>>> {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	428 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	429 if self.is_inline() && offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	430 offsets.replace(inline_scan(&self.bytes.bytes).1);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	431 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	432 offsets
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	433 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	434
45542 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	435 /// Returns `true` if the `Index` has zero `entries`.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	436 pub fn is_empty(&self) -> bool {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	437 self.len() == 0
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	438 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45537 diff changeset	439
51224 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	440 /// 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: 51219 diff changeset	441 /// 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: 51219 diff changeset	442 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	443 /// 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: 51219 diff changeset	444 /// if it was validated by this index.
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	445 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	446 if rev == NULL_REVISION {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	447 return None;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	448 }
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	449 Some(if let Some(offsets) = &*self.get_offsets() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	450 self.get_entry_inline(rev, offsets.as_ref())
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	451 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	452 self.get_entry_separated(rev)
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	453 })
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	454 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	455
51224 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	456 /// 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: 51219 diff changeset	457 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	458 /// See [get_entry()](`Self::get_entry()`) for cases when `None` is
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	459 /// returned.
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	460 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: 51219 diff changeset	461 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: 51219 diff changeset	462 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: 51219 diff changeset	463 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: 51219 diff changeset	464 &bytes[4..]
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	465 } else {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	466 bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	467 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	468 })
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	469 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	470
51226 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	471 pub fn entry_as_params(
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	472 &self,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	473 rev: UncheckedRevision,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	474 ) -> Option<RevisionDataParams> {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	475 let rev = self.check_revision(rev)?;
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	476 self.get_entry(rev).map(\|e\| RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	477 flags: e.flags(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	478 data_offset: if rev.0 == 0 && !self.bytes.is_new() {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	479 e.flags() as u64
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	480 } else {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	481 e.raw_offset()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	482 },
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	483 data_compressed_length: e.compressed_len().try_into().unwrap(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	484 data_uncompressed_length: e.uncompressed_len(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	485 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: 51224 diff changeset	486 link_rev: e.link_revision().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	487 parent_rev_1: e.p1().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	488 parent_rev_2: e.p2().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	489 node_id: e.hash().as_bytes().try_into().unwrap(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	490 ..Default::default()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	491 })
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	492 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	493
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	494 fn get_entry_inline(
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	495 &self,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	496 rev: Revision,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	497 offsets: &[usize],
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	498 ) -> IndexEntry {
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	499 let start = offsets[rev.0 as usize];
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	500 let end = start + INDEX_ENTRY_SIZE;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	501 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	502
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	503 // See IndexEntry for an explanation of this override.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	504 let offset_override = Some(end);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	505
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	506 IndexEntry {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	507 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	508 offset_override,
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	509 }
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	510 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	511
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	512 fn get_entry_separated(&self, rev: Revision) -> IndexEntry {
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	513 let start = rev.0 as usize * INDEX_ENTRY_SIZE;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	514 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	515 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	516
45594 f38adf8b0711 hg-core: Explain offset override of first revision Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	517 // Override the offset of the first revision as its bytes are used
f38adf8b0711 hg-core: Explain offset override of first revision Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	518 // for the index's metadata (saving space because it is always 0)
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	519 let offset_override = if rev == Revision(0) { Some(0) } else { None };
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	520
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	521 IndexEntry {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	522 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	523 offset_override,
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	524 }
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	525 }
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	526
51239 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	527 fn null_entry(&self) -> IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	528 IndexEntry {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	529 bytes: &[0; INDEX_ENTRY_SIZE],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	530 offset_override: Some(0),
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	531 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	532 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	533
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	534 /// Return the head revisions of this index
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	535 pub fn head_revs(&mut self) -> Result<Vec<Revision>, GraphError> {
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	536 self.head_revs_filtered(&HashSet::new())
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	537 }
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	538
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	539 /// Return the head revisions of this index
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	540 pub fn head_revs_filtered(
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	541 &mut self,
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	542 filtered_revs: &HashSet<Revision>,
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	543 ) -> Result<Vec<Revision>, GraphError> {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	544 if !self.head_revs.is_empty() && filtered_revs == &self.filtered_revs {
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	545 return Ok(self.head_revs.to_owned());
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	546 }
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	547 let mut revs: HashSet<Revision, RandomState> =
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	548 if filtered_revs.is_empty() {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	549 (0..self.len())
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	550 .into_iter()
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	551 .map(\|i\| Revision(i as BaseRevision))
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	552 .collect()
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	553 } else {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	554 (0..self.len())
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	555 .into_iter()
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	556 .filter_map(\|i\| {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	557 let r = Revision(i as BaseRevision);
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	558 if filtered_revs.contains(&r) {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	559 None
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	560 } else {
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	561 Some(r)
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	562 }
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	563 })
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	564 .collect()
9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	565 };
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	566 dagops::retain_heads(self, &mut revs)?;
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	567 if self.is_empty() {
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	568 revs.insert(NULL_REVISION);
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	569 }
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	570 let mut as_vec: Vec<Revision> =
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	571 revs.into_iter().map(Into::into).collect();
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	572 as_vec.sort_unstable();
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	573 self.head_revs = as_vec.to_owned();
51237 9f876765cbe2 rust-index: add support for `headrevsfiltered` Rapha?l Gom?s <rgomes@octobus.net> parents: 51236 diff changeset	574 self.filtered_revs = filtered_revs.to_owned();
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	575 Ok(as_vec)
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	576 }
a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	577
51234 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	578 /// Obtain the delta chain for a revision.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	579 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	580 /// `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: 51233 diff changeset	581 /// stop at the base of the chain.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	582 ///
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	583 /// 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: 51233 diff changeset	584 /// 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: 51233 diff changeset	585 /// `stoprev` was hit.
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	586 pub fn delta_chain(
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	587 &self,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	588 rev: Revision,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	589 stop_rev: Option<Revision>,
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	590 ) -> Result<(Vec<Revision>, bool), HgError> {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	591 let mut current_rev = rev;
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	592 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: 51233 diff changeset	593 let mut chain = vec![];
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	594 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: 51233 diff changeset	595 && 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: 51233 diff changeset	596 {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	597 chain.push(current_rev);
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	598 let new_rev = if self.uses_generaldelta() {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	599 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: 51233 diff changeset	600 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	601 UncheckedRevision(current_rev.0 - 1)
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	602 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	603 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: 51233 diff changeset	604 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: 51233 diff changeset	605 })?;
51239 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	606 if current_rev.0 == NULL_REVISION.0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	607 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	608 }
51234 62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	609 entry = self.get_entry(current_rev).unwrap()
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	610 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	611
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	612 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: 51233 diff changeset	613 true
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	614 } else {
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	615 chain.push(current_rev);
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	616 false
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	617 };
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	618 chain.reverse();
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	619 Ok((chain, stopped))
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	620 }
62e39bef36ca rust-index: add support for delta-chain computation Rapha?l Gom?s <rgomes@octobus.net> parents: 51233 diff changeset	621
51233 9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	622 pub fn find_snapshots(
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	623 &self,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	624 start_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	625 end_rev: UncheckedRevision,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	626 cache: &mut impl SnapshotsCache,
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	627 ) -> Result<(), RevlogError> {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	628 let mut start_rev = start_rev.0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	629 let mut end_rev = end_rev.0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	630 end_rev += 1;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	631 let len = self.len().try_into().unwrap();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	632 if end_rev > len {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	633 end_rev = len;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	634 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	635 if start_rev < 0 {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	636 start_rev = 0;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	637 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	638 for rev in start_rev..end_rev {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	639 if !self.is_snapshot_unchecked(Revision(rev))? {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	640 continue;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	641 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	642 let mut base = self
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	643 .get_entry(Revision(rev))
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	644 .unwrap()
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	645 .base_revision_or_base_of_delta_chain();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	646 if base.0 == rev {
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	647 base = NULL_REVISION.into();
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	648 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	649 cache.insert_for(base.0, rev)?;
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	650 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	651 Ok(())
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	652 }
9b06e7f32bc5 rust-index: add support for `find_snapshots` Rapha?l Gom?s <rgomes@octobus.net> parents: 51232 diff changeset	653
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	654 /// 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: 51209 diff changeset	655 pub fn append(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	656 &mut self,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	657 revision_data: RevisionDataParams,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	658 ) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	659 revision_data.validate()?;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	660 let new_offset = self.bytes.len();
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	661 if let Some(offsets) = &mut *self.get_offsets_mut() {
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	662 offsets.push(new_offset)
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	663 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	664 self.bytes.added.extend(revision_data.into_v1().as_bytes());
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	665 self.head_revs.clear();
51210 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	666 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51209 diff changeset	667 }
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	668
51219 51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51218 diff changeset	669 pub fn pack_header(&self, header: i32) -> [u8; 4] {
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51218 diff changeset	670 header.to_be_bytes()
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51218 diff changeset	671 }
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51218 diff changeset	672
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	673 pub fn remove(&mut self, rev: Revision) -> Result<(), RevlogError> {
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	674 let offsets = self.get_offsets().clone();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	675 self.bytes.remove(rev, offsets.as_deref())?;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	676 if let Some(offsets) = &mut *self.get_offsets_mut() {
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	677 offsets.truncate(rev.0 as usize)
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	678 }
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	679 self.head_revs.clear();
51216 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	680 Ok(())
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51213 diff changeset	681 }
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	682
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	683 pub fn clear_caches(&mut self) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	684 // 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: 51216 diff changeset	685 // 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: 51216 diff changeset	686 // clear caches. This implies re-populating the offsets on-demand.
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	687 self.offsets = RwLock::new(None);
51236 a7bba7df9189 rust-index: implement headrevs Rapha?l Gom?s <rgomes@octobus.net> parents: 51234 diff changeset	688 self.head_revs.clear();
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	689 }
51232 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	690
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	691 /// Unchecked version of `is_snapshot`.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	692 /// 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: 51230 diff changeset	693 pub fn is_snapshot_unchecked(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	694 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	695 mut rev: Revision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	696 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	697 while rev.0 >= 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	698 let entry = self.get_entry(rev).unwrap();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	699 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: 51230 diff changeset	700 if base == rev.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	701 base = NULL_REVISION.0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	702 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	703 if base == NULL_REVISION.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	704 return Ok(true);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	705 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	706 let [mut p1, mut p2] = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	707 .parents(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	708 .map_err(\|_\| RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	709 while let Some(p1_entry) = self.get_entry(p1) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	710 if p1_entry.compressed_len() != 0 \|\| p1.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	711 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	712 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	713 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	714 p1_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	715 if parent_base.0 == p1.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	716 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	717 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	718 p1 = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	719 .check_revision(parent_base)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	720 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	721 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	722 while let Some(p2_entry) = self.get_entry(p2) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	723 if p2_entry.compressed_len() != 0 \|\| p2.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	724 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	725 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	726 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	727 p2_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	728 if parent_base.0 == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	729 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	730 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	731 p2 = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	732 .check_revision(parent_base)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	733 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	734 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	735 if base == p1.0 \|\| base == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	736 return Ok(false);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	737 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	738 rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	739 .check_revision(base.into())
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	740 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	741 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	742 Ok(rev == NULL_REVISION)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	743 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	744
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	745 /// 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: 51230 diff changeset	746 /// `rev` is not within a valid revision range.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	747 pub fn is_snapshot(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	748 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	749 rev: UncheckedRevision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	750 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	751 let rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	752 .check_revision(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	753 .ok_or_else(\|\| RevlogError::corrupted("test"))?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	754 self.is_snapshot_unchecked(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51230 diff changeset	755 }
51239 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	756
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	757 /// 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: 51237 diff changeset	758 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	759 /// 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: 51237 diff changeset	760 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	761 /// The initial chunk is sliced until the overall density
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	762 /// (payload/chunks-span ratio) is above `target_density`.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	763 /// No gap smaller than `min_gap_size` is skipped.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	764 pub fn slice_chunk_to_density(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	765 &self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	766 revs: &[Revision],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	767 target_density: f64,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	768 min_gap_size: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	769 ) -> Vec<Vec<Revision>> {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	770 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	771 return vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	772 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	773 if revs.len() == 1 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	774 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	775 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	776 let delta_chain_span = self.segment_span(revs);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	777 if delta_chain_span < min_gap_size {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	778 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	779 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	780 let entries: Vec<_> = revs
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	781 .iter()
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	782 .map(\|r\| {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	783 (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: 51237 diff changeset	784 })
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	785 .collect();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	786
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	787 let mut read_data = delta_chain_span;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	788 let chain_payload: u32 =
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	789 entries.iter().map(\|(_r, e)\| e.compressed_len()).sum();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	790 let mut density = if delta_chain_span > 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	791 chain_payload as f64 / delta_chain_span as f64
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	792 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	793 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	794 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	795
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	796 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	797 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	798 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	799
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	800 // 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: 51237 diff changeset	801 let mut gaps = Vec::new();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	802 let mut previous_end = None;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	803
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	804 for (i, (_rev, entry)) in entries.iter().enumerate() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	805 let start = entry.c_start() as usize;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	806 let length = entry.compressed_len();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	807
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	808 // Skip empty revisions to form larger holes
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	809 if length == 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	810 continue;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	811 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	812
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	813 if let Some(end) = previous_end {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	814 let gap_size = start - end;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	815 // Only consider holes that are large enough
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	816 if gap_size > min_gap_size {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	817 gaps.push((gap_size, i));
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	818 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	819 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	820 previous_end = Some(start + length as usize);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	821 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	822 if gaps.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	823 return vec![revs.to_owned()];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	824 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	825 // 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: 51237 diff changeset	826 gaps.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	827
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	828 // Collect the indices of the largest holes until
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	829 // the density is acceptable
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	830 let mut selected = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	831 while let Some((gap_size, gap_id)) = gaps.pop() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	832 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	833 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	834 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	835 selected.push(gap_id);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	836
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	837 // 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: 51237 diff changeset	838 // by the heap
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	839 read_data -= gap_size;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	840 density = if read_data > 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	841 chain_payload as f64 / read_data as f64
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	842 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	843 1.0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	844 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	845 if density >= target_density {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	846 break;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	847 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	848 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	849 selected.sort_unstable();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	850 selected.push(revs.len());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	851
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	852 // Cut the revs at collected indices
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	853 let mut previous_idx = 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	854 let mut chunks = vec![];
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	855 for idx in selected {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	856 let chunk = self.trim_chunk(&entries, previous_idx, idx);
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	857 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	858 chunks.push(chunk.iter().map(\|(rev, _entry)\| *rev).collect());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	859 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	860 previous_idx = idx;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	861 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	862 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: 51237 diff changeset	863 if !chunk.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	864 chunks.push(chunk.iter().map(\|(rev, _entry)\| *rev).collect());
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	865 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	866
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	867 chunks
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	868 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	869
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	870 /// 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: 51237 diff changeset	871 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	872 /// 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: 51237 diff changeset	873 /// the `revs` segment.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	874 ///
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	875 /// panics:
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	876 /// - 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: 51237 diff changeset	877 /// - 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: 51237 diff changeset	878 /// `revs`.
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	879 fn segment_span(&self, revs: &[Revision]) -> usize {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	880 if revs.is_empty() {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	881 return 0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	882 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	883 let last_entry = &self.get_entry(revs[revs.len() - 1]).unwrap();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	884 let end = last_entry.c_start() + last_entry.compressed_len() as u64;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	885 let first_rev = revs.iter().find(\|r\| r.0 != NULL_REVISION.0).unwrap();
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	886 let start = if (*first_rev).0 == 0 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	887 0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	888 } else {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	889 self.get_entry(*first_rev).unwrap().c_start()
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	890 };
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	891 (end - start) as usize
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	892 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	893
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	894 /// Returns `&revs[startidx..endidx]` without empty trailing revs
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	895 fn trim_chunk<'a>(
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	896 &'a self,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	897 revs: &'a [(Revision, IndexEntry)],
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	898 start: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	899 mut end: usize,
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	900 ) -> &'a [(Revision, IndexEntry)] {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	901 // 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: 51237 diff changeset	902 let last_rev = revs[end - 1].0;
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	903 if last_rev.0 < self.len() as BaseRevision {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	904 while end > 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	905 && end > start
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	906 && revs[end - 1].1.compressed_len() == 0
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	907 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	908 end -= 1
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	909 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	910 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	911 &revs[start..end]
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	912 }
51218 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	913 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	914 fn inline_scan(bytes: &[u8]) -> (usize, Vec<usize>) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	915 let mut offset: usize = 0;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	916 let mut offsets = Vec::new();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	917
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	918 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	919 offsets.push(offset);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	920 let end = offset + INDEX_ENTRY_SIZE;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	921 let entry = IndexEntry {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	922 bytes: &bytes[offset..end],
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	923 offset_override: None,
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	924 };
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	925
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	926 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	927 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51216 diff changeset	928 (offset, offsets)
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	929 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	930
46091 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	931 impl super::RevlogIndex for Index {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	932 fn len(&self) -> usize {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	933 self.len()
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	934 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	935
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	936 fn node(&self, rev: Revision) -> Option<&Node> {
51230 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	937 if rev == NULL_REVISION {
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	938 return Some(&NULL_NODE);
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51226 diff changeset	939 }
46091 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	940 self.get_entry(rev).map(\|entry\| entry.hash())
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	941 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	942 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	943
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	944 #[derive(Debug)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	945 pub struct IndexEntry<'a> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	946 bytes: &'a [u8],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	947 /// Allows to override the offset value of the entry.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	948 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	949 /// For interleaved index and data, the offset stored in the index
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	950 /// corresponds to the separated data offset.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	951 /// It has to be overridden with the actual offset in the interleaved
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	952 /// index which is just after the index block.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	953 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	954 /// For separated index and data, the offset stored in the first index
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	955 /// entry is mixed with the index headers.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	956 /// It has to be overridden with 0.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	957 offset_override: Option<usize>,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	958 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	959
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	960 impl<'a> IndexEntry<'a> {
45596 da30e4b553c3 hg-core: minor docstring update (D8958#inline-14991 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45595 diff changeset	961 /// Return the offset of the data.
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	962 pub fn offset(&self) -> usize {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	963 if let Some(offset_override) = self.offset_override {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	964 offset_override
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	965 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	966 let mut bytes = [0; 8];
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	967 bytes[2..8].copy_from_slice(&self.bytes[0..=5]);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	968 BigEndian::read_u64(&bytes[..]) as usize
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	969 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	970 }
51226 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	971 pub fn raw_offset(&self) -> u64 {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	972 BigEndian::read_u64(&self.bytes[0..8])
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51224 diff changeset	973 }
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	974
51239 0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	975 /// Same result (except potentially for rev 0) as C `index_get_start()`
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	976 fn c_start(&self) -> u64 {
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	977 self.raw_offset() >> 16
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	978 }
0112803e6c01 rust-index: add support for `_slicechunktodensity` Rapha?l Gom?s <rgomes@octobus.net> parents: 51237 diff changeset	979
48575 e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48572 diff changeset	980 pub fn flags(&self) -> u16 {
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48572 diff changeset	981 BigEndian::read_u16(&self.bytes[6..=7])
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48572 diff changeset	982 }
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48572 diff changeset	983
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	984 /// Return the compressed length of the data.
48572 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48497 diff changeset	985 pub fn compressed_len(&self) -> u32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48497 diff changeset	986 BigEndian::read_u32(&self.bytes[8..=11])
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	987 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	988
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	989 /// Return the uncompressed length of the data.
48572 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48497 diff changeset	990 pub fn uncompressed_len(&self) -> i32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48497 diff changeset	991 BigEndian::read_i32(&self.bytes[12..=15])
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	992 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	993
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	994 /// Return the revision upon which the data has been derived.
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	995 pub fn base_revision_or_base_of_delta_chain(&self) -> UncheckedRevision {
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	996 // 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	997 // 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	998
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	999 BigEndian::read_i32(&self.bytes[16..]).into()
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1000 }
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1001
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1002 pub fn link_revision(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1003 BigEndian::read_i32(&self.bytes[20..]).into()
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1004 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1005
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1006 pub fn p1(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1007 BigEndian::read_i32(&self.bytes[24..]).into()
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1008 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1009
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1010 pub fn p2(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1011 BigEndian::read_i32(&self.bytes[28..]).into()
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1012 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1013
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1014 /// Return the hash of revision's full text.
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1015 ///
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1016 /// 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: 45532 diff changeset	1017 /// are used.
46091 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46037 diff changeset	1018 pub fn hash(&self) -> &'a Node {
46037 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45605 diff changeset	1019 (&self.bytes[32..52]).try_into().unwrap()
45537 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45532 diff changeset	1020 }
51224 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1021
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1022 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: 51219 diff changeset	1023 self.bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51219 diff changeset	1024 }
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1025 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1026
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1027 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1028 mod tests {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1029 use super::*;
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1030 use crate::node::NULL_NODE;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1031
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1032 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1033 #[derive(Debug, Copy, Clone)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1034 pub struct IndexEntryBuilder {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1035 is_first: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1036 is_inline: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1037 is_general_delta: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1038 version: u16,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1039 offset: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1040 compressed_len: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1041 uncompressed_len: usize,
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1042 base_revision_or_base_of_delta_chain: Revision,
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1043 link_revision: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1044 p1: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1045 p2: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1046 node: Node,
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1047 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1048
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1049 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1050 impl IndexEntryBuilder {
49999 0780371d6b1e rust-clippy: tell `clippy` we don't need to declare a default here Rapha?l Gom?s <rgomes@octobus.net> parents: 49749 diff changeset	1051 #[allow(clippy::new_without_default)]
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1052 pub fn new() -> Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1053 Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1054 is_first: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1055 is_inline: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1056 is_general_delta: true,
49147 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48575 diff changeset	1057 version: 1,
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1058 offset: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1059 compressed_len: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1060 uncompressed_len: 0,
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1061 base_revision_or_base_of_delta_chain: Revision(0),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1062 link_revision: Revision(0),
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1063 p1: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1064 p2: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1065 node: NULL_NODE,
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1066 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1067 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1068
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1069 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	1070 self.is_first = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1071 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1072 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1073
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1074 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	1075 self.is_inline = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1076 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1077 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1078
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1079 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	1080 self.is_general_delta = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1081 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1082 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1083
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1084 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	1085 self.version = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1086 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1087 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1088
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1089 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	1090 self.offset = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1091 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1092 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1093
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1094 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	1095 self.compressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1096 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1097 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1098
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1099 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	1100 self.uncompressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1101 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1102 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1103
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1104 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: 48496 diff changeset	1105 &mut self,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1106 value: Revision,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1107 ) -> &mut Self {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1108 self.base_revision_or_base_of_delta_chain = value;
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1109 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1110 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1111
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1112 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: 49147 diff changeset	1113 self.link_revision = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1114 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1115 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1116
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1117 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: 49147 diff changeset	1118 self.p1 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1119 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1120 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1121
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1122 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: 49147 diff changeset	1123 self.p2 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1124 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1125 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1126
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1127 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: 49147 diff changeset	1128 self.node = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1129 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1130 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1131
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1132 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	1133 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	1134 if self.is_first {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1135 bytes.extend(&match (self.is_general_delta, self.is_inline) {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1136 (false, false) => [0u8, 0],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1137 (false, true) => [0u8, 1],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1138 (true, false) => [0u8, 2],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1139 (true, true) => [0u8, 3],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1140 });
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1141 bytes.extend(&self.version.to_be_bytes());
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1142 // Remaining offset bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1143 bytes.extend(&[0u8; 2]);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1144 } else {
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46511 diff changeset	1145 // Offset stored on 48 bits (6 bytes)
6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46511 diff changeset	1146 bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1147 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1148 bytes.extend(&[0u8; 2]); // Revision flags.
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46511 diff changeset	1149 bytes.extend(&(self.compressed_len as u32).to_be_bytes());
6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46511 diff changeset	1150 bytes.extend(&(self.uncompressed_len as u32).to_be_bytes());
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1151 bytes.extend(
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1152 &self.base_revision_or_base_of_delta_chain.0.to_be_bytes(),
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1153 );
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1154 bytes.extend(&self.link_revision.0.to_be_bytes());
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1155 bytes.extend(&self.p1.0.to_be_bytes());
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1156 bytes.extend(&self.p2.0.to_be_bytes());
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1157 bytes.extend(self.node.as_bytes());
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1158 bytes.extend(vec![0u8; 12]);
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1159 bytes
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1160 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1161 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1162
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1163 pub fn is_inline(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1164 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1165 .expect("too short")
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	1166 .unwrap()
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1167 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1168 .is_inline()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1169 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1170
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1171 pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1172 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1173 .expect("too short")
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	1174 .unwrap()
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1175 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1176 .uses_generaldelta()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1177 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1178
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1179 pub fn get_version(index_bytes: &[u8]) -> u16 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1180 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1181 .expect("too short")
51212 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51210 diff changeset	1182 .unwrap()
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1183 .format_version()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1184 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1185
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1186 #[test]
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1187 fn flags_when_no_inline_flag_test() {
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1188 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: 45596 diff changeset	1189 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1190 .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: 45596 diff changeset	1191 .with_inline(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1192 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1193
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1194 assert!(!is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1195 assert!(!uses_generaldelta(&bytes));
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1196 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1197
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1198 #[test]
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1199 fn flags_when_inline_flag_test() {
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1200 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: 45596 diff changeset	1201 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1202 .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: 45596 diff changeset	1203 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1204 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1205
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1206 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1207 assert!(!uses_generaldelta(&bytes));
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1208 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1209
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1210 #[test]
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1211 fn flags_when_inline_and_generaldelta_flags_test() {
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1212 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: 45596 diff changeset	1213 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1214 .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: 45596 diff changeset	1215 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1216 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1217
50003 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1218 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49999 diff changeset	1219 assert!(uses_generaldelta(&bytes));
45604 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1220 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1221
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45596 diff changeset	1222 #[test]
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1223 fn test_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1224 let bytes = IndexEntryBuilder::new().with_offset(1).build();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1225 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1226 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1227 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1228 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1229
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1230 assert_eq!(entry.offset(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1231 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1232
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1233 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1234 fn test_with_overridden_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1235 let bytes = IndexEntryBuilder::new().with_offset(1).build();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1236 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1237 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1238 offset_override: Some(2),
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1239 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1240
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1241 assert_eq!(entry.offset(), 2)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1242 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1243
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1244 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1245 fn test_compressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1246 let bytes = IndexEntryBuilder::new().with_compressed_len(1).build();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1247 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1248 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1249 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1250 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1251
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1252 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	1253 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1254
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1255 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1256 fn test_uncompressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1257 let bytes = IndexEntryBuilder::new().with_uncompressed_len(1).build();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1258 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1259 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1260 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1261 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1262
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1263 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	1264 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1265
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1266 #[test]
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1267 fn test_base_revision_or_base_of_delta_chain() {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1268 let bytes = IndexEntryBuilder::new()
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1269 .with_base_revision_or_base_of_delta_chain(Revision(1))
48497 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48496 diff changeset	1270 .build();
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1271 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1272 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1273 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1274 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1275
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1276 assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1.into())
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1277 }
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1278
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1279 #[test]
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1280 fn link_revision_test() {
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1281 let bytes = IndexEntryBuilder::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1282 .with_link_revision(Revision(123))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1283 .build();
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1284
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1285 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1286 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1287 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1288 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1289
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1290 assert_eq!(entry.link_revision(), 123.into());
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1291 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1292
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1293 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1294 fn p1_test() {
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1295 let bytes = IndexEntryBuilder::new().with_p1(Revision(123)).build();
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1296
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1297 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1298 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1299 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1300 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1301
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1302 assert_eq!(entry.p1(), 123.into());
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1303 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1304
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1305 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1306 fn p2_test() {
50990 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50989 diff changeset	1307 let bytes = IndexEntryBuilder::new().with_p2(Revision(123)).build();
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1308
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1309 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1310 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1311 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1312 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1313
50988 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 50003 diff changeset	1314 assert_eq!(entry.p2(), 123.into());
49148 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1315 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1316
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1317 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1318 fn node_test() {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1319 let node = Node::from_hex("0123456789012345678901234567890123456789")
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1320 .unwrap();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1321 let bytes = IndexEntryBuilder::new().with_node(node).build();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1322
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1323 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1324 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1325 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1326 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1327
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1328 assert_eq!(*entry.hash(), node);
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1329 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1330
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49147 diff changeset	1331 #[test]
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1332 fn version_test() {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1333 let bytes = IndexEntryBuilder::new()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1334 .is_first(true)
49147 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48575 diff changeset	1335 .with_version(2)
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1336 .build();
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1337
49147 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48575 diff changeset	1338 assert_eq!(get_version(&bytes), 2)
48496 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48238 diff changeset	1339 }
45532 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1340 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1341
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1342 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1343 pub use tests::IndexEntryBuilder;

Mercurial > public > mercurial-scm > hg-stable

annotate rust/hg-core/src/revlog/index.rs @ 51239:0112803e6c01