alumet 0.8.0

Modular framework for hardware and software measurement (including energy consumption and more).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
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

//! Automatic name generation.

use std::{
    borrow::Cow,
    sync::atomic::{AtomicU32, Ordering},
};

/// Generates unique names with a prefix.
///
/// # Uniqueness
/// Every name returned by the generator is unique, in that it will never return the same name twice.
/// It is your responsibility to ensure that you **do not give the same prefix to different generators**.
///
/// # Thread safety
/// `NameGenerator` is [`Send`] and [`Sync`]: it can be sent to threads and shared between threads safely.
/// You may need to wrap the generator in an [`Arc`].
///
/// # Example
///
/// ```
/// use alumet::pipeline::naming::generate::NameGenerator;
///
/// let namegen = NameGenerator::new("prefix");
/// assert_eq!(namegen.next_name(), "prefix-0");
/// assert_eq!(namegen.next_name(), "prefix-1");
/// ```
///
pub struct NameGenerator {
    prefix: Cow<'static, str>,
    counter: AtomicU32,
}

impl NameGenerator {
    /// Creates a new generator with a statically known prefix.
    pub const fn new(prefix: &'static str) -> Self {
        Self {
            prefix: Cow::Borrowed(prefix), // no copy
            counter: AtomicU32::new(0),
        }
    }

    /// Creates a new generator with the given prefix.
    pub fn with_prefix_slice(prefix: &str) -> Self {
        Self {
            prefix: Cow::Owned(prefix.to_owned()), // copy
            counter: AtomicU32::new(0),
        }
    }

    /// Creates a new generator with the given prefix.
    pub fn with_prefix_owned(prefix: String) -> Self {
        Self {
            prefix: Cow::Owned(prefix), // no copy
            counter: AtomicU32::new(0),
        }
    }

    /// Generates a new name of the form `{prefix}-{n}` where n is unique.
    pub fn next_name(&self) -> String {
        let prefix = &self.prefix;
        let n = self.counter.fetch_add(1, Ordering::Relaxed);
        format!("{prefix}-{n}")
    }

    /// Generates a new name of the form `{prefix}-{n}-{addendum}` where n is unique.
    pub fn custom_name(&self, addendum: &str) -> String {
        let prefix = &self.prefix;
        let n = self.counter.fetch_add(1, Ordering::Relaxed);
        format!("{prefix}-{n}-{addendum}")
    }
}

#[cfg(test)]
mod tests {
    use crate::pipeline::util::{assert_send, assert_sync};

    use super::NameGenerator;

    #[test]
    fn type_properties() {
        assert_send::<NameGenerator>();
        assert_sync::<NameGenerator>();
    }

    #[test]
    fn unique_names() {
        let g = NameGenerator::new("test");
        assert_eq!(g.next_name(), "test-0");
        assert_eq!(g.next_name(), "test-1");
        assert_eq!(g.next_name(), "test-2");
        assert_eq!(g.custom_name("wow"), "test-3-wow");
        assert_eq!(g.custom_name("wow"), "test-4-wow");
        assert_eq!(g.next_name(), "test-5");
    }
}