hexga_core 0.0.11-beta.48

Basic set of functionalities common to all hexga crate
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use super::*;

pub trait Push<T>: Collection
{
    type Output;
    /// Push an value and return it's index.
    fn push(&mut self, value: T) -> Self::Output;

    //fn push_mut ...
}
pub trait TryPush<T>: Push<T>
{
    type Error: Debug;
    /// Push an value and return it's index.
    fn try_push(&mut self, value: T) -> Result<Self::Output, Self::Error>;
}

pub trait PushFront<T>: Collection
{
    type Output;
    /// Push an value and return it's index.
    fn push_front(&mut self, value: T) -> Self::Output;
}
pub trait TryPushFront<T>: PushFront<T>
{
    type Error: Debug;
    /// Push an value and return it's index.
    fn try_push_front(&mut self, value: T) -> Result<Self::Output, Self::Error>;
}


impl<T> Push<T> for Vec<T>
{
    type Output = usize;
    #[inline(always)]
    fn push(&mut self, value: T) -> Self::Output
    {
        let l = self.len();
        self.push(value);
        l
    }
}
impl<T> TryPush<T> for Vec<T>
{
    type Error = (); // #proper_error
    fn try_push(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(Push::push(self, value)) }
}


impl<T> Push<T> for VecDeque<T>
{
    type Output = usize;
    fn push(&mut self, value: T) -> Self::Output
    {
        let l = self.len();
        self.push_back(value);
        l
    }
}
impl<T> TryPush<T> for VecDeque<T>
{
    type Error=(); // #proper_error
    fn try_push(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}
impl<T> PushFront<T> for VecDeque<T>
{
    type Output = usize;
    fn push_front(&mut self, value: T) -> Self::Output
    {
        self.push_front(value);
        0
    }
}
impl<T> TryPushFront<T> for VecDeque<T>
{
    type Error=(); // #proper_error
    fn try_push_front(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}



impl<T> Push<T> for LinkedList<T>
{
    type Output = ();
    fn push(&mut self, value: T) -> Self::Output { self.push_back(value); }
}
impl<T> TryPush<T> for LinkedList<T>
{
    type Error=();
    fn try_push(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}
impl<T> PushFront<T> for LinkedList<T>
{
    type Output = (); // #proper_error
    fn push_front(&mut self, value: T) -> Self::Output { self.push_front(value); }
}
impl<T> TryPushFront<T> for LinkedList<T>
{
    type Error=(); // #proper_error
    fn try_push_front(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}

impl<T> Push<T> for BinaryHeap<T>
where
    T: Ord,
{
    type Output = ();
    fn push(&mut self, value: T) -> Self::Output { self.push(value); }
}
impl<T> TryPush<T> for BinaryHeap<T>
where
    T: Ord,
{
    type Error=(); // #proper_error
    fn try_push(&mut self, value: T) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}


impl Push<char> for String
{
    type Output = ();
    fn push(&mut self, value: char) -> Self::Output { self.push(value); }
}
impl TryPush<char> for String
{
    type Error = (); // #proper_error
    fn try_push(&mut self, value: char) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}

#[cfg(feature = "std")]
impl<'b> Push<&'b OsStr> for OsString
{
    type Output = ();
    fn push(&mut self, value: &'b OsStr) -> Self::Output { self.push(value); }
}
#[cfg(feature = "std")]
impl<'b> TryPush<&'b OsStr> for OsString
{
    type Error = (); // #proper_error
    fn try_push(&mut self, value: &'b OsStr) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}

#[cfg(feature = "std")]
impl<P> Push<P> for PathBuf
where
    P: AsRef<Path>,
{
    type Output = ();
    fn push(&mut self, value: P) -> Self::Output { self.push(value); }
}
#[cfg(feature = "std")]
impl<P> TryPush<P> for PathBuf where P: AsRef<Path>
{
    type Error = (); // #proper_error
    fn try_push(&mut self, value: P) -> Result<Self::Output, Self::Error> { Ok(self.push(value)) }
}