[commitgraph] Rename LexPosition to 'file::Position'

That way it's in line with 'graph::Position'

Sebastian Thiel committed 6 years ago

Commit 6f90bee1 parent d2eec1d6 files · +72 −55Browse files

Showing the changes to git-commitgraph/src/file (4 of 6 files). Show all

Unified · Split

4 files

git-commitgraph/src/file/access.rs +16 −14
git-commitgraph/src/file/commit.rs +20 −16
git-commitgraph/src/file/init.rs +5 −3
git-commitgraph/src/file/mod.rs +13 −10

git-commitgraph/src/file/access.rs+16−14

-use crate::file::commit::Commit;
+use crate::file::{self, commit::Commit, File, COMMIT_DATA_ENTRY_SIZE};
-use crate::file::{File, LexPosition, COMMIT_DATA_ENTRY_SIZE};
 use git_object::{borrowed, HashKind, SHA1_SIZE};
-use std::convert::{TryFrom, TryInto};
+use std::{
-use std::fmt::{Debug, Formatter};
+    convert::{TryFrom, TryInto},
-use std::path::Path;
+    fmt::{Debug, Formatter},
+    path::Path,
+};
+/// Access
 impl File {
     /// Returns the commit data for the commit located at the given lex position.
     ///
     /// # Panics
     ///
     /// Panics if `pos` is out of bounds.
-    pub fn commit_at(&self, pos: LexPosition) -> Commit<'_> {
+    pub fn commit_at(&self, pos: file::Position) -> Commit<'_> {
         Commit::new(self, pos)
     }
     // copied from git-odb/src/pack/index/access.rs
     /// Returns 20 bytes sha1 at the given index in our list of (sorted) sha1 hashes.
     /// The position ranges from 0 to self.num_commits()
-    pub fn id_at(&self, pos: LexPosition) -> borrowed::Id<'_> {
+    pub fn id_at(&self, pos: file::Position) -> borrowed::Id<'_> {
         assert!(
             pos.0 < self.num_commits(),
             "expected lex position less than {}, got {}",
     }
     pub fn iter_commits(&self) -> impl Iterator<Item = Commit<'_>> {
-        (0..self.num_commits()).map(move |i| self.commit_at(LexPosition(i)))
+        (0..self.num_commits()).map(move |i| self.commit_at(file::Position(i)))
     }
     pub fn iter_ids(&self) -> impl Iterator<Item = borrowed::Id<'_>> {
-        (0..self.num_commits()).map(move |i| self.id_at(LexPosition(i)))
+        (0..self.num_commits()).map(move |i| self.id_at(file::Position(i)))
     }
     // copied from git-odb/src/pack/index/access.rs
-    pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<LexPosition> {
+    pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<file::Position> {
         let first_byte = id.first_byte() as usize;
         let mut upper_bound = self.fan[first_byte];
         let mut lower_bound = if first_byte != 0 { self.fan[first_byte - 1] } else { 0 };
         // it should not be if the bytes match up and the type has no destructor.
         while lower_bound < upper_bound {
             let mid = (lower_bound + upper_bound) / 2;
-            let mid_sha = self.id_at(LexPosition(mid));
+            let mid_sha = self.id_at(file::Position(mid));
             use std::cmp::Ordering::*;
             match id.cmp(&mid_sha) {
                 Less => upper_bound = mid,
-                Equal => return Some(LexPosition(mid)),
+                Equal => return Some(file::Position(mid)),
                 Greater => lower_bound = mid + 1,
             }
         }
     /// Returns the number of commits in this graph file.
     ///
-    /// The maximum valid `LexPosition` that can be used with this file is one less than
+    /// The maximum valid `Lexfile::Position` that can be used with this file is one less than
     /// `num_commits()`.
     pub fn num_commits(&self) -> u32 {
         self.fan[255]
 impl File {
     /// Returns the byte slice for the given commit in this file's Commit Data (CDAT) chunk.
-    pub(crate) fn commit_data_bytes(&self, pos: LexPosition) -> &[u8] {
+    pub(crate) fn commit_data_bytes(&self, pos: file::Position) -> &[u8] {
         assert!(
             pos.0 < self.num_commits(),
             "expected lex position less than {}, got {}",

git-commitgraph/src/file/commit.rs+20−16

-use crate::file::{File, LexPosition};
+use crate::{
-use crate::graph::Position;
+    file::{self, File},
+    graph,
+};
 use byteorder::{BigEndian, ByteOrder};
 use git_object::{borrowed, owned, SHA1_SIZE};
 use quick_error::quick_error;
-use std::convert::{TryFrom, TryInto};
+use std::{
-use std::fmt::{Debug, Formatter};
+    convert::{TryFrom, TryInto},
-use std::slice::Chunks;
+    fmt::{Debug, Formatter},
+    slice::Chunks,
+};
 quick_error! {
     #[derive(Debug)]
 pub struct Commit<'a> {
     file: &'a File,
-    lex_pos: LexPosition,
+    lex_pos: file::Position,
     // We can parse the below fields lazily if needed.
     commit_timestamp: u64,
     generation: u32,
 }
 impl<'a> Commit<'a> {
-    pub(crate) fn new(file: &'a File, pos: LexPosition) -> Self {
+    pub(crate) fn new(file: &'a File, pos: file::Position) -> Self {
         let bytes = file.commit_data_bytes(pos);
         Commit {
             file,
         self.generation
     }
-    pub fn iter_parents(&'a self) -> impl Iterator<Item = Result<Position, Error>> + 'a {
+    pub fn iter_parents(&'a self) -> impl Iterator<Item = Result<graph::Position, Error>> + 'a {
         // I didn't find a combinator approach that a) was as strict as ParentIterator, b) supported
         // fuse-after-first-error behavior, and b) was significantly shorter or more understandable
         // than ParentIterator. So here we are.
         self.file.id_at(self.lex_pos)
     }
-    pub fn parent1(&self) -> Result<Option<Position>, Error> {
+    pub fn parent1(&self) -> Result<Option<graph::Position>, Error> {
         self.iter_parents().next().transpose()
     }
 }
 impl<'a> Iterator for ParentIterator<'a> {
-    type Item = Result<Position, Error>;
+    type Item = Result<graph::Position, Error>;
     fn next(&mut self) -> Option<Self::Item> {
         let state = std::mem::replace(&mut self.state, ParentIteratorState::Exhausted);
 #[derive(Clone, Copy, Debug)]
 enum ParentEdge {
     None,
-    GraphPosition(Position),
+    GraphPosition(graph::Position),
     ExtraEdgeIndex(u32),
 }
         if raw & EXTENDED_EDGES_MASK != 0 {
             ParentEdge::ExtraEdgeIndex(raw & !EXTENDED_EDGES_MASK)
         } else {
-            ParentEdge::GraphPosition(Position(raw))
+            ParentEdge::GraphPosition(graph::Position(raw))
         }
     }
 }
 const LAST_EXTENDED_EDGE_MASK: u32 = 0x8000_0000;
 enum ExtraEdge {
-    Internal(Position),
+    Internal(graph::Position),
-    Last(Position),
+    Last(graph::Position),
 }
 impl ExtraEdge {
     pub fn from_raw(raw: u32) -> Self {
         if raw & LAST_EXTENDED_EDGE_MASK != 0 {
-            Self::Last(Position(raw & !LAST_EXTENDED_EDGE_MASK))
+            Self::Last(graph::Position(raw & !LAST_EXTENDED_EDGE_MASK))
         } else {
-            Self::Internal(Position(raw))
+            Self::Internal(graph::Position(raw))
         }
     }
 }

git-commitgraph/src/file/init.rs+5−3

 use filebuffer::FileBuffer;
 use git_object::SHA1_SIZE;
 use quick_error::quick_error;
-use std::convert::{TryFrom, TryInto};
+use std::{
-use std::ops::Range;
+    convert::{TryFrom, TryInto},
-use std::path::Path;
+    ops::Range,
+    path::Path,
+};
 type ChunkId = [u8; 4];

git-commitgraph/src/file/mod.rs+13−10

 //! Operations on a single commit-graph file.
 mod access;
 pub mod commit;
 mod init;
+pub use init::Error;
 pub use commit::Commit;
 use filebuffer::FileBuffer;
 use git_object::SHA1_SIZE;
-pub use init::Error;
+use std::{
-use std::fmt::{Display, Formatter};
+    fmt::{Display, Formatter},
-use std::ops::Range;
+    ops::Range,
-use std::path::PathBuf;
+    path::PathBuf,
+};
 const COMMIT_DATA_ENTRY_SIZE: usize = SHA1_SIZE + 16;
 const FAN_LEN: usize = 256;
 /// The position of a given commit within a graph file, starting at 0.
 ///
-/// Commits within a graph file are sorted in lexicographical order by OID; a commit's lex position
+/// Commits within a graph file are sorted in lexicographical order by OID; a commit's lexigraphical position
 /// is its position in this ordering. If a commit graph spans multiple files, each file's commits
-/// start at lex position 0, so lex position is unique across a single file but is not unique across
+/// start at lexigraphical position 0, so it is unique across a single file but is not unique across
-/// the whole commit graph. Each commit also has a graph position (`GraphPosition`), which is unique
+/// the whole commit graph. Each commit also has a graph position (`graph::Position`), which is unique
-/// across the whole commit graph. In order to avoid accidentally mixing lex positions with graph
+/// across the whole commit graph. In order to avoid accidentally mixing lexigraphical positions with graph
 /// positions, distinct types are used for each.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct LexPosition(pub u32);
+pub struct Position(pub u32);
-impl Display for LexPosition {
+impl Display for Position {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }