7 use crate::CopyMapIter;

    10 use crate::DirstateMap;

    14 use crate::StateMapIter;

   215 

   216 impl DirstateMapMethods for DirstateMap {

   217     fn clear(&mut self) {

   218         self.clear()

   219     }

   220 

   221     /// Used to set a value directory.

   222     ///

   223     /// XXX Is temporary during a refactor of V1 dirstate and will disappear

   224     /// shortly.

   225     fn set_entry(

   226         &mut self,

   227         filename: &HgPath,

   228         entry: DirstateEntry,

   229     ) -> Result<(), DirstateV2ParseError> {

   230         self.set_entry(&filename, entry);

   231         Ok(())

   232     }

   233 

   234     fn add_file(

   235         &mut self,

   236         filename: &HgPath,

   237         entry: DirstateEntry,

   238     ) -> Result<(), DirstateError> {

   239         self.add_file(filename, entry)

   240     }

   241 

   242     fn remove_file(

   243         &mut self,

   244         filename: &HgPath,

   245         in_merge: bool,

   246     ) -> Result<(), DirstateError> {

   247         self.remove_file(filename, in_merge)

   248     }

   249 

   250     fn drop_entry_and_copy_source(

   251         &mut self,

   252         filename: &HgPath,

   253     ) -> Result<(), DirstateError> {

   254         self.drop_entry_and_copy_source(filename)

   255     }

   256 

   257     fn has_tracked_dir(

   258         &mut self,

   259         directory: &HgPath,

   260     ) -> Result<bool, DirstateError> {

   261         self.has_tracked_dir(directory)

   262     }

   263 

   264     fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {

   265         self.has_dir(directory)

   266     }

   267 

   268     fn pack_v1(

   269         &mut self,

   270         parents: DirstateParents,

   271         now: Timestamp,

   272     ) -> Result<Vec<u8>, DirstateError> {

   273         Ok(self.pack(parents, now)?)

   274     }

   275 

   276     fn pack_v2(

   277         &mut self,

   278         _now: Timestamp,

   279         _can_append: bool,

   280     ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {

   281         panic!(

   282             "should have used dirstate_tree::DirstateMap to use the v2 format"

   283         )

   284     }

   285 

   286     fn status<'a>(

   287         &'a mut self,

   288         matcher: &'a (dyn Matcher + Sync),

   289         root_dir: PathBuf,

   290         ignore_files: Vec<PathBuf>,

   291         options: StatusOptions,

   292     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>

   293     {

   294         crate::status(self, matcher, root_dir, ignore_files, options)

   295     }

   296 

   297     fn copy_map_len(&self) -> usize {

   298         self.copy_map.len()

   299     }

   300 

   301     fn copy_map_iter(&self) -> CopyMapIter<'_> {

   302         Box::new(

   303             self.copy_map

   304                 .iter()

   305                 .map(|(key, value)| Ok((&**key, &**value))),

   306         )

   307     }

   308 

   309     fn copy_map_contains_key(

   310         &self,

   311         key: &HgPath,

   312     ) -> Result<bool, DirstateV2ParseError> {

   313         Ok(self.copy_map.contains_key(key))

   314     }

   315 

   316     fn copy_map_get(

   317         &self,

   318         key: &HgPath,

   319     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {

   320         Ok(self.copy_map.get(key).map(|p| &**p))

   321     }

   322 

   323     fn copy_map_remove(

   324         &mut self,

   325         key: &HgPath,

   326     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {

   327         Ok(self.copy_map.remove(key))

   328     }

   329 

   330     fn copy_map_insert(

   331         &mut self,

   332         key: HgPathBuf,

   333         value: HgPathBuf,

   334     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {

   335         Ok(self.copy_map.insert(key, value))

   336     }

   337 

   338     fn len(&self) -> usize {

   339         (&**self).len()

   340     }

   341 

   342     fn contains_key(

   343         &self,

   344         key: &HgPath,

   345     ) -> Result<bool, DirstateV2ParseError> {

   346         Ok((&**self).contains_key(key))

   347     }

   348 

   349     fn get(

   350         &self,

   351         key: &HgPath,

   352     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {

   353         Ok((&**self).get(key).cloned())

   354     }

   355 

   356     fn iter(&self) -> StateMapIter<'_> {

   357         Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value))))

   358     }

   359 

   360     fn iter_tracked_dirs(

   361         &mut self,

   362     ) -> Result<

   363         Box<

   364             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>

   365                 + Send

   366                 + '_,

   367         >,

   368         DirstateError,

   369     > {

   370         self.set_all_dirs()?;

   371         Ok(Box::new(

   372             self.all_dirs

   373                 .as_ref()

   374                 .unwrap()

   375                 .iter()

   376                 .map(|path| Ok(&**path)),

   377         ))

   378     }

   379 

   380     fn debug_iter(

   381         &self,

   382         all: bool,

   383     ) -> Box<

   384         dyn Iterator<

   385                 Item = Result<

   386                     (&HgPath, (u8, i32, i32, i32)),

   387                     DirstateV2ParseError,

   388                 >,

   389             > + Send

   390             + '_,

   391     > {

   392         // Not used for the flat (not tree-based) DirstateMap

   393         let _ = all;

   394 

   395         Box::new(

   396             (&**self)

   397                 .iter()

   398                 .map(|(path, entry)| Ok((&**path, entry.debug_tuple()))),

   399         )

   400     }

   401 }