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

annotate rust/hg-core/src/revlog/index.rs @ 51194:4e6620b7fbbb

rust-index: support cache clearing I'm not 100% sure how useful it is outside of perf, but it's still worth implementing.

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Mon, 30 Oct 2023 10:34:48 +0100
parents	f6403bcd9f96
children	51cc12158f97

rev	line source
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	1 use std::fmt::Debug;
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	2 use std::ops::Deref;
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	3 use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	4
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	5 use byteorder::{BigEndian, ByteOrder};
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	6 use bytes_cast::{unaligned, BytesCast};
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	7
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	8 use super::REVIDX_KNOWN_FLAGS;
46443 43d63979a75e rust: use HgError in RevlogError and Vfs Simon Sapin <simon.sapin@octobus.net> parents: 46090 diff changeset	9 use crate::errors::HgError;
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	10 use crate::node::{NODE_BYTES_LENGTH, STORED_NODE_ID_BYTES};
46033 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45602 diff changeset	11 use crate::revlog::node::Node;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	12 use crate::revlog::{Revision, NULL_REVISION};
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	13 use crate::{Graph, GraphError, RevlogError, RevlogIndex, UncheckedRevision};
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	14
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	15 pub const INDEX_ENTRY_SIZE: usize = 64;
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	16 pub const COMPRESSION_MODE_INLINE: u8 = 2;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	17
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	18 pub struct IndexHeader {
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	19 pub(super) header_bytes: [u8; 4],
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	20 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	21
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	22 #[derive(Copy, Clone)]
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	23 pub struct IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	24 flags: u16,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	25 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	26
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	27 /// Corresponds to the high bits of `_format_flags` in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	28 impl IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	29 /// Corresponds to FLAG_INLINE_DATA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	30 pub fn is_inline(self) -> bool {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	31 self.flags & 1 != 0
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	32 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	33 /// Corresponds to FLAG_GENERALDELTA in python
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	34 pub fn uses_generaldelta(self) -> bool {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	35 self.flags & 2 != 0
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	36 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	37 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	38
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	39 /// Corresponds to the INDEX_HEADER structure,
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	40 /// which is parsed as a `header` variable in `_loadindex` in `revlog.py`
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	41 impl IndexHeader {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	42 fn format_flags(&self) -> IndexHeaderFlags {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	43 // No "unknown flags" check here, unlike in python. Maybe there should
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	44 // be.
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	45 IndexHeaderFlags {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	46 flags: BigEndian::read_u16(&self.header_bytes[0..2]),
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	47 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	48 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	49
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	50 /// The only revlog version currently supported by rhg.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	51 const REVLOGV1: u16 = 1;
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	52
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	53 /// Corresponds to `_format_version` in Python.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	54 fn format_version(&self) -> u16 {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	55 BigEndian::read_u16(&self.header_bytes[2..4])
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	56 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	57
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	58 pub fn parse(index_bytes: &[u8]) -> Result<Option<IndexHeader>, HgError> {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	59 if index_bytes.is_empty() {
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	60 return Ok(None);
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	61 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	62 if index_bytes.len() < 4 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	63 return Err(HgError::corrupted(
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	64 "corrupted revlog: can't read the index format header",
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	65 ));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	66 }
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	67 Ok(Some(IndexHeader {
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	68 header_bytes: {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	69 let bytes: [u8; 4] =
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	70 index_bytes[0..4].try_into().expect("impossible");
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	71 bytes
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	72 },
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	73 }))
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	74 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	75 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	76
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	77 /// Abstracts the access to the index bytes since they can be spread between
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	78 /// the immutable (bytes) part and the mutable (added) part if any appends
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	79 /// happened. This makes it transparent for the callers.
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	80 struct IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	81 /// 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: 50976 diff changeset	82 bytes: Box<dyn Deref<Target = [u8]> + Send>,
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	83 /// Used when stripping index contents, keeps track of the start of the
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	84 /// first stripped revision, which is used to give a slice of the
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	85 /// `bytes` field.
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	86 truncation: Option<usize>,
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	87 /// Bytes that were added after reading the index
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	88 added: Vec<u8>,
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	89 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	90
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	91 impl IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	92 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: 50976 diff changeset	93 Self {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	94 bytes,
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	95 truncation: None,
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	96 added: vec![],
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	97 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	98 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	99
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	100 pub fn len(&self) -> usize {
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	101 match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	102 Some(truncation) => truncation + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	103 None => self.bytes.len() + self.added.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	104 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	105 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	106
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	107 fn remove(
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	108 &mut self,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	109 rev: Revision,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	110 offsets: Option<&[usize]>,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	111 ) -> Result<(), RevlogError> {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	112 let rev = rev.0 as usize;
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	113 let truncation = if let Some(offsets) = offsets {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	114 offsets[rev]
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	115 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	116 rev * INDEX_ENTRY_SIZE
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	117 };
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	118 if truncation < self.bytes.len() {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	119 self.truncation = Some(truncation);
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	120 self.added.clear();
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	121 } else {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	122 self.added.truncate(truncation - self.bytes.len());
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	123 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	124 Ok(())
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	125 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	126 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	127
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	128 impl std::ops::Index<std::ops::Range<usize>> for IndexData {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	129 type Output = [u8];
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	130
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	131 fn index(&self, index: std::ops::Range<usize>) -> &Self::Output {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	132 let start = index.start;
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	133 let end = index.end;
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	134 let immutable_len = match self.truncation {
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	135 Some(truncation) => truncation,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	136 None => self.bytes.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	137 };
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	138 if start < immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	139 if end > immutable_len {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	140 panic!("index data cannot span existing and added ranges");
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	141 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	142 &self.bytes[index]
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	143 } else {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	144 &self.added[start - immutable_len..end - immutable_len]
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	145 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	146 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	147 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	148
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	149 pub struct RevisionDataParams {
51189 65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	150 pub flags: u16,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	151 pub data_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	152 pub data_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	153 pub data_uncompressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	154 pub data_delta_base: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	155 pub link_rev: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	156 pub parent_rev_1: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	157 pub parent_rev_2: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	158 pub node_id: [u8; NODE_BYTES_LENGTH],
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	159 pub _sidedata_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	160 pub _sidedata_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	161 pub data_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	162 pub _sidedata_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	163 pub _rank: i32,
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	164 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	165
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	166 #[derive(BytesCast)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	167 #[repr(C)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	168 pub struct RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	169 data_offset_or_flags: unaligned::U64Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	170 data_compressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	171 data_uncompressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	172 data_delta_base: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	173 link_rev: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	174 parent_rev_1: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	175 parent_rev_2: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	176 node_id: [u8; STORED_NODE_ID_BYTES],
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	177 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	178
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	179 fn _static_assert_size_of_revision_data_v1() {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	180 let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	181 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	182
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	183 impl RevisionDataParams {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	184 pub fn validate(&self) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	185 if self.flags & !REVIDX_KNOWN_FLAGS != 0 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	186 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	187 "unknown revlog index flags: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	188 self.flags
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	189 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	190 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	191 if self.data_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	192 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	193 "invalid data compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	194 self.data_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	195 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	196 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	197 // FIXME isn't this only for v2 or changelog v2?
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	198 if self._sidedata_compression_mode != COMPRESSION_MODE_INLINE {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	199 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	200 "invalid sidedata compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	201 self._sidedata_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	202 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	203 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	204 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	205 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	206
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	207 pub fn into_v1(self) -> RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	208 let data_offset_or_flags = self.data_offset << 16 \| self.flags as u64;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	209 let mut node_id = [0; STORED_NODE_ID_BYTES];
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	210 node_id[..NODE_BYTES_LENGTH].copy_from_slice(&self.node_id);
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	211 RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	212 data_offset_or_flags: data_offset_or_flags.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	213 data_compressed_length: self.data_compressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	214 data_uncompressed_length: self.data_uncompressed_length.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	215 data_delta_base: self.data_delta_base.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	216 link_rev: self.link_rev.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	217 parent_rev_1: self.parent_rev_1.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	218 parent_rev_2: self.parent_rev_2.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	219 node_id,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	220 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	221 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	222 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	223
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	224 /// A Revlog index
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	225 pub struct Index {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	226 bytes: IndexData,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	227 /// 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	228 /// Only needed when the index is interleaved with data.
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	229 offsets: RwLock<Option<Vec<usize>>>,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	230 uses_generaldelta: bool,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	231 is_inline: bool,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	232 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	233
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	234 impl Debug for Index {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	235 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	236 f.debug_struct("Index")
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	237 .field("offsets", &self.offsets)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	238 .field("uses_generaldelta", &self.uses_generaldelta)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	239 .finish()
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	240 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	241 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	242
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	243 impl Graph for Index {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	244 fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	245 let err = \|\| GraphError::ParentOutOfRange(rev);
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	246 match self.get_entry(rev) {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	247 Some(entry) => {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	248 // The C implementation checks that the parents are valid
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	249 // before returning
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	250 Ok([
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	251 self.check_revision(entry.p1()).ok_or_else(err)?,
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	252 self.check_revision(entry.p2()).ok_or_else(err)?,
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	253 ])
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	254 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	255 None => Ok([NULL_REVISION, NULL_REVISION]),
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	256 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	257 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	258 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	259
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	260 impl Index {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	261 /// Create an index from bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	262 /// Calculate the start of each entry when is_inline is true.
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	263 pub fn new(
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	264 bytes: Box<dyn Deref<Target = [u8]> + Send>,
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	265 default_header: IndexHeader,
47963 001d747c2baf rust: Return HgError instead of RevlogError in revlog constructors Simon Sapin <simon.sapin@octobus.net> parents: 46887 diff changeset	266 ) -> Result<Self, HgError> {
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	267 let header =
13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	268 IndexHeader::parse(bytes.as_ref())?.unwrap_or(default_header);
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	269
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	270 if header.format_version() != IndexHeader::REVLOGV1 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	271 // A proper new version should have had a repo/store
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	272 // requirement.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	273 return Err(HgError::corrupted("unsupported revlog version"));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	274 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	275
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	276 // 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: 48457 diff changeset	277 // 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: 48457 diff changeset	278 // 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: 48457 diff changeset	279 let uses_generaldelta = header.format_flags().uses_generaldelta();
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	280
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	281 if header.format_flags().is_inline() {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	282 let mut offset: usize = 0;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	283 let mut offsets = Vec::new();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	284
45590 11f3c3f408fd hg-core: minor code style change (D8958#inline-14993 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45536 diff changeset	285 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	286 offsets.push(offset);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	287 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	288 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	289 bytes: &bytes[offset..end],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	290 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	291 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	292
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	293 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	294 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	295
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	296 if offset == bytes.len() {
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	297 Ok(Self {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	298 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	299 offsets: RwLock::new(Some(offsets)),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	300 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	301 is_inline: true,
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	302 })
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	303 } else {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	304 Err(HgError::corrupted("unexpected inline revlog length"))
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	305 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	306 } else {
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	307 Ok(Self {
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	308 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	309 offsets: RwLock::new(None),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	310 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	311 is_inline: false,
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	312 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	313 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	314 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	315
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	316 pub fn uses_generaldelta(&self) -> bool {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	317 self.uses_generaldelta
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	318 }
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	319
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	320 /// Value of the inline flag.
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	321 pub fn is_inline(&self) -> bool {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	322 self.is_inline
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	323 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	324
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	325 /// Return a slice of bytes if `revlog` is inline. Panic if not.
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	326 pub fn data(&self, start: usize, end: usize) -> &[u8] {
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	327 if !self.is_inline() {
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	328 panic!("tried to access data in the index of a revlog that is not inline");
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	329 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	330 &self.bytes[start..end]
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	331 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	332
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	333 /// Return number of entries of the revlog index.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	334 pub fn len(&self) -> usize {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	335 if let Some(offsets) = &*self.get_offsets() {
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	336 offsets.len()
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	337 } else {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	338 self.bytes.len() / INDEX_ENTRY_SIZE
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	339 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	340 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	341
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	342 pub fn get_offsets(&self) -> RwLockReadGuard<Option<Vec<usize>>> {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	343 if self.is_inline() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	344 {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	345 // Wrap in a block to drop the read guard
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	346 // TODO perf?
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	347 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	348 if offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	349 offsets.replace(inline_scan(&self.bytes.bytes).1);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	350 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	351 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	352 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	353 self.offsets.read().unwrap()
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	354 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	355
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	356 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: 51192 diff changeset	357 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	358 if self.is_inline() && offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	359 offsets.replace(inline_scan(&self.bytes.bytes).1);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	360 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	361 offsets
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	362 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	363
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	364 /// Returns `true` if the `Index` has zero `entries`.
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	365 pub fn is_empty(&self) -> bool {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	366 self.len() == 0
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	367 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	368
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	369 /// Return the index entry corresponding to the given revision if it
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	370 /// exists.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	371 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	372 if rev == NULL_REVISION {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	373 return None;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	374 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	375 Some(if let Some(offsets) = &*self.get_offsets() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	376 self.get_entry_inline(rev, offsets.as_ref())
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	377 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	378 self.get_entry_separated(rev)
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	379 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	380 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	381
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	382 fn get_entry_inline(
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	383 &self,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	384 rev: Revision,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	385 offsets: &[usize],
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	386 ) -> IndexEntry {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	387 let start = offsets[rev.0 as usize];
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	388 let end = start + INDEX_ENTRY_SIZE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	389 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	390
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	391 // 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	392 let offset_override = Some(end);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	393
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	394 IndexEntry {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	395 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	396 offset_override,
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	397 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	398 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	399
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	400 fn get_entry_separated(&self, rev: Revision) -> IndexEntry {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	401 let start = rev.0 as usize * INDEX_ENTRY_SIZE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	402 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	403 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	404
45591 f38adf8b0711 hg-core: Explain offset override of first revision Antoine cezar<acezar@chwitlabs.fr> parents: 45590 diff changeset	405 // 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: 45590 diff changeset	406 // for the index's metadata (saving space because it is always 0)
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	407 let offset_override = if rev == Revision(0) { Some(0) } else { None };
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	408
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	409 IndexEntry {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	410 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	411 offset_override,
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	412 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	413 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	414
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	415 /// TODO move this to the trait probably, along with other things
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	416 pub fn append(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	417 &mut self,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	418 revision_data: RevisionDataParams,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	419 ) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	420 revision_data.validate()?;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	421 let new_offset = self.bytes.len();
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	422 if let Some(offsets) = &mut *self.get_offsets_mut() {
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	423 offsets.push(new_offset)
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	424 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	425 self.bytes.added.extend(revision_data.into_v1().as_bytes());
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	426 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	427 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	428
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	429 pub fn remove(&mut self, rev: Revision) -> Result<(), RevlogError> {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	430 let offsets = self.get_offsets().clone();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	431 self.bytes.remove(rev, offsets.as_deref())?;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	432 if let Some(offsets) = &mut *self.get_offsets_mut() {
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	433 offsets.truncate(rev.0 as usize)
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	434 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	435 Ok(())
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	436 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	437
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	438 pub fn clear_caches(&mut self) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	439 // We need to get the 'inline' value from Python at init and use this
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	440 // instead of offsets to determine whether we're inline since we might
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	441 // clear caches. This implies re-populating the offsets on-demand.
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	442 self.offsets = RwLock::new(None);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	443 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	444 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	445
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	446 fn inline_scan(bytes: &[u8]) -> (usize, Vec<usize>) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	447 let mut offset: usize = 0;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	448 let mut offsets = Vec::new();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	449
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	450 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	451 offsets.push(offset);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	452 let end = offset + INDEX_ENTRY_SIZE;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	453 let entry = IndexEntry {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	454 bytes: &bytes[offset..end],
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	455 offset_override: None,
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	456 };
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	457
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	458 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	459 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	460 (offset, offsets)
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	461 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	462
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	463 impl super::RevlogIndex for Index {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	464 fn len(&self) -> usize {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	465 self.len()
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	466 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	467
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	468 fn node(&self, rev: Revision) -> Option<&Node> {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	469 self.get_entry(rev).map(\|entry\| entry.hash())
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	470 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	471 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	472
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	473 #[derive(Debug)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	474 pub struct IndexEntry<'a> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	475 bytes: &'a [u8],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	476 /// 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	477 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	478 /// 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	479 /// 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	480 /// 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	481 /// 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	482 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	483 /// 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	484 /// 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	485 /// 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	486 offset_override: Option<usize>,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	487 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	488
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	489 impl<'a> IndexEntry<'a> {
45593 da30e4b553c3 hg-core: minor docstring update (D8958#inline-14991 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45592 diff changeset	490 /// Return the offset of the data.
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	491 pub fn offset(&self) -> usize {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	492 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	493 offset_override
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	494 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	495 let mut bytes = [0; 8];
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	496 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	497 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	498 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	499 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	500
48546 e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	501 pub fn flags(&self) -> u16 {
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	502 BigEndian::read_u16(&self.bytes[6..=7])
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	503 }
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	504
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	505 /// Return the compressed length of the data.
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	506 pub fn compressed_len(&self) -> u32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	507 BigEndian::read_u32(&self.bytes[8..=11])
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	508 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	509
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	510 /// Return the uncompressed length of the data.
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	511 pub fn uncompressed_len(&self) -> i32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	512 BigEndian::read_i32(&self.bytes[12..=15])
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	513 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	514
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	515 /// Return the revision upon which the data has been derived.
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	516 pub fn base_revision_or_base_of_delta_chain(&self) -> UncheckedRevision {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	517 // 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	518 // 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	519
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	520 BigEndian::read_i32(&self.bytes[16..]).into()
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	521 }
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	522
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	523 pub fn link_revision(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	524 BigEndian::read_i32(&self.bytes[20..]).into()
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	525 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	526
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	527 pub fn p1(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	528 BigEndian::read_i32(&self.bytes[24..]).into()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	529 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	530
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	531 pub fn p2(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	532 BigEndian::read_i32(&self.bytes[28..]).into()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	533 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	534
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	535 /// Return the hash of revision's full text.
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	536 ///
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	537 /// Currently, SHA-1 is used and only the first 20 bytes of this field
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	538 /// are used.
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	539 pub fn hash(&self) -> &'a Node {
46033 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45602 diff changeset	540 (&self.bytes[32..52]).try_into().unwrap()
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	541 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	542 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	543
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	544 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	545 mod tests {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	546 use super::*;
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	547 use crate::node::NULL_NODE;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	548
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	549 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	550 #[derive(Debug, Copy, Clone)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	551 pub struct IndexEntryBuilder {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	552 is_first: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	553 is_inline: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	554 is_general_delta: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	555 version: u16,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	556 offset: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	557 compressed_len: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	558 uncompressed_len: usize,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	559 base_revision_or_base_of_delta_chain: Revision,
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	560 link_revision: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	561 p1: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	562 p2: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	563 node: Node,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	564 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	565
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	566 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	567 impl IndexEntryBuilder {
49926 0780371d6b1e rust-clippy: tell `clippy` we don't need to declare a default here Rapha?l Gom?s <rgomes@octobus.net> parents: 49631 diff changeset	568 #[allow(clippy::new_without_default)]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	569 pub fn new() -> Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	570 Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	571 is_first: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	572 is_inline: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	573 is_general_delta: true,
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	574 version: 1,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	575 offset: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	576 compressed_len: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	577 uncompressed_len: 0,
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	578 base_revision_or_base_of_delta_chain: Revision(0),
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	579 link_revision: Revision(0),
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	580 p1: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	581 p2: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	582 node: NULL_NODE,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	583 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	584 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	585
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	586 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	587 self.is_first = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	588 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	589 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	590
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	591 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	592 self.is_inline = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	593 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	594 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	595
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	596 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	597 self.is_general_delta = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	598 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	599 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	600
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	601 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	602 self.version = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	603 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	604 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	605
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	606 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	607 self.offset = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	608 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	609 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	610
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	611 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	612 self.compressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	613 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	614 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	615
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	616 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	617 self.uncompressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	618 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	619 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	620
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	621 pub fn with_base_revision_or_base_of_delta_chain(
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	622 &mut self,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	623 value: Revision,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	624 ) -> &mut Self {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	625 self.base_revision_or_base_of_delta_chain = value;
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	626 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	627 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	628
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	629 pub fn with_link_revision(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	630 self.link_revision = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	631 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	632 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	633
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	634 pub fn with_p1(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	635 self.p1 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	636 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	637 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	638
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	639 pub fn with_p2(&mut self, value: Revision) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	640 self.p2 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	641 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	642 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	643
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	644 pub fn with_node(&mut self, value: Node) -> &mut Self {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	645 self.node = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	646 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	647 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	648
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	649 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	650 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	651 if self.is_first {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	652 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	653 (false, false) => [0u8, 0],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	654 (false, true) => [0u8, 1],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	655 (true, false) => [0u8, 2],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	656 (true, true) => [0u8, 3],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	657 });
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	658 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	659 // Remaining offset bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	660 bytes.extend(&[0u8; 2]);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	661 } else {
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	662 // Offset stored on 48 bits (6 bytes)
6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	663 bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	664 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	665 bytes.extend(&[0u8; 2]); // Revision flags.
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	666 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: 46443 diff changeset	667 bytes.extend(&(self.uncompressed_len as u32).to_be_bytes());
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	668 bytes.extend(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	669 &self.base_revision_or_base_of_delta_chain.0.to_be_bytes(),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	670 );
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	671 bytes.extend(&self.link_revision.0.to_be_bytes());
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	672 bytes.extend(&self.p1.0.to_be_bytes());
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	673 bytes.extend(&self.p2.0.to_be_bytes());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	674 bytes.extend(self.node.as_bytes());
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	675 bytes.extend(vec![0u8; 12]);
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	676 bytes
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	677 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	678 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	679
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	680 pub fn is_inline(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	681 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	682 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	683 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	684 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	685 .is_inline()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	686 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	687
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	688 pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	689 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	690 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	691 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	692 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	693 .uses_generaldelta()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	694 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	695
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	696 pub fn get_version(index_bytes: &[u8]) -> u16 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	697 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	698 .expect("too short")
51188 13f58ce70299 rust-revlog: teach the revlog opening code to read the repo options Rapha?l Gom?s <rgomes@octobus.net> parents: 51186 diff changeset	699 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	700 .format_version()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	701 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	702
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	703 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	704 fn flags_when_no_inline_flag_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	705 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	706 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	707 .with_general_delta(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	708 .with_inline(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	709 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	710
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	711 assert!(!is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	712 assert!(!uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	713 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	714
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	715 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	716 fn flags_when_inline_flag_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	717 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	718 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	719 .with_general_delta(false)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	720 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	721 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	722
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	723 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	724 assert!(!uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	725 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	726
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	727 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	728 fn flags_when_inline_and_generaldelta_flags_test() {
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	729 let bytes = IndexEntryBuilder::new()
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	730 .is_first(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	731 .with_general_delta(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	732 .with_inline(true)
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	733 .build();
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	734
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	735 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	736 assert!(uses_generaldelta(&bytes));
45601 900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	737 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	738
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	739 #[test]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	740 fn test_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	741 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	742 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	743 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	744 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	745 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	746
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	747 assert_eq!(entry.offset(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	748 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	749
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	750 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	751 fn test_with_overridden_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	752 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	753 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	754 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	755 offset_override: Some(2),
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	756 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	757
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	758 assert_eq!(entry.offset(), 2)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	759 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	760
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	761 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	762 fn test_compressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	763 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	764 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	765 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	766 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	767 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	768
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	769 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	770 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	771
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	772 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	773 fn test_uncompressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	774 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	775 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	776 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	777 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	778 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	779
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	780 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	781 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	782
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	783 #[test]
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	784 fn test_base_revision_or_base_of_delta_chain() {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	785 let bytes = IndexEntryBuilder::new()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	786 .with_base_revision_or_base_of_delta_chain(Revision(1))
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	787 .build();
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	788 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	789 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	790 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	791 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	792
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	793 assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1.into())
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	794 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	795
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	796 #[test]
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	797 fn link_revision_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	798 let bytes = IndexEntryBuilder::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	799 .with_link_revision(Revision(123))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	800 .build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	801
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	802 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	803 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	804 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	805 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	806
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	807 assert_eq!(entry.link_revision(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	808 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	809
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	810 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	811 fn p1_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	812 let bytes = IndexEntryBuilder::new().with_p1(Revision(123)).build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	813
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	814 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	815 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	816 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	817 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	818
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	819 assert_eq!(entry.p1(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	820 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	821
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	822 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	823 fn p2_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	824 let bytes = IndexEntryBuilder::new().with_p2(Revision(123)).build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	825
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	826 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	827 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	828 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	829 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	830
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	831 assert_eq!(entry.p2(), 123.into());
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	832 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	833
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	834 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	835 fn node_test() {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	836 let node = Node::from_hex("0123456789012345678901234567890123456789")
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	837 .unwrap();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	838 let bytes = IndexEntryBuilder::new().with_node(node).build();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	839
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	840 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	841 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	842 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	843 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	844
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	845 assert_eq!(*entry.hash(), node);
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	846 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	847
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	848 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	849 fn version_test() {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	850 let bytes = IndexEntryBuilder::new()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	851 .is_first(true)
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	852 .with_version(2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	853 .build();
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	854
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	855 assert_eq!(get_version(&bytes), 2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	856 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	857 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	858
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	859 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	860 pub use tests::IndexEntryBuilder;

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/revlog/index.rs @ 51194:4e6620b7fbbb