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

use crate::traits::Identify;
use crate::{Error, Result};
use crate::{NonNegative, Positive};
use log::{Level, Metadata, Record};
use std::collections::HashSet;
use std::iter::FromIterator;

/// Returns ⌈log2(x)⌉.
pub(crate) const fn log2_ceil(x: Positive) -> NonNegative {
    8 * std::mem::size_of::<NonNegative>() as NonNegative
        - (x.get() - 1).leading_zeros() as NonNegative
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn log2_ceil_fn() {
        for i in (1..65_536).map(Positive::new).map(Option::unwrap) {
            assert_eq!((i.get() as f64).log2().ceil() as NonNegative, log2_ceil(i));
        }
    }
}

#[derive(Debug)]
pub struct UniquelyNamedBuilder<T: Identify> {
    items: Vec<T>,
}

impl<T: Identify> UniquelyNamedBuilder<T> {
    pub fn new() -> Self {
        UniquelyNamedBuilder::default()
    }

    pub fn add_item(&mut self, item: T) {
        self.items.push(item);
    }

    pub fn with_item(mut self, item: T) -> Self {
        self.add_item(item);
        self
    }

    pub fn with_items(mut self, items: impl IntoIterator<Item = T>) -> Self {
        items.into_iter().for_each(|item| {
            self.add_item(item);
        });
        self
    }

    pub fn finish(self) -> Result<Vec<T>> {
        let set: HashSet<&str> = self.items.iter().map(|item| item.identifier()).collect();
        if self.items.len() != set.len() {
            Err(Error::UnexpectedDuplicate)
        } else {
            Ok(self.items)
        }
    }
}

impl<T: Identify> FromIterator<T> for UniquelyNamedBuilder<T> {
    fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self {
        UniquelyNamedBuilder {
            items: iter.into_iter().collect(),
        }
    }
}

impl<T: Identify> Default for UniquelyNamedBuilder<T> {
    fn default() -> Self {
        UniquelyNamedBuilder { items: Vec::new() }
    }
}

pub struct Logger;

impl log::Log for Logger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Debug
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            println!("{:5} - {}", record.level(), record.args());
        }
    }

    fn flush(&self) {}
}