restd 0.3.0

A re-implementation of various std features
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

use crate::io::{Error, Read, ReadResult, Result, Seek, Write};

/// A moving cursor over a slice of bytes.
///
/// Reading and writing both move forward in the data: if you don't want this,
/// consider using [`Buffer`](crate::io::Buffer) instead.
pub struct Cursor<A> {
    data: A,
    idx: usize,
}

impl<A> Cursor<A>
where
    A: AsRef<[u8]>,
{
    /// Create a new cursor, starting at the beginning.
    pub fn new(data: A) -> Self {
        Self { data, idx: 0 }
    }

    /// Create a new cursor, starting partway through the data.
    pub fn new_at(data: A, idx: usize) -> Self {
        Self { data, idx }
    }

    /// Returns the amount of remaining data.
    pub fn len(&self) -> usize {
        self.remaining().len() - self.idx
    }

    /// Returns the current position in the data.
    pub fn position(&self) -> usize {
        self.idx
    }

    /// Returns whether or not the cursor is at the end of the data.
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Consumes the cursor and returns the original data.
    pub fn into_inner(self) -> A {
        self.data
    }

    /// Returns a view into the remaining data.
    pub fn remaining(&self) -> &[u8] {
        &self.data.as_ref()[self.idx..]
    }

    /// Get a mutable reference to the underlying data.
    pub fn get_ref(&self) -> &A {
        &self.data
    }

    /// Get a mutable reference to the underlying data.
    pub fn get_mut(&mut self) -> &mut A {
        &mut self.data
    }
}

impl<A> Cursor<A>
where
    A: AsMut<[u8]>,
{
    /// Returns a mutable view into the remaining data.
    pub fn remaining_mut(&mut self) -> &mut [u8] {
        &mut self.data.as_mut()[self.idx..]
    }
}

impl<A> Seek for Cursor<A>
where
    A: AsRef<[u8]>,
{
    fn seek(&mut self, by: isize) -> Result<usize> {
        self.idx = self
            .idx
            .saturating_add_signed(by)
            .min(self.data.as_ref().len());
        Ok(self.idx)
    }

    fn seek_to(&mut self, to: usize) -> Result<usize> {
        self.idx = to.min(self.data.as_ref().len());
        Ok(self.idx)
    }

    fn seek_from_end(&mut self, by: usize) -> Result<usize> {
        self.idx = self.data.as_ref().len().saturating_sub(by);
        Ok(self.idx)
    }

    fn rewind(&mut self) -> Result<()> {
        self.idx = 0;
        Ok(())
    }
}

impl<A> Read for Cursor<A>
where
    A: AsRef<[u8]>,
{
    fn read(&mut self, buf: &mut [u8]) -> ReadResult {
        let data = &self.data.as_ref()[self.idx..];

        if !data.is_empty() {
            let cap = data.len().min(buf.len());
            buf[..cap].copy_from_slice(&data[..cap]);

            self.idx += cap;
            Ok(Some(cap))
        } else {
            Ok(None)
        }
    }
}

impl<A> Write for Cursor<A>
where
    A: AsMut<[u8]>,
{
    fn write(&mut self, buf: &[u8]) -> Result<usize> {
        let data = &mut self.data.as_mut()[self.idx..];

        if !data.is_empty() {
            let cap = data.len().min(buf.len());
            data[..cap].copy_from_slice(&buf[..cap]);

            self.idx += cap;
            Ok(cap)
        } else {
            Err(Error::OutOfSpace)
        }
    }

    fn flush(&mut self) -> Result<()> {
        Ok(())
    }
}