pkgcraft 0.0.31

library of Gentoo functionality
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use indexmap::IndexSet;

pub mod cpn;
pub use cpn::Cpn;
pub mod cpv;
pub use cpv::{Cpv, CpvOrDep};
mod dependency;
pub use dependency::Dependency;
mod dependency_iter;
pub use dependency_iter::*;
mod dependency_set;
pub use dependency_set::DependencySet;
pub mod parse;
pub mod pkg;
pub use pkg::{Blocker, Dep, DepField, Slot, SlotDep, SlotOperator};
pub mod uri;
pub use uri::Uri;
pub mod use_dep;
pub use use_dep::{UseDep, UseDepKind};
pub mod version;
pub use version::{Operator, Revision, Version};

pub trait Stringable:
    std::fmt::Debug
    + std::fmt::Display
    + Default
    + Ord
    + Clone
    + std::hash::Hash
    + std::borrow::Borrow<str>
    + AsRef<str>
{
}

impl<T> Stringable for T where
    T: std::fmt::Debug
        + std::fmt::Display
        + Default
        + Ord
        + Clone
        + std::hash::Hash
        + std::borrow::Borrow<str>
        + AsRef<str>
{
}

/// Evaluation support for dependency objects.
pub trait Evaluate<'a, S: Stringable + 'a> {
    type Evaluated;
    fn evaluate(self, options: &'a IndexSet<S>) -> Self::Evaluated;

    type Item;
    type IntoIterEvaluate: Iterator<Item = Self::Item>;
    fn into_iter_evaluate(self, options: &'a IndexSet<S>) -> Self::IntoIterEvaluate;
}

/// Forced evaluation support for dependency objects.
pub trait EvaluateForce {
    type Evaluated;
    fn evaluate_force(self, force: bool) -> Self::Evaluated;

    type Item;
    type IntoIterEvaluateForce: Iterator<Item = Self::Item>;
    fn into_iter_evaluate_force(self, force: bool) -> Self::IntoIterEvaluateForce;
}

/// Flattened iterator support for dependency objects.
pub trait Flatten {
    type Item;
    type IntoIterFlatten: Iterator<Item = Self::Item>;
    fn into_iter_flatten(self) -> Self::IntoIterFlatten;
}

/// Recursive iterator support for dependency objects.
pub trait Recursive {
    type Item;
    type IntoIterRecursive: Iterator<Item = Self::Item>;
    fn into_iter_recursive(self) -> Self::IntoIterRecursive;
}

/// Conditional iterator support for dependency objects.
pub trait Conditionals {
    type Item;
    type IntoIterConditionals: Iterator<Item = Self::Item>;
    fn into_iter_conditionals(self) -> Self::IntoIterConditionals;
}

/// Flattened iterator support for dependency objects including conditionals.
pub trait ConditionalFlatten {
    type Item;
    type IntoIterConditionalFlatten: Iterator<Item = Self::Item>;
    fn into_iter_conditional_flatten(self) -> Self::IntoIterConditionalFlatten;
}

/// Convert iterator into a space-separated string of values.
#[macro_export]
macro_rules! p {
    ($x:expr) => {
        $x.into_iter().map(|x| x.to_string()).join(" ")
    };
}
use p;

/// Recursively sort a set with sortable elements into an iterator.
// TODO: replace with in-place mutation when IndexSet supports IndexMut and/or iter_mut()
#[macro_export]
macro_rules! sort_set {
    ($vals:expr) => {
        itertools::sorted($vals.clone().into_iter().map(|mut d| {
            d.sort();
            d
        }))
    };
}
use sort_set;