raster_tools/cli/
counters.rs

1use std::fmt;
2use std::sync::atomic::{AtomicUsize, Ordering};
3
4#[derive(Debug, Default)]
5pub struct Counter {
6    val: AtomicUsize,
7}
8impl Counter {
9    pub fn load(&self) -> usize {
10        self.val.load(Ordering::Acquire)
11    }
12
13    pub fn store(&self, val: usize) {
14        self.val.store(val, Ordering::Release);
15    }
16
17    pub fn fetch_add(&self, inc: usize) -> usize {
18        self.val.fetch_add(inc, Ordering::AcqRel)
19    }
20
21    pub fn fetch_sub(&self, inc: usize) -> usize {
22        self.val.fetch_sub(inc, Ordering::AcqRel)
23    }
24}
25impl fmt::Display for Counter {
26    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
27        write!(f, "{}", self.load())
28    }
29}
30
31#[derive(Debug)]
32pub struct DetailCounter {
33    pub total: Counter,
34    pub processed: Counter,
35    pub skipped: Counter,
36    name: &'static str,
37}
38impl DetailCounter {
39    pub fn new(name: &'static str) -> Self {
40        DetailCounter {
41            total: Default::default(),
42            processed: Default::default(),
43            skipped: Default::default(),
44            name,
45        }
46    }
47}
48impl fmt::Display for DetailCounter {
49    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
50        write!(f, "{}: completed {}", self.name, self.processed.load())?;
51        let skipped = self.skipped.load();
52        if skipped > 0 {
53            write!(f, " (skipped {})", skipped)?;
54        }
55        write!(f, " of {}.", self.total.load())
56    }
57}
58
59// #[derive(Debug)]
60// pub struct ChunkCounter {
61//     pub chunk: DetailCounter,
62//     pub detail: DetailCounter,
63// }
64// impl ChunkCounter {
65//     pub fn new(name: &'static str, detail: &'static str) -> Self {
66//         ChunkCounter {
67//             chunk: DetailCounter::new(name),
68//             detail: DetailCounter::new(detail),
69//         }
70//     }
71// }
72// impl fmt::Display for ChunkCounter {
73//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
74//         write!(f, "{}", self.chunk)?;
75//         write!(f, " {}", self.detail)?;
76//         Ok(())
77//     }
78// }