zeros 17.3.2

...
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

/*
==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--

Zeros

Copyright (C) 2019-2025  Anonymous

There are several releases over multiple years,
they are listed as ranges, such as: "2019-2025".

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--
*/

//! # Bytes

use self::inner::Inner;

mod inner;

/// # No bytes
pub const NO_BYTES: Option<&[u8]> = None;

/// # Bytes
///
/// This struct can be converted from:
///
/// - A single slice of bytes.
/// - A slice of slices of bytes.
/// - An array of slices of bytes.
///
/// You rarely use this struct directly. Some functions in this project look like below example:
///
/// ```
/// use zeros::Bytes;
///
/// fn some<'a, const N: usize, B, B0>(bytes: B)
/// where B: Into<Bytes<'a, N, B0>>, B0: AsRef<[u8]> + 'a {
/// }
///
/// some("data");
/// some(["test", "data"]);
/// some([0, 1, 2]);
/// some(&[[3, 4, 5], [6, 7, 8]][..]);
/// ```
///
/// So it's just a convenient way for you to provide your data to those functions.
#[derive(Debug)]
pub struct Bytes<'a, const N: usize, B> where B: AsRef<[u8]> {
    inner: Inner<'a, N, B>,
}

impl<const N: usize, B> Bytes<'_, N, B> where B: AsRef<[u8]> {

    /// # Access to bytes-slice
    pub (crate) fn as_slice(&self) -> &[B] {
        match &self.inner {
            Inner::Slice(slice) => &slice,
            Inner::Array(array) => &array[..],
        }
    }

}

impl<'a, B> From<&'a [B]> for Bytes<'a, {usize::MIN}, B> where B: AsRef<[u8]> {

    fn from(bytes: &'a [B]) -> Self {
        Self {
            inner: Inner::Slice(bytes),
        }
    }

}

impl<B> From<B> for Bytes<'_, 1, B> where B: AsRef<[u8]> {

    fn from(bytes: B) -> Self {
        Self {
            inner: Inner::Array([bytes]),
        }
    }

}

impl<const N: usize, B> From<[B; N]> for Bytes<'_, N, B> where B: AsRef<[u8]> {

    fn from(bytes: [B; N]) -> Self {
        Self {
            inner: Inner::Array(bytes),
        }
    }

}