Move std::{str,vec}::raw::set_len to an unsafe method on Owned{Vector,Str}.

Author: huonw

doc/po/ja/tutorial-ffi.md.po

@@ -224,7 +224,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "        snappy_compress(psrc, srclen, pdst, &mut dstlen);\n"
-"        vec::raw::set_len(&mut dst, dstlen as uint);\n"
+"        dst.set_len(dstlen as uint);\n"
 "        dst\n"
 "    }\n"
 "}\n"
@@ -271,7 +271,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "        if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {\n"
-"            vec::raw::set_len(&mut dst, dstlen as uint);\n"
+"            dst.set_len(dstlen as uint);\n"
 "            Some(dst)\n"
 "        } else {\n"
 "            None // SNAPPY_INVALID_INPUT\n"

doc/po/tutorial-ffi.md.pot

@@ -224,7 +224,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "        snappy_compress(psrc, srclen, pdst, &mut dstlen);\n"
-"        vec::raw::set_len(&mut dst, dstlen as uint);\n"
+"        dst.set_len(dstlen as uint);\n"
 "        dst\n"
 "    }\n"
 "}\n"
@@ -271,7 +271,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "        if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {\n"
-"            vec::raw::set_len(&mut dst, dstlen as uint);\n"
+"            dst.set_len(dstlen as uint);\n"
 "            Some(dst)\n"
 "        } else {\n"
 "            None // SNAPPY_INVALID_INPUT\n"

doc/tutorial-ffi.md

@@ -107,7 +107,7 @@ pub fn compress(src: &[u8]) -> ~[u8] {
         let pdst = vec::raw::to_mut_ptr(dst);
 
         snappy_compress(psrc, srclen, pdst, &mut dstlen);
-        vec::raw::set_len(&mut dst, dstlen as uint);
+        dst.set_len(dstlen as uint);
         dst
     }
 }
@@ -129,7 +129,7 @@ pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
         let pdst = vec::raw::to_mut_ptr(dst);
 
         if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
-            vec::raw::set_len(&mut dst, dstlen as uint);
+            dst.set_len(dstlen as uint);
             Some(dst)
         } else {
             None // SNAPPY_INVALID_INPUT

src/librustuv/process.rs

@@ -49,7 +49,7 @@ impl Process {
         let mut stdio = vec::with_capacity::<uvll::uv_stdio_container_t>(io.len());
         let mut ret_io = vec::with_capacity(io.len());
         unsafe {
-            vec::raw::set_len(&mut stdio, io.len());
+            stdio.set_len(io.len());
             for (slot, other) in stdio.iter().zip(io.iter()) {
                 let io = set_stdio(slot as *uvll::uv_stdio_container_t, other,
                                    loop_);

src/libstd/io/buffered.rs

@@ -79,7 +79,7 @@ impl<R: Reader> BufferedReader<R> {
         // to be very cheap (large mallocs are not nearly as expensive as large
         // callocs).
         let mut buf = vec::with_capacity(cap);
-        unsafe { vec::raw::set_len(&mut buf, cap); }
+        unsafe { buf.set_len(cap); }
         BufferedReader {
             inner: inner,
             buf: buf,
@@ -154,7 +154,7 @@ impl<W: Writer> BufferedWriter<W> {
     pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
         // See comments in BufferedReader for why this uses unsafe code.
         let mut buf = vec::with_capacity(cap);
-        unsafe { vec::raw::set_len(&mut buf, cap); }
+        unsafe { buf.set_len(cap); }
         BufferedWriter {
             inner: inner,
             buf: buf,

src/libstd/io/mod.rs

@@ -523,7 +523,7 @@ pub trait Reader {
             let mut total_read = 0;
 
             buf.reserve_additional(len);
-            vec::raw::set_len(buf, start_len + len);
+            buf.set_len(start_len + len);
 
             (|| {
                 while total_read < len {
@@ -539,7 +539,7 @@ pub trait Reader {
                         }
                     }
                 }
-            }).finally(|| vec::raw::set_len(buf, start_len + total_read))
+            }).finally(|| buf.set_len(start_len + total_read))
         }
     }
 

src/libstd/io/native/file.rs

@@ -706,7 +706,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
             -1 => Err(super::last_error()),
             n => {
                 assert!(n > 0);
-                unsafe { vec::raw::set_len(&mut buf, n as uint); }
+                unsafe { buf.set_len(n as uint); }
                 Ok(Path::new(buf))
             }
         }

src/libstd/os.rs

@@ -369,7 +369,7 @@ pub fn self_exe_path() -> Option<Path> {
             });
             if err != 0 { return None; }
             if sz == 0 { return None; }
-            vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL
+            v.set_len(sz as uint - 1); // chop off trailing NUL
             Some(v)
         }
     }
@@ -398,7 +398,7 @@ pub fn self_exe_path() -> Option<Path> {
                 _NSGetExecutablePath(buf as *mut i8, &mut sz)
             });
             if err != 0 { return None; }
-            vec::raw::set_len(&mut v, sz as uint - 1); // chop off trailing NUL
+            v.set_len(sz as uint - 1); // chop off trailing NUL
             Some(v)
         }
     }

src/libstd/rt/stack.rs

@@ -24,7 +24,7 @@ impl StackSegment {
         unsafe {
             // Crate a block of uninitialized values
             let mut stack = vec::with_capacity(size);
-            vec::raw::set_len(&mut stack, size);
+            stack.set_len(size);
 
             let mut stk = StackSegment {
                 buf: stack,

src/libstd/str.rs

@@ -993,7 +993,7 @@ pub mod raw {
     use cast;
     use libc;
     use ptr;
-    use str::is_utf8;
+    use str::{is_utf8, OwnedStr};
     use vec;
     use vec::MutableVector;
     use unstable::raw::Slice;
@@ -1002,7 +1002,7 @@ pub mod raw {
     pub unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str {
         let mut v: ~[u8] = vec::with_capacity(len);
         v.as_mut_buf(|vbuf, _len| ptr::copy_memory(vbuf, buf as *u8, len));
-        vec::raw::set_len(&mut v, len);
+        v.set_len(len);
 
         assert!(is_utf8(v));
         ::cast::transmute(v)
@@ -1109,7 +1109,7 @@ pub mod raw {
         let len = s.len();
         assert!((len > 0u));
         let b = s[len - 1u];
-        set_len(s, len - 1u);
+        s.set_len(len - 1);
         return b;
     }
 
@@ -1130,16 +1130,6 @@ pub mod raw {
         cast::transmute(s)
     }
 
-    /// Sets the length of a string
-    ///
-    /// This will explicitly set the size of the string, without actually
-    /// modifying its buffers, so it is up to the caller to ensure that
-    /// the string is actually the specified size.
-    #[inline]
-    pub unsafe fn set_len(s: &mut ~str, new_len: uint) {
-        vec::raw::set_len(as_owned_vec(s), new_len)
-    }
-
     /// Sets the length of a string
     ///
     /// This will explicitly set the size of the string, without actually
@@ -1339,7 +1329,7 @@ impl Mutable for ~str {
     #[inline]
     fn clear(&mut self) {
         unsafe {
-            raw::set_len(self, 0)
+            self.set_len(0)
         }
     }
 }
@@ -2293,7 +2283,7 @@ impl<'a> StrSlice<'a> for &'a str {
                 let mut v = vec::with_capacity(len);
 
                 v.as_mut_buf(|dst, _| ptr::copy_memory(dst, src, len));
-                vec::raw::set_len(&mut v, len);
+                v.set_len(len);
                 ::cast::transmute(v)
             }
         })
@@ -2598,6 +2588,13 @@ pub trait OwnedStr {
     /// The caller must make sure any mutations to this buffer keep the string
     /// valid UTF-8!
     fn as_mut_buf<T>(&mut self, f: |*mut u8, uint| -> T) -> T;
+
+    /// Sets the length of a string
+    ///
+    /// This will explicitly set the size of the string, without actually
+    /// modifying its buffers, so it is up to the caller to ensure that
+    /// the string is actually the specified size.
+    unsafe fn set_len(&mut self, new_len: uint);
 }
 
 impl OwnedStr for ~str {
@@ -2629,7 +2626,7 @@ impl OwnedStr for ~str {
                     c.encode_utf8(slc)
                 })
             });
-            raw::set_len(self, cur_len + used);
+            self.set_len(cur_len + used);
         }
     }
 
@@ -2638,7 +2635,7 @@ impl OwnedStr for ~str {
         let end = self.len();
         assert!(end > 0u);
         let CharRange {ch, next} = self.char_range_at_reverse(end);
-        unsafe { raw::set_len(self, next); }
+        unsafe { self.set_len(next); }
         return ch;
     }
 
@@ -2689,7 +2686,7 @@ impl OwnedStr for ~str {
     fn truncate(&mut self, len: uint) {
         assert!(len <= self.len());
         assert!(self.is_char_boundary(len));
-        unsafe { raw::set_len(self, len); }
+        unsafe { self.set_len(len); }
     }
 
     #[inline]
@@ -2703,6 +2700,11 @@ impl OwnedStr for ~str {
             raw::as_owned_vec(self).as_mut_buf(f)
         }
     }
+
+    #[inline]
+    unsafe fn set_len(&mut self, new_len: uint) {
+        raw::as_owned_vec(self).set_len(new_len)
+    }
 }
 
 impl Clone for ~str {