about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/libextra/ebml.rs3
-rw-r--r--src/libextra/json.rs8
-rw-r--r--src/libextra/stats.rs3
-rw-r--r--src/libextra/term.rs16
-rw-r--r--src/libextra/test.rs3
-rw-r--r--src/libextra/uuid.rs3
-rw-r--r--src/libextra/workcache.rs4
-rw-r--r--src/librustc/metadata/encoder.rs7
-rw-r--r--src/librustc/metadata/tyencode.rs3
-rw-r--r--src/librustc/middle/astencode.rs3
-rw-r--r--src/librustdoc/lib.rs3
-rw-r--r--src/libstd/fmt/mod.rs3
-rw-r--r--src/libstd/io/buffered.rs144
-rw-r--r--src/libstd/io/extensions.rs11
-rw-r--r--src/libstd/io/flate.rs69
-rw-r--r--src/libstd/io/mem.rs51
-rw-r--r--src/libstd/io/mod.rs27
-rw-r--r--src/libstd/io/option.rs3
-rw-r--r--src/libstd/io/util.rs5
-rw-r--r--src/libstd/repr.rs6
-rw-r--r--src/libsyntax/parse/mod.rs3
-rw-r--r--src/libsyntax/print/pprust.rs3
-rw-r--r--src/test/run-pass/auto-encode.rs3
-rw-r--r--src/test/run-pass/deriving-encodable-decodable.rs3
-rw-r--r--src/test/run-pass/ifmt.rs5
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<T: Writer> Terminal<T> {
             color-8
         } else { color }
     }
-}
 
-impl<T: Writer> Decorator<T> for Terminal<T> {
-    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<T: Writer> Writer for Terminal<T> {
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<json::Encoder<'a>>>(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<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);
     }
 
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<Encoder> +
     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");
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-09-07 00:30:53 +0000