Implement a StringRef

This is the string equivalent of VecRef. I had some trouble with
lifetimes trying to implement StrSlice, so I've left it for now,
iterating on strings isn't as common and the .as_slice() method
merely means you need to add an extra method call.

Author: Aatch

src/libstd/str.rs

@@ -34,7 +34,7 @@ use ptr::RawPtr;
 use to_str::ToStr;
 use uint;
 use vec;
-use vec::{OwnedVector, OwnedCopyableVector, ImmutableVector};
+use vec::{OwnedVector, OwnedCopyableVector, ImmutableVector, Vector};
 
 /*
 Section: Conditions
@@ -2238,6 +2238,82 @@ impl OwnedStr for ~str {
     }
 }
 
+/**
+ * A StringRef is a string that can hold either a ~str or a &'static str.
+ * This can be useful as an optimization when an allocation is sometimes
+ * needed but the common case is statically known.
+ */
+#[deriving(Eq,Ord,Clone)]
+pub struct StringRef {
+    priv r: ::vec::VecRef<u8>
+}
+
+impl StringRef {
+
+    /**
+     * Constructs a StringRef from an owned string
+     */
+    #[inline]
+    pub fn from_owned(s: ~str) -> StringRef {
+        StringRef {
+            r: ::vec::VecRef::from_owned(s.as_bytes_with_null_consume())
+        }
+    }
+
+    /**
+     * Constructs a StringRef from a static string
+     */
+    #[inline]
+    pub fn from_static(s: &'static str) -> StringRef {
+        unsafe {
+            StringRef {
+                r: ::vec::VecRef::from_static(::cast::transmute(s))
+            }
+        }
+    }
+
+    /**
+     * Converts this type into a standard owned string, consuming it in the process.
+     *
+     * If the StringRef holds a static string, it is copied to an owned one, otherwise the held
+     * owned vector is returned
+     */
+    #[inline]
+    pub fn to_owned_consume(self) -> ~str {
+        unsafe {
+            ::cast::transmute(self.r.to_owned_consume())
+        }
+    }
+
+    /**
+     * Returns the backing VecRef for this StringRef
+     */
+    #[inline]
+    pub fn as_vec_ref<'r>(&'r self) -> &'r vec::VecRef<u8> {
+        &self.r
+    }
+}
+
+impl Str for StringRef {
+    #[inline(always)]
+    pub fn as_slice<'r>(&'r self) -> &'r str {
+        unsafe {
+            ::cast::transmute(self.r.as_slice())
+        }
+    }
+}
+
+impl Container for StringRef {
+    #[inline]
+    fn len(&self) -> uint {
+        self.as_slice().len()
+    }
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
 impl Clone for ~str {
     #[inline]
     fn clone(&self) -> ~str {
@@ -3448,4 +3524,15 @@ mod tests {
         t::<@str>();
         t::<~str>();
     }
+
+    #[test]
+    fn test_str_ref() {
+        let r = StringRef::from_static("abcde");
+        assert_eq!(r.len(), 5);
+        assert_eq!(r.as_slice(), "abcde")
+
+        let r = StringRef::from_owned(~"abcde");
+        assert_eq!(r.len(), 5);
+        assert_eq!(r.as_slice(), "abcde")
+    }
 }

src/libstd/vec.rs

@@ -17,6 +17,7 @@ use cast;
 use container::{Container, Mutable};
 use cmp;
 use cmp::{Eq, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use ops::Index;
 use clone::Clone;
 use iterator::{FromIterator, Iterator, IteratorUtil};
 use kinds::Copy;
@@ -1758,47 +1759,47 @@ impl<T> VecRef<T> {
     // on self-by-value, which means VecRef would move into
     // it. So I'm just gonna re-impl here
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn iter<'r>(&'r self) -> VecIterator<'r, T> {
         self.as_slice().iter()
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn rev_iter<'r>(&'r self) -> VecRevIterator<'r, T> {
         self.as_slice().rev_iter()
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn split_iter<'r>(&'r self, pred: &'r fn(&T) -> bool) -> VecSplitIterator<'r, T> {
         self.as_slice().split_iter(pred)
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn splitn_iter<'r>(&'r self, n: uint, pred: &'r fn(&T) -> bool) -> VecSplitIterator<'r, T> {
-        self.as_slice().split_iter(n, pred)
+        self.as_slice().splitn_iter(n, pred)
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn rsplit_iter<'r>(&'r self, pred: &'r fn(&T) -> bool) -> VecRSplitIterator<'r, T> {
         self.as_slice().rsplit_iter(pred)
     }
 
-    #[inline]
-    pub fn rsplitn_iter<'r>(&'r self, pred: &'r fn(&T) -> bool) -> VecRSplitIterator<'r, T> {
-        self.as_slice().rsplit_iter(pred)
+    #[inline] #[allow(missing_doc)]
+    pub fn rsplitn_iter<'r>(&'r self, n: uint, pred: &'r fn(&T) -> bool) -> VecRSplitIterator<'r, T> {
+        self.as_slice().rsplitn_iter(n, pred)
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn window_iter<'r>(&'r self, size: uint) -> VecWindowIter<'r, T> {
         self.as_slice().window_iter(size)
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn chunk_iter<'r>(&'r self, size: uint) -> VecChunkIter<'r, T> {
-        self.as_slice().window_iter(size)
+        self.as_slice().chunk_iter(size)
     }
 
-    #[inline]
+    #[inline] #[allow(missing_doc)]
     pub fn as_imm_buf<U>(&self, f: &fn(*T, uint) -> U) -> U {
         self.as_slice().as_imm_buf(f)
     }
@@ -1809,7 +1810,7 @@ impl<T:Copy> VecRef<T> {
     /**
      * Converts this type into a standard owned vector, consuming it in the process.
      * 
-     * If the VecRef holds a static vector, it is converted to an owned one, otherwise the held
+     * If the VecRef holds a static vector, it is copied to an owned one, otherwise the held
      * owned vector is returned.
      */
     pub fn to_owned_consume(self) -> ~[T] {
@@ -1858,7 +1859,7 @@ impl<T:Eq> ImmutableEqVector<T> for VecRef<T> {
 
     #[inline]
     fn rposition_elem(&self, t: &T) -> Option<uint> {
-        self.as_slice().rposition(t)
+        self.as_slice().rposition_elem(t)
     }
 
     #[inline]
@@ -1887,8 +1888,8 @@ impl<T:Copy> ImmutableCopyableVector<T> for VecRef<T> {
 }
 
 impl<T:Copy> Index<uint, T> for VecRef<T> {
-    fn index(&self, index: uint) -> T {
-        copy self.as_slice()[index]
+    fn index(&self, index: &uint) -> T {
+        copy self.as_slice()[*index]
     }
 }
 
@@ -3443,10 +3444,10 @@ mod tests {
         let v = VecRef::from_owned(~[1, 2, 3]);
         assert_eq!(v.len(), 3);
 
-        let v : VecRef<int> = VecRef::from_static([]);
+        let v : VecRef<int> = VecRef::from_static(&[]);
         assert!(v.is_empty());
 
-        let v : VecRef<int> = VecRef::from_static([1, 2, 3, 4]);
+        let v : VecRef<int> = VecRef::from_static(&[1, 2, 3, 4]);
         assert_eq!(v.len(), 4);
     }
 
@@ -3456,8 +3457,21 @@ mod tests {
         let vec = v.to_owned_consume();
         assert_eq!(vec, ~[1, 2, 3, 4]);
 
-        let v = VecRef::from_static([1, 2, 3, 4]);
+        let v = VecRef::from_static(&[1, 2, 3, 4]);
         let vec = v.to_owned_consume();
         assert_eq!(vec, ~[1, 2, 3, 4]);
     }
+
+    #[test]
+    fn test_vec_iter() {
+        let v = VecRef::from_static(&[1, 2, 3, 4]);
+
+        let mut iter = v.iter().transform(|&x| x);
+
+        assert_eq!(iter.next(), Some(1));
+        assert_eq!(iter.next(), Some(2));
+        assert_eq!(iter.next(), Some(3));
+        assert_eq!(iter.next(), Some(4));
+        assert_eq!(iter.next(), None);
+    }
 }