blue-build-utils 0.9.13

A CLI tool built for creating Containerfile templates for ostree based atomic distros
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
96
97
98
99
100

use std::{borrow::Cow, ffi::OsStr, path::Path};

trait PrivateTrait<T: ?Sized>: IntoIterator {}

impl<T, R> PrivateTrait<R> for T where T: IntoIterator {}

#[allow(private_bounds)]
pub trait CowCollecter<'a, IN, OUT>: PrivateTrait<IN>
where
    IN: ToOwned + ?Sized,
    OUT: ToOwned + ?Sized,
{
    fn collect_cow_vec(&'a self) -> Vec<Cow<'a, OUT>>;
}

impl<'a, T, R> CowCollecter<'a, R, R> for T
where
    T: AsRef<[R]> + IntoIterator,
    R: ToOwned,
{
    fn collect_cow_vec(&'a self) -> Vec<Cow<'a, R>> {
        self.as_ref().iter().map(Cow::Borrowed).collect()
    }
}

macro_rules! impl_cow_collector {
    ($type:ty) => {
        impl<'a, T, R> CowCollecter<'a, R, $type> for T
        where
            T: AsRef<[R]> + IntoIterator,
            R: AsRef<$type> + ToOwned + 'a,
        {
            fn collect_cow_vec(&'a self) -> Vec<Cow<'a, $type>> {
                self.as_ref()
                    .iter()
                    .map(|v| v.as_ref())
                    .map(Cow::from)
                    .collect()
            }
        }
    };
}

impl_cow_collector!(str);
impl_cow_collector!(Path);
impl_cow_collector!(OsStr);

#[allow(private_bounds)]
pub trait AsRefCollector<'a, IN, OUT>: PrivateTrait<IN>
where
    IN: ?Sized,
    OUT: ?Sized,
{
    fn collect_as_ref_vec(&'a self) -> Vec<&'a OUT>;
}

impl<'a, T, R> AsRefCollector<'a, R, R> for T
where
    T: AsRef<[R]> + IntoIterator,
{
    fn collect_as_ref_vec(&'a self) -> Vec<&'a R> {
        self.as_ref().iter().collect()
    }
}

macro_rules! impl_asref_collector {
    ($type:ty) => {
        impl<'a, T, R> AsRefCollector<'a, R, $type> for T
        where
            T: AsRef<[R]> + IntoIterator,
            R: AsRef<$type> + 'a,
        {
            fn collect_as_ref_vec(&'a self) -> Vec<&'a $type> {
                self.as_ref().iter().map(AsRef::as_ref).collect()
            }
        }
    };
}

impl_asref_collector!(str);
impl_asref_collector!(Path);
impl_asref_collector!(OsStr);

#[allow(private_bounds)]
pub trait IntoCollector<IN, OUT>: PrivateTrait<IN>
where
    IN: Into<OUT>,
{
    fn collect_into_vec(self) -> Vec<OUT>;
}

impl<T, U, R> IntoCollector<U, R> for T
where
    T: IntoIterator<Item = U>,
    U: Into<R>,
{
    fn collect_into_vec(self) -> Vec<R> {
        self.into_iter().map(Into::into).collect()
    }
}