ewe_mem 0.0.1

Low-level memory management utilities that implement a poor man allocator wrappers
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

use std::borrow::Cow;
use std::fmt::{self, Debug};
use std::ops::Deref;
use std::{slice, str};

use crate::encoding;

pub trait Align {
    fn align(&mut self, offset: usize);
}

impl<T: Align> Align for Vec<T> {
    #[inline]
    fn align(&mut self, offset: usize) {
        for item in self.iter_mut() {
            item.align(offset);
        }
    }
}

impl<T: Align> Align for Option<T> {
    #[inline]
    fn align(&mut self, offset: usize) {
        if let Some(val) = self {
            val.align(offset);
        }
    }
}

impl Align for usize {
    #[inline]
    fn align(&mut self, offset: usize) {
        if *self >= offset {
            *self -= offset;
        }
    }
}

#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
pub struct Range {
    pub start: usize,
    pub end: usize,
}

impl Align for Range {
    fn align(&mut self, offset: usize) {
        self.start.align(offset);
        self.end.align(offset);
    }
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Bytes<'b>(Cow<'b, [u8]>);

impl<'b> Bytes<'b> {
    #[inline]
    pub fn from_slice(slice: &'b [u8]) -> Bytes<'b> {
        Bytes(Cow::from(slice))
    }

    #[inline]
    pub fn from_str(text: &'b str, encoder: encoding::SharedEncoding) -> Bytes<'b> {
        Self(encoder.encode(text))
    }

    #[inline]
    pub fn to_string(&self, decoder: encoding::SharedEncoding) -> String {
        decoder.decode(self).to_owned()
    }

    #[inline]
    pub fn to_utf8_string(&self) -> String {
        str::from_utf8(self.0.as_ref())
            .expect("should be utf8 string")
            .to_string()
    }

    #[inline]
    pub fn to_upper(self) -> Bytes<'b> {
        Bytes(Cow::from(self.0.to_ascii_uppercase()))
    }

    #[inline]
    pub fn to_lower(self) -> Bytes<'b> {
        Bytes(Cow::from(self.0.to_ascii_lowercase()))
    }

    #[inline]
    pub fn as_upper(&self, encoder: encoding::SharedEncoding) -> String {
        encoder.decode(self).to_ascii_uppercase()
    }

    #[inline]
    pub fn as_lower(&self, encoder: encoding::SharedEncoding) -> String {
        encoder.decode(self).to_ascii_lowercase()
    }

    #[inline]
    pub fn into_owned(self) -> Bytes<'static> {
        Bytes(Cow::Owned(self.0.into_owned()))
    }

    #[inline]
    pub fn to_slice(&'b self, range: Range) -> Bytes<'b> {
        let byte_slice = self.0[range.start..range.end].into();
        Bytes(Cow::Borrowed(byte_slice))
    }

    #[inline]
    pub fn opt_slice(&self, range: Option<Range>) -> Option<Bytes> {
        range.map(|range| self.to_slice(range))
    }

    #[inline]
    pub fn into_iter(&'b self) -> slice::Iter<'b, u8> {
        self.0.into_iter()
    }
}

impl Deref for Bytes<'_> {
    type Target = [u8];

    fn deref(&self) -> &[u8] {
        &self.0
    }
}

impl<'b> From<Cow<'b, [u8]>> for Bytes<'b> {
    #[inline]
    fn from(bytes: Cow<'b, [u8]>) -> Self {
        Bytes(bytes)
    }
}

impl<'b> From<&'b [u8]> for Bytes<'b> {
    #[inline]
    fn from(bytes: &'b [u8]) -> Self {
        Bytes(bytes.into())
    }
}

impl Debug for Bytes<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "`{}`", self.to_utf8_string())
    }
}