Move std::rt::io to std::io

1 files changed, 0 insertions, 472 deletions

diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs
deleted file mode 100644
index 8afb7183d77..00000000000
--- a/src/libstd/rt/io/buffered.rs
+++ /dev/null
@@ -1,472 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Buffering wrappers for I/O traits
-//!
-//! It can be excessively inefficient to work directly with a `Reader` or
-//! `Writer`. Every call to `read` or `write` on `TcpStream` results in a
-//! system call, for example. This module provides structures that wrap
-//! `Readers`, `Writers`, and `Streams` and buffer input and output to them.
-//!
-//! # Examples
-//!
-//! ```
-//! let tcp_stream = TcpStream::connect(addr);
-//! let reader = BufferedReader::new(tcp_stream);
-//!
-//! let mut buf: ~[u8] = vec::from_elem(100, 0u8);
-//! match reader.read(buf.as_slice()) {
-//!     Some(nread) => println!("Read {} bytes", nread),
-//!     None => println!("At the end of the stream!")
-//! }
-//! ```
-//!
-//! ```
-//! let tcp_stream = TcpStream::connect(addr);
-//! let writer = BufferedWriter::new(tcp_stream);
-//!
-//! writer.write("hello, world".as_bytes());
-//! writer.flush();
-//! ```
-//!
-//! ```
-//! let tcp_stream = TcpStream::connect(addr);
-//! let stream = BufferedStream::new(tcp_stream);
-//!
-//! stream.write("hello, world".as_bytes());
-//! stream.flush();
-//!
-//! let mut buf = vec::from_elem(100, 0u8);
-//! match stream.read(buf.as_slice()) {
-//!     Some(nread) => println!("Read {} bytes", nread),
-//!     None => println!("At the end of the stream!")
-//! }
-//! ```
-//!
-
-use prelude::*;
-
-use num;
-use vec;
-use str;
-use super::{Reader, Writer, Stream, Decorator};
-
-// libuv recommends 64k buffers to maximize throughput
-// https://groups.google.com/forum/#!topic/libuv/oQO1HJAIDdA
-static DEFAULT_CAPACITY: uint = 64 * 1024;
-
-/// Wraps a Reader and buffers input from it
-pub struct BufferedReader<R> {
-    priv inner: R,
-    priv buf: ~[u8],
-    priv pos: uint,
-    priv cap: uint
-}
-
-impl<R: Reader> BufferedReader<R> {
-    /// Creates a new `BufferedReader` with with the specified buffer capacity
-    pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
-        // It's *much* faster to create an uninitialized buffer than it is to
-        // fill everything in with 0. This buffer is entirely an implementation
-        // detail and is never exposed, so we're safe to not initialize
-        // everything up-front. This allows creation of BufferedReader instances
-        // to be very cheap (large mallocs are not nearly as expensive as large
-        // callocs).
-        let mut buf = vec::with_capacity(cap);
-        unsafe { vec::raw::set_len(&mut buf, cap); }
-        BufferedReader {
-            inner: inner,
-            buf: buf,
-            pos: 0,
-            cap: 0
-        }
-    }
-
-    /// Creates a new `BufferedReader` with a default buffer capacity
-    pub fn new(inner: R) -> BufferedReader<R> {
-        BufferedReader::with_capacity(DEFAULT_CAPACITY, inner)
-    }
-
-    /// Reads the next line of input, interpreted as a sequence of utf-8
-    /// encoded unicode codepoints. If a newline is encountered, then the
-    /// newline is contained in the returned string.
-    pub fn read_line(&mut self) -> Option<~str> {
-        self.read_until('\n' as u8).map(str::from_utf8_owned)
-    }
-
-    /// Reads a sequence of bytes leading up to a specified delimeter. Once the
-    /// specified byte is encountered, reading ceases and the bytes up to and
-    /// including the delimiter are returned.
-    pub fn read_until(&mut self, byte: u8) -> Option<~[u8]> {
-        let mut res = ~[];
-        let mut used;
-        loop {
-            {
-                let available = self.fill_buffer();
-                match available.iter().position(|&b| b == byte) {
-                    Some(i) => {
-                        res.push_all(available.slice_to(i + 1));
-                        used = i + 1;
-                        break
-                    }
-                    None => {
-                        res.push_all(available);
-                        used = available.len();
-                    }
-                }
-            }
-            if used == 0 {
-                break
-            }
-            self.pos += used;
-        }
-        self.pos += used;
-        return if res.len() == 0 {None} else {Some(res)};
-    }
-
-    fn fill_buffer<'a>(&'a mut self) -> &'a [u8] {
-        if self.pos == self.cap {
-            match self.inner.read(self.buf) {
-                Some(cap) => {
-                    self.pos = 0;
-                    self.cap = cap;
-                }
-                None => {}
-            }
-        }
-        return self.buf.slice(self.pos, self.cap);
-    }
-}
-
-impl<R: Reader> Reader for BufferedReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        let nread = {
-            let available = self.fill_buffer();
-            if available.len() == 0 {
-                return None;
-            }
-            let nread = num::min(available.len(), buf.len());
-            vec::bytes::copy_memory(buf, available, nread);
-            nread
-        };
-        self.pos += nread;
-        Some(nread)
-    }
-
-    fn eof(&mut self) -> bool {
-        self.pos == self.cap && self.inner.eof()
-    }
-}
-
-impl<R: Reader> Decorator<R> for BufferedReader<R> {
-    fn inner(self) -> R {
-        self.inner
-    }
-
-    fn inner_ref<'a>(&'a self) -> &'a R {
-        &self.inner
-    }
-
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut R {
-        &mut self.inner
-    }
-}
-
-/// Wraps a Writer and buffers output to it
-///
-/// Note that `BufferedWriter` will NOT flush its buffer when dropped.
-pub struct BufferedWriter<W> {
-    priv inner: W,
-    priv buf: ~[u8],
-    priv pos: uint
-}
-
-impl<W: Writer> BufferedWriter<W> {
-    /// Creates a new `BufferedWriter` with with the specified buffer capacity
-    pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
-        // See comments in BufferedReader for why this uses unsafe code.
-        let mut buf = vec::with_capacity(cap);
-        unsafe { vec::raw::set_len(&mut buf, cap); }
-        BufferedWriter {
-            inner: inner,
-            buf: buf,
-            pos: 0
-        }
-    }
-
-    /// Creates a new `BufferedWriter` with a default buffer capacity
-    pub fn new(inner: W) -> BufferedWriter<W> {
-        BufferedWriter::with_capacity(DEFAULT_CAPACITY, inner)
-    }
-}
-
-impl<W: Writer> Writer for BufferedWriter<W> {
-    fn write(&mut self, buf: &[u8]) {
-        if self.pos + buf.len() > self.buf.len() {
-            self.flush();
-        }
-
-        if buf.len() > self.buf.len() {
-            self.inner.write(buf);
-        } else {
-            let dst = self.buf.mut_slice_from(self.pos);
-            vec::bytes::copy_memory(dst, buf, buf.len());
-            self.pos += buf.len();
-        }
-    }
-
-    fn flush(&mut self) {
-        if self.pos != 0 {
-            self.inner.write(self.buf.slice_to(self.pos));
-            self.pos = 0;
-        }
-        self.inner.flush();
-    }
-}
-
-impl<W: Writer> Decorator<W> for BufferedWriter<W> {
-    fn inner(self) -> W { self.inner }
-    fn inner_ref<'a>(&'a self) -> &'a W { &self.inner }
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W { &mut self.inner }
-}
-
-/// Wraps a Writer and buffers output to it, flushing whenever a newline (0xa,
-/// '\n') is detected.
-///
-/// Note that this structure does NOT flush the output when dropped.
-pub struct LineBufferedWriter<W> {
-    priv inner: BufferedWriter<W>,
-}
-
-impl<W: Writer> LineBufferedWriter<W> {
-    /// Creates a new `LineBufferedWriter`
-    pub fn new(inner: W) -> LineBufferedWriter<W> {
-        // Lines typically aren't that long, don't use a giant buffer
-        LineBufferedWriter {
-            inner: BufferedWriter::with_capacity(1024, inner)
-        }
-    }
-}
-
-impl<W: Writer> Writer for LineBufferedWriter<W> {
-    fn write(&mut self, buf: &[u8]) {
-        match buf.iter().position(|&b| b == '\n' as u8) {
-            Some(i) => {
-                self.inner.write(buf.slice_to(i + 1));
-                self.inner.flush();
-                self.inner.write(buf.slice_from(i + 1));
-            }
-            None => self.inner.write(buf),
-        }
-    }
-
-    fn flush(&mut self) { self.inner.flush() }
-}
-
-impl<W: Writer> Decorator<W> for LineBufferedWriter<W> {
-    fn inner(self) -> W { self.inner.inner() }
-    fn inner_ref<'a>(&'a self) -> &'a W { self.inner.inner_ref() }
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W { self.inner.inner_mut_ref() }
-}
-
-struct InternalBufferedWriter<W>(BufferedWriter<W>);
-
-impl<W: Reader> Reader for InternalBufferedWriter<W> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        self.inner.read(buf)
-    }
-
-    fn eof(&mut self) -> bool {
-        self.inner.eof()
-    }
-}
-
-/// Wraps a Stream and buffers input and output to and from it
-///
-/// Note that `BufferedStream` will NOT flush its output buffer when dropped.
-pub struct BufferedStream<S> {
-    priv inner: BufferedReader<InternalBufferedWriter<S>>
-}
-
-impl<S: Stream> BufferedStream<S> {
-    pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S)
-                           -> BufferedStream<S> {
-        let writer = BufferedWriter::with_capacity(writer_cap, inner);
-        let internal_writer = InternalBufferedWriter(writer);
-        let reader = BufferedReader::with_capacity(reader_cap,
-                                                   internal_writer);
-        BufferedStream { inner: reader }
-    }
-
-    pub fn new(inner: S) -> BufferedStream<S> {
-        BufferedStream::with_capacities(DEFAULT_CAPACITY, DEFAULT_CAPACITY,
-                                        inner)
-    }
-}
-
-impl<S: Stream> Reader for BufferedStream<S> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        self.inner.read(buf)
-    }
-
-    fn eof(&mut self) -> bool {
-        self.inner.eof()
-    }
-}
-
-impl<S: Stream> Writer for BufferedStream<S> {
-    fn write(&mut self, buf: &[u8]) {
-        self.inner.inner.write(buf)
-    }
-
-    fn flush(&mut self) {
-        self.inner.inner.flush()
-    }
-}
-
-impl<S: Stream> Decorator<S> for BufferedStream<S> {
-    fn inner(self) -> S {
-        self.inner.inner.inner()
-    }
-
-    fn inner_ref<'a>(&'a self) -> &'a S {
-        self.inner.inner.inner_ref()
-    }
-
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut S {
-        self.inner.inner.inner_mut_ref()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use prelude::*;
-    use super::*;
-    use super::super::mem::{MemReader, MemWriter};
-
-    #[test]
-    fn test_buffered_reader() {
-        let inner = MemReader::new(~[0, 1, 2, 3, 4]);
-        let mut reader = BufferedReader::with_capacity(2, inner);
-
-        let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
-        assert_eq!(Some(2), nread);
-        assert_eq!([0, 1, 0], buf);
-        assert!(!reader.eof());
-
-        let mut buf = [0];
-        let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
-        assert_eq!([2], buf);
-        assert!(!reader.eof());
-
-        let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
-        assert_eq!([3, 0, 0], buf);
-        assert!(!reader.eof());
-
-        let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
-        assert_eq!([4, 0, 0], buf);
-        assert!(reader.eof());
-
-        assert_eq!(None, reader.read(buf));
-    }
-
-    #[test]
-    fn test_buffered_writer() {
-        let inner = MemWriter::new();
-        let mut writer = BufferedWriter::with_capacity(2, inner);
-
-        writer.write([0, 1]);
-        assert_eq!([], writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([2]);
-        assert_eq!([0, 1], writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([3]);
-        assert_eq!([0, 1], writer.inner_ref().inner_ref().as_slice());
-
-        writer.flush();
-        assert_eq!([0, 1, 2, 3], writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([4]);
-        writer.write([5]);
-        assert_eq!([0, 1, 2, 3], writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([6]);
-        assert_eq!([0, 1, 2, 3, 4, 5],
-                   writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([7, 8]);
-        assert_eq!([0, 1, 2, 3, 4, 5, 6],
-                   writer.inner_ref().inner_ref().as_slice());
-
-        writer.write([9, 10, 11]);
-        assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-                   writer.inner_ref().inner_ref().as_slice());
-
-        writer.flush();
-        assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-                   writer.inner_ref().inner_ref().as_slice());
-    }
-
-    // This is just here to make sure that we don't infinite loop in the
-    // newtype struct autoderef weirdness
-    #[test]
-    fn test_buffered_stream() {
-        use rt;
-        struct S;
-
-        impl rt::io::Writer for S {
-            fn write(&mut self, _: &[u8]) {}
-        }
-
-        impl rt::io::Reader for S {
-            fn read(&mut self, _: &mut [u8]) -> Option<uint> { None }
-            fn eof(&mut self) -> bool { true }
-        }
-
-        let mut stream = BufferedStream::new(S);
-        let mut buf = [];
-        stream.read(buf);
-        stream.eof();
-        stream.write(buf);
-        stream.flush();
-    }
-
-    #[test]
-    fn test_read_until() {
-        let inner = MemReader::new(~[0, 1, 2, 1, 0]);
-        let mut reader = BufferedReader::with_capacity(2, inner);
-        assert_eq!(reader.read_until(0), Some(~[0]));
-        assert_eq!(reader.read_until(2), Some(~[1, 2]));
-        assert_eq!(reader.read_until(1), Some(~[1]));
-        assert_eq!(reader.read_until(8), Some(~[0]));
-        assert_eq!(reader.read_until(9), None);
-    }
-
-    #[test]
-    fn test_line_buffer() {
-        let mut writer = LineBufferedWriter::new(MemWriter::new());
-        writer.write([0]);
-        assert_eq!(*writer.inner_ref().inner_ref(), ~[]);
-        writer.write([1]);
-        assert_eq!(*writer.inner_ref().inner_ref(), ~[]);
-        writer.flush();
-        assert_eq!(*writer.inner_ref().inner_ref(), ~[0, 1]);
-        writer.write([0, '\n' as u8, 1]);
-        assert_eq!(*writer.inner_ref().inner_ref(), ~[0, 1, 0, '\n' as u8]);
-        writer.flush();
-        assert_eq!(*writer.inner_ref().inner_ref(), ~[0, 1, 0, '\n' as u8, 1]);
-    }
-}