diff options
Diffstat (limited to 'src/libstd')
| -rw-r--r-- | src/libstd/fmt/mod.rs | 3 | ||||
| -rw-r--r-- | src/libstd/io/buffered.rs | 144 | ||||
| -rw-r--r-- | src/libstd/io/extensions.rs | 11 | ||||
| -rw-r--r-- | src/libstd/io/flate.rs | 69 | ||||
| -rw-r--r-- | src/libstd/io/mem.rs | 51 | ||||
| -rw-r--r-- | src/libstd/io/mod.rs | 27 | ||||
| -rw-r--r-- | src/libstd/io/option.rs | 3 | ||||
| -rw-r--r-- | src/libstd/io/util.rs | 5 | ||||
| -rw-r--r-- | src/libstd/repr.rs | 6 |
9 files changed, 121 insertions, 198 deletions
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index 53eaf17c7f8..8de406f306f 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -470,7 +470,6 @@ use prelude::*; use cast; use char::Char; -use io::Decorator; use io::mem::MemWriter; use io; use str; @@ -692,7 +691,7 @@ pub fn format(args: &Arguments) -> ~str { pub unsafe fn format_unsafe(fmt: &[rt::Piece], args: &[Argument]) -> ~str { let mut output = MemWriter::new(); write_unsafe(&mut output as &mut io::Writer, fmt, args); - return str::from_utf8_owned(output.inner()); + return str::from_utf8_owned(output.unwrap()); } impl<'a> Formatter<'a> { diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 47213e39434..96cb59ce778 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -55,7 +55,7 @@ use prelude::*; use num; use vec; -use super::{Stream, Decorator}; +use super::Stream; // libuv recommends 64k buffers to maximize throughput // https://groups.google.com/forum/#!topic/libuv/oQO1HJAIDdA @@ -92,6 +92,17 @@ impl<R: Reader> BufferedReader<R> { pub fn new(inner: R) -> BufferedReader<R> { BufferedReader::with_capacity(DEFAULT_CAPACITY, inner) } + + /// Gets a reference to the underlying reader. + /// + /// This type does not expose the ability to get a mutable reference to the + /// underlying reader because that could possibly corrupt the buffer. + pub fn get_ref<'a>(&'a self) -> &'a R { &self.inner } + + /// Unwraps this buffer, returning the underlying reader. + /// + /// Note that any leftover data in the internal buffer is lost. + pub fn unwrap(self) -> R { self.inner } } impl<R: Reader> Buffer for BufferedReader<R> { @@ -134,12 +145,6 @@ impl<R: Reader> Reader for BufferedReader<R> { } } -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. @@ -173,6 +178,20 @@ impl<W: Writer> BufferedWriter<W> { self.pos = 0; } } + + /// Gets a reference to the underlying writer. + /// + /// This type does not expose the ability to get a mutable reference to the + /// underlying reader because that could possibly corrupt the buffer. + pub fn get_ref<'a>(&'a self) -> &'a W { &self.inner } + + /// Unwraps this buffer, returning the underlying writer. + /// + /// The buffer is flushed before returning the writer. + pub fn unwrap(mut self) -> W { + self.flush_buf(); + self.inner + } } impl<W: Writer> Writer for BufferedWriter<W> { @@ -196,12 +215,6 @@ impl<W: Writer> Writer for BufferedWriter<W> { } } -impl<W: Writer> Decorator<W> for BufferedWriter<W> { - fn inner(mut self) -> W { self.flush_buf(); 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 (`0x0a`, /// `'\n'`) is detected. /// @@ -218,6 +231,17 @@ impl<W: Writer> LineBufferedWriter<W> { inner: BufferedWriter::with_capacity(1024, inner) } } + + /// Gets a reference to the underlying writer. + /// + /// This type does not expose the ability to get a mutable reference to the + /// underlying reader because that could possibly corrupt the buffer. + pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() } + + /// Unwraps this buffer, returning the underlying writer. + /// + /// The internal buffer is flushed before returning the writer. + pub fn unwrap(mut self) -> W { self.inner.unwrap() } } impl<W: Writer> Writer for LineBufferedWriter<W> { @@ -235,12 +259,6 @@ impl<W: Writer> Writer for LineBufferedWriter<W> { 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> InternalBufferedWriter<W> { @@ -250,21 +268,6 @@ impl<W> InternalBufferedWriter<W> { } } -impl<W: Writer> Decorator<W> for InternalBufferedWriter<W> { - fn inner(self) -> W { - let InternalBufferedWriter(s) = self; - s.inner() - } - fn inner_ref<'a>(&'a self) -> &'a W { - let InternalBufferedWriter(ref s) = *self; - s.inner_ref() - } - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W { - let InternalBufferedWriter(ref mut s) = *self; - s.inner_mut_ref() - } -} - impl<W: Reader> Reader for InternalBufferedWriter<W> { fn read(&mut self, buf: &mut [u8]) -> Option<uint> { self.get_mut_ref().inner.read(buf) } fn eof(&mut self) -> bool { self.get_mut_ref().inner.eof() } @@ -278,6 +281,8 @@ pub struct BufferedStream<S> { } impl<S: Stream> BufferedStream<S> { + /// Creates a new buffered stream with explicitly listed capacities for the + /// reader/writer buffer. pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S) -> BufferedStream<S> { let writer = BufferedWriter::with_capacity(writer_cap, inner); @@ -287,10 +292,30 @@ impl<S: Stream> BufferedStream<S> { BufferedStream { inner: reader } } + /// Creates a new buffered stream with the default reader/writer buffer + /// capacities. pub fn new(inner: S) -> BufferedStream<S> { BufferedStream::with_capacities(DEFAULT_CAPACITY, DEFAULT_CAPACITY, inner) } + + /// Gets a reference to the underlying stream. + /// + /// This type does not expose the ability to get a mutable reference to the + /// underlying reader because that could possibly corrupt the buffer. + pub fn get_ref<'a>(&'a self) -> &'a S { + let InternalBufferedWriter(ref w) = self.inner.inner; + w.get_ref() + } + + /// Unwraps this buffer, returning the underlying stream. + /// + /// The internal buffer is flushed before returning the stream. Any leftover + /// data in the read buffer is lost. + pub fn unwrap(self) -> S { + let InternalBufferedWriter(w) = self.inner.inner; + w.unwrap() + } } impl<S: Stream> Buffer for BufferedStream<S> { @@ -308,17 +333,8 @@ impl<S: Stream> Writer for BufferedStream<S> { fn flush(&mut self) { self.inner.inner.get_mut_ref().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.get_mut_ref().inner_mut_ref() - } -} - #[cfg(test)] mod test { - use io::Decorator; use io; use prelude::*; use super::*; @@ -397,45 +413,45 @@ mod test { let mut writer = BufferedWriter::with_capacity(2, inner); writer.write([0, 1]); - assert_eq!([], writer.inner_ref().inner_ref().as_slice()); + assert_eq!([], writer.get_ref().get_ref()); writer.write([2]); - assert_eq!([0, 1], writer.inner_ref().inner_ref().as_slice()); + assert_eq!([0, 1], writer.get_ref().get_ref()); writer.write([3]); - assert_eq!([0, 1], writer.inner_ref().inner_ref().as_slice()); + assert_eq!([0, 1], writer.get_ref().get_ref()); writer.flush(); - assert_eq!([0, 1, 2, 3], writer.inner_ref().inner_ref().as_slice()); + assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref()); writer.write([4]); writer.write([5]); - assert_eq!([0, 1, 2, 3], writer.inner_ref().inner_ref().as_slice()); + assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref()); writer.write([6]); assert_eq!([0, 1, 2, 3, 4, 5], - writer.inner_ref().inner_ref().as_slice()); + writer.get_ref().get_ref()); writer.write([7, 8]); assert_eq!([0, 1, 2, 3, 4, 5, 6], - writer.inner_ref().inner_ref().as_slice()); + writer.get_ref().get_ref()); 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.get_ref().get_ref()); writer.flush(); assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], - writer.inner_ref().inner_ref().as_slice()); + writer.get_ref().get_ref()); } #[test] fn test_buffered_writer_inner_flushes() { let mut w = BufferedWriter::with_capacity(3, MemWriter::new()); w.write([0, 1]); - assert_eq!([], w.inner_ref().inner_ref().as_slice()); - let w = w.inner(); - assert_eq!([0, 1], w.inner_ref().as_slice()); + assert_eq!([], w.get_ref().get_ref()); + let w = w.unwrap(); + assert_eq!([0, 1], w.get_ref()); } // This is just here to make sure that we don't infinite loop in the @@ -476,20 +492,20 @@ mod test { fn test_line_buffer() { let mut writer = LineBufferedWriter::new(MemWriter::new()); writer.write([0]); - assert_eq!(*writer.inner_ref().inner_ref(), ~[]); + assert_eq!(writer.get_ref().get_ref(), []); writer.write([1]); - assert_eq!(*writer.inner_ref().inner_ref(), ~[]); + assert_eq!(writer.get_ref().get_ref(), []); writer.flush(); - assert_eq!(*writer.inner_ref().inner_ref(), ~[0, 1]); + assert_eq!(writer.get_ref().get_ref(), [0, 1]); writer.write([0, '\n' as u8, 1, '\n' as u8, 2]); - assert_eq!(*writer.inner_ref().inner_ref(), - ~[0, 1, 0, '\n' as u8, 1, '\n' as u8]); + assert_eq!(writer.get_ref().get_ref(), + [0, 1, 0, '\n' as u8, 1, '\n' as u8]); writer.flush(); - assert_eq!(*writer.inner_ref().inner_ref(), - ~[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]); + assert_eq!(writer.get_ref().get_ref(), + [0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]); writer.write([3, '\n' as u8]); - assert_eq!(*writer.inner_ref().inner_ref(), - ~[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2, 3, '\n' as u8]); + assert_eq!(writer.get_ref().get_ref(), + [0, 1, 0, '\n' as u8, 1, '\n' as u8, 2, 3, '\n' as u8]); } #[test] diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 860ff644018..3ad05348960 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -132,7 +132,6 @@ pub fn u64_from_be_bytes(data: &[u8], #[cfg(test)] mod test { use unstable::finally::Finally; - use io::Decorator; use prelude::*; use io::mem::{MemReader, MemWriter}; use io::{io_error, placeholder_error}; @@ -419,7 +418,7 @@ mod test { writer.write_le_u64(*i); } - let mut reader = MemReader::new(writer.inner()); + let mut reader = MemReader::new(writer.unwrap()); for i in uints.iter() { assert!(reader.read_le_u64() == *i); } @@ -435,7 +434,7 @@ mod test { writer.write_be_u64(*i); } - let mut reader = MemReader::new(writer.inner()); + let mut reader = MemReader::new(writer.unwrap()); for i in uints.iter() { assert!(reader.read_be_u64() == *i); } @@ -450,7 +449,7 @@ mod test { writer.write_be_i32(*i); } - let mut reader = MemReader::new(writer.inner()); + let mut reader = MemReader::new(writer.unwrap()); for i in ints.iter() { // this tests that the sign extension is working // (comparing the values as i32 would not test this) @@ -466,7 +465,7 @@ mod test { let mut writer = MemWriter::new(); writer.write(buf); - let mut reader = MemReader::new(writer.inner()); + let mut reader = MemReader::new(writer.unwrap()); let f = reader.read_be_f32(); assert!(f == 8.1250); } @@ -479,7 +478,7 @@ mod test { writer.write_be_f32(f); writer.write_le_f32(f); - let mut reader = MemReader::new(writer.inner()); + let mut reader = MemReader::new(writer.unwrap()); assert!(reader.read_be_f32() == 8.1250); assert!(reader.read_le_f32() == 8.1250); } diff --git a/src/libstd/io/flate.rs b/src/libstd/io/flate.rs index 4a31449e105..c56bdf5bec8 100644 --- a/src/libstd/io/flate.rs +++ b/src/libstd/io/flate.rs @@ -34,26 +34,6 @@ impl<W: Writer> Writer for DeflateWriter<W> { fn flush(&mut self) { fail!() } } -impl<W: Writer> Decorator<W> for DeflateWriter<W> { - fn inner(self) -> W { - match self { - DeflateWriter { inner_writer: w } => w - } - } - - fn inner_ref<'a>(&'a self) -> &'a W { - match *self { - DeflateWriter { inner_writer: ref w } => w - } - } - - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W { - match *self { - DeflateWriter { inner_writer: ref mut w } => w - } - } -} - /// A Reader decorator that decompresses using the 'deflate' scheme pub struct InflateReader<R> { priv inner_reader: R @@ -72,52 +52,3 @@ impl<R: Reader> Reader for InflateReader<R> { fn eof(&mut self) -> bool { fail!() } } - -impl<R: Reader> Decorator<R> for InflateReader<R> { - fn inner(self) -> R { - match self { - InflateReader { inner_reader: r } => r - } - } - - fn inner_ref<'a>(&'a self) -> &'a R { - match *self { - InflateReader { inner_reader: ref r } => r - } - } - - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut R { - match *self { - InflateReader { inner_reader: ref mut r } => r - } - } -} - -#[cfg(test)] -mod test { - use prelude::*; - use super::*; - use super::super::mem::*; - use super::super::Decorator; - - use str; - - #[test] - #[ignore] - fn smoke_test() { - let mem_writer = MemWriter::new(); - let mut deflate_writer = DeflateWriter::new(mem_writer); - let in_msg: &str = "test"; - let in_bytes = in_msg.as_bytes(); - deflate_writer.write(in_bytes); - deflate_writer.flush(); - let buf = deflate_writer.inner().inner(); - let mem_reader = MemReader::new(buf); - let mut inflate_reader = InflateReader::new(mem_reader); - let mut out_bytes = [0, .. 100]; - let bytes_read = inflate_reader.read(out_bytes).unwrap(); - assert_eq!(bytes_read, in_bytes.len()); - let out_msg = str::from_utf8(out_bytes); - assert_eq!(in_msg, out_msg); - } -} diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index aaba3232aa0..95cf7ab4078 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -36,6 +36,16 @@ impl MemWriter { pub fn with_capacity(n: uint) -> MemWriter { MemWriter { buf: vec::with_capacity(n), pos: 0 } } + + /// Acquires an immutable reference to the underlying buffer of this + /// `MemWriter`. + /// + /// No method is exposed for acquiring a mutable reference to the buffer + /// because it could corrupt the state of this `MemWriter`. + pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() } + + /// Unwraps this `MemWriter`, returning the underlying buffer + pub fn unwrap(self) -> ~[u8] { self.buf } } impl Writer for MemWriter { @@ -85,12 +95,6 @@ impl Seek for MemWriter { } } -impl Decorator<~[u8]> for MemWriter { - fn inner(self) -> ~[u8] { self.buf } - fn inner_ref<'a>(&'a self) -> &'a ~[u8] { &self.buf } - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut ~[u8] { &mut self.buf } -} - /// Reads from an owned byte vector pub struct MemReader { priv buf: ~[u8], @@ -98,12 +102,24 @@ pub struct MemReader { } impl MemReader { + /// Creates a new `MemReader` which will read the buffer given. The buffer + /// can be re-acquired through `unwrap` pub fn new(buf: ~[u8]) -> MemReader { MemReader { buf: buf, pos: 0 } } + + /// Acquires an immutable reference to the underlying buffer of this + /// `MemReader`. + /// + /// No method is exposed for acquiring a mutable reference to the buffer + /// because it could corrupt the state of this `MemReader`. + pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() } + + /// Unwraps this `MemReader`, returning the underlying buffer + pub fn unwrap(self) -> ~[u8] { self.buf } } impl Reader for MemReader { @@ -136,13 +152,6 @@ impl Buffer for MemReader { fn consume(&mut self, amt: uint) { self.pos += amt; } } -impl Decorator<~[u8]> for MemReader { - fn inner(self) -> ~[u8] { self.buf } - fn inner_ref<'a>(&'a self) -> &'a ~[u8] { &self.buf } - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut ~[u8] { &mut self.buf } -} - - /// Writes to a fixed-size byte slice /// /// If a write will not fit in the buffer, it raises the `io_error` @@ -247,7 +256,7 @@ impl<'a> Buffer for BufReader<'a> { pub fn with_mem_writer(writeFn: |&mut MemWriter|) -> ~[u8] { let mut writer = MemWriter::new(); writeFn(&mut writer); - writer.inner() + writer.unwrap() } #[cfg(test)] @@ -265,24 +274,24 @@ mod test { writer.write([1, 2, 3]); writer.write([4, 5, 6, 7]); assert_eq!(writer.tell(), 8); - assert_eq!(*writer.inner_ref(), ~[0, 1, 2, 3, 4, 5, 6, 7]); + assert_eq!(writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7]); writer.seek(0, SeekSet); assert_eq!(writer.tell(), 0); writer.write([3, 4]); - assert_eq!(*writer.inner_ref(), ~[3, 4, 2, 3, 4, 5, 6, 7]); + assert_eq!(writer.get_ref(), [3, 4, 2, 3, 4, 5, 6, 7]); writer.seek(1, SeekCur); writer.write([0, 1]); - assert_eq!(*writer.inner_ref(), ~[3, 4, 2, 0, 1, 5, 6, 7]); + assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 7]); writer.seek(-1, SeekEnd); writer.write([1, 2]); - assert_eq!(*writer.inner_ref(), ~[3, 4, 2, 0, 1, 5, 6, 1, 2]); + assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 1, 2]); writer.seek(1, SeekEnd); writer.write([1]); - assert_eq!(*writer.inner_ref(), ~[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]); + assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]); } #[test] @@ -415,7 +424,7 @@ mod test { writer.write_str("testing"); writer.write_line("testing"); writer.write_str("testing"); - let mut r = BufReader::new(*writer.inner_ref()); + let mut r = BufReader::new(writer.get_ref()); assert_eq!(r.read_to_str(), ~"testingtesting\ntesting"); } @@ -425,7 +434,7 @@ mod test { writer.write_char('a'); writer.write_char('\n'); writer.write_char('ệ'); - let mut r = BufReader::new(*writer.inner_ref()); + let mut r = BufReader::new(writer.get_ref()); assert_eq!(r.read_to_str(), ~"a\nệ"); } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 5f597847057..a40999a8042 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -113,7 +113,6 @@ Some examples of obvious things you might want to do * Writer - An I/O sink, writes bytes from a buffer * Stream - Typical I/O sources like files and sockets are both Readers and Writers, and are collectively referred to a `streams`. -* Decorator - A Reader or Writer that composes with others to add additional capabilities such as encoding or decoding # Blocking and synchrony @@ -1298,32 +1297,6 @@ impl<'a, T, A: Acceptor<T>> Iterator<Option<T>> for IncomingIterator<'a, A> { } } -/// Common trait for decorator types. -/// -/// Provides accessors to get the inner, 'decorated' values. The I/O library -/// uses decorators to add functionality like compression and encryption to I/O -/// streams. -/// -/// # XXX -/// -/// Is this worth having a trait for? May be overkill -pub trait Decorator<T> { - /// Destroy the decorator and extract the decorated value - /// - /// # XXX - /// - /// Because this takes `self' one could never 'undecorate' a Reader/Writer - /// that has been boxed. Is that ok? This feature is mostly useful for - /// extracting the buffer from MemWriter - fn inner(self) -> T; - - /// Take an immutable reference to the decorated value - fn inner_ref<'a>(&'a self) -> &'a T; - - /// Take a mutable reference to the decorated value - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut T; -} - pub fn standard_error(kind: IoErrorKind) -> IoError { let desc = match kind { PreviousIoError => "failing due to previous I/O error", diff --git a/src/libstd/io/option.rs b/src/libstd/io/option.rs index 60e63e95dcc..65fa71dd415 100644 --- a/src/libstd/io/option.rs +++ b/src/libstd/io/option.rs @@ -106,7 +106,6 @@ impl<T, A: Acceptor<T>> Acceptor<T> for Option<A> { mod test { use prelude::*; use super::super::mem::*; - use io::Decorator; use super::super::{PreviousIoError, io_error}; #[test] @@ -114,7 +113,7 @@ mod test { let mut writer: Option<MemWriter> = Some(MemWriter::new()); writer.write([0, 1, 2]); writer.flush(); - assert_eq!(writer.unwrap().inner(), ~[0, 1, 2]); + assert_eq!(writer.unwrap().unwrap(), ~[0, 1, 2]); } #[test] diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index 86538c37249..0f64e9f874b 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -193,7 +193,6 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) { #[cfg(test)] mod test { - use io::Decorator; use io::mem::{MemReader, MemWriter}; use super::*; use prelude::*; @@ -282,7 +281,7 @@ mod test { MemWriter::new()); assert_eq!(~[0, 1, 2], r.read_to_end()); let (_, w) = r.unwrap(); - assert_eq!(~[0, 1, 2], w.inner()); + assert_eq!(~[0, 1, 2], w.unwrap()); } #[test] @@ -291,6 +290,6 @@ mod test { let mut w = MemWriter::new(); copy(&mut r, &mut w); assert!(r.eof()); - assert_eq!(~[0, 1, 2, 3, 4], w.inner()); + assert_eq!(~[0, 1, 2, 3, 4], w.unwrap()); } } diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index e60abed42f2..888eed0e762 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -620,11 +620,10 @@ pub fn write_repr<T>(writer: &mut io::Writer, object: &T) { pub fn repr_to_str<T>(t: &T) -> ~str { use str; use io; - use io::Decorator; let mut result = io::mem::MemWriter::new(); write_repr(&mut result as &mut io::Writer, t); - str::from_utf8_owned(result.inner()) + str::from_utf8_owned(result.unwrap()) } #[cfg(test)] @@ -635,14 +634,13 @@ fn test_repr() { use prelude::*; use str; use str::Str; - use io::Decorator; use util::swap; use char::is_alphabetic; fn exact_test<T>(t: &T, e:&str) { let mut m = io::mem::MemWriter::new(); write_repr(&mut m as &mut io::Writer, t); - let s = str::from_utf8_owned(m.inner()); + let s = str::from_utf8_owned(m.unwrap()); assert_eq!(s.as_slice(), e); } |