This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1518

nodemap: move some methods to changelog utils
AbandonedPublic

Authored by quark on Nov 27 2017, 1:30 PM.
Tags
None
Subscribers
kevincox, jsgf

Details

Reviewers
jsgf
Group Reviewers
Restricted Project
Summary

Those methods and constants will be reused by another module.

Diff Detail

Repository
rFBHGX Facebook Mercurial Extensions
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark created this revision.Nov 27 2017, 1:30 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptNov 27 2017, 1:30 PM
jsgf requested changes to this revision.Dec 7 2017, 12:25 PM
jsgf added a subscriber: jsgf.
jsgf added inline comments.
rust/indexes/src/nodemap.rs
222–225

(driveby) You can use b'a' to get a character value as a u8. so b'a'...b'f' => ch - b'a',, etc

rust/indexes/src/utils.rs
13 ↗(On Diff #3880)
if rev > i32::MAX as u64 {

You may need to use std::i32;

This revision now requires changes to proceed.Dec 7 2017, 12:25 PM
quark updated this revision to Diff 4455.Dec 14 2017, 9:21 PM
quark edited the summary of this revision. (Show Details)Dec 14 2017, 10:15 PM
quark retitled this revision from nodemap: move some methods to utils to nodemap: move some methods to changelog utils.
quark updated this revision to Diff 4461.
quark abandoned this revision.Dec 7 2019, 2:14 AM

No longer use this approach.

Revision Contents
Changeset List

Diff 4461

rust/indexes/src/changelog_utils.rs

  • This file was added.
// Copyright 2017 Facebook, Inc.
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use std::u32;
use radixbuf::key::KeyId;
use radixbuf::errors as rerrors;
/// See "index ng" comment in mercurial/revlog.py
pub const CHANGELOG_ENTRY_SIZE: usize = 64;
// Offsets of fields in a changelog entry
pub const CHANGELOG_ENTRY_P1_OFFSET: usize = 24;
pub const CHANGELOG_ENTRY_NODE_OFFSET: usize = 32;
/// Return the minimal revision number the changelog.i does not have.
pub fn changelog_end_rev<T: AsRef<[u8]>>(changelogi: &T) -> u32 {
let changelogi = changelogi.as_ref();
let rev = changelogi.len() / CHANGELOG_ENTRY_SIZE;
if rev > u32::MAX as usize {
panic!("rev exceeds 32 bit integers")
}
rev as u32
}
/// Helper method similar to `radixbuf::key::FixedKey::read`, but takes a revision number instead.
pub fn rev_to_node<K: AsRef<[u8]>>(changelogi: &K, rev: KeyId) -> rerrors::Result<&[u8]> {
let buf = changelogi.as_ref();
let rev_usize: usize = rev.into();
let start_pos = rev_usize * CHANGELOG_ENTRY_SIZE + CHANGELOG_ENTRY_NODE_OFFSET;
let end_pos = start_pos + 20;
if buf.len() < end_pos {
Err(rerrors::ErrorKind::InvalidKeyId(rev).into())
} else {
Ok(&buf[start_pos..end_pos])
}
}

rust/indexes/src/lib.rs

// Copyright 2017 Facebook, Inc. // Copyright 2017 Facebook, Inc.
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
extern crate python27_sys; extern crate python27_sys;
#[macro_use] #[macro_use]
extern crate cpython; extern crate cpython;
#[macro_use] #[macro_use]
extern crate error_chain; extern crate error_chain;
extern crate radixbuf; extern crate radixbuf;
pub mod errors; pub mod errors;
pub mod nodemap; pub mod nodemap;
mod changelog_utils;
mod pybuf; mod pybuf;
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
pub mod pyext; pub mod pyext;

rust/indexes/src/nodemap.rs

// Copyright 2017 Facebook, Inc. // Copyright 2017 Facebook, Inc.
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use std::u32; use std::u32;
use errors::{Result, ResultExt, ErrorKind}; use errors::{Result, ResultExt, ErrorKind};
use radixbuf::radix::{radix_lookup, radix_prefix_lookup, radix_lookup_unchecked, radix_insert, use radixbuf::radix::{radix_lookup, radix_prefix_lookup, radix_lookup_unchecked, radix_insert,
RADIX_NCHILDREN}; RADIX_NCHILDREN};
use radixbuf::key::KeyId; use radixbuf::key::KeyId;
use radixbuf::errors as rerrors; use radixbuf::errors as rerrors;
use changelog_utils::{changelog_end_rev, rev_to_node};
/// An index for node to rev lookups. /// An index for node to rev lookups.
/// ///
/// The index depends entirely on an append-only changelog.i source /// The index depends entirely on an append-only changelog.i source
/// of truth. It does not support in-memory overrides, which could be /// of truth. It does not support in-memory overrides, which could be
/// implemented at a higher level. /// implemented at a higher level.
/// ///
/// ```text /// ```text
// Offsets in the main radix and key buffers // Offsets in the main radix and key buffers
const RADIX_NEXT_REV_OFFSET: usize = 0; const RADIX_NEXT_REV_OFFSET: usize = 0;
const RADIX_HEADER_LEN: usize = RADIX_NEXT_REV_OFFSET + 1; const RADIX_HEADER_LEN: usize = RADIX_NEXT_REV_OFFSET + 1;
// Offsets of root nodes in radix buffers // Offsets of root nodes in radix buffers
const MAIN_RADIX_OFFSET: u32 = 1; const MAIN_RADIX_OFFSET: u32 = 1;
const SIDE_RADIX_OFFSET: u32 = 0; const SIDE_RADIX_OFFSET: u32 = 0;
const CHANGELOG_ENTRY_SIZE: u64 = 64; impl<C: AsRef<[u8]>, I: AsRef<[u32]>> NodeRevMap<C, I> {
impl<C: AsRef<[u8]>, I: AsRef<[u32]>> NodeRevMap<C, I>
{
/// Initialize NodeMap from a non-inlined version of changelog.i and an incomplete index. /// Initialize NodeMap from a non-inlined version of changelog.i and an incomplete index.
pub fn new(changelogi: C, main_index: I) -> Result<Self> { pub fn new(changelogi: C, main_index: I) -> Result<Self> {
// Sanity check if the index is corrupted or not. // Sanity check if the index is corrupted or not.
// The index must contain at least 17 elements. index[0] tracks the last rev the index has. // The index must contain at least 17 elements. index[0] tracks the last rev the index has.
// index[1..17] is the root radix node. // index[1..17] is the root radix node.
if main_index.as_ref().len() < RADIX_HEADER_LEN + RADIX_NCHILDREN { if main_index.as_ref().len() < RADIX_HEADER_LEN + RADIX_NCHILDREN {
bail!(ErrorKind::IndexCorrupted); bail!(ErrorKind::IndexCorrupted);
next_rev, next_rev,
end_rev, end_rev,
)?; )?;
index[0] = end_rev.to_be(); index[0] = end_rev.to_be();
Ok(index) Ok(index)
} }
} }
/// Return the minimal revision number the changelog.i does not have.
fn changelog_end_rev<T: AsRef<[u8]>>(changelogi: &T) -> u32 {
let changelogi = changelogi.as_ref();
let rev = changelogi.len() as u64 / CHANGELOG_ENTRY_SIZE;
if rev > u32::MAX as u64 {
panic!("rev exceeds 32 bit integers")
}
rev as u32
}
/// Read the given range of revisions (from `start_rev` (inclusive) to /// Read the given range of revisions (from `start_rev` (inclusive) to
/// `end_rev` (exclusive)) from changelogi. Insert them to the radix /// `end_rev` (exclusive)) from changelogi. Insert them to the radix
/// index. /// index.
fn build<T>(changelogi: &T, index: &mut Vec<u32>, radix_offset: u32, start_rev: u32, end_rev: u32) fn build<T>(changelogi: &T, index: &mut Vec<u32>, radix_offset: u32, start_rev: u32, end_rev: u32)
-> Result<()> -> Result<()>
where where
T: AsRef<[u8]>, T: AsRef<[u8]>,
{ {
// Reserve the approximate size needed for the index - 28 bytes for each revision. // Reserve the approximate size needed for the index - 28 bytes for each revision.
// See D1291 for a table of number of revisions and index sizes. // See D1291 for a table of number of revisions and index sizes.
index.reserve(7 * (end_rev - start_rev) as usize); index.reserve(7 * (end_rev - start_rev) as usize);
for i in start_rev..end_rev { for i in start_rev..end_rev {
let res = radix_insert(index, radix_offset, i.into(), rev_to_node, changelogi); let res = radix_insert(index, radix_offset, i.into(), rev_to_node, changelogi);
res.chain_err(|| ErrorKind::IndexCorrupted)?; res.chain_err(|| ErrorKind::IndexCorrupted)?;
} }
Ok(()) Ok(())
} }
/// Helper method similar to `radixbuf::key::FixedKey::read`, but takes a revision number instead.
fn rev_to_node<K: AsRef<[u8]>>(changelogi: &K, rev: KeyId) -> rerrors::Result<&[u8]> {
let buf = changelogi.as_ref();
let rev_usize: usize = rev.into();
let start_pos = rev_usize * 64 + 32;
let end_pos = start_pos + 20;
if buf.len() < end_pos {
Err(rerrors::ErrorKind::InvalidKeyId(rev).into())
} else {
Ok(&buf[start_pos..end_pos])
}
}
/// Convert hex base16 sequence to binary base16 sequence. /// Convert hex base16 sequence to binary base16 sequence.
fn hex_to_bin_base16<T: AsRef<[u8]>>(base16: T) -> Option<Vec<u8>> { fn hex_to_bin_base16<T: AsRef<[u8]>>(base16: T) -> Option<Vec<u8>> {
let base16 = base16.as_ref(); let base16 = base16.as_ref();
let len = base16.len(); let len = base16.len();
let mut result = vec![0u8; len]; let mut result = vec![0u8; len];
for (i, &ch) in base16.iter().enumerate() { for (i, &ch) in base16.iter().enumerate() {
result[i] = match ch { result[i] = match ch {
b'a'...b'f' => ch - b'a' + 10, b'a'...b'f' => ch - b'a' + 10,
b'A'...b'F' => ch - b'A' + 10, b'A'...b'F' => ch - b'A' + 10,
b'0'...b'9' => ch - b'0', b'0'...b'9' => ch - b'0',
jsgfUnsubmitted
Not Done

(driveby) You can use b'a' to get a character value as a u8. so b'a'...b'f' => ch - b'a',, etc

jsgf: (driveby) You can use `b'a'` to get a character value as a `u8`. so `b'a'...b'f' => ch - b'a',`…
_ => return None, _ => return None,
} }
} }
Some(result) Some(result)
} }