diff options
Diffstat (limited to 'vendor/gix-index/src/entry/flags.rs')
-rw-r--r-- | vendor/gix-index/src/entry/flags.rs | 53 |
1 files changed, 35 insertions, 18 deletions
diff --git a/vendor/gix-index/src/entry/flags.rs b/vendor/gix-index/src/entry/flags.rs index ec00a78db..05198bafb 100644 --- a/vendor/gix-index/src/entry/flags.rs +++ b/vendor/gix-index/src/entry/flags.rs @@ -3,24 +3,27 @@ use bitflags::bitflags; use crate::entry::Stage; bitflags! { - /// In-memory flags + /// In-memory flags. + /// + /// Notably, not all of these will be persisted but can be used to aid all kinds of operations. + #[derive(Debug, Clone, Copy, Eq, PartialEq)] pub struct Flags: u32 { - /// The mask to apply to obtain the stage number of an entry. - const STAGE_MASK = 0x3000; - /// If set, additional bits need to be written to storage. - const EXTENDED = 0x4000; // TODO: could we use the pathlen ourselves to save 8 bytes? And how to handle longer paths than that? 0 as sentinel maybe? - /// The mask to obtain the length of the path associated with this entry. + /// The mask to obtain the length of the path associated with this entry, up to 4095 characters without extension. const PATH_LEN = 0x0fff; + /// The mask to apply to obtain the stage number of an entry, encoding three value: 0 = base, 1 = ours, 2 = theirs. + const STAGE_MASK = 1<<12 | 1<<13; + /// If set, additional bits need to be written to storage. + const EXTENDED = 1<<14; /// If set, the entry be assumed to match with the version on the working tree, as a way to avoid `lstat()` checks. const ASSUME_VALID = 1 << 15; /// Indicates that an entry needs to be updated as it's in-memory representation doesn't match what's on disk. const UPDATE = 1 << 16; /// Indicates an entry should be removed - this typically happens during writing, by simply skipping over them. const REMOVE = 1 << 17; - /// Indicates that an entry is known to be uptodate. + /// Indicates that an entry is known to be up-to-date. const UPTODATE = 1 << 18; - /// Only temporarily used by unpack_trees() (in C) + /// Only temporarily used by unpack_trees() (in C). const ADDED = 1 << 19; /// Whether an up-to-date object hash exists for the entry. @@ -45,8 +48,8 @@ bitflags! { /// Indicates the entry name is present in the base/shared index, and thus doesn't have to be stored in this one. const STRIP_NAME = 1 << 28; - /// - /// stored at rest, see at_rest::FlagsExtended + /// Created with `git add --intent-to-add` to mark empty entries that have their counter-part in the worktree, but not + /// yet in the object database. const INTENT_TO_ADD = 1 << 29; /// Stored at rest const SKIP_WORKTREE = 1 << 30; @@ -59,21 +62,20 @@ bitflags! { impl Flags { /// Return the stage as extracted from the bits of this instance. pub fn stage(&self) -> Stage { - (*self & Flags::STAGE_MASK).bits >> 12 + (*self & Flags::STAGE_MASK).bits() >> 12 } /// Transform ourselves to a storage representation to keep all flags which are to be persisted, /// skipping all extended flags. Note that the caller has to check for the `EXTENDED` bit to be present /// and write extended flags as well if so. pub fn to_storage(mut self) -> at_rest::Flags { - at_rest::Flags::from_bits( + at_rest::Flags::from_bits_retain( { self.remove(Self::PATH_LEN); self } .bits() as u16, ) - .unwrap() } } @@ -82,6 +84,7 @@ pub(crate) mod at_rest { bitflags! { /// Flags how they are serialized to a storage location + #[derive(Copy, Clone, Debug)] pub struct Flags: u16 { /// A portion of a the flags that encodes the length of the path that follows. const PATH_LEN = 0x0fff; @@ -95,12 +98,13 @@ pub(crate) mod at_rest { impl Flags { pub fn to_memory(self) -> super::Flags { - super::Flags::from_bits(self.bits as u32).expect("PATHLEN is part of memory representation") + super::Flags::from_bits_retain(self.bits() as u32) } } bitflags! { /// Extended flags - add flags for serialization here and offset them down to u16. + #[derive(Copy, Clone, Debug, PartialEq)] pub struct FlagsExtended: u16 { const INTENT_TO_ADD = 1 << (29 - 16); const SKIP_WORKTREE = 1 << (30 - 16); @@ -109,11 +113,12 @@ pub(crate) mod at_rest { impl FlagsExtended { pub fn from_flags(flags: super::Flags) -> Self { - Self::from_bits(((flags & (super::Flags::INTENT_TO_ADD | super::Flags::SKIP_WORKTREE)).bits >> 16) as u16) - .expect("valid") + Self::from_bits_retain( + ((flags & (super::Flags::INTENT_TO_ADD | super::Flags::SKIP_WORKTREE)).bits() >> 16) as u16, + ) } pub fn to_flags(self) -> Option<super::Flags> { - super::Flags::from_bits((self.bits as u32) << 16) + super::Flags::from_bits((self.bits() as u32) << 16) } } @@ -122,9 +127,21 @@ pub(crate) mod at_rest { use super::*; #[test] + fn flags_extended_conversion() { + assert_eq!( + FlagsExtended::all().to_flags(), + Some(super::super::Flags::INTENT_TO_ADD | super::super::Flags::SKIP_WORKTREE) + ); + assert_eq!( + FlagsExtended::from_flags(super::super::Flags::all()), + FlagsExtended::all() + ); + } + + #[test] fn flags_from_bits_with_conflict() { let input = 0b1110_0010_1000_1011; - assert_eq!(Flags::from_bits(input).unwrap().bits, input); + assert_eq!(Flags::from_bits_retain(input).bits(), input); } } } |