#[inline]
#[unstable = "the panic conventions for strings are under development"]
pub fn truncate(&mut self, new_len: uint) {
- assert!(self.as_slice().is_char_boundary(new_len));
+ assert!(self.is_char_boundary(new_len));
self.vec.truncate(new_len)
}
return None
}
- let CharRange {ch, next} = self.as_slice().char_range_at_reverse(len);
+ let CharRange {ch, next} = self.char_range_at_reverse(len);
unsafe {
self.vec.set_len(next);
}
let len = self.len();
if idx >= len { return None }
- let CharRange { ch, next } = self.as_slice().char_range_at(idx);
+ let CharRange { ch, next } = self.char_range_at(idx);
unsafe {
ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
self.vec.as_ptr().offset(next as int),
pub fn insert(&mut self, idx: uint, ch: char) {
let len = self.len();
assert!(idx <= len);
- assert!(self.as_slice().is_char_boundary(idx));
+ assert!(self.is_char_boundary(idx));
self.vec.reserve(4);
let mut bits = [0, ..4];
let amt = ch.encode_utf8(&mut bits).unwrap();
}
}
+#[experimental = "waiting on FromIterator stabilization"]
+impl<'a> FromIterator<&'a str> for String {
+ fn from_iter<I:Iterator<&'a str>>(iterator: I) -> String {
+ let mut buf = String::new();
+ buf.extend(iterator);
+ buf
+ }
+}
+
#[experimental = "waiting on Extend stabilization"]
impl Extend<char> for String {
fn extend<I:Iterator<char>>(&mut self, mut iterator: I) {
+ let (lower_bound, _) = iterator.size_hint();
+ self.reserve(lower_bound);
for ch in iterator {
self.push(ch)
}
}
}
+#[experimental = "waiting on Extend stabilization"]
+impl<'a> Extend<&'a str> for String {
+ fn extend<I: Iterator<&'a str>>(&mut self, mut iterator: I) {
+ // A guess that at least one byte per iterator element will be needed.
+ let (lower_bound, _) = iterator.size_hint();
+ self.reserve(lower_bound);
+ for s in iterator {
+ self.push_str(s)
+ }
+ }
+}
+
impl PartialEq for String {
#[inline]
fn eq(&self, other: &String) -> bool { PartialEq::eq(&**self, &**other) }
for p in pairs.iter() {
let (s, u) = (*p).clone();
- let s_as_utf16 = s.as_slice().utf16_units().collect::<Vec<u16>>();
+ let s_as_utf16 = s.utf16_units().collect::<Vec<u16>>();
let u_as_string = String::from_utf16(u.as_slice()).unwrap();
assert!(str::is_utf16(u.as_slice()));
assert_eq!(String::from_utf16_lossy(u.as_slice()), s);
assert_eq!(String::from_utf16(s_as_utf16.as_slice()).unwrap(), s);
- assert_eq!(u_as_string.as_slice().utf16_units().collect::<Vec<u16>>(), u);
+ assert_eq!(u_as_string.utf16_units().collect::<Vec<u16>>(), u);
}
}
let mv = s.as_mut_vec();
mv.push_all(&[b'D']);
}
- assert_eq!(s.as_slice(), "ABCD");
+ assert_eq!(s, "ABCD");
}
#[test]
fn test_push_str() {
let mut s = String::new();
s.push_str("");
- assert_eq!(s.as_slice().slice_from(0), "");
+ assert_eq!(s.slice_from(0), "");
s.push_str("abc");
- assert_eq!(s.as_slice().slice_from(0), "abc");
+ assert_eq!(s.slice_from(0), "abc");
s.push_str("ประเทศไทย中华Việt Nam");
- assert_eq!(s.as_slice().slice_from(0), "abcประเทศไทย中华Việt Nam");
+ assert_eq!(s.slice_from(0), "abcประเทศไทย中华Việt Nam");
}
#[test]
data.push('¢'); // 2 byte
data.push('€'); // 3 byte
data.push('𤭢'); // 4 byte
- assert_eq!(data.as_slice(), "ประเทศไทย中华b¢€𤭢");
+ assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
}
#[test]
assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
assert_eq!(data.pop().unwrap(), '华');
- assert_eq!(data.as_slice(), "ประเทศไทย中");
+ assert_eq!(data, "ประเทศไทย中");
}
#[test]
fn test_str_truncate() {
let mut s = String::from_str("12345");
s.truncate(5);
- assert_eq!(s.as_slice(), "12345");
+ assert_eq!(s, "12345");
s.truncate(3);
- assert_eq!(s.as_slice(), "123");
+ assert_eq!(s, "123");
s.truncate(0);
- assert_eq!(s.as_slice(), "");
+ assert_eq!(s, "");
let mut s = String::from_str("12345");
- let p = s.as_slice().as_ptr();
+ let p = s.as_ptr();
s.truncate(3);
s.push_str("6");
- let p_ = s.as_slice().as_ptr();
+ let p_ = s.as_ptr();
assert_eq!(p_, p);
}
let mut s = String::from_str("12345");
s.clear();
assert_eq!(s.len(), 0);
- assert_eq!(s.as_slice(), "");
+ assert_eq!(s, "");
}
#[test]
let b = a + "2";
let b = b + String::from_str("2");
assert_eq!(b.len(), 7);
- assert_eq!(b.as_slice(), "1234522");
+ assert_eq!(b, "1234522");
}
#[test]
let mut s = "ศไทย中华Việt Nam; foobar".to_string();;
assert_eq!(s.remove(0), Some('ศ'));
assert_eq!(s.len(), 33);
- assert_eq!(s.as_slice(), "ไทย中华Việt Nam; foobar");
+ assert_eq!(s, "ไทย中华Việt Nam; foobar");
assert_eq!(s.remove(33), None);
assert_eq!(s.remove(300), None);
assert_eq!(s.remove(17), Some('ệ'));
- assert_eq!(s.as_slice(), "ไทย中华Vit Nam; foobar");
+ assert_eq!(s, "ไทย中华Vit Nam; foobar");
}
#[test] #[should_fail]
fn insert() {
let mut s = "foobar".to_string();
s.insert(0, 'ệ');
- assert_eq!(s.as_slice(), "ệfoobar");
+ assert_eq!(s, "ệfoobar");
s.insert(6, 'ย');
- assert_eq!(s.as_slice(), "ệfooยbar");
+ assert_eq!(s, "ệfooยbar");
}
#[test] #[should_fail] fn insert_bad1() { "".to_string().insert(1, 't'); }
#[test]
fn test_simple_types() {
- assert_eq!(1i.to_string(), "1".to_string());
- assert_eq!((-1i).to_string(), "-1".to_string());
- assert_eq!(200u.to_string(), "200".to_string());
- assert_eq!(2u8.to_string(), "2".to_string());
- assert_eq!(true.to_string(), "true".to_string());
- assert_eq!(false.to_string(), "false".to_string());
- assert_eq!(().to_string(), "()".to_string());
- assert_eq!(("hi".to_string()).to_string(), "hi".to_string());
+ assert_eq!(1i.to_string(), "1");
+ assert_eq!((-1i).to_string(), "-1");
+ assert_eq!(200u.to_string(), "200");
+ assert_eq!(2u8.to_string(), "2");
+ assert_eq!(true.to_string(), "true");
+ assert_eq!(false.to_string(), "false");
+ assert_eq!(().to_string(), "()");
+ assert_eq!(("hi".to_string()).to_string(), "hi");
}
#[test]
fn test_vectors() {
let x: Vec<int> = vec![];
- assert_eq!(x.to_string(), "[]".to_string());
- assert_eq!((vec![1i]).to_string(), "[1]".to_string());
- assert_eq!((vec![1i, 2, 3]).to_string(), "[1, 2, 3]".to_string());
+ assert_eq!(x.to_string(), "[]");
+ assert_eq!((vec![1i]).to_string(), "[1]");
+ assert_eq!((vec![1i, 2, 3]).to_string(), "[1, 2, 3]");
assert!((vec![vec![], vec![1i], vec![1i, 1]]).to_string() ==
- "[[], [1], [1, 1]]".to_string());
+ "[[], [1], [1, 1]]");
+ }
+
+ #[test]
+ fn test_from_iterator() {
+ let s = "ศไทย中华Việt Nam".to_string();
+ let t = "ศไทย中华";
+ let u = "Việt Nam";
+
+ let a: String = s.chars().collect();
+ assert_eq!(s, a);
+
+ let mut b = t.to_string();
+ b.extend(u.chars());
+ assert_eq!(s, b);
+
+ let c: String = vec![t, u].into_iter().collect();
+ assert_eq!(s, c);
+
+ let mut d = t.to_string();
+ d.extend(vec![u].into_iter());
+ assert_eq!(s, d);
}
#[bench]