tosca 0.1.1

A library that acts as an interface between a device and its controller.
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

macro_rules! set {
    (
        /// $desc:expr
        $(#[$attrs:meta])*
        pub struct $name:ident(IndexSet<$element:ty, DefaultHashBuilder>);
    ) => {
        ///
        $(#[$attrs])*
        pub struct $name(IndexSet<$element, DefaultHashBuilder>);

        impl IntoIterator for $name {
            type Item = $element;
            type IntoIter = IntoIter<$element>;

            fn into_iter(self) -> Self::IntoIter {
                self.0.into_iter()
            }
        }

        impl<'a> IntoIterator for &'a $name {
            type Item = &'a $element;
            type IntoIter = Iter<'a, $element>;

            fn into_iter(self) -> Self::IntoIter {
                self.iter()
            }
        }

        impl Default for $name {
            fn default() -> Self {
                Self::new()
            }
        }

        impl $name {
            #[doc = concat!("Creates an empty [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn new() -> Self {
                Self(IndexSet::default())
            }

            #[doc = concat!("Initializes [`", stringify!($name), "`] with a specific element.")]
            #[must_use]
            #[inline]
            pub fn init(element: $element) -> Self {
                Self::new().insert(element)
            }

            #[doc = concat!("Inserts a new element into [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn insert(mut self, element: $element) -> Self {
                self.0.insert(element);
                self
            }

            #[doc = concat!("Adds a new element into [`", stringify!($name), "`].")]
            #[doc = ""]
            #[doc = concat!("Unlike [`Self::insert`], this method does not return a modified [`", stringify!($name), "`].")]
            #[inline]
            pub fn add(&mut self, element: $element) {
                self.0.insert(element);
            }

            #[doc = concat!("Checks if [`", stringify!($name), "`] contains the given [`", stringify!($element), "`].")]
            #[inline]
            #[must_use]
            pub fn contains(&self, hazard: &$element) -> bool {
                self.0.contains(hazard)
            }

            #[doc = concat!("Checks if [`", stringify!($name), "`] is empty.")]
            #[must_use]
            #[inline]
            pub fn is_empty(&self) -> bool {
                self.0.is_empty()
            }

            #[doc = concat!("Provides the number of elements in [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn len(&self) -> usize {
                self.0.len()
            }

            #[doc = concat!("Gets an element from [`", stringify!($name), "`] by index.")]
            #[inline]
            pub fn get_index(&self, index: usize) -> Option<&$element> {
                self.0.get_index(index)
            }

            #[doc = concat!("Returns an iterator over [`", stringify!($name), "`].")]
            #[doc = ""]
            #[doc = "**Iterates over the elements in the order they were inserted.**"]
            #[must_use]
            #[inline]
            pub fn iter(&self) -> Iter<'_, $element> {
                self.0.iter()
            }
        }
    };
}

pub(crate) use set;