ruyi 0.1.6

An event-driven framework for non-blocking, asynchronous I/O in Rust
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

use std::io::{self, Write};
use std::ptr;

use super::ByteBuf;

pub struct Writer<'a> {
    inner: &'a mut ByteBuf,
}

#[inline]
pub(super) fn new<'a>(inner: &'a mut ByteBuf) -> Writer<'a> {
    Writer { inner }
}

impl<'a> Write for Writer<'a> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        let mut n = buf.len();
        let mut src_dst = buf.as_ptr();
        loop {
            if let Some(block) = self.inner.last_mut() {
                let dst_off = block.write_pos();
                let appendable = block.appendable();
                if appendable >= n {
                    unsafe {
                        ptr::copy_nonoverlapping(
                            src_dst,
                            block.as_mut_ptr().offset(dst_off as isize),
                            n,
                        );
                    }
                    block.set_write_pos(dst_off + n);
                    return Ok(buf.len());
                } else {
                    unsafe {
                        ptr::copy_nonoverlapping(
                            src_dst,
                            block.as_mut_ptr().offset(dst_off as isize),
                            appendable,
                        );
                        src_dst = src_dst.offset(appendable as isize);
                    }
                    n -= appendable;
                    let cap = block.capacity();
                    block.set_write_pos(cap);
                }
            }
            self.inner.append_block(0);
        }
    }

    #[inline]
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}