DSTify BytesContainer

Author: Jorge Aparicio

src/libstd/path/mod.rs

@@ -68,6 +68,7 @@ println!("path exists: {}", path.exists());
 #![experimental]
 
 use collections::{Collection, MutableSeq};
+use core::kinds::Sized;
 use c_str::CString;
 use clone::Clone;
 use fmt;
@@ -627,7 +628,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// ```
     #[inline]
     fn push_many<T: BytesContainer>(&mut self, paths: &[T]) {
-        let t: Option<T> = None;
+        let t: Option<&T> = None;
         if BytesContainer::is_str(t) {
             for p in paths.iter() {
                 self.push(p.container_as_str().unwrap())
@@ -792,14 +793,9 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 }
 
 /// A trait that represents something bytes-like (e.g. a &[u8] or a &str)
-pub trait BytesContainer {
+pub trait BytesContainer for Sized? {
     /// Returns a &[u8] representing the receiver
     fn container_as_bytes<'a>(&'a self) -> &'a [u8];
-    /// Consumes the receiver and converts it into Vec<u8>
-    #[inline]
-    fn container_into_owned_bytes(self) -> Vec<u8> {
-        self.container_as_bytes().to_vec()
-    }
     /// Returns the receiver interpreted as a utf-8 string, if possible
     #[inline]
     fn container_as_str<'a>(&'a self) -> Option<&'a str> {
@@ -808,7 +804,7 @@ pub trait BytesContainer {
     /// Returns whether .container_as_str() is guaranteed to not fail
     // FIXME (#8888): Remove unused arg once ::<for T> works
     #[inline]
-    fn is_str(_: Option<Self>) -> bool { false }
+    fn is_str(_: Option<&Self>) -> bool { false }
 }
 
 /// A trait that represents the unsafe operations on GenericPaths
@@ -860,48 +856,44 @@ impl<'a, P: GenericPath> Display<'a, P> {
     }
 }
 
-impl<'a> BytesContainer for &'a str {
+impl BytesContainer for str {
     #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
+    fn container_as_bytes(&self) -> &[u8] {
         self.as_bytes()
     }
     #[inline]
-    fn container_as_str<'a>(&'a self) -> Option<&'a str> {
-        Some(*self)
+    fn container_as_str(&self) -> Option<&str> {
+        Some(self)
     }
     #[inline]
-    fn is_str(_: Option<&'a str>) -> bool { true }
+    fn is_str(_: Option<&str>) -> bool { true }
 }
 
 impl BytesContainer for String {
     #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
+    fn container_as_bytes(&self) -> &[u8] {
         self.as_bytes()
     }
     #[inline]
-    fn container_as_str<'a>(&'a self) -> Option<&'a str> {
+    fn container_as_str(&self) -> Option<&str> {
         Some(self.as_slice())
     }
     #[inline]
-    fn is_str(_: Option<String>) -> bool { true }
+    fn is_str(_: Option<&String>) -> bool { true }
 }
 
-impl<'a> BytesContainer for &'a [u8] {
+impl BytesContainer for [u8] {
     #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
-        *self
+    fn container_as_bytes(&self) -> &[u8] {
+        self
     }
 }
 
 impl BytesContainer for Vec<u8> {
     #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
+    fn container_as_bytes(&self) -> &[u8] {
         self.as_slice()
     }
-    #[inline]
-    fn container_into_owned_bytes(self) -> Vec<u8> {
-        self
-    }
 }
 
 impl BytesContainer for CString {
@@ -921,7 +913,20 @@ impl<'a> BytesContainer for str::MaybeOwned<'a> {
         Some(self.as_slice())
     }
     #[inline]
-    fn is_str(_: Option<str::MaybeOwned>) -> bool { true }
+    fn is_str(_: Option<&str::MaybeOwned>) -> bool { true }
+}
+
+impl<'a, Sized? T: BytesContainer> BytesContainer for &'a T {
+    #[inline]
+    fn container_as_bytes(&self) -> &[u8] {
+        (**self).container_as_bytes()
+    }
+    #[inline]
+    fn container_as_str(&self) -> Option<&str> {
+        (**self).container_as_str()
+    }
+    #[inline]
+    fn is_str(_: Option<& &'a T>) -> bool { BytesContainer::is_str(None::<&T>) }
 }
 
 #[inline(always)]

src/libstd/path/posix.rs

@@ -130,17 +130,6 @@ impl BytesContainer for Path {
     fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
         self.as_vec()
     }
-    #[inline]
-    fn container_into_owned_bytes(self) -> Vec<u8> {
-        self.into_vec()
-    }
-}
-
-impl<'a> BytesContainer for &'a Path {
-    #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
-        self.as_vec()
-    }
 }
 
 impl GenericPathUnsafe for Path {

src/libstd/path/windows.rs

@@ -157,23 +157,6 @@ impl<S: hash::Writer> hash::Hash<S> for Path {
 }
 
 impl BytesContainer for Path {
-    #[inline]
-    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
-        self.as_vec()
-    }
-    #[inline]
-    fn container_into_owned_bytes(self) -> Vec<u8> {
-        self.into_vec()
-    }
-    #[inline]
-    fn container_as_str<'a>(&'a self) -> Option<&'a str> {
-        self.as_str()
-    }
-    #[inline]
-    fn is_str(_: Option<Path>) -> bool { true }
-}
-
-impl<'a> BytesContainer for &'a Path {
     #[inline]
     fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
         self.as_vec()
@@ -183,7 +166,7 @@ impl<'a> BytesContainer for &'a Path {
         self.as_str()
     }
     #[inline]
-    fn is_str(_: Option<&'a Path>) -> bool { true }
+    fn is_str(_: Option<&Path>) -> bool { true }
 }
 
 impl GenericPathUnsafe for Path {