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

annotate rust/hg-core/src/revlog/index.rs @ 51208:b8c89957a6b7

rust-index: add `is_snapshot` method

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Thu, 03 Aug 2023 12:05:32 +0200
parents	e9d47e2f5dcf
children	9b06e7f32bc5

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;
51206 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	10 use crate::node::{NODE_BYTES_LENGTH, NULL_NODE, STORED_NODE_ID_BYTES};
46033 88e741bf2d93 rust: use NodePrefix::from_hex instead of hex::decode directly Simon Sapin <simon-commits@exyr.org> parents: 45602 diff changeset	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 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	126
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	127 fn is_new(&self) -> bool {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	128 self.bytes.is_empty()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	129 }
51185 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
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	132 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	133 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	134
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	135 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	136 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	137 let end = index.end;
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	138 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	139 Some(truncation) => truncation,
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	140 None => self.bytes.len(),
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	141 };
51185 1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	142 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	143 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	144 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	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 &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	147 } else {
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	148 &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	149 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	150 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	151 }
1ef4a36a934d rust-index: add an abstraction to support bytes added at runtimes Rapha?l Gom?s <rgomes@octobus.net> parents: 50976 diff changeset	152
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	153 #[derive(Debug, PartialEq, Eq)]
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	154 pub struct RevisionDataParams {
51189 65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	155 pub flags: u16,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	156 pub data_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	157 pub data_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	158 pub data_uncompressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	159 pub data_delta_base: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	160 pub link_rev: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	161 pub parent_rev_1: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	162 pub parent_rev_2: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	163 pub node_id: [u8; NODE_BYTES_LENGTH],
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	164 pub _sidedata_offset: u64,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	165 pub _sidedata_compressed_length: i32,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	166 pub data_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	167 pub _sidedata_compression_mode: u8,
65c9032e2e5a rust-index: synchronize append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51188 diff changeset	168 pub _rank: i32,
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	169 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	170
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	171 impl Default for RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	172 fn default() -> Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	173 Self {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	174 flags: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	175 data_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	176 data_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	177 data_uncompressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	178 data_delta_base: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	179 link_rev: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	180 parent_rev_1: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	181 parent_rev_2: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	182 node_id: [0; NODE_BYTES_LENGTH],
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	183 _sidedata_offset: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	184 _sidedata_compressed_length: 0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	185 data_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	186 _sidedata_compression_mode: COMPRESSION_MODE_INLINE,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	187 _rank: -1,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	188 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	189 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	190 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	191
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	192 #[derive(BytesCast)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	193 #[repr(C)]
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	194 pub struct RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	195 data_offset_or_flags: unaligned::U64Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	196 data_compressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	197 data_uncompressed_length: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	198 data_delta_base: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	199 link_rev: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	200 parent_rev_1: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	201 parent_rev_2: unaligned::I32Be,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	202 node_id: [u8; STORED_NODE_ID_BYTES],
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
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	205 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	206 let _ = std::mem::transmute::<RevisionDataV1, [u8; 64]>;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	207 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	208
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	209 impl RevisionDataParams {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	210 pub fn validate(&self) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	211 if self.flags & !REVIDX_KNOWN_FLAGS != 0 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	212 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	213 "unknown revlog index flags: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	214 self.flags
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	215 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	216 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	217 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	218 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	219 "invalid data compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	220 self.data_compression_mode
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 // 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	224 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	225 return Err(RevlogError::corrupted(format!(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	226 "invalid sidedata compression mode: {}",
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	227 self._sidedata_compression_mode
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	228 )));
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	229 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	230 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	231 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	232
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	233 pub fn into_v1(self) -> RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	234 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	235 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	236 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	237 RevisionDataV1 {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	238 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	239 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	240 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	241 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	242 link_rev: self.link_rev.into(),
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	243 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	244 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	245 node_id,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	246 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	247 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	248 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	249
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	250 /// 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	251 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	252 bytes: IndexData,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	253 /// 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	254 /// 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	255 offsets: RwLock<Option<Vec<usize>>>,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	256 uses_generaldelta: bool,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	257 is_inline: bool,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	258 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	259
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	260 impl Debug for Index {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	261 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	262 f.debug_struct("Index")
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	263 .field("offsets", &self.offsets)
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	264 .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	265 .finish()
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	266 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	267 }
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	268
50975 27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	269 impl Graph for Index {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	270 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	271 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	272 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	273 Some(entry) => {
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	274 // 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	275 // before returning
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	276 Ok([
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	277 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	278 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	279 ])
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	280 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	281 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	282 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	283 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	284 }
27e773aa607d rust: implement the `Graph` trait for all revlogs Rapha?l Gom?s <rgomes@octobus.net> parents: 50974 diff changeset	285
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	286 impl Index {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	287 /// Create an index from bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	288 /// 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	289 pub fn new(
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	290 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	291 default_header: IndexHeader,
47963 001d747c2baf rust: Return HgError instead of RevlogError in revlog constructors Simon Sapin <simon.sapin@octobus.net> parents: 46887 diff changeset	292 ) -> 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	293 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	294 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	295
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	296 if header.format_version() != IndexHeader::REVLOGV1 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	297 // 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	298 // requirement.
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	299 return Err(HgError::corrupted("unsupported revlog version"));
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	300 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	301
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	302 // 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	303 // 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	304 // 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	305 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	306
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	307 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	308 let mut offset: usize = 0;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	309 let mut offsets = Vec::new();
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	310
45590 11f3c3f408fd hg-core: minor code style change (D8958#inline-14993 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45536 diff changeset	311 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	312 offsets.push(offset);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	313 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	314 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	315 bytes: &bytes[offset..end],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	316 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	317 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	318
48543 0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	319 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	320 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	321
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	322 if offset == bytes.len() {
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	323 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	324 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	325 offsets: RwLock::new(Some(offsets)),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	326 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	327 is_inline: true,
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	328 })
1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	329 } else {
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	330 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	331 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	332 } else {
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	333 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	334 bytes: IndexData::new(bytes),
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	335 offsets: RwLock::new(None),
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	336 uses_generaldelta,
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	337 is_inline: false,
45602 1cef583541c0 hg-core: return Err if `offset != bytes.len()` Antoine cezar<acezar@chwitlabs.fr> parents: 45601 diff changeset	338 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	339 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	340 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	341
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	342 pub fn uses_generaldelta(&self) -> bool {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	343 self.uses_generaldelta
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	344 }
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	345
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	346 /// 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	347 pub fn is_inline(&self) -> bool {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	348 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	349 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	350
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	351 /// 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	352 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	353 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	354 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	355 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	356 &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	357 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	358
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	359 /// 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	360 pub fn len(&self) -> usize {
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	361 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	362 offsets.len()
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	363 } else {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	364 self.bytes.len() / INDEX_ENTRY_SIZE
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	365 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	366 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	367
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	368 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	369 if self.is_inline() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	370 {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	371 // 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	372 // TODO perf?
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	373 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	374 if offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	375 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	376 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	377 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	378 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	379 self.offsets.read().unwrap()
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	380 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	381
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	382 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	383 let mut offsets = self.offsets.write().unwrap();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	384 if self.is_inline() && offsets.is_none() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	385 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	386 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	387 offsets
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	388 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	389
45536 639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	390 /// 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	391 pub fn is_empty(&self) -> bool {
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	392 self.len() == 0
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	393 }
639f33f22faf hg-core: add a `ListRevTrackedFiles` operation Antoine Cezar <antoine.cezar@octobus.net> parents: 45531 diff changeset	394
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	395 /// Return the index entry corresponding to the given revision or `None`
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	396 /// for [`NULL_REVISION`]
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	397 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	398 /// The specified revision being of the checked type, it always exists
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	399 /// if it was validated by this index.
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	400 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	401 if rev == NULL_REVISION {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	402 return None;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	403 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	404 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	405 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	406 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	407 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	408 })
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	409 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	410
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	411 /// Return the binary content of the index entry for the given revision
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	412 ///
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	413 /// See [get_entry()](`Self::get_entry()`) for cases when `None` is
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	414 /// returned.
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	415 pub fn entry_binary(&self, rev: Revision) -> Option<&[u8]> {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	416 self.get_entry(rev).map(\|e\| {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	417 let bytes = e.as_bytes();
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	418 if rev.0 == 0 {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	419 &bytes[4..]
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	420 } else {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	421 bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	422 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	423 })
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	424 }
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	425
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	426 pub fn entry_as_params(
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	427 &self,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	428 rev: UncheckedRevision,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	429 ) -> Option<RevisionDataParams> {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	430 let rev = self.check_revision(rev)?;
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	431 self.get_entry(rev).map(\|e\| RevisionDataParams {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	432 flags: e.flags(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	433 data_offset: if rev.0 == 0 && !self.bytes.is_new() {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	434 e.flags() as u64
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	435 } else {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	436 e.raw_offset()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	437 },
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	438 data_compressed_length: e.compressed_len().try_into().unwrap(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	439 data_uncompressed_length: e.uncompressed_len(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	440 data_delta_base: e.base_revision_or_base_of_delta_chain().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	441 link_rev: e.link_revision().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	442 parent_rev_1: e.p1().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	443 parent_rev_2: e.p2().0,
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	444 node_id: e.hash().as_bytes().try_into().unwrap(),
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	445 ..Default::default()
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	446 })
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	447 }
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	448
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	449 fn get_entry_inline(
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	450 &self,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	451 rev: Revision,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	452 offsets: &[usize],
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	453 ) -> IndexEntry {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	454 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	455 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	456 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	457
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	458 // 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	459 let offset_override = Some(end);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	460
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	461 IndexEntry {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	462 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	463 offset_override,
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	464 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	465 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	466
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	467 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	468 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	469 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	470 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	471
45591 f38adf8b0711 hg-core: Explain offset override of first revision Antoine cezar<acezar@chwitlabs.fr> parents: 45590 diff changeset	472 // 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	473 // 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	474 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	475
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	476 IndexEntry {
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	477 bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	478 offset_override,
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	479 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	480 }
51186 b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	481
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	482 /// 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	483 pub fn append(
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	484 &mut self,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	485 revision_data: RevisionDataParams,
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	486 ) -> Result<(), RevlogError> {
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	487 revision_data.validate()?;
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	488 let new_offset = self.bytes.len();
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	489 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	490 offsets.push(new_offset)
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	491 }
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	492 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	493 Ok(())
b4d152a28742 rust-index: add append method Rapha?l Gom?s <rgomes@octobus.net> parents: 51185 diff changeset	494 }
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	495
51195 51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	496 pub fn pack_header(&self, header: i32) -> [u8; 4] {
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	497 header.to_be_bytes()
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	498 }
51cc12158f97 rust-index: add `pack_header` support Rapha?l Gom?s <rgomes@octobus.net> parents: 51194 diff changeset	499
51192 f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	500 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	501 let offsets = self.get_offsets().clone();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	502 self.bytes.remove(rev, offsets.as_deref())?;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	503 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	504 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	505 }
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	506 Ok(())
f6403bcd9f96 rust-index: synchronize remove to Rust index Rapha?l Gom?s <rgomes@octobus.net> parents: 51189 diff changeset	507 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	508
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	509 pub fn clear_caches(&mut self) {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	510 // 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	511 // 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	512 // 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	513 self.offsets = RwLock::new(None);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	514 }
51208 b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	515
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	516 /// Unchecked version of `is_snapshot`.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	517 /// Assumes the caller checked that `rev` is within a valid revision range.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	518 pub fn is_snapshot_unchecked(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	519 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	520 mut rev: Revision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	521 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	522 while rev.0 >= 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	523 let entry = self.get_entry(rev).unwrap();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	524 let mut base = entry.base_revision_or_base_of_delta_chain().0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	525 if base == rev.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	526 base = NULL_REVISION.0;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	527 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	528 if base == NULL_REVISION.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	529 return Ok(true);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	530 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	531 let [mut p1, mut p2] = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	532 .parents(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	533 .map_err(\|_\| RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	534 while let Some(p1_entry) = self.get_entry(p1) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	535 if p1_entry.compressed_len() != 0 \|\| p1.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	536 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	537 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	538 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	539 p1_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	540 if parent_base.0 == p1.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	541 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	542 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	543 p1 = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	544 .check_revision(parent_base)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	545 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	546 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	547 while let Some(p2_entry) = self.get_entry(p2) {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	548 if p2_entry.compressed_len() != 0 \|\| p2.0 == 0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	549 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	550 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	551 let parent_base =
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	552 p2_entry.base_revision_or_base_of_delta_chain();
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	553 if parent_base.0 == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	554 break;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	555 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	556 p2 = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	557 .check_revision(parent_base)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	558 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	559 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	560 if base == p1.0 \|\| base == p2.0 {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	561 return Ok(false);
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	562 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	563 rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	564 .check_revision(base.into())
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	565 .ok_or(RevlogError::InvalidRevision)?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	566 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	567 Ok(rev == NULL_REVISION)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	568 }
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	569
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	570 /// Return whether the given revision is a snapshot. Returns an error if
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	571 /// `rev` is not within a valid revision range.
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	572 pub fn is_snapshot(
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	573 &self,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	574 rev: UncheckedRevision,
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	575 ) -> Result<bool, RevlogError> {
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	576 let rev = self
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	577 .check_revision(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	578 .ok_or_else(\|\| RevlogError::corrupted("test"))?;
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	579 self.is_snapshot_unchecked(rev)
b8c89957a6b7 rust-index: add `is_snapshot` method Rapha?l Gom?s <rgomes@octobus.net> parents: 51206 diff changeset	580 }
51194 4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	581 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	582 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	583 let mut offset: usize = 0;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	584 let mut offsets = Vec::new();
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	585
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	586 while offset + INDEX_ENTRY_SIZE <= bytes.len() {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	587 offsets.push(offset);
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	588 let end = offset + INDEX_ENTRY_SIZE;
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	589 let entry = IndexEntry {
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	590 bytes: &bytes[offset..end],
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	591 offset_override: None,
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	592 };
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	593
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	594 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	595 }
4e6620b7fbbb rust-index: support cache clearing Rapha?l Gom?s <rgomes@octobus.net> parents: 51192 diff changeset	596 (offset, offsets)
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	597 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	598
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	599 impl super::RevlogIndex for Index {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	600 fn len(&self) -> usize {
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	601 self.len()
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	602 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	603
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	604 fn node(&self, rev: Revision) -> Option<&Node> {
51206 e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	605 if rev == NULL_REVISION {
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	606 return Some(&NULL_NODE);
e9d47e2f5dcf rust-index: add missing special case for null rev Rapha?l Gom?s <rgomes@octobus.net> parents: 51202 diff changeset	607 }
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	608 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	609 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	610 }
9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	611
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	612 #[derive(Debug)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	613 pub struct IndexEntry<'a> {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	614 bytes: &'a [u8],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	615 /// 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	616 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	617 /// 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	618 /// 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	619 /// 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	620 /// 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	621 ///
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	622 /// 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	623 /// 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	624 /// 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	625 offset_override: Option<usize>,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	626 }
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 impl<'a> IndexEntry<'a> {
45593 da30e4b553c3 hg-core: minor docstring update (D8958#inline-14991 followup) Antoine cezar<acezar@chwitlabs.fr> parents: 45592 diff changeset	629 /// 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	630 pub fn offset(&self) -> usize {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	631 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	632 offset_override
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	633 } else {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	634 let mut bytes = [0; 8];
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	635 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	636 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	637 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	638 }
51202 002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	639 pub fn raw_offset(&self) -> u64 {
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	640 BigEndian::read_u64(&self.bytes[0..8])
002b49905aac rust-index: implementation of __getitem__ Rapha?l Gom?s <rgomes@octobus.net> parents: 51200 diff changeset	641 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	642
48546 e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	643 pub fn flags(&self) -> u16 {
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	644 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	645 }
e91aa800ae5b rhg: desambiguate status without decompressing filelog if possible Simon Sapin <simon.sapin@octobus.net> parents: 48543 diff changeset	646
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	647 /// 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	648 pub fn compressed_len(&self) -> u32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	649 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	650 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	651
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	652 /// 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	653 pub fn uncompressed_len(&self) -> i32 {
0a4ac916673e rhg: RevlogEntry::uncompressed_len is signed Simon Sapin <simon.sapin@octobus.net> parents: 48458 diff changeset	654 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	655 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	656
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	657 /// 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	658 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	659 // 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	660 // 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	661
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	662 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	663 }
45531 b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	664
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	665 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	666 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	667 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	668
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	669 pub fn p1(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	670 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	671 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	672
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	673 pub fn p2(&self) -> UncheckedRevision {
1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	674 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	675 }
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	676
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	677 /// 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	678 ///
b0d6309ff50c hg-core: check data integrity in `Revlog` Antoine Cezar <antoine.cezar@octobus.net> parents: 45526 diff changeset	679 /// 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	680 /// are used.
46090 9eb07ab3f2d4 rhg: use persistent nodemap when available Simon Sapin <simon-commits@exyr.org> parents: 46033 diff changeset	681 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	682 (&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	683 }
51200 7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	684
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	685 pub fn as_bytes(&self) -> &'a [u8] {
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	686 self.bytes
7434747343ab rust-index: check that the entry bytes are the same in both indexes Rapha?l Gom?s <rgomes@octobus.net> parents: 51195 diff changeset	687 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	688 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	689
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	690 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	691 mod tests {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	692 use super::*;
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	693 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	694
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	695 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	696 #[derive(Debug, Copy, Clone)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	697 pub struct IndexEntryBuilder {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	698 is_first: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	699 is_inline: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	700 is_general_delta: bool,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	701 version: u16,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	702 offset: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	703 compressed_len: usize,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	704 uncompressed_len: usize,
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	705 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	706 link_revision: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	707 p1: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	708 p2: Revision,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	709 node: Node,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	710 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	711
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	712 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	713 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	714 #[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	715 pub fn new() -> Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	716 Self {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	717 is_first: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	718 is_inline: false,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	719 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	720 version: 1,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	721 offset: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	722 compressed_len: 0,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	723 uncompressed_len: 0,
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	724 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	725 link_revision: Revision(0),
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	726 p1: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	727 p2: NULL_REVISION,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	728 node: NULL_NODE,
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	729 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	730 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	731
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	732 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	733 self.is_first = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	734 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	735 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	736
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	737 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	738 self.is_inline = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	739 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	740 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	741
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	742 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	743 self.is_general_delta = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	744 self
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 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	748 self.version = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	749 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	750 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	751
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	752 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	753 self.offset = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	754 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	755 }
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 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	758 self.compressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	759 self
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
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	762 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	763 self.uncompressed_len = value;
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	764 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	765 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	766
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	767 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	768 &mut self,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	769 value: Revision,
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	770 ) -> &mut Self {
96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	771 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	772 self
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	773 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	774
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	775 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	776 self.link_revision = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	777 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	778 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	779
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	780 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	781 self.p1 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	782 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	783 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	784
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	785 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	786 self.p2 = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	787 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	788 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	789
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	790 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	791 self.node = value;
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	792 self
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	793 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	794
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	795 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	796 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	797 if self.is_first {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	798 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	799 (false, false) => [0u8, 0],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	800 (false, true) => [0u8, 1],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	801 (true, false) => [0u8, 2],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	802 (true, true) => [0u8, 3],
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	803 });
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	804 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	805 // Remaining offset bytes.
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	806 bytes.extend(&[0u8; 2]);
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	807 } else {
46887 6d5a26e94d9e unit-tests: Fix `cargo test` on 32-bit platforms Simon Sapin <simon.sapin@octobus.net> parents: 46443 diff changeset	808 // 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	809 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	810 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	811 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	812 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	813 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	814 bytes.extend(
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	815 &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	816 );
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	817 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	818 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	819 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	820 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	821 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	822 bytes
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	823 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	824 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	825
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	826 pub fn is_inline(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	827 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	828 .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	829 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	830 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	831 .is_inline()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	832 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	833
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	834 pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	835 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	836 .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	837 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	838 .format_flags()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	839 .uses_generaldelta()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	840 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	841
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	842 pub fn get_version(index_bytes: &[u8]) -> u16 {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	843 IndexHeader::parse(index_bytes)
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	844 .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	845 .unwrap()
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	846 .format_version()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	847 }
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	848
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	849 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	850 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	851 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	852 .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	853 .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	854 .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	855 .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	856
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	857 assert!(!is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	858 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	859 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	860
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	861 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	862 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	863 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	864 .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	865 .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	866 .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	867 .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	868
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	869 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	870 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	871 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	872
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	873 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	874 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	875 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	876 .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	877 .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	878 .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	879 .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	880
49930 e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	881 assert!(is_inline(&bytes));
e98fd81bb151 rust-clippy: fix most warnings in `hg-core` Rapha?l Gom?s <rgomes@octobus.net> parents: 49926 diff changeset	882 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	883 }
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	884
900b9b79b99c hg-core: make `Index` owner of its bytes (D8958#inline-14994 followup 1/2) Antoine cezar<acezar@chwitlabs.fr> parents: 45593 diff changeset	885 #[test]
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	886 fn test_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	887 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	888 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	889 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	890 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	891 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	892
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	893 assert_eq!(entry.offset(), 1)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	894 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	895
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	896 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	897 fn test_with_overridden_offset() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	898 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	899 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	900 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	901 offset_override: Some(2),
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	902 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	903
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	904 assert_eq!(entry.offset(), 2)
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	905 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	906
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	907 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	908 fn test_compressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	909 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	910 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	911 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	912 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	913 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	914
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	915 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	916 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	917
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	918 #[test]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	919 fn test_uncompressed_len() {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	920 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	921 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	922 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	923 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	924 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	925
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	926 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	927 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	928
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	929 #[test]
48458 96ea4db4741b rhg: fix a crash on non-generaldelta revlogs Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48457 diff changeset	930 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	931 let bytes = IndexEntryBuilder::new()
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	932 .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	933 .build();
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	934 let entry = IndexEntry {
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	935 bytes: &bytes,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	936 offset_override: None,
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	937 };
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	938
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	939 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	940 }
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	941
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	942 #[test]
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	943 fn link_revision_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	944 let bytes = IndexEntryBuilder::new()
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	945 .with_link_revision(Revision(123))
4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	946 .build();
49093 2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	947
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	948 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	949 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	950 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	951 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	952
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	953 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	954 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	955
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	956 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	957 fn p1_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	958 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	959
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	960 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	961 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	962 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	963 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	964
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	965 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	966 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	967
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	968 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	969 fn p2_test() {
50976 4c5f6e95df84 rust: make `Revision` a newtype Rapha?l Gom?s <rgomes@octobus.net> parents: 50975 diff changeset	970 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	971
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	972 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	973 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	974 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	975 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	976
50974 1928b770e3e7 rust: use the new `UncheckedRevision` everywhere applicable Rapha?l Gom?s <rgomes@octobus.net> parents: 49930 diff changeset	977 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	978 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	979
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	980 #[test]
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	981 fn node_test() {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	982 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	983 .unwrap();
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	984 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	985
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	986 let entry = IndexEntry {
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	987 bytes: &bytes,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	988 offset_override: None,
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	989 };
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	990
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	991 assert_eq!(*entry.hash(), node);
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	992 }
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	993
2a9a55ffe24f rust-revlog: make `IndexEntryBuilder` build a whole entry Martin von Zweigbergk <martinvonz@google.com> parents: 49092 diff changeset	994 #[test]
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	995 fn version_test() {
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	996 let bytes = IndexEntryBuilder::new()
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	997 .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	998 .with_version(2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	999 .build();
1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1000
49092 d200ecb76c72 rust-revlog: change default version from 2 to 1 in test builder Martin von Zweigbergk <martinvonz@google.com> parents: 48546 diff changeset	1001 assert_eq!(get_version(&bytes), 2)
48457 1fb3615dfce2 rhg: centralize index header parsing Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 48226 diff changeset	1002 }
45526 26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1003 }
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1004
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1005 #[cfg(test)]
26c53ee51c68 hg-core: Add a limited read only `revlog` implementation Antoine Cezar <antoine.cezar@octobus.net> parents: diff changeset	1006 pub use tests::IndexEntryBuilder;

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/revlog/index.rs @ 51208:b8c89957a6b7