use io::ErrorKind;
use std::{cmp, io::{self, Read, Write}, sync::{Arc, atomic::{AtomicBool, Ordering}, mpsc::{Receiver, SyncSender, sync_channel}}};
pub trait OutputSink {
fn write_borrowed(&mut self, bytes: &[u8]) -> io::Result<()>;
fn write_owned_from(&mut self, bytes: Vec<u8>, start: usize) -> io::Result<()> {
let suffix = bytes.get(start..).ok_or_else(|| io::Error::new(ErrorKind::InvalidInput, "owned chunk start exceeds its length"))?;
self.write_borrowed(suffix)
}
fn flush(&mut self) -> io::Result<()> { Ok(()) }
fn is_cancelled(&self) -> bool { false }
}
impl<S: OutputSink + ?Sized> OutputSink for &mut S {
fn write_borrowed(&mut self, bytes: &[u8]) -> io::Result<()> { (**self).write_borrowed(bytes) }
fn write_owned_from(&mut self, bytes: Vec<u8>, start: usize) -> io::Result<()> { (**self).write_owned_from(bytes, start) }
fn flush(&mut self) -> io::Result<()> { (**self).flush() }
fn is_cancelled(&self) -> bool { (**self).is_cancelled() }
}
pub struct WriterSink<W> { writer: W }
impl<W> WriterSink<W> { pub fn new(writer: W) -> Self { Self { writer } } }
impl<W: Write> OutputSink for WriterSink<W> {
fn write_borrowed(&mut self, bytes: &[u8]) -> io::Result<()> { self.writer.write_all(bytes) }
fn flush(&mut self) -> io::Result<()> { self.writer.flush() }
}
struct Chunk { bytes: Vec<u8>, offset: usize }
#[doc(hidden)]
pub struct PipeWriter { sender: SyncSender<Chunk>, cancelled: Arc<AtomicBool> }
impl PipeWriter {
fn send(&self, bytes: Vec<u8>, offset: usize) -> io::Result<()> {
let suffix = bytes.get(offset..).ok_or_else(|| io::Error::new(ErrorKind::InvalidInput, "owned chunk start exceeds its length"))?;
if suffix.is_empty() { return Ok(()); }
self.sender.send(Chunk { bytes, offset }).map_err(|_| io::Error::new(ErrorKind::BrokenPipe, "output reader stopped reading"))
}
}
impl OutputSink for PipeWriter {
fn write_borrowed(&mut self, bytes: &[u8]) -> io::Result<()> { self.send(bytes.to_vec(), 0) }
fn write_owned_from(&mut self, bytes: Vec<u8>, start: usize) -> io::Result<()> { self.send(bytes, start) }
fn is_cancelled(&self) -> bool { self.cancelled.load(Ordering::Relaxed) }
}
#[doc(hidden)]
pub struct PipeReader { receiver: Receiver<Chunk>, chunk: Vec<u8>, offset: usize, cancelled: Arc<AtomicBool> }
impl Drop for PipeReader { fn drop(&mut self) { self.cancelled.store(true, Ordering::Relaxed); } }
impl Read for PipeReader {
fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
if buffer.is_empty() { return Ok(0); }
if self.offset == self.chunk.len() {
match self.receiver.recv() {
Ok(chunk) => {
self.chunk = chunk.bytes;
self.offset = chunk.offset;
}
Err(_) => return Ok(0),
}
}
let count = cmp::min(buffer.len(), self.chunk.len() - self.offset);
buffer[..count].copy_from_slice(&self.chunk[self.offset..self.offset + count]);
self.offset += count;
Ok(count)
}
}
#[doc(hidden)]
pub fn output_pipe() -> (PipeWriter, PipeReader) {
let (sender, receiver) = sync_channel(0);
let cancelled = Arc::new(AtomicBool::new(false));
(PipeWriter { sender, cancelled: Arc::clone(&cancelled) }, PipeReader { receiver, chunk: Vec::new(), offset: 0, cancelled })
}
#[cfg(test)]
mod tests {
use std::thread;
use super::*;
#[test]
fn pipe_transfers_owned_allocation() {
let (mut writer, mut reader) = output_pipe();
let bytes = vec![1, 2, 3, 4];
let pointer = bytes.as_ptr() as usize;
let worker = thread::spawn(move || writer.write_owned_from(bytes, 1).unwrap());
let mut output = [0; 3];
assert_eq!(reader.read(&mut output).unwrap(), 3);
assert_eq!(output, [2, 3, 4]);
assert_eq!(reader.chunk.as_ptr() as usize, pointer);
worker.join().unwrap();
}
}