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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
use super::*;
pub trait SetLength
{
unsafe fn set_len(&mut self, new_len: usize);
}
#[cfg(feature = "std")]
impl<T> SetLength for Vec<T>
{
unsafe fn set_len(&mut self, new_len: usize) {
unsafe { self.set_len(new_len) };
}
}
pub trait Length: Collection
{
// Returns the number of elements inside this collection, also referred as a 'length'.
fn len(&self) -> usize;
/// True if the container contains 0 elements.
///
/// ```rust
/// use hexga_core::prelude::*;
///
/// assert_eq!([1, 2, 3].is_empty(), false);
///
/// let empty_array : [i32; 0] = [];
/// assert_eq!(empty_array.is_empty(), true);
///
/// assert_eq!("".is_empty(), true);
/// assert_eq!("hello".is_empty(), false);
///
/// assert_eq!("".is_empty(), !("".is_not_empty()));
/// ```
#[inline(always)]
fn is_empty(&self) -> bool { self.len() == 0 }
/// True if the container contains at least one element.
/// Will always be different than `is_empty()`.
///
/// ```rust
/// use hexga_core::prelude::*;
///
/// assert_eq!([1, 2, 3].is_not_empty(), true);
///
/// let empty_array : [i32; 0] = [];
/// assert_eq!(empty_array.is_not_empty(), false);
///
/// assert_eq!("".is_not_empty(), false);
/// assert_eq!("hello".is_not_empty(), true);
///
/// assert_eq!("".is_empty(), !("".is_not_empty()));
/// ```
#[inline(always)]
fn is_not_empty(&self) -> bool { !self.is_empty() }
}
impl<T> Length for Vec<T>
{
fn len(&self) -> usize { self.len() }
}
impl<T> Length for VecDeque<T>
{
fn len(&self) -> usize { self.len() }
}
impl<T, const N: usize> Length for [T; N]
{
fn len(&self) -> usize { N }
}
impl<T> Length for [T]
{
fn len(&self) -> usize { self.len() }
}
impl<T> Length for &[T]
{
fn len(&self) -> usize { (*self).len() }
}
impl<T> Length for &mut [T]
{
fn len(&self) -> usize { (**self).len() }
}
impl Length for String
{
fn len(&self) -> usize { self.len() }
}
impl Length for str
{
fn len(&self) -> usize { self.len() }
}
impl Length for &str
{
fn len(&self) -> usize { (*self).len() }
}
impl Length for &mut str
{
fn len(&self) -> usize { (**self).len() }
}
#[cfg(feature = "std")]
impl Length for OsStr
{
fn len(&self) -> usize { self.len() }
}
impl<T> Length for LinkedList<T>
{
fn len(&self) -> usize { self.len() }
}
#[cfg(feature = "std")]
impl<K, V, S> Length for HashMap<K, V, S>
{
fn len(&self) -> usize { self.len() }
}
impl<K, V> Length for BTreeMap<K, V>
{
fn len(&self) -> usize { self.len() }
}
#[cfg(feature = "std")]
impl<T, S> Length for HashSet<T, S>
{
fn len(&self) -> usize { self.len() }
}
impl<T> Length for BinaryHeap<T>
{
fn len(&self) -> usize { self.len() }
}
impl<T> Length for BTreeSet<T>
{
fn len(&self) -> usize { self.len() }
}
//impl<T: ?Sized> Length for &T where T: Length { fn len(&self) -> usize { (*self).len() } }
//impl<T: ?Sized> Length for &mut T where T: Length { fn len(&self) -> usize { (**self).len() } }