comparison rust/hg-core/src/dirstate/entry.rs @ 48043:3e69bef2031a

rust: Add Python bindings for DirstateEntry as rustext.dirstate.DirstateItem

Differential Revision: https://phab.mercurial-scm.org/D11485

48042:008959fcbfb2

    size: i32,
    mtime: i32,
}

bitflags! {
    struct Flags: u8 {
        const WDIR_TRACKED = 1 << 0;
        const P1_TRACKED = 1 << 1;
        const P2_TRACKED = 1 << 2;
        const POSSIBLY_DIRTY = 1 << 3;
        const MERGED = 1 << 4;

/// A special value used for internal representation of special case in
/// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1;

impl DirstateEntry {
    pub fn from_v1_data(
        state: EntryState,
        mode: i32,
        size: i32,
        mtime: i32,

        // XXX Arbitrary default value since the value is determined later
        let state = EntryState::Normal;
        Self::from_v1_data(state, mode, size, mtime)
    }

    fn tracked_in_any_parent(&self) -> bool {
        self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED)
    }

    fn removed(&self) -> bool {
        self.tracked_in_any_parent()
            && !self.flags.contains(Flags::WDIR_TRACKED)
    }

    fn merged_removed(&self) -> bool {
        self.removed() && self.flags.contains(Flags::MERGED)
    }

    fn from_p2_removed(&self) -> bool {
        self.removed() && self.flags.contains(Flags::CLEAN_P2)
    }

    fn merged(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED)
    }

    fn added(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED)
            && !self.tracked_in_any_parent()
    }

    fn from_p2(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2)
    }

    pub fn state(&self) -> EntryState {
        if self.removed() {

        } else {
            self.mtime
        }
    }

    /// Returns `(state, mode, size, mtime)` for the puprose of serialization
    /// in the dirstate-v1 format.
    ///
    /// This includes marker values such as `mtime == -1`. In the future we may
    /// want to not represent these cases that way in memory, but serialization

48043:3e69bef2031a

    size: i32,
    mtime: i32,
}

bitflags! {
    pub struct Flags: u8 {
        const WDIR_TRACKED = 1 << 0;
        const P1_TRACKED = 1 << 1;
        const P2_TRACKED = 1 << 2;
        const POSSIBLY_DIRTY = 1 << 3;
        const MERGED = 1 << 4;

/// A special value used for internal representation of special case in
/// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1;

impl DirstateEntry {
    pub fn new(
        flags: Flags,
        mode_size_mtime: Option<(i32, i32, i32)>,
    ) -> Self {
        let (mode, size, mtime) =
            mode_size_mtime.unwrap_or((0, SIZE_NON_NORMAL, MTIME_UNSET));
        Self {
            flags,
            mode,
            size,
            mtime,
        }
    }

    pub fn from_v1_data(
        state: EntryState,
        mode: i32,
        size: i32,
        mtime: i32,

        // XXX Arbitrary default value since the value is determined later
        let state = EntryState::Normal;
        Self::from_v1_data(state, mode, size, mtime)
    }

    pub fn tracked(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED)
    }

    fn tracked_in_any_parent(&self) -> bool {
        self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED)
    }

    pub fn removed(&self) -> bool {
        self.tracked_in_any_parent()
            && !self.flags.contains(Flags::WDIR_TRACKED)
    }

    pub fn merged_removed(&self) -> bool {
        self.removed() && self.flags.contains(Flags::MERGED)
    }

    pub fn from_p2_removed(&self) -> bool {
        self.removed() && self.flags.contains(Flags::CLEAN_P2)
    }

    pub fn merged(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED)
    }

    pub fn added(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED)
            && !self.tracked_in_any_parent()
    }

    pub fn from_p2(&self) -> bool {
        self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2)
    }

    pub fn state(&self) -> EntryState {
        if self.removed() {

        } else {
            self.mtime
        }
    }

    pub fn set_possibly_dirty(&mut self) {
        self.flags.insert(Flags::POSSIBLY_DIRTY)
    }

    pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) {
        self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
        self.flags.remove(
            Flags::P2_TRACKED // This might be wrong
                | Flags::MERGED
                | Flags::CLEAN_P2
                | Flags::POSSIBLY_DIRTY,
        );
        self.mode = mode;
        self.size = size;
        self.mtime = mtime;
    }

    pub fn set_tracked(&mut self) {
        self.flags
            .insert(Flags::WDIR_TRACKED | Flags::POSSIBLY_DIRTY);
        // size = None on the python size turn into size = NON_NORMAL when
        // accessed. So the next line is currently required, but a some future
        // clean up would be welcome.
        self.size = SIZE_NON_NORMAL;
    }

    pub fn set_untracked(&mut self) {
        self.flags.remove(Flags::WDIR_TRACKED);
        self.mode = 0;
        self.size = 0;
        self.mtime = 0;
    }

    /// Returns `(state, mode, size, mtime)` for the puprose of serialization
    /// in the dirstate-v1 format.
    ///
    /// This includes marker values such as `mtime == -1`. In the future we may
    /// want to not represent these cases that way in memory, but serialization