[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 (5 of 6 files). Show all

Unified · Split

5 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/graph/access.rs +12 −12

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)
     }

git-commitgraph/src/graph/access.rs+12−12

@@ -1,12 +1,12 @@
1	use crate::{	1	use crate::{
2	file::{Commit, File, LexPosition},	2	file::{self, Commit, File},
3	graph::{Graph, Position},	3	graph::{self, Graph},
4	};	4	};
5	use git_object::borrowed;	5	use git_object::borrowed;
6		6
7	/// Access convenience	7	/// Access
8	impl Graph {	8	impl Graph {
9	pub fn commit_at(&self, pos: Position) -> Commit<'_> {	9	pub fn commit_at(&self, pos: graph::Position) -> Commit<'_> {
10	let r = self.lookup_by_pos(pos);	10	let r = self.lookup_by_pos(pos);
11	r.file.commit_at(r.lex_pos)	11	r.file.commit_at(r.lex_pos)
12	}	12	}
@@ -16,7 +16,7 @@ impl Graph { · 3 unmodified lines
16	Some(r.file.commit_at(r.lex_pos))	16	Some(r.file.commit_at(r.lex_pos))
17	}	17	}
18		18
19	pub fn id_at(&self, pos: Position) -> borrowed::Id<'_> {	19	pub fn id_at(&self, pos: graph::Position) -> borrowed::Id<'_> {
20	let r = self.lookup_by_pos(pos);	20	let r = self.lookup_by_pos(pos);
21	r.file.id_at(r.lex_pos)	21	r.file.id_at(r.lex_pos)
22	}	22	}
@@ -31,7 +31,7 @@ impl Graph { · 8 unmodified lines
31	self.files.iter().flat_map(\|file\| file.iter_ids())	31	self.files.iter().flat_map(\|file\| file.iter_ids())
32	}	32	}
33		33
34	pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<Position> {	34	pub fn lookup(&self, id: borrowed::Id<'_>) -> Option<graph::Position> {
35	Some(self.lookup_by_id(id)?.graph_pos)	35	Some(self.lookup_by_id(id)?.graph_pos)
36	}	36	}
37		37
@@ -49,7 +49,7 @@ impl Graph { · 11 unmodified lines
49	return Some(LookupByIdResult {	49	return Some(LookupByIdResult {
50	file,	50	file,
51	lex_pos,	51	lex_pos,
52	graph_pos: Position(current_file_start + lex_pos.0),	52	graph_pos: graph::Position(current_file_start + lex_pos.0),
53	});	53	});
54	}	54	}
55	current_file_start += file.num_commits();	55	current_file_start += file.num_commits();
@@ -57,7 +57,7 @@ impl Graph { · 1 unmodified line
57	None	57	None
58	}	58	}
59		59
60	fn lookup_by_pos(&self, pos: Position) -> LookupByPositionResult<'_> {	60	fn lookup_by_pos(&self, pos: graph::Position) -> LookupByPositionResult<'_> {
61	let mut remaining = pos.0;	61	let mut remaining = pos.0;
62	for file in &self.files {	62	for file in &self.files {
63	match remaining.checked_sub(file.num_commits()) {	63	match remaining.checked_sub(file.num_commits()) {
@@ -65,7 +65,7 @@ impl Graph { · 1 unmodified line
65	None => {	65	None => {
66	return LookupByPositionResult {	66	return LookupByPositionResult {
67	file,	67	file,
68	lex_pos: LexPosition(remaining),	68	lex_pos: file::Position(remaining),
69	}	69	}
70	}	70	}
71	}	71	}
@@ -77,12 +77,12 @@ impl Graph { · 5 unmodified lines
77	#[derive(Clone)]	77	#[derive(Clone)]
78	struct LookupByIdResult<'a> {	78	struct LookupByIdResult<'a> {
79	pub file: &'a File,	79	pub file: &'a File,
80	pub graph_pos: Position,	80	pub graph_pos: graph::Position,
81	pub lex_pos: LexPosition,	81	pub lex_pos: file::Position,
82	}	82	}
83		83
84	#[derive(Clone)]	84	#[derive(Clone)]
85	struct LookupByPositionResult<'a> {	85	struct LookupByPositionResult<'a> {
86	pub file: &'a File,	86	pub file: &'a File,
87	pub lex_pos: LexPosition,	87	pub lex_pos: file::Position,
88	}	88	}