rust/hg-core/src/dirstate_tree/dirstate_map.rs
changeset 49101 dd0430434ce9
parent 49097 791430b0b2d2
child 49104 b5c2aca84618
equal deleted inserted replaced
49100:38e5bb1425dd 49101:dd0430434ce9
     9 use super::path_with_basename::WithBasename;
     9 use super::path_with_basename::WithBasename;
    10 use crate::dirstate::parsers::pack_entry;
    10 use crate::dirstate::parsers::pack_entry;
    11 use crate::dirstate::parsers::packed_entry_size;
    11 use crate::dirstate::parsers::packed_entry_size;
    12 use crate::dirstate::parsers::parse_dirstate_entries;
    12 use crate::dirstate::parsers::parse_dirstate_entries;
    13 use crate::dirstate::CopyMapIter;
    13 use crate::dirstate::CopyMapIter;
       
    14 use crate::dirstate::DirstateV2Data;
       
    15 use crate::dirstate::ParentFileData;
    14 use crate::dirstate::StateMapIter;
    16 use crate::dirstate::StateMapIter;
    15 use crate::dirstate::TruncatedTimestamp;
    17 use crate::dirstate::TruncatedTimestamp;
    16 use crate::dirstate::SIZE_FROM_OTHER_PARENT;
    18 use crate::dirstate::SIZE_FROM_OTHER_PARENT;
    17 use crate::dirstate::SIZE_NON_NORMAL;
    19 use crate::dirstate::SIZE_NON_NORMAL;
    18 use crate::matchers::Matcher;
    20 use crate::matchers::Matcher;
   602                 child_nodes = &mut child_node.children;
   604                 child_nodes = &mut child_node.children;
   603             } else {
   605             } else {
   604                 return Ok(child_node);
   606                 return Ok(child_node);
   605             }
   607             }
   606         }
   608         }
       
   609     }
       
   610 
       
   611     fn reset_state(
       
   612         &mut self,
       
   613         filename: &HgPath,
       
   614         old_entry_opt: Option<DirstateEntry>,
       
   615         wc_tracked: bool,
       
   616         p1_tracked: bool,
       
   617         p2_info: bool,
       
   618         has_meaningful_mtime: bool,
       
   619         parent_file_data_opt: Option<ParentFileData>,
       
   620     ) -> Result<(), DirstateError> {
       
   621         let (had_entry, was_tracked) = match old_entry_opt {
       
   622             Some(old_entry) => (true, old_entry.tracked()),
       
   623             None => (false, false),
       
   624         };
       
   625         let node = Self::get_or_insert_node(
       
   626             self.on_disk,
       
   627             &mut self.unreachable_bytes,
       
   628             &mut self.root,
       
   629             filename,
       
   630             WithBasename::to_cow_owned,
       
   631             |ancestor| {
       
   632                 if !had_entry {
       
   633                     ancestor.descendants_with_entry_count += 1;
       
   634                 }
       
   635                 if was_tracked {
       
   636                     if !wc_tracked {
       
   637                         ancestor.tracked_descendants_count = ancestor
       
   638                             .tracked_descendants_count
       
   639                             .checked_sub(1)
       
   640                             .expect("tracked count to be >= 0");
       
   641                     }
       
   642                 } else {
       
   643                     if wc_tracked {
       
   644                         ancestor.tracked_descendants_count += 1;
       
   645                     }
       
   646                 }
       
   647             },
       
   648         )?;
       
   649 
       
   650         let v2_data = if let Some(parent_file_data) = parent_file_data_opt {
       
   651             DirstateV2Data {
       
   652                 wc_tracked,
       
   653                 p1_tracked,
       
   654                 p2_info,
       
   655                 mode_size: parent_file_data.mode_size,
       
   656                 mtime: if has_meaningful_mtime {
       
   657                     parent_file_data.mtime
       
   658                 } else {
       
   659                     None
       
   660                 },
       
   661                 ..Default::default()
       
   662             }
       
   663         } else {
       
   664             DirstateV2Data {
       
   665                 wc_tracked,
       
   666                 p1_tracked,
       
   667                 p2_info,
       
   668                 ..Default::default()
       
   669             }
       
   670         };
       
   671         if !had_entry {
       
   672             self.nodes_with_entry_count += 1;
       
   673         }
       
   674         node.data = NodeData::Entry(DirstateEntry::from_v2_data(v2_data));
       
   675         Ok(())
   607     }
   676     }
   608 
   677 
   609     fn set_tracked(
   678     fn set_tracked(
   610         &mut self,
   679         &mut self,
   611         filename: &HgPath,
   680         filename: &HgPath,
   808         &mut self,
   877         &mut self,
   809         filename: &HgPath,
   878         filename: &HgPath,
   810     ) -> Result<bool, DirstateV2ParseError> {
   879     ) -> Result<bool, DirstateV2ParseError> {
   811         let old_entry_opt = self.get(filename)?;
   880         let old_entry_opt = self.get(filename)?;
   812         self.with_dmap_mut(|map| map.set_tracked(filename, old_entry_opt))
   881         self.with_dmap_mut(|map| map.set_tracked(filename, old_entry_opt))
       
   882     }
       
   883 
       
   884     pub fn reset_state(
       
   885         &mut self,
       
   886         filename: &HgPath,
       
   887         wc_tracked: bool,
       
   888         p1_tracked: bool,
       
   889         p2_info: bool,
       
   890         has_meaningful_mtime: bool,
       
   891         parent_file_data_opt: Option<ParentFileData>,
       
   892     ) -> Result<(), DirstateError> {
       
   893         if !(p1_tracked || p2_info || wc_tracked) {
       
   894             self.drop_entry_and_copy_source(filename)?;
       
   895             return Ok(());
       
   896         }
       
   897         self.copy_map_remove(filename)?;
       
   898         let old_entry_opt = self.get(filename)?;
       
   899         self.with_dmap_mut(|map| {
       
   900             map.reset_state(
       
   901                 filename,
       
   902                 old_entry_opt,
       
   903                 wc_tracked,
       
   904                 p1_tracked,
       
   905                 p2_info,
       
   906                 has_meaningful_mtime,
       
   907                 parent_file_data_opt,
       
   908             )
       
   909         })
   813     }
   910     }
   814 
   911 
   815     pub fn remove_file(
   912     pub fn remove_file(
   816         &mut self,
   913         &mut self,
   817         filename: &HgPath,
   914         filename: &HgPath,