From 6df57ec2e2cf4dc956b43c05fe7c6d6006f0a80a Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 7 Jan 2014 20:05:33 -0800 Subject: [PATCH] Remove the io::Decorator trait This is just an unnecessary trait that no one's ever going to parameterize over and it's more useful to just define the methods directly on the types themselves. The implementors of this type almost always don't want inner_mut_ref() but they're forced to define it as well. --- src/libextra/ebml.rs | 3 +- src/libextra/json.rs | 8 +- src/libextra/stats.rs | 3 +- src/libextra/term.rs | 16 +- src/libextra/test.rs | 3 +- src/libextra/uuid.rs | 3 +- src/libextra/workcache.rs | 4 +- src/librustc/metadata/encoder.rs | 7 +- src/librustc/metadata/tyencode.rs | 3 +- src/librustc/middle/astencode.rs | 3 +- src/librustdoc/lib.rs | 3 +- src/libstd/fmt/mod.rs | 3 +- src/libstd/io/buffered.rs | 144 ++++++++++-------- src/libstd/io/extensions.rs | 11 +- src/libstd/io/flate.rs | 69 --------- src/libstd/io/mem.rs | 51 ++++--- src/libstd/io/mod.rs | 27 ---- src/libstd/io/option.rs | 3 +- src/libstd/io/util.rs | 5 +- src/libstd/repr.rs | 6 +- src/libsyntax/parse/mod.rs | 3 +- src/libsyntax/print/pprust.rs | 3 +- src/test/run-pass/auto-encode.rs | 3 +- .../run-pass/deriving-encodable-decodable.rs | 3 +- src/test/run-pass/ifmt.rs | 5 +- 25 files changed, 145 insertions(+), 247 deletions(-) diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs index fd5e95d8c23..3798ed8617e 100644 --- a/src/libextra/ebml.rs +++ b/src/libextra/ebml.rs @@ -935,7 +935,6 @@ mod tests { use serialize::Encodable; use serialize; - use std::io::Decorator; use std::io::mem::MemWriter; use std::option::{None, Option, Some}; @@ -948,7 +947,7 @@ mod tests { let mut ebml_w = writer::Encoder(&mut wr); v.encode(&mut ebml_w); } - let ebml_doc = reader::Doc(*wr.inner_ref()); + let ebml_doc = reader::Doc(wr.get_ref()); let mut deser = reader::Decoder(ebml_doc); let v1 = serialize::Decodable::decode(&mut deser); debug!("v1 == {:?}", v1); diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 748d751a2df..68eb4e1e5ac 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -21,7 +21,6 @@ use std::cast::transmute; use std::f64; use std::hashmap::HashMap; use std::io; -use std::io::Decorator; use std::io::mem::MemWriter; use std::num; use std::str; @@ -464,7 +463,7 @@ impl Json{ pub fn to_pretty_str(&self) -> ~str { let mut s = MemWriter::new(); self.to_pretty_writer(&mut s as &mut io::Writer); - str::from_utf8_owned(s.inner()) + str::from_utf8_owned(s.unwrap()) } } @@ -1321,7 +1320,7 @@ impl to_str::ToStr for Json { fn to_str(&self) -> ~str { let mut s = MemWriter::new(); self.to_writer(&mut s as &mut io::Writer); - str::from_utf8_owned(s.inner()) + str::from_utf8_owned(s.unwrap()) } } @@ -1508,12 +1507,11 @@ mod tests { fn with_str_writer(f: |&mut io::Writer|) -> ~str { use std::io::mem::MemWriter; - use std::io::Decorator; use std::str; let mut m = MemWriter::new(); f(&mut m as &mut io::Writer); - str::from_utf8_owned(m.inner()) + str::from_utf8_owned(m.unwrap()) } #[test] diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs index f95c12904ff..7e715c82f9f 100644 --- a/src/libextra/stats.rs +++ b/src/libextra/stats.rs @@ -991,10 +991,9 @@ mod tests { fn test_boxplot_nonpositive() { fn t(s: &Summary, expected: ~str) { use std::io::mem::MemWriter; - use std::io::Decorator; let mut m = MemWriter::new(); write_boxplot(&mut m as &mut io::Writer, s, 30); - let out = str::from_utf8_owned(m.inner()); + let out = str::from_utf8_owned(m.unwrap()); assert_eq!(out, expected); } diff --git a/src/libextra/term.rs b/src/libextra/term.rs index c01530e1255..ca5c4cfa85b 100644 --- a/src/libextra/term.rs +++ b/src/libextra/term.rs @@ -13,8 +13,6 @@ #[allow(missing_doc)]; -use std::io::{Decorator, Writer}; - use std::os; use terminfo::*; use terminfo::searcher::open; @@ -234,20 +232,12 @@ impl Terminal { color-8 } else { color } } -} -impl Decorator for Terminal { - fn inner(self) -> T { - self.out - } + pub fn unwrap(self) -> T { self.out } - fn inner_ref<'a>(&'a self) -> &'a T { - &self.out - } + pub fn get_ref<'a>(&'a self) -> &'a T { &self.out } - fn inner_mut_ref<'a>(&'a mut self) -> &'a mut T { - &mut self.out - } + pub fn get_mut<'a>(&'a mut self) -> &'a mut T { &mut self.out } } impl Writer for Terminal { diff --git a/src/libextra/test.rs b/src/libextra/test.rs index c592290ee16..6881d104442 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -673,7 +673,6 @@ pub fn run_tests_console(opts: &TestOpts, #[test] fn should_sort_failures_before_printing_them() { - use std::io::Decorator; use std::io::mem::MemWriter; use std::str; @@ -705,7 +704,7 @@ fn should_sort_failures_before_printing_them() { st.write_failures(); let s = match st.out { - Raw(ref m) => str::from_utf8(*m.inner_ref()), + Raw(ref m) => str::from_utf8(m.get_ref()), Pretty(_) => unreachable!() }; diff --git a/src/libextra/uuid.rs b/src/libextra/uuid.rs index ef6c9e7f9cd..5a5b3814b74 100644 --- a/src/libextra/uuid.rs +++ b/src/libextra/uuid.rs @@ -522,7 +522,6 @@ mod test { use std::str; use std::rand; use std::num::Zero; - use std::io::Decorator; use std::io::mem::MemWriter; #[test] @@ -798,7 +797,7 @@ mod test { let u = Uuid::new_v4(); let mut wr = MemWriter::new(); u.encode(&mut ebml::writer::Encoder(&mut wr)); - let doc = ebml::reader::Doc(wr.inner_ref().as_slice()); + let doc = ebml::reader::Doc(wr.get_ref()); let u2 = Decodable::decode(&mut ebml::reader::Decoder(doc)); assert_eq!(u, u2); } diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index 19c5f6f69d8..31f5091dd5f 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -17,7 +17,7 @@ use arc::{Arc,RWArc}; use treemap::TreeMap; use std::str; use std::io; -use std::io::{File, Decorator}; +use std::io::File; use std::io::mem::MemWriter; /** @@ -261,7 +261,7 @@ fn json_encode<'a, T:Encodable>>(t: &T) -> ~str { let mut writer = MemWriter::new(); let mut encoder = json::Encoder::new(&mut writer as &mut io::Writer); t.encode(&mut encoder); - str::from_utf8_owned(writer.inner()) + str::from_utf8_owned(writer.unwrap()) } // FIXME(#5121) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 33a34c3f5ba..0f5d5d293d6 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -25,7 +25,6 @@ use std::cast; use std::cell::{Cell, RefCell}; use std::hashmap::{HashMap, HashSet}; use std::io::mem::MemWriter; -use std::io::{Writer, Seek, Decorator}; use std::str; use std::vec; @@ -1807,7 +1806,7 @@ pub static metadata_encoding_version : &'static [u8] = pub fn encode_metadata(parms: EncodeParams, crate: &Crate) -> ~[u8] { let mut wr = MemWriter::new(); encode_metadata_inner(&mut wr, parms, crate); - wr.inner() + wr.unwrap() } fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate) { @@ -1900,7 +1899,7 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate) ecx.stats.total_bytes.set(ebml_w.writer.tell()); if (tcx.sess.meta_stats()) { - for e in ebml_w.writer.inner_ref().iter() { + for e in ebml_w.writer.get_ref().iter() { if *e == 0 { ecx.stats.zero_bytes.set(ecx.stats.zero_bytes.get() + 1); } @@ -1930,5 +1929,5 @@ pub fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str { abbrevs: tyencode::ac_no_abbrevs}; let mut wr = MemWriter::new(); tyencode::enc_ty(&mut wr, cx, t); - str::from_utf8_owned(wr.inner_ref().to_owned()) + str::from_utf8_owned(wr.get_ref().to_owned()) } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 2ba4038e5b4..448e15352ca 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -13,7 +13,6 @@ use std::cell::RefCell; use std::hashmap::HashMap; use std::io; -use std::io::{Decorator, Writer, Seek}; use std::io::mem::MemWriter; use std::str; use std::fmt; @@ -73,7 +72,7 @@ pub fn enc_ty(w: &mut MemWriter, cx: @ctxt, t: ty::t) { None => { let wr = &mut MemWriter::new(); enc_sty(wr, cx, &ty::get(t).sty); - let s = str::from_utf8(*wr.inner_ref()).to_managed(); + let s = str::from_utf8(wr.get_ref()).to_managed(); let mut short_names_cache = cx.tcx .short_names_cache .borrow_mut(); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 640d69432fc..b0f0c71e91d 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1465,7 +1465,6 @@ fn mk_ctxt() -> @fake_ext_ctxt { #[cfg(test)] fn roundtrip(in_item: Option<@ast::item>) { - use std::io::Decorator; use std::io::mem::MemWriter; let in_item = in_item.unwrap(); @@ -1474,7 +1473,7 @@ fn roundtrip(in_item: Option<@ast::item>) { let mut ebml_w = writer::Encoder(&mut wr); encode_item_ast(&mut ebml_w, in_item); } - let ebml_doc = reader::Doc(wr.inner_ref().as_slice()); + let ebml_doc = reader::Doc(wr.get_ref()); let out_item = decode_item_ast(ebml_doc); assert_eq!(in_item, out_item); diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 36caed437f5..28c4d721c84 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -23,7 +23,6 @@ use std::local_data; use std::io; use std::io::File; use std::io::mem::MemWriter; -use std::io::Decorator; use std::str; use extra::getopts; use extra::getopts::groups; @@ -322,7 +321,7 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) { let mut encoder = json::Encoder::new(&mut w as &mut io::Writer); crate.encode(&mut encoder); } - str::from_utf8_owned(w.inner()) + str::from_utf8_owned(w.unwrap()) }; let crate_json = match json::from_str(crate_json_str) { Ok(j) => j, 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 BufferedReader { pub fn new(inner: R) -> BufferedReader { 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 Buffer for BufferedReader { @@ -134,12 +145,6 @@ impl Reader for BufferedReader { } } -impl Decorator for BufferedReader { - 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 BufferedWriter { 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 Writer for BufferedWriter { @@ -196,12 +215,6 @@ impl Writer for BufferedWriter { } } -impl Decorator for BufferedWriter { - 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 LineBufferedWriter { 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 Writer for LineBufferedWriter { @@ -235,12 +259,6 @@ impl Writer for LineBufferedWriter { fn flush(&mut self) { self.inner.flush() } } -impl Decorator for LineBufferedWriter { - 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(BufferedWriter); impl InternalBufferedWriter { @@ -250,21 +268,6 @@ impl InternalBufferedWriter { } } -impl Decorator for InternalBufferedWriter { - 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 Reader for InternalBufferedWriter { fn read(&mut self, buf: &mut [u8]) -> Option { 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 { } impl BufferedStream { + /// 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 { let writer = BufferedWriter::with_capacity(writer_cap, inner); @@ -287,10 +292,30 @@ impl BufferedStream { BufferedStream { inner: reader } } + /// Creates a new buffered stream with the default reader/writer buffer + /// capacities. pub fn new(inner: S) -> BufferedStream { 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 Buffer for BufferedStream { @@ -308,17 +333,8 @@ impl Writer for BufferedStream { fn flush(&mut self) { self.inner.inner.get_mut_ref().flush() } } -impl Decorator for BufferedStream { - 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 Writer for DeflateWriter { fn flush(&mut self) { fail!() } } -impl Decorator for DeflateWriter { - 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 { priv inner_reader: R @@ -72,52 +52,3 @@ impl Reader for InflateReader { fn eof(&mut self) -> bool { fail!() } } - -impl Decorator for InflateReader { - 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> Iterator> 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 { - /// 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> Acceptor for Option { 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 = 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: &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(writer: &mut io::Writer, object: &T) { pub fn repr_to_str(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, 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); } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c20e7f4aaec..b64f16aff59 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -338,7 +338,6 @@ mod test { use extra::serialize::Encodable; use extra; use std::io; - use std::io::Decorator; use std::io::mem::MemWriter; use std::str; use codemap::{Span, BytePos, Spanned}; @@ -356,7 +355,7 @@ mod test { let mut writer = MemWriter::new(); let mut encoder = extra::json::Encoder::new(&mut writer as &mut io::Writer); val.encode(&mut encoder); - str::from_utf8_owned(writer.inner()) + str::from_utf8_owned(writer.unwrap()) } // produce a codemap::span diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 9725d6e38de..82a7d550f64 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -32,7 +32,6 @@ use std::cell::RefCell; use std::char; use std::str; use std::io; -use std::io::Decorator; use std::io::mem::MemWriter; // The &mut ps is stored here to prevent recursive type. @@ -2322,7 +2321,7 @@ pub fn print_string(s: &mut ps, st: &str, style: ast::StrStyle) { // downcasts. unsafe fn get_mem_writer(writer: &mut ~io::Writer) -> ~str { let (_, wr): (uint, ~MemWriter) = cast::transmute_copy(writer); - let result = str::from_utf8_owned(wr.inner_ref().to_owned()); + let result = str::from_utf8_owned(wr.get_ref().to_owned()); cast::forget(wr); result } diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 8058556a469..35e171704ac 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -20,7 +20,6 @@ extern mod extra; // the common code. use std::hashmap::{HashMap, HashSet}; -use std::io::Decorator; use EBReader = extra::ebml::reader; use EBWriter = extra::ebml::writer; @@ -38,7 +37,7 @@ fn test_ebml<'a, A: let mut wr = std::io::mem::MemWriter::new(); let mut ebml_w = EBWriter::Encoder(&mut wr); a1.encode(&mut ebml_w); - let bytes = wr.inner_ref().as_slice(); + let bytes = wr.get_ref(); let d: extra::ebml::Doc<'a> = EBReader::Doc(bytes); let mut decoder: EBReader::Decoder<'a> = EBReader::Decoder(d); diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs index 9194304a376..e22f0a8f8c7 100644 --- a/src/test/run-pass/deriving-encodable-decodable.rs +++ b/src/test/run-pass/deriving-encodable-decodable.rs @@ -19,7 +19,6 @@ extern mod extra; use std::io::mem::MemWriter; -use std::io::Decorator; use std::rand::{random, Rand}; use extra::serialize::{Encodable, Decodable}; use extra::ebml; @@ -61,7 +60,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable + let mut w = MemWriter::new(); let mut e = Encoder(&mut w); obj.encode(&mut e); - let doc = ebml::reader::Doc(@w.inner_ref().to_owned()); + let doc = ebml::reader::Doc(@w.get_ref()); let mut dec = Decoder(doc); let obj2 = Decodable::decode(&mut dec); assert!(obj == obj2); diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index f39bb8fef0c..837adfce048 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -14,7 +14,6 @@ #[deny(warnings)]; use std::fmt; -use std::io::Decorator; use std::io::mem::MemWriter; use std::io; use std::io::Writer; @@ -262,7 +261,7 @@ fn test_write() { writeln!(w, "{foo}", foo="bar"); } - let s = str::from_utf8_owned(buf.inner()); + let s = str::from_utf8_owned(buf.unwrap()); t!(s, "34helloline\nbar\n"); } @@ -286,7 +285,7 @@ fn test_format_args() { format_args!(|args| { fmt::write(w, args) }, "test"); format_args!(|args| { fmt::write(w, args) }, "{test}", test=3); } - let s = str::from_utf8_owned(buf.inner()); + let s = str::from_utf8_owned(buf.unwrap()); t!(s, "1test3"); let s = format_args!(fmt::format, "hello {}", "world");