From 5b118f5ecde796ad62fa349a045d7ad8129b711c Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Tue, 10 Mar 2015 23:13:24 -0500 Subject: [PATCH] impl str --- src/libcollections/lib.rs | 4 + src/libcollections/str.rs | 1136 +++++++++++++++++ src/libstd/ffi/c_str.rs | 1 + src/libstd/io/mod.rs | 3 + src/libstd/num/strconv.rs | 1 + src/libstd/old_io/mod.rs | 1 + src/libstd/old_io/net/ip.rs | 3 + src/libstd/old_io/process.rs | 2 +- src/libstd/old_io/stdio.rs | 1 + src/libstd/old_io/tempfile.rs | 1 + src/libstd/old_path/mod.rs | 1 + src/libstd/old_path/posix.rs | 5 +- src/libstd/old_path/windows.rs | 3 + src/libstd/os.rs | 3 + src/libstd/prelude/v1.rs | 4 + src/libstd/process.rs | 2 +- .../method-suggestion-no-duplication.rs | 1 - 17 files changed, 1168 insertions(+), 4 deletions(-) diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index dd23bcbaf81..3a2fc17e1e9 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -27,6 +27,7 @@ #![feature(box_syntax)] #![feature(box_patterns)] #![feature(core)] +#![feature(lang_items)] #![feature(staged_api)] #![feature(unboxed_closures)] #![feature(unicode)] @@ -162,7 +163,10 @@ mod prelude { // in core and collections (may differ). pub use slice::{AsSlice, SliceExt}; + #[cfg(stage0)] pub use str::{Str, StrExt}; + #[cfg(not(stage0))] + pub use str::Str; // from other crates. pub use alloc::boxed::Box; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 31d7677d19e..b4e548e137e 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -59,7 +59,9 @@ use self::DecompositionType::*; use core::clone::Clone; use core::iter::AdditiveIterator; use core::iter::{Iterator, IteratorExt, Extend}; +#[cfg(stage0)] use core::ops::Index; +#[cfg(stage0)] use core::ops::RangeFull; use core::option::Option::{self, Some, None}; use core::result::Result; @@ -415,6 +417,7 @@ Section: CowString Section: Trait implementations */ +#[cfg(stage0)] /// Any string that can be represented as a slice. #[stable(feature = "rust1", since = "1.0.0")] pub trait StrExt: Index { @@ -1539,6 +1542,7 @@ pub trait StrExt: Index { } } +#[cfg(stage0)] #[stable(feature = "rust1", since = "1.0.0")] impl StrExt for str { fn slice(&self, begin: usize, end: usize) -> &str { @@ -1554,6 +1558,1138 @@ impl StrExt for str { } } +#[cfg(not(stage0))] +/// Any string that can be represented as a slice. +#[lang = "str"] +#[stable(feature = "rust1", since = "1.0.0")] +impl str { + /// Escapes each char in `s` with `char::escape_default`. + #[unstable(feature = "collections", + reason = "return type may change to be an iterator")] + pub fn escape_default(&self) -> String { + self.chars().flat_map(|c| c.escape_default()).collect() + } + + /// Escapes each char in `s` with `char::escape_unicode`. + #[unstable(feature = "collections", + reason = "return type may change to be an iterator")] + pub fn escape_unicode(&self) -> String { + self.chars().flat_map(|c| c.escape_unicode()).collect() + } + + /// Replaces all occurrences of one string with another. + /// + /// `replace` takes two arguments, a sub-`&str` to find in `self`, and a second `&str` to + /// replace it with. If the original `&str` isn't found, no change occurs. + /// + /// # Examples + /// + /// ``` + /// let s = "this is old"; + /// + /// assert_eq!(s.replace("old", "new"), "this is new"); + /// ``` + /// + /// When a `&str` isn't found: + /// + /// ``` + /// let s = "this is old"; + /// assert_eq!(s.replace("cookie monster", "little lamb"), s); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn replace(&self, from: &str, to: &str) -> String { + let mut result = String::new(); + let mut last_end = 0; + for (start, end) in self.match_indices(from) { + result.push_str(unsafe { self.slice_unchecked(last_end, start) }); + result.push_str(to); + last_end = end; + } + result.push_str(unsafe { self.slice_unchecked(last_end, self.len()) }); + result + } + + /// Returns an iterator over the string in Unicode Normalization Form D + /// (canonical decomposition). + #[inline] + #[unstable(feature = "collections", + reason = "this functionality may be moved to libunicode")] + pub fn nfd_chars(&self) -> Decompositions { + Decompositions { + iter: self[..].chars(), + buffer: Vec::new(), + sorted: false, + kind: Canonical + } + } + + /// Returns an iterator over the string in Unicode Normalization Form KD + /// (compatibility decomposition). + #[inline] + #[unstable(feature = "collections", + reason = "this functionality may be moved to libunicode")] + pub fn nfkd_chars(&self) -> Decompositions { + Decompositions { + iter: self[..].chars(), + buffer: Vec::new(), + sorted: false, + kind: Compatible + } + } + + /// An Iterator over the string in Unicode Normalization Form C + /// (canonical decomposition followed by canonical composition). + #[inline] + #[unstable(feature = "collections", + reason = "this functionality may be moved to libunicode")] + pub fn nfc_chars(&self) -> Recompositions { + Recompositions { + iter: self.nfd_chars(), + state: Composing, + buffer: VecDeque::new(), + composee: None, + last_ccc: None + } + } + + /// An Iterator over the string in Unicode Normalization Form KC + /// (compatibility decomposition followed by canonical composition). + #[inline] + #[unstable(feature = "collections", + reason = "this functionality may be moved to libunicode")] + pub fn nfkc_chars(&self) -> Recompositions { + Recompositions { + iter: self.nfkd_chars(), + state: Composing, + buffer: VecDeque::new(), + composee: None, + last_ccc: None + } + } + + /// Returns `true` if `self` contains another `&str`. + /// + /// # Examples + /// + /// ``` + /// assert!("bananas".contains("nana")); + /// + /// assert!(!"bananas".contains("foobar")); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { + core_str::StrExt::contains(&self[..], pat) + } + + /// Returns `true` if `self` contains a `char`. + /// + /// # Examples + /// + /// ``` + /// assert!("hello".contains_char('e')); + /// + /// assert!(!"hello".contains_char('z')); + /// ``` + #[unstable(feature = "collections")] + #[deprecated(since = "1.0.0", reason = "use `contains()` with a char")] + pub fn contains_char<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { + core_str::StrExt::contains_char(&self[..], pat) + } + + /// An iterator over the codepoints of `self`. + /// + /// # Examples + /// + /// ``` + /// let v: Vec = "abc åäö".chars().collect(); + /// + /// assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn chars(&self) -> Chars { + core_str::StrExt::chars(&self[..]) + } + + /// An iterator over the bytes of `self`. + /// + /// # Examples + /// + /// ``` + /// let v: Vec = "bors".bytes().collect(); + /// + /// assert_eq!(v, b"bors".to_vec()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn bytes(&self) -> Bytes { + core_str::StrExt::bytes(&self[..]) + } + + /// An iterator over the characters of `self` and their byte offsets. + /// + /// # Examples + /// + /// ``` + /// let v: Vec<(usize, char)> = "abc".char_indices().collect(); + /// let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; + /// + /// assert_eq!(v, b); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn char_indices(&self) -> CharIndices { + core_str::StrExt::char_indices(&self[..]) + } + + /// An iterator over substrings of `self`, separated by characters + /// matched by a pattern. + /// + /// The pattern can be a simple `&str`, or a closure that determines + /// the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); + /// + /// let v: Vec<&str> = "".split('X').collect(); + /// assert_eq!(v, [""]); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); + /// assert_eq!(v, ["abc", "def", "ghi"]); + /// + /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); + /// assert_eq!(v, ["lion", "", "tiger", "leopard"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> { + core_str::StrExt::split(&self[..], pat) + } + + /// An iterator over substrings of `self`, separated by characters matched by a pattern, + /// restricted to splitting at most `count` times. + /// + /// The pattern can be a simple `&str`, or a closure that determines + /// the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let v: Vec<&str> = "Mary had a little lambda".splitn(2, ' ').collect(); + /// assert_eq!(v, ["Mary", "had", "a little lambda"]); + /// + /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(2, 'X').collect(); + /// assert_eq!(v, ["lion", "", "tigerXleopard"]); + /// + /// let v: Vec<&str> = "abcXdef".splitn(0, 'X').collect(); + /// assert_eq!(v, ["abcXdef"]); + /// + /// let v: Vec<&str> = "".splitn(1, 'X').collect(); + /// assert_eq!(v, [""]); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |c: char| c.is_numeric()).collect(); + /// assert_eq!(v, ["abc", "def2ghi"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> { + core_str::StrExt::splitn(&self[..], count, pat) + } + + /// An iterator over substrings of `self`, separated by characters + /// matched by a pattern. + /// + /// Equivalent to `split`, except that the trailing substring is skipped if empty. + /// + /// The pattern can be a simple `&str`, or a closure that determines + /// the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let v: Vec<&str> = "A.B.".split_terminator('.').collect(); + /// assert_eq!(v, ["A", "B"]); + /// + /// let v: Vec<&str> = "A..B..".split_terminator('.').collect(); + /// assert_eq!(v, ["A", "", "B", ""]); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); + /// assert_eq!(v, ["abc", "def", "ghi"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> { + core_str::StrExt::split_terminator(&self[..], pat) + } + + /// An iterator over substrings of `self`, separated by characters matched by a pattern, + /// starting from the end of the string. + /// + /// Restricted to splitting at most `count` times. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(2, ' ').collect(); + /// assert_eq!(v, ["lamb", "little", "Mary had a"]); + /// + /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect(); + /// assert_eq!(v, ["leopard", "tiger", "lionX"]); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |c: char| c.is_numeric()).collect(); + /// assert_eq!(v, ["ghi", "abc1def"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> { + core_str::StrExt::rsplitn(&self[..], count, pat) + } + + /// An iterator over the start and end indices of the disjoint matches of a `&str` within + /// `self`. + /// + /// That is, each returned value `(start, end)` satisfies `self.slice(start, end) == sep`. For + /// matches of `sep` within `self` that overlap, only the indices corresponding to the first + /// match are returned. + /// + /// # Examples + /// + /// ``` + /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); + /// assert_eq!(v, [(0,3), (6,9), (12,15)]); + /// + /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); + /// assert_eq!(v, [(1,4), (4,7)]); + /// + /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); + /// assert_eq!(v, [(0, 3)]); // only the first `aba` + /// ``` + #[unstable(feature = "collections", + reason = "might have its iterator type changed")] + // NB: Right now MatchIndices yields `(usize, usize)`, + // but it would be more consistent and useful to return `(usize, &str)` + pub fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> { + core_str::StrExt::match_indices(&self[..], pat) + } + + /// An iterator over the substrings of `self` separated by a `&str`. + /// + /// # Examples + /// + /// ``` + /// let v: Vec<&str> = "abcXXXabcYYYabc".split_str("abc").collect(); + /// assert_eq!(v, ["", "XXX", "YYY", ""]); + /// + /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); + /// assert_eq!(v, ["1", "", "2"]); + /// ``` + #[unstable(feature = "collections")] + #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] + #[allow(deprecated) /* for SplitStr */] + pub fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> { + core_str::StrExt::split_str(&self[..], pat) + } + + /// An iterator over the lines of a string, separated by `\n`. + /// + /// This does not include the empty string after a trailing `\n`. + /// + /// # Examples + /// + /// ``` + /// let four_lines = "foo\nbar\n\nbaz"; + /// let v: Vec<&str> = four_lines.lines().collect(); + /// + /// assert_eq!(v, ["foo", "bar", "", "baz"]); + /// ``` + /// + /// Leaving off the trailing character: + /// + /// ``` + /// let four_lines = "foo\nbar\n\nbaz\n"; + /// let v: Vec<&str> = four_lines.lines().collect(); + /// + /// assert_eq!(v, ["foo", "bar", "", "baz"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn lines(&self) -> Lines { + core_str::StrExt::lines(&self[..]) + } + + /// An iterator over the lines of a string, separated by either `\n` or `\r\n`. + /// + /// As with `.lines()`, this does not include an empty trailing line. + /// + /// # Examples + /// + /// ``` + /// let four_lines = "foo\r\nbar\n\r\nbaz"; + /// let v: Vec<&str> = four_lines.lines_any().collect(); + /// + /// assert_eq!(v, ["foo", "bar", "", "baz"]); + /// ``` + /// + /// Leaving off the trailing character: + /// + /// ``` + /// let four_lines = "foo\r\nbar\n\r\nbaz\n"; + /// let v: Vec<&str> = four_lines.lines_any().collect(); + /// + /// assert_eq!(v, ["foo", "bar", "", "baz"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn lines_any(&self) -> LinesAny { + core_str::StrExt::lines_any(&self[..]) + } + + /// Deprecated: use `s[a .. b]` instead. + #[unstable(feature = "collections", + reason = "use slice notation [a..b] instead")] + #[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")] + pub fn slice(&self, begin: usize, end: usize) -> &str { + &self[begin..end] + } + + /// Deprecated: use `s[a..]` instead. + #[unstable(feature = "collections", + reason = "use slice notation [a..b] instead")] + #[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")] + pub fn slice_from(&self, begin: usize) -> &str { + &self[begin..] + } + + /// Deprecated: use `s[..a]` instead. + #[unstable(feature = "collections", + reason = "use slice notation [a..b] instead")] + #[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")] + pub fn slice_to(&self, end: usize) -> &str { + &self[..end] + } + + /// Returns a slice of the string from the character range [`begin`..`end`). + /// + /// That is, start at the `begin`-th code point of the string and continue + /// to the `end`-th code point. This does not detect or handle edge cases + /// such as leaving a combining character as the first code point of the + /// string. + /// + /// Due to the design of UTF-8, this operation is `O(end)`. See `slice`, + /// `slice_to` and `slice_from` for `O(1)` variants that use byte indices + /// rather than code point indices. + /// + /// # Panics + /// + /// Panics if `begin` > `end` or the either `begin` or `end` are beyond the + /// last character of the string. + /// + /// # Examples + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.slice_chars(0, 4), "Löwe"); + /// assert_eq!(s.slice_chars(5, 7), "老虎"); + /// ``` + #[unstable(feature = "collections", + reason = "may have yet to prove its worth")] + pub fn slice_chars(&self, begin: usize, end: usize) -> &str { + core_str::StrExt::slice_chars(&self[..], begin, end) + } + + /// Takes a bytewise slice from a string. + /// + /// Returns the substring from [`begin`..`end`). + /// + /// # Unsafety + /// + /// Caller must check both UTF-8 character boundaries and the boundaries of the entire slice as + /// well. + /// + /// # Examples + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// unsafe { + /// assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str { + core_str::StrExt::slice_unchecked(&self[..], begin, end) + } + + /// Returns `true` if the given `&str` is a prefix of the string. + /// + /// # Examples + /// + /// ``` + /// assert!("banana".starts_with("ba")); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { + core_str::StrExt::starts_with(&self[..], pat) + } + + /// Returns true if the given `&str` is a suffix of the string. + /// + /// # Examples + /// + /// ```rust + /// assert!("banana".ends_with("nana")); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool + where P::Searcher: ReverseSearcher<'a> + { + core_str::StrExt::ends_with(&self[..], pat) + } + + /// Returns a string with all pre- and suffixes that match a pattern repeatedly removed. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); + /// + /// let x: &[_] = &['1', '2']; + /// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str + where P::Searcher: DoubleEndedSearcher<'a> + { + core_str::StrExt::trim_matches(&self[..], pat) + } + + /// Returns a string with all prefixes that match a pattern repeatedly removed. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); + /// + /// let x: &[_] = &['1', '2']; + /// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str { + core_str::StrExt::trim_left_matches(&self[..], pat) + } + + /// Returns a string with all suffixes that match a pattern repeatedly removed. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); + /// let x: &[_] = &['1', '2']; + /// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str + where P::Searcher: ReverseSearcher<'a> + { + core_str::StrExt::trim_right_matches(&self[..], pat) + } + + /// Check that `index`-th byte lies at the start and/or end of a UTF-8 code point sequence. + /// + /// The start and end of the string (when `index == self.len()`) are considered to be + /// boundaries. + /// + /// # Panics + /// + /// Panics if `index` is greater than `self.len()`. + /// + /// # Examples + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// assert!(s.is_char_boundary(0)); + /// // start of `老` + /// assert!(s.is_char_boundary(6)); + /// assert!(s.is_char_boundary(s.len())); + /// + /// // second byte of `ö` + /// assert!(!s.is_char_boundary(2)); + /// + /// // third byte of `老` + /// assert!(!s.is_char_boundary(8)); + /// ``` + #[unstable(feature = "collections", + reason = "naming is uncertain with container conventions")] + pub fn is_char_boundary(&self, index: usize) -> bool { + core_str::StrExt::is_char_boundary(&self[..], index) + } + + /// Given a byte position, return the next char and its index. + /// + /// This can be used to iterate over the Unicode characters of a string. + /// + /// # Panics + /// + /// If `i` is greater than or equal to the length of the string. + /// If `i` is not the index of the beginning of a valid UTF-8 character. + /// + /// # Examples + /// + /// This example manually iterates through the characters of a string; this should normally be + /// done by `.chars()` or `.char_indices()`. + /// + /// ``` + /// use std::str::CharRange; + /// + /// let s = "中华Việt Nam"; + /// let mut i = 0; + /// while i < s.len() { + /// let CharRange {ch, next} = s.char_range_at(i); + /// println!("{}: {}", i, ch); + /// i = next; + /// } + /// ``` + /// + /// This outputs: + /// + /// ```text + /// 0: 中 + /// 3: 华 + /// 6: V + /// 7: i + /// 8: ệ + /// 11: t + /// 12: + /// 13: N + /// 14: a + /// 15: m + /// ``` + #[unstable(feature = "collections", + reason = "naming is uncertain with container conventions")] + pub fn char_range_at(&self, start: usize) -> CharRange { + core_str::StrExt::char_range_at(&self[..], start) + } + + /// Given a byte position, return the previous `char` and its position. + /// + /// This function can be used to iterate over a Unicode string in reverse. + /// + /// Returns 0 for next index if called on start index 0. + /// + /// # Panics + /// + /// If `i` is greater than the length of the string. + /// If `i` is not an index following a valid UTF-8 character. + /// + /// # Examples + /// + /// This example manually iterates through the characters of a string; this should normally be + /// done by `.chars().rev()` or `.char_indices()`. + /// + /// ``` + /// use std::str::CharRange; + /// + /// let s = "中华Việt Nam"; + /// let mut i = s.len(); + /// while i > 0 { + /// let CharRange {ch, next} = s.char_range_at_reverse(i); + /// println!("{}: {}", i, ch); + /// i = next; + /// } + /// ``` + /// + /// This outputs: + /// + /// ```text + /// 16: m + /// 15: a + /// 14: N + /// 13: + /// 12: t + /// 11: ệ + /// 8: i + /// 7: V + /// 6: 华 + /// 3: 中 + /// ``` + #[unstable(feature = "collections", + reason = "naming is uncertain with container conventions")] + pub fn char_range_at_reverse(&self, start: usize) -> CharRange { + core_str::StrExt::char_range_at_reverse(&self[..], start) + } + + /// Given a byte position, return the `char` at that position. + /// + /// # Panics + /// + /// If `i` is greater than or equal to the length of the string. + /// If `i` is not the index of the beginning of a valid UTF-8 character. + /// + /// # Examples + /// + /// ``` + /// let s = "abπc"; + /// assert_eq!(s.char_at(1), 'b'); + /// assert_eq!(s.char_at(2), 'π'); + /// ``` + #[unstable(feature = "collections", + reason = "naming is uncertain with container conventions")] + pub fn char_at(&self, i: usize) -> char { + core_str::StrExt::char_at(&self[..], i) + } + + /// Given a byte position, return the `char` at that position, counting from the end. + /// + /// # Panics + /// + /// If `i` is greater than the length of the string. + /// If `i` is not an index following a valid UTF-8 character. + /// + /// # Examples + /// + /// ``` + /// let s = "abπc"; + /// assert_eq!(s.char_at_reverse(1), 'a'); + /// assert_eq!(s.char_at_reverse(2), 'b'); + /// ``` + #[unstable(feature = "collections", + reason = "naming is uncertain with container conventions")] + pub fn char_at_reverse(&self, i: usize) -> char { + core_str::StrExt::char_at_reverse(&self[..], i) + } + + /// Convert `self` to a byte slice. + /// + /// # Examples + /// + /// ``` + /// assert_eq!("bors".as_bytes(), b"bors"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_bytes(&self) -> &[u8] { + core_str::StrExt::as_bytes(&self[..]) + } + + /// Returns the byte index of the first character of `self` that matches the pattern, if it + /// exists. + /// + /// Returns `None` if it doesn't exist. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.find('L'), Some(0)); + /// assert_eq!(s.find('é'), Some(14)); + /// + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5)); + /// ``` + /// + /// Not finding the pattern: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// let x: &[_] = &['1', '2']; + /// + /// assert_eq!(s.find(x), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option { + core_str::StrExt::find(&self[..], pat) + } + + /// Returns the byte index of the last character of `self` that matches the pattern, if it + /// exists. + /// + /// Returns `None` if it doesn't exist. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// Simple `&str` patterns: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.rfind('L'), Some(13)); + /// assert_eq!(s.rfind('é'), Some(14)); + /// ``` + /// + /// More complex patterns with a lambda: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12)); + /// ``` + /// + /// Not finding the pattern: + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// let x: &[_] = &['1', '2']; + /// + /// assert_eq!(s.rfind(x), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option + where P::Searcher: ReverseSearcher<'a> + { + core_str::StrExt::rfind(&self[..], pat) + } + + /// Returns the byte index of the first matching substring if it exists. + /// + /// Returns `None` if it doesn't exist. + /// + /// The pattern can be a simple `&str`, or a closure that determines the split. + /// + /// # Examples + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// + /// assert_eq!(s.find_str("老虎 L"), Some(6)); + /// assert_eq!(s.find_str("muffin man"), None); + /// ``` + #[unstable(feature = "collections")] + #[deprecated(since = "1.0.0", reason = "use `find()` with a `&str`")] + pub fn find_str<'a, P: Pattern<'a>>(&'a self, needle: P) -> Option { + core_str::StrExt::find_str(&self[..], needle) + } + + /// Retrieves the first character from a `&str` and returns it. + /// + /// This does not allocate a new string; instead, it returns a slice that points one character + /// beyond the character that was shifted. + /// + /// If the slice does not contain any characters, None is returned instead. + /// + /// # Examples + /// + /// ``` + /// let s = "Löwe 老虎 Léopard"; + /// let (c, s1) = s.slice_shift_char().unwrap(); + /// + /// assert_eq!(c, 'L'); + /// assert_eq!(s1, "öwe 老虎 Léopard"); + /// + /// let (c, s2) = s1.slice_shift_char().unwrap(); + /// + /// assert_eq!(c, 'ö'); + /// assert_eq!(s2, "we 老虎 Léopard"); + /// ``` + #[unstable(feature = "collections", + reason = "awaiting conventions about shifting and slices")] + pub fn slice_shift_char(&self) -> Option<(char, &str)> { + core_str::StrExt::slice_shift_char(&self[..]) + } + + /// Returns the byte offset of an inner slice relative to an enclosing outer slice. + /// + /// # Panics + /// + /// Panics if `inner` is not a direct slice contained within self. + /// + /// # Examples + /// + /// ``` + /// let string = "a\nb\nc"; + /// let lines: Vec<&str> = string.lines().collect(); + /// + /// assert!(string.subslice_offset(lines[0]) == 0); // &"a" + /// assert!(string.subslice_offset(lines[1]) == 2); // &"b" + /// assert!(string.subslice_offset(lines[2]) == 4); // &"c" + /// ``` + #[unstable(feature = "collections", + reason = "awaiting convention about comparability of arbitrary slices")] + pub fn subslice_offset(&self, inner: &str) -> usize { + core_str::StrExt::subslice_offset(&self[..], inner) + } + + /// Return an unsafe pointer to the `&str`'s buffer. + /// + /// The caller must ensure that the string outlives this pointer, and that it is not + /// reallocated (e.g. by pushing to the string). + /// + /// # Examples + /// + /// ``` + /// let s = "Hello"; + /// let p = s.as_ptr(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn as_ptr(&self) -> *const u8 { + core_str::StrExt::as_ptr(&self[..]) + } + + /// Return an iterator of `u16` over the string encoded as UTF-16. + #[unstable(feature = "collections", + reason = "this functionality may only be provided by libunicode")] + pub fn utf16_units(&self) -> Utf16Units { + Utf16Units { encoder: Utf16Encoder::new(self[..].chars()) } + } + + /// Returns the length of `self` in bytes. + /// + /// # Examples + /// + /// ``` + /// assert_eq!("foo".len(), 3); + /// assert_eq!("ƒoo".len(), 4); // fancy f! + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn len(&self) -> usize { + core_str::StrExt::len(&self[..]) + } + + /// Returns true if this slice has a length of zero bytes. + /// + /// # Examples + /// + /// ``` + /// assert!("".is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + core_str::StrExt::is_empty(&self[..]) + } + + /// Parses `self` into the specified type. + /// + /// # Failure + /// + /// Will return `Err` if it's not possible to parse `self` into the type. + /// + /// # Example + /// + /// ``` + /// assert_eq!("4".parse::(), Ok(4)); + /// ``` + /// + /// Failing: + /// + /// ``` + /// assert!("j".parse::().is_err()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn parse(&self) -> Result { + core_str::StrExt::parse(&self[..]) + } + + /// Returns an iterator over the [grapheme clusters][graphemes] of `self`. + /// + /// [graphemes]: http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries + /// + /// If `is_extended` is true, the iterator is over the *extended grapheme clusters*; + /// otherwise, the iterator is over the *legacy grapheme clusters*. + /// [UAX#29](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) + /// recommends extended grapheme cluster boundaries for general processing. + /// + /// # Examples + /// + /// ``` + /// let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::>(); + /// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; + /// + /// assert_eq!(gr1.as_slice(), b); + /// + /// let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::>(); + /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; + /// + /// assert_eq!(gr2.as_slice(), b); + /// ``` + #[unstable(feature = "collections", + reason = "this functionality may only be provided by libunicode")] + pub fn graphemes(&self, is_extended: bool) -> Graphemes { + UnicodeStr::graphemes(&self[..], is_extended) + } + + /// Returns an iterator over the grapheme clusters of `self` and their byte offsets. See + /// `graphemes()` for more information. + /// + /// # Examples + /// + /// ``` + /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::>(); + /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + /// + /// assert_eq!(gr_inds.as_slice(), b); + /// ``` + #[unstable(feature = "collections", + reason = "this functionality may only be provided by libunicode")] + pub fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { + UnicodeStr::grapheme_indices(&self[..], is_extended) + } + + /// An iterator over the non-empty words of `self`. + /// + /// A 'word' is a subsequence separated by any sequence of whitespace. Sequences of whitespace + /// are collapsed, so empty "words" are not included. + /// + /// # Examples + /// + /// ``` + /// let some_words = " Mary had\ta little \n\t lamb"; + /// let v: Vec<&str> = some_words.words().collect(); + /// + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); + /// ``` + #[unstable(feature = "str_words", + reason = "the precise algorithm to use is unclear")] + pub fn words(&self) -> Words { + UnicodeStr::words(&self[..]) + } + + /// Returns a string's displayed width in columns. + /// + /// Control characters have zero width. + /// + /// `is_cjk` determines behavior for characters in the Ambiguous category: if `is_cjk` is + /// `true`, these are 2 columns wide; otherwise, they are 1. In CJK locales, `is_cjk` should be + /// `true`, else it should be `false`. + /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) recommends that these + /// characters be treated as 1 column (i.e., `is_cjk = false`) if the locale is unknown. + #[unstable(feature = "collections", + reason = "this functionality may only be provided by libunicode")] + pub fn width(&self, is_cjk: bool) -> usize { + UnicodeStr::width(&self[..], is_cjk) + } + + /// Returns a `&str` with leading and trailing whitespace removed. + /// + /// # Examples + /// + /// ``` + /// let s = " Hello\tworld\t"; + /// assert_eq!(s.trim(), "Hello\tworld"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim(&self) -> &str { + UnicodeStr::trim(&self[..]) + } + + /// Returns a `&str` with leading whitespace removed. + /// + /// # Examples + /// + /// ``` + /// let s = " Hello\tworld\t"; + /// assert_eq!(s.trim_left(), "Hello\tworld\t"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim_left(&self) -> &str { + UnicodeStr::trim_left(&self[..]) + } + + /// Returns a `&str` with trailing whitespace removed. + /// + /// # Examples + /// + /// ``` + /// let s = " Hello\tworld\t"; + /// assert_eq!(s.trim_right(), " Hello\tworld"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn trim_right(&self) -> &str { + UnicodeStr::trim_right(&self[..]) + } + + /// Returns the lowercase equivalent of this string. + /// + /// # Examples + /// + /// let s = "HELLO"; + /// assert_eq!(s.to_lowercase(), "hello"); + #[unstable(feature = "collections")] + pub fn to_lowercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + s.extend(self[..].chars().flat_map(|c| c.to_lowercase())); + return s; + } + + /// Returns the uppercase equivalent of this string. + /// + /// # Examples + /// + /// let s = "hello"; + /// assert_eq!(s.to_uppercase(), "HELLO"); + #[unstable(feature = "collections")] + pub fn to_uppercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + s.extend(self[..].chars().flat_map(|c| c.to_uppercase())); + return s; + } +} + #[cfg(test)] mod tests { use prelude::*; diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index 677894ba6e4..47069a81d85 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -23,6 +23,7 @@ use ops::Deref; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; use slice::{self, SliceExt}; +#[cfg(stage0)] use str::StrExt; use string::String; use vec::Vec; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 35ef375174a..ce3b690098f 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -25,7 +25,10 @@ use result::Result::{Ok, Err}; use result; use slice::{self, SliceExt}; use string::String; +#[cfg(stage0)] use str::{self, StrExt}; +#[cfg(not(stage0))] +use str; use vec::Vec; pub use self::buffered::{BufReader, BufWriter, BufStream, LineWriter}; diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index fa24e9fd5af..968ffcf6225 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -24,6 +24,7 @@ use num::{self, Int, Float, ToPrimitive}; use num::FpCategory as Fp; use ops::FnMut; use slice::SliceExt; +#[cfg(stage0)] use str::StrExt; use string::String; use vec::Vec; diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs index 711faa98bd9..23a7c3d1114 100644 --- a/src/libstd/old_io/mod.rs +++ b/src/libstd/old_io/mod.rs @@ -269,6 +269,7 @@ use result::Result; use result::Result::{Ok, Err}; use sys; use slice::SliceExt; +#[cfg(stage0)] use str::StrExt; use str; use string::String; diff --git a/src/libstd/old_io/net/ip.rs b/src/libstd/old_io/net/ip.rs index 6e2f491262d..f71fa9f92ba 100644 --- a/src/libstd/old_io/net/ip.rs +++ b/src/libstd/old_io/net/ip.rs @@ -27,7 +27,10 @@ use option::Option; use option::Option::{None, Some}; use result::Result::{self, Ok, Err}; use slice::SliceExt; +#[cfg(stage0)] use str::{FromStr, StrExt}; +#[cfg(not(stage0))] +use str::FromStr; use vec::Vec; pub type Port = u16; diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs index cabba8e358a..647ef730617 100644 --- a/src/libstd/old_io/process.rs +++ b/src/libstd/old_io/process.rs @@ -761,7 +761,7 @@ mod tests { use old_io::{Truncate, Write, TimedOut, timer, process, FileNotFound}; use prelude::v1::{Ok, Err, range, drop, Some, None, Vec}; use prelude::v1::{Path, String, Reader, Writer, Clone}; - use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath}; + use prelude::v1::{SliceExt, Str, AsSlice, ToString, GenericPath}; use old_io::fs::PathExtensions; use old_io::timer::*; use rt::running_on_valgrind; diff --git a/src/libstd/old_io/stdio.rs b/src/libstd/old_io/stdio.rs index dcc34505730..0e6a4b60e77 100644 --- a/src/libstd/old_io/stdio.rs +++ b/src/libstd/old_io/stdio.rs @@ -44,6 +44,7 @@ use ptr; use result::Result::{Ok, Err}; use rt; use slice::SliceExt; +#[cfg(stage0)] use str::StrExt; use string::String; use sys::{fs, tty}; diff --git a/src/libstd/old_io/tempfile.rs b/src/libstd/old_io/tempfile.rs index 76753dca52e..b34804fce61 100644 --- a/src/libstd/old_io/tempfile.rs +++ b/src/libstd/old_io/tempfile.rs @@ -21,6 +21,7 @@ use option::Option; use old_path::{Path, GenericPath}; use rand::{Rng, thread_rng}; use result::Result::{Ok, Err}; +#[cfg(stage0)] use str::StrExt; use string::String; diff --git a/src/libstd/old_path/mod.rs b/src/libstd/old_path/mod.rs index 01eec230d21..3f9cfbd2a07 100644 --- a/src/libstd/old_path/mod.rs +++ b/src/libstd/old_path/mod.rs @@ -72,6 +72,7 @@ use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; use str; +#[cfg(stage0)] use str::StrExt; use string::{String, CowString}; use slice::SliceExt; diff --git a/src/libstd/old_path/posix.rs b/src/libstd/old_path/posix.rs index 8d5765e1ffe..790dd87ae91 100644 --- a/src/libstd/old_path/posix.rs +++ b/src/libstd/old_path/posix.rs @@ -21,7 +21,10 @@ use marker::Sized; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; use slice::{AsSlice, Split, SliceExt, SliceConcatExt}; +#[cfg(stage0)] use str::{self, FromStr, StrExt}; +#[cfg(not(stage0))] +use str::{self, FromStr}; use vec::Vec; use super::{BytesContainer, GenericPath, GenericPathUnsafe}; @@ -448,7 +451,7 @@ mod tests { use option::Option::{self, Some, None}; use old_path::GenericPath; use slice::{AsSlice, SliceExt}; - use str::{self, Str, StrExt}; + use str::{self, Str}; use string::ToString; use vec::Vec; diff --git a/src/libstd/old_path/windows.rs b/src/libstd/old_path/windows.rs index 1387d531001..4e36befefe8 100644 --- a/src/libstd/old_path/windows.rs +++ b/src/libstd/old_path/windows.rs @@ -28,7 +28,10 @@ use mem; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; use slice::{SliceExt, SliceConcatExt}; +#[cfg(stage0)] use str::{SplitTerminator, FromStr, StrExt}; +#[cfg(not(stage0))] +use str::{SplitTerminator, FromStr}; use string::{String, ToString}; use vec::Vec; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 2dea77a3ccd..2e869312946 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -57,7 +57,10 @@ use ptr; use result::Result::{Err, Ok}; use result::Result; use slice::{AsSlice, SliceExt}; +#[cfg(stage0)] use str::{Str, StrExt}; +#[cfg(not(stage0))] +use str::Str; use str; use string::{String, ToString}; use sync::atomic::{AtomicIsize, ATOMIC_ISIZE_INIT, Ordering}; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index b244f785852..81cdced58bd 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -46,8 +46,12 @@ #[doc(no_inline)] pub use result::Result::{self, Ok, Err}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use slice::{SliceExt, SliceConcatExt, AsSlice}; +#[cfg(stage0)] #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use str::{Str, StrExt}; +#[cfg(not(stage0))] +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] pub use str::Str; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use string::{String, ToString}; #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/process.rs b/src/libstd/process.rs index 08aa92d5f20..db613db74cf 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -533,7 +533,7 @@ mod tests { use io::prelude::*; use prelude::v1::{Ok, Err, drop, Some, Vec}; use prelude::v1::{String, Clone}; - use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath}; + use prelude::v1::{SliceExt, Str, AsSlice, ToString, GenericPath}; use old_path; use old_io::fs::PathExtensions; use rt::running_on_valgrind; diff --git a/src/test/compile-fail/method-suggestion-no-duplication.rs b/src/test/compile-fail/method-suggestion-no-duplication.rs index e807d2b9448..d05e2ba0e19 100644 --- a/src/test/compile-fail/method-suggestion-no-duplication.rs +++ b/src/test/compile-fail/method-suggestion-no-duplication.rs @@ -20,5 +20,4 @@ fn main() { //~^^ HELP #1: `core::slice::SliceExt` //~^^^ HELP #2: `core::str::StrExt` //~^^^^ HELP #3: `collections::slice::SliceExt` - //~^^^^^ HELP #4: `collections::str::StrExt` }