Struct broot::path::SpecialPath
source · pub struct SpecialPath {
pub pattern: Pattern,
pub handling: SpecialHandling,
}Fields§
§pattern: Pattern§handling: SpecialHandlingImplementations§
source§impl SpecialPath
impl SpecialPath
sourcepub fn new(glob: Glob, handling: SpecialHandling) -> Self
pub fn new(glob: Glob, handling: SpecialHandling) -> Self
Examples found in repository?
src/app/app_context.rs (line 112)
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
pub fn from(
launch_args: Args,
verb_store: VerbStore,
config: &Conf,
) -> Result<Self, ProgramError> {
let config_paths = config.files.clone();
let standard_status = StandardStatus::new(&verb_store);
let true_colors = if let Some(value) = config.true_colors {
value
} else {
are_true_colors_available()
};
let icons = config.icon_theme.as_ref()
.and_then(|itn| icon_plugin(itn));
let special_paths = config.special_paths
.iter()
.map(|(k, v)| SpecialPath::new(k.clone(), *v))
.collect();
let search_modes = config
.search_modes
.as_ref()
.map(|map| map.try_into())
.transpose()?
.unwrap_or_default();
let ext_colors = ExtColorMap::try_from(&config.ext_colors)
.map_err(ConfError::from)?;
let file_sum_threads_count = config.file_sum_threads_count
.unwrap_or(file_sum::DEFAULT_THREAD_COUNT);
if file_sum_threads_count < 1 || file_sum_threads_count > 50 {
return Err(ConfError::InvalidThreadsCount{ count: file_sum_threads_count }.into());
}
let max_panels_count = config.max_panels_count
.unwrap_or(2)
.clamp(2, 100);
let capture_mouse = match (config.capture_mouse, config.disable_mouse_capture) {
(Some(b), _) => b, // the new "capture_mouse" argument takes precedence
(_, Some(b)) => !b,
_ => true,
};
let max_staged_count = config.max_staged_count
.unwrap_or(10_000)
.clamp(10, 100_000);
let initial_root = get_root_path(&launch_args)?;
// tree options are built from the default_flags
// found in the config file(s) (if any) then overridden
// by the cli args
let mut initial_tree_options = TreeOptions::default();
initial_tree_options.apply_config(config)?;
initial_tree_options.apply_launch_args(&launch_args);
if launch_args.color == TriBool::No {
initial_tree_options.show_selection_mark = true;
}
let content_search_max_file_size = config.content_search_max_file_size
.map(|u64value| usize::try_from(u64value).unwrap_or(usize::MAX))
.unwrap_or(content_search::DEFAULT_MAX_FILE_SIZE);
Ok(Self {
initial_root,
initial_tree_options,
config_paths,
launch_args,
verb_store,
special_paths,
search_modes,
show_selection_mark: config.show_selection_mark.unwrap_or(false),
ext_colors,
syntax_theme: config.syntax_theme,
standard_status,
true_colors,
icons,
modal: config.modal.unwrap_or(false),
capture_mouse,
max_panels_count,
quit_on_last_cancel: config.quit_on_last_cancel.unwrap_or(false),
file_sum_threads_count,
max_staged_count,
content_search_max_file_size,
})
}sourcepub fn can_have_matches_in(&self, path: &Path) -> bool
pub fn can_have_matches_in(&self, path: &Path) -> bool
Examples found in repository?
src/file_sum/sum_computation.rs (line 106)
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
pub fn compute_dir_sum(
&mut self,
path: &Path,
cache: &mut AHashMap<PathBuf, FileSum>,
dam: &Dam,
con: &AppContext,
) -> Option<FileSum> {
let threads_count = self.thread_count;
if is_ignored(path, &con.special_paths) {
return Some(FileSum::zero());
}
// there are problems in /proc - See issue #637
if path.starts_with("/proc") {
debug!("not summing in /proc");
return Some(FileSum::zero());
}
if path.starts_with("/run") {
debug!("not summing in /run");
return Some(FileSum::zero());
}
// to avoid counting twice a node, we store their id in a set
#[cfg(unix)]
let nodes = Arc::new(Mutex::new(FnvHashSet::<NodeId>::default()));
// busy is the number of directories which are either being processed or queued
// We use this count to determine when threads can stop waiting for tasks
let mut busy = 0;
let mut sum = compute_file_sum(path);
// this MPMC channel contains the directory paths which must be handled.
// A None means there's nothing left and the thread may send its result and stop
let (dirs_sender, dirs_receiver) = channel::unbounded();
let special_paths: Vec<SpecialPath> = con.special_paths.iter()
.filter(|sp| sp.can_have_matches_in(path))
.cloned()
.collect();
// the first level is managed a little differently: we look at the cache
// before adding. This enables faster computations in two cases:
// - for the root line (assuming it's computed after the content)
// - when we navigate up the tree
if let Ok(entries) = fs::read_dir(path) {
for e in entries.flatten() {
if let Ok(md) = e.metadata() {
if md.is_dir() {
let entry_path = e.path();
if is_ignored(&entry_path, &special_paths) {
debug!("not summing special path {:?}", entry_path);
continue;
}
// we check the cache
if let Some(entry_sum) = cache.get(&entry_path) {
sum += *entry_sum;
continue;
}
// we add the directory to the channel of dirs needing
// processing
busy += 1;
dirs_sender.send(Some(entry_path)).unwrap();
} else {
#[cfg(unix)]
if md.nlink() > 1 {
let mut nodes = nodes.lock().unwrap();
let node_id = NodeId {
inode: md.ino(),
dev: md.dev(),
};
if !nodes.insert(node_id) {
// it was already in the set
continue;
}
}
}
sum += md_sum(&md);
}
}
}
if busy == 0 {
return Some(sum);
}
let busy = Arc::new(AtomicIsize::new(busy));
// this MPMC channel is here for the threads to send their results
// at end of computation
let (thread_sum_sender, thread_sum_receiver) = channel::bounded(threads_count);
// Each thread does a summation without merge and the data are merged
// at the end (this avoids waiting for a mutex during computation)
for _ in 0..threads_count {
let busy = Arc::clone(&busy);
let (dirs_sender, dirs_receiver) = (dirs_sender.clone(), dirs_receiver.clone());
#[cfg(unix)]
let nodes = nodes.clone();
let special_paths = special_paths.clone();
let observer = dam.observer();
let thread_sum_sender = thread_sum_sender.clone();
self.thread_pool.spawn(move || {
let mut thread_sum = FileSum::zero();
loop {
let o = dirs_receiver.recv();
if let Ok(Some(open_dir)) = o {
if let Ok(entries) = fs::read_dir(&open_dir) {
for e in entries.flatten() {
if let Ok(md) = e.metadata() {
if md.is_dir() {
let path = e.path();
if is_ignored(&path, &special_paths) {
debug!("not summing (deep) special path {:?}", path);
continue;
}
// we add the directory to the channel of dirs needing
// processing
busy.fetch_add(1, Ordering::Relaxed);
dirs_sender.send(Some(path)).unwrap();
} else {
#[cfg(unix)]
if md.nlink() > 1 {
let mut nodes = nodes.lock().unwrap();
let node_id = NodeId {
inode: md.ino(),
dev: md.dev(),
};
if !nodes.insert(node_id) {
// it was already in the set
continue;
}
}
}
thread_sum += md_sum(&md);
} else {
// we can't measure much but we can count the file
thread_sum.incr();
}
}
}
busy.fetch_sub(1, Ordering::Relaxed);
}
if observer.has_event() {
dirs_sender.send(None).unwrap(); // to unlock the next waiting thread
break;
}
if busy.load(Ordering::Relaxed) < 1 {
dirs_sender.send(None).unwrap(); // to unlock the next waiting thread
break;
}
}
thread_sum_sender.send(thread_sum).unwrap();
});
}
// Wait for the threads to finish and consolidate their results
for _ in 0..threads_count {
match thread_sum_receiver.recv() {
Ok(thread_sum) => {
sum += thread_sum;
}
Err(e) => {
warn!("Error while recv summing thread result : {:?}", e);
}
}
}
if dam.has_event() {
return None;
}
Some(sum)
}Trait Implementations§
source§impl Clone for SpecialPath
impl Clone for SpecialPath
source§fn clone(&self) -> SpecialPath
fn clone(&self) -> SpecialPath
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read more