rust/hg-core/src/dirstate_tree/dirstate_map.rs
changeset 47683 284a20269a97
parent 47682 78f7f0d490ee
child 47692 e5fb14a07866
equal deleted inserted replaced
47682:78f7f0d490ee 47683:284a20269a97
  1244                 None
  1244                 None
  1245             })
  1245             })
  1246         }))
  1246         }))
  1247     }
  1247     }
  1248 
  1248 
  1249     fn iter_directories(
  1249     fn iter_tracked_dirs(
       
  1250         &mut self,
       
  1251     ) -> Result<
       
  1252         Box<
       
  1253             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
       
  1254                 + Send
       
  1255                 + '_,
       
  1256         >,
       
  1257         DirstateError,
       
  1258     > {
       
  1259         let on_disk = self.on_disk;
       
  1260         Ok(Box::new(filter_map_results(
       
  1261             self.iter_nodes(),
       
  1262             move |node| {
       
  1263                 Ok(if node.tracked_descendants_count() > 0 {
       
  1264                     Some(node.full_path(on_disk)?)
       
  1265                 } else {
       
  1266                     None
       
  1267                 })
       
  1268             },
       
  1269         )))
       
  1270     }
       
  1271 
       
  1272     fn debug_iter(
  1250         &self,
  1273         &self,
  1251     ) -> Box<
  1274     ) -> Box<
  1252         dyn Iterator<
  1275         dyn Iterator<
  1253                 Item = Result<
  1276                 Item = Result<
  1254                     (&HgPath, Option<Timestamp>),
  1277                     (&HgPath, (u8, i32, i32, i32)),
  1255                     DirstateV2ParseError,
  1278                     DirstateV2ParseError,
  1256                 >,
  1279                 >,
  1257             > + Send
  1280             > + Send
  1258             + '_,
  1281             + '_,
  1259     > {
  1282     > {
  1260         Box::new(filter_map_results(self.iter_nodes(), move |node| {
  1283         Box::new(self.iter_nodes().map(move |node| {
  1261             Ok(if node.state()?.is_none() {
  1284             let node = node?;
  1262                 Some((
  1285             let debug_tuple = if let Some(entry) = node.entry()? {
  1263                     node.full_path(self.on_disk)?,
  1286                 entry.debug_tuple()
  1264                     node.cached_directory_mtime()
  1287             } else if let Some(mtime) = node.cached_directory_mtime() {
  1265                         .map(|mtime| Timestamp(mtime.seconds())),
  1288                 (b' ', 0, -1, mtime.seconds() as i32)
  1266                 ))
       
  1267             } else {
  1289             } else {
  1268                 None
  1290                 (b' ', 0, -1, -1)
  1269             })
  1291             };
       
  1292             Ok((node.full_path(self.on_disk)?, debug_tuple))
  1270         }))
  1293         }))
  1271     }
  1294     }
  1272 }
  1295 }