Mercurial Mercurial > mercurial / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rust/hg-core/src/dirstate/dirs_multiset.rs
changeset 43826 5ac243a92e37
parent 43788 1fe2e574616e
child 43831 088ba9d94079
equal deleted inserted replaced
43825:8f26dd09aa78 43826:5ac243a92e37 
     9 //!
 
     9 //!
 
    10 //! Used to counts the references to directories in a manifest or dirstate.
 
    10 //! Used to counts the references to directories in a manifest or dirstate.
 
    11 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
    11 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
    12 use crate::{
 
    12 use crate::{
 
    13     dirstate::EntryState, utils::files, DirstateEntry, DirstateMapError,
 
    13     dirstate::EntryState, utils::files, DirstateEntry, DirstateMapError,
 
       
    14     FastHashMap,
 
    14 };
 
    15 };
 
    15 use std::collections::hash_map::{self, Entry};
 
    16 use std::collections::hash_map::{self, Entry};
 
    16 use std::collections::HashMap;
 
       
    17 
    17 
    18 // could be encapsulated if we care API stability more seriously
 
    18 // could be encapsulated if we care API stability more seriously
 
    19 pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>;
 
    19 pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>;
 
    20 
    20 
    21 #[derive(PartialEq, Debug)]
 
    21 #[derive(PartialEq, Debug)]
 
    22 pub struct DirsMultiset {
 
    22 pub struct DirsMultiset {
 
    23     inner: HashMap<HgPathBuf, u32>,
 
    23     inner: FastHashMap<HgPathBuf, u32>,
 
    24 }
 
    24 }
 
    25 
    25 
    26 impl DirsMultiset {
 
    26 impl DirsMultiset {
 
    27     /// Initializes the multiset from a dirstate.
 
    27     /// Initializes the multiset from a dirstate.
 
    28     ///
 
    28     ///
 
    29     /// If `skip_state` is provided, skips dirstate entries with equal state.
 
    29     /// If `skip_state` is provided, skips dirstate entries with equal state.
 
    30     pub fn from_dirstate(
 
    30     pub fn from_dirstate(
 
    31         vec: &HashMap<HgPathBuf, DirstateEntry>,
 
    31         vec: &FastHashMap<HgPathBuf, DirstateEntry>,
 
    32         skip_state: Option<EntryState>,
 
    32         skip_state: Option<EntryState>,
 
    33     ) -> Self {
 
    33     ) -> Self {
 
    34         let mut multiset = DirsMultiset {
 
    34         let mut multiset = DirsMultiset {
 
    35             inner: HashMap::new(),
 
    35             inner: FastHashMap::default(),
 
    36         };
 
    36         };
 
    37 
    37 
    38         for (filename, DirstateEntry { state, .. }) in vec {
 
    38         for (filename, DirstateEntry { state, .. }) in vec {
 
    39             // This `if` is optimized out of the loop
 
    39             // This `if` is optimized out of the loop
 
    40             if let Some(skip) = skip_state {
 
    40             if let Some(skip) = skip_state {
 
    50     }
 
    50     }
 
    51 
    51 
    52     /// Initializes the multiset from a manifest.
 
    52     /// Initializes the multiset from a manifest.
 
    53     pub fn from_manifest(vec: &Vec<HgPathBuf>) -> Self {
 
    53     pub fn from_manifest(vec: &Vec<HgPathBuf>) -> Self {
 
    54         let mut multiset = DirsMultiset {
 
    54         let mut multiset = DirsMultiset {
 
    55             inner: HashMap::new(),
 
    55             inner: FastHashMap::default(),
 
    56         };
 
    56         };
 
    57 
    57 
    58         for filename in vec {
 
    58         for filename in vec {
 
    59             multiset.add_path(filename);
 
    59             multiset.add_path(filename);
 
    60         }
 
    60         }
 
   125 }
 
   125 }
 
   126 
   126 
   127 #[cfg(test)]
 
   127 #[cfg(test)]
 
   128 mod tests {
 
   128 mod tests {
 
   129     use super::*;
 
   129     use super::*;
 
   130     use std::collections::HashMap;
 
       
   131 
   130 
   132     #[test]
 
   131     #[test]
 
   133     fn test_delete_path_path_not_found() {
 
   132     fn test_delete_path_path_not_found() {
 
   134         let mut map = DirsMultiset::from_manifest(&vec![]);
 
   133         let mut map = DirsMultiset::from_manifest(&vec![]);
 
   135         let path = HgPathBuf::from_bytes(b"doesnotexist/");
 
   134         let path = HgPathBuf::from_bytes(b"doesnotexist/");
 
   241 
   240 
   242     #[test]
 
   241     #[test]
 
   243     fn test_dirsmultiset_new_empty() {
 
   242     fn test_dirsmultiset_new_empty() {
 
   244         let new = DirsMultiset::from_manifest(&vec![]);
 
   243         let new = DirsMultiset::from_manifest(&vec![]);
 
   245         let expected = DirsMultiset {
 
   244         let expected = DirsMultiset {
 
   246             inner: HashMap::new(),
 
   245             inner: FastHashMap::default(),
 
   247         };
 
   246         };
 
   248         assert_eq!(expected, new);
 
   247         assert_eq!(expected, new);
 
   249 
   248 
   250         let new = DirsMultiset::from_dirstate(&HashMap::new(), None);
 
   249         let new = DirsMultiset::from_dirstate(&FastHashMap::default(), None);
 
   251         let expected = DirsMultiset {
 
   250         let expected = DirsMultiset {
 
   252             inner: HashMap::new(),
 
   251             inner: FastHashMap::default(),
 
   253         };
 
   252         };
 
   254         assert_eq!(expected, new);
 
   253         assert_eq!(expected, new);
 
   255     }
 
   254     }
 
   256 
   255 
   257     #[test]
 
   256     #[test]
mercurial