mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Un-renamed trim and substr functions.

Browse Source
This commit is contained in:
Marvin Löbel 2013-03-21 23:02:27 +01:00
parent ee2f3d9673
commit 0a47cd5ef1
15 changed files with 80 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/tutorial.md
View File

@ -1363,11 +1363,11 @@ let crayon_names = crayons.map(|v| crayon_to_str(*v));
let favorite_crayon_name = crayon_names[0];
// Remove whitespace from before and after the string
let new_favorite_crayon_name = favorite_crayon_name.trim_DBGBRWD();
let new_favorite_crayon_name = favorite_crayon_name.trim();
if favorite_crayon_name.len() > 5 {
// Create a substring
println(favorite_crayon_name.substr_DBGBRWD(0, 5));
println(favorite_crayon_name.substr(0, 5));
}
~~~

2
src/compiletest/runtest.rs
View File

@ -268,7 +268,7 @@ fn run_debuginfo_test(config: config, props: TestProps, testfile: &Path) {
// output (in order)
let mut i = 0u;
for str::lines(ProcRes.stdout).each |line| {
if props.check_lines[i].trim_DBGBRWD() == line.trim_DBGBRWD() {
if props.check_lines[i].trim() == line.trim() {
i += 1u;
}
if i == num_check_lines {

116
src/libcore/str.rs
View File

@ -313,7 +313,7 @@ pub fn unshift_char(s: &mut ~str, ch: char) {
* * chars_to_trim - A vector of chars
*
*/
pub pure fn trim_left_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
pub pure fn trim_left_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
if chars_to_trim.is_empty() { return s; }
match find(s, |c| !chars_to_trim.contains(&c)) {
@ -331,7 +331,7 @@ pub pure fn trim_left_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a s
* * chars_to_trim - A vector of chars
*
*/
pub pure fn trim_right_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
pub pure fn trim_right_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
if chars_to_trim.is_empty() { return s; }
match rfind(s, |c| !chars_to_trim.contains(&c)) {
@ -352,12 +352,12 @@ pub pure fn trim_right_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a
* * chars_to_trim - A vector of chars
*
*/
pub pure fn trim_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
trim_left_chars_DBGBRWD(trim_right_chars_DBGBRWD(s, chars_to_trim), chars_to_trim)
pub pure fn trim_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
trim_left_chars(trim_right_chars(s, chars_to_trim), chars_to_trim)
}
/// Returns a string with leading whitespace removed
pub pure fn trim_left_DBGBRWD(s: &'a str) -> &'a str {
pub pure fn trim_left(s: &'a str) -> &'a str {
match find(s, |c| !char::is_whitespace(c)) {
None => "",
Some(first) => unsafe { raw::slice_bytes(s, first, len(s)) }
@ -365,7 +365,7 @@ pub pure fn trim_left_DBGBRWD(s: &'a str) -> &'a str {
}
/// Returns a string with trailing whitespace removed
pub pure fn trim_right_DBGBRWD(s: &'a str) -> &'a str {
pub pure fn trim_right(s: &'a str) -> &'a str {
match rfind(s, |c| !char::is_whitespace(c)) {
None => "",
Some(last) => {
@ -376,7 +376,7 @@ pub pure fn trim_right_DBGBRWD(s: &'a str) -> &'a str {
}
/// Returns a string with leading and trailing whitespace removed
pub pure fn trim_DBGBRWD(s: &'a str) -> &'a str { trim_left_DBGBRWD(trim_right_DBGBRWD(s)) }
pub pure fn trim(s: &'a str) -> &'a str { trim_left(trim_right(s)) }
/*
Section: Transforming strings
@ -421,7 +421,7 @@ pub pure fn chars(s: &str) -> ~[char] {
* Returns a string containing `n` characters starting at byte offset
* `begin`.
*/
pub pure fn substr_DBGBRWD(s: &'a str, begin: uint, n: uint) -> &'a str {
pub pure fn substr(s: &'a str, begin: uint, n: uint) -> &'a str {
slice(s, begin, begin + count_bytes(s, begin, n))
}
@ -2275,17 +2275,17 @@ pub trait StrSlice {
pure fn split_char(&self, sep: char) -> ~[~str];
pure fn split_str(&self, sep: &'a str) -> ~[~str];
pure fn starts_with(&self, needle: &'a str) -> bool;
pure fn substr_DBGBRWD(&self, begin: uint, n: uint) -> &'self str;
pure fn substr(&self, begin: uint, n: uint) -> &'self str;
pure fn to_lower(&self) -> ~str;
pure fn to_upper(&self) -> ~str;
pure fn escape_default(&self) -> ~str;
pure fn escape_unicode(&self) -> ~str;
pure fn trim_DBGBRWD(&self) -> &'self str;
pure fn trim_left_DBGBRWD(&self) -> &'self str;
pure fn trim_right_DBGBRWD(&self) -> &'self str;
pure fn trim_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
pure fn trim_left_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
pure fn trim_right_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
pure fn trim(&self) -> &'self str;
pure fn trim_left(&self) -> &'self str;
pure fn trim_right(&self) -> &'self str;
pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str;
pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str;
pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str;
pure fn to_owned(&self) -> ~str;
pure fn to_managed(&self) -> @str;
pure fn char_at(&self, i: uint) -> char;
@ -2419,8 +2419,8 @@ impl StrSlice for &'self str {
* `begin`.
*/
#[inline]
pure fn substr_DBGBRWD(&self, begin: uint, n: uint) -> &'self str {
substr_DBGBRWD(*self, begin, n)
pure fn substr(&self, begin: uint, n: uint) -> &'self str {
substr(*self, begin, n)
}
/// Convert a string to lowercase
#[inline]
@ -2437,25 +2437,25 @@ impl StrSlice for &'self str {
/// Returns a string with leading and trailing whitespace removed
#[inline]
pure fn trim_DBGBRWD(&self) -> &'self str { trim_DBGBRWD(*self) }
pure fn trim(&self) -> &'self str { trim(*self) }
/// Returns a string with leading whitespace removed
#[inline]
pure fn trim_left_DBGBRWD(&self) -> &'self str { trim_left_DBGBRWD(*self) }
pure fn trim_left(&self) -> &'self str { trim_left(*self) }
/// Returns a string with trailing whitespace removed
#[inline]
pure fn trim_right_DBGBRWD(&self) -> &'self str { trim_right_DBGBRWD(*self) }
pure fn trim_right(&self) -> &'self str { trim_right(*self) }
#[inline]
pure fn trim_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
trim_chars_DBGBRWD(*self, chars_to_trim)
pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str {
trim_chars(*self, chars_to_trim)
}
#[inline]
pure fn trim_left_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
trim_left_chars_DBGBRWD(*self, chars_to_trim)
pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str {
trim_left_chars(*self, chars_to_trim)
}
#[inline]
pure fn trim_right_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
trim_right_chars_DBGBRWD(*self, chars_to_trim)
pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str {
trim_right_chars(*self, chars_to_trim)
}
@ -2817,11 +2817,11 @@ mod tests {
#[test]
fn test_substr() {
fn t(a: &str, b: &str, start: int) {
fail_unless!(substr_DBGBRWD(a, start as uint, len(b)) == b);
fail_unless!(substr(a, start as uint, len(b)) == b);
}
t("hello", "llo", 2);
t("hello", "el", 1);
fail_unless!("ะเทศไท" == substr_DBGBRWD("ประเทศไทย中华Việt Nam", 6u, 6u));
fail_unless!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u));
}
#[test]
@ -3054,62 +3054,62 @@ mod tests {
#[test]
fn test_trim_left_chars() {
fail_unless!(trim_left_chars_DBGBRWD(" *** foo *** ", ~[]) ==
fail_unless!(trim_left_chars(" *** foo *** ", ~[]) ==
" *** foo *** ");
fail_unless!(trim_left_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) ==
fail_unless!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
"foo *** ");
fail_unless!(trim_left_chars_DBGBRWD(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_left_chars_DBGBRWD("foo *** ", ~['*', ' ']) ==
fail_unless!(trim_left_chars(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_left_chars("foo *** ", ~['*', ' ']) ==
"foo *** ");
}
#[test]
fn test_trim_right_chars() {
fail_unless!(trim_right_chars_DBGBRWD(" *** foo *** ", ~[]) ==
fail_unless!(trim_right_chars(" *** foo *** ", ~[]) ==
" *** foo *** ");
fail_unless!(trim_right_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) ==
fail_unless!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
" *** foo");
fail_unless!(trim_right_chars_DBGBRWD(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_right_chars_DBGBRWD(" *** foo", ~['*', ' ']) ==
fail_unless!(trim_right_chars(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_right_chars(" *** foo", ~['*', ' ']) ==
" *** foo");
}
#[test]
fn test_trim_chars() {
fail_unless!(trim_chars_DBGBRWD(" *** foo *** ", ~[]) == " *** foo *** ");
fail_unless!(trim_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) == "foo");
fail_unless!(trim_chars_DBGBRWD(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_chars_DBGBRWD("foo", ~['*', ' ']) == "foo");
fail_unless!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** ");
fail_unless!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo");
fail_unless!(trim_chars(" *** *** ", ~['*', ' ']) == "");
fail_unless!(trim_chars("foo", ~['*', ' ']) == "foo");
}
#[test]
fn test_trim_left() {
fail_unless!((trim_left_DBGBRWD("") == ""));
fail_unless!((trim_left_DBGBRWD("a") == "a"));
fail_unless!((trim_left_DBGBRWD(" ") == ""));
fail_unless!((trim_left_DBGBRWD(" blah") == "blah"));
fail_unless!((trim_left_DBGBRWD(" \u3000 wut") == "wut"));
fail_unless!((trim_left_DBGBRWD("hey ") == "hey "));
fail_unless!((trim_left("") == ""));
fail_unless!((trim_left("a") == "a"));
fail_unless!((trim_left(" ") == ""));
fail_unless!((trim_left(" blah") == "blah"));
fail_unless!((trim_left(" \u3000 wut") == "wut"));
fail_unless!((trim_left("hey ") == "hey "));
}
#[test]
fn test_trim_right() {
fail_unless!((trim_right_DBGBRWD("") == ""));
fail_unless!((trim_right_DBGBRWD("a") == "a"));
fail_unless!((trim_right_DBGBRWD(" ") == ""));
fail_unless!((trim_right_DBGBRWD("blah ") == "blah"));
fail_unless!((trim_right_DBGBRWD("wut \u3000 ") == "wut"));
fail_unless!((trim_right_DBGBRWD(" hey") == " hey"));
fail_unless!((trim_right("") == ""));
fail_unless!((trim_right("a") == "a"));
fail_unless!((trim_right(" ") == ""));
fail_unless!((trim_right("blah ") == "blah"));
fail_unless!((trim_right("wut \u3000 ") == "wut"));
fail_unless!((trim_right(" hey") == " hey"));
}
#[test]
fn test_trim() {
fail_unless!((trim_DBGBRWD("") == ""));
fail_unless!((trim_DBGBRWD("a") == "a"));
fail_unless!((trim_DBGBRWD(" ") == ""));
fail_unless!((trim_DBGBRWD(" blah ") == "blah"));
fail_unless!((trim_DBGBRWD("\nwut \u3000 ") == "wut"));
fail_unless!((trim_DBGBRWD(" hey dude ") == "hey dude"));
fail_unless!((trim("") == ""));
fail_unless!((trim("a") == "a"));
fail_unless!((trim(" ") == ""));
fail_unless!((trim(" blah ") == "blah"));
fail_unless!((trim("\nwut \u3000 ") == "wut"));
fail_unless!((trim(" hey dude ") == "hey dude"));
}
#[test]

4
src/libcore/unstable/extfmt.rs
View File

@ -325,7 +325,7 @@ pub mod ct {
'o' as u8 => TyOctal,
'f' as u8 => TyFloat,
'?' as u8 => TyPoly,
_ => err(~"unknown type in conversion: " + s.substr_DBGBRWD(i, 1))
_ => err(~"unknown type in conversion: " + s.substr(i, 1))
};
Parsed::new(t, i + 1)
@ -537,7 +537,7 @@ pub mod rt {
let mut unpadded = match cv.precision {
CountImplied => s.to_owned(),
CountIs(max) => if (max as uint) < str::char_len(s) {
str::substr_DBGBRWD(s, 0, max as uint).to_owned()
str::substr(s, 0, max as uint).to_owned()
} else {
s.to_owned()
}

2
src/librustc/driver/driver.rs
View File

@ -543,7 +543,7 @@ pub fn build_session_options(+binary: ~str,
let lint_dict = lint::get_lint_dict();
for lint_levels.each |level| {
let level_name = lint::level_to_str(*level);
let level_short = level_name.substr_DBGBRWD(0,1).to_upper();
let level_short = level_name.substr(0,1).to_upper();
let flags = vec::append(getopts::opt_strs(matches, level_short),
getopts::opt_strs(matches, level_name));
for flags.each |lint_name| {

2
src/librustc/middle/trans/expr.rs
View File

@ -1851,5 +1851,5 @@ fn trans_assign_op(bcx: block,
// NOTE: Mode neccessary here?
fn shorten(+x: ~str) -> ~str {
if x.len() > 60 { x.substr_DBGBRWD(0, 60).to_owned() } else { x }
if x.len() > 60 { x.substr(0, 60).to_owned() } else { x }
}

2
src/librustdoc/text_pass.rs
View File

@ -311,7 +311,7 @@ mod test {
let doc = (attr_pass::mk_pass().f)(srv.clone(), doc);
let doc = (desc_to_brief_pass::mk_pass().f)(srv.clone(), doc);
let doc = (sectionalize_pass::mk_pass().f)(srv.clone(), doc);
(mk_pass(~"", |s| str::trim_DBGBRWD(s).to_owned() ).f)(srv.clone(), doc)
(mk_pass(~"", |s| str::trim(s).to_owned() ).f)(srv.clone(), doc)
}
}
}

2
src/librustdoc/trim_pass.rs
View File

@ -21,7 +21,7 @@ use text_pass;
use core::str;
pub fn mk_pass() -> Pass {
text_pass::mk_pass(~"trim", |s| s.trim_DBGBRWD().to_owned() )
text_pass::mk_pass(~"trim", |s| s.trim().to_owned() )
}
#[test]

2
src/librustdoc/unindent_pass.rs
View File

@ -78,7 +78,7 @@ fn unindent(s: &str) -> ~str {
};
if !lines.is_empty() {
let unindented = ~[lines.head().trim_DBGBRWD().to_owned()]
let unindented = ~[lines.head().trim().to_owned()]
+ do lines.tail().map |line| {
if str::is_whitespace(*line) {
copy *line

6
src/librusti/rusti.rc
View File

@ -283,7 +283,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
for args.each |arg| {
let (crate, filename) =
if arg.ends_with(".rs") || arg.ends_with(".rc") {
(arg.substr_DBGBRWD(0, arg.len() - 3).to_owned(), *arg)
(arg.substr(0, arg.len() - 3).to_owned(), *arg)
} else {
(*arg, arg + ~".rs")
};
@ -317,7 +317,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
match get_line(~"rusti| ") {
None => fail!(~"unterminated multiline command :{ .. :}"),
Some(line) => {
if str::trim_DBGBRWD(line) == ~":}" {
if str::trim(line) == ~":}" {
end_multiline = true;
} else {
multiline_cmd += line + ~"\n";
@ -337,7 +337,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
fn run_line(repl: &mut Repl, in: @io::Reader, out: @io::Writer, line: ~str)
-> Option<Repl> {
if line.starts_with(~":") {
let full = line.substr_DBGBRWD(1, line.len() - 1);
let full = line.substr(1, line.len() - 1);
let split = str::words(full);
let len = split.len();

2
src/libstd/bigint.rs
View File

@ -462,7 +462,7 @@ pub impl BigUint {
let s = uint::to_str_radix(*n as uint, radix);
str::from_chars(vec::from_elem(l - s.len(), '0')) + s
}));
str::trim_left_chars_DBGBRWD(s, ['0']).to_owned()
str::trim_left_chars(s, ['0']).to_owned()
}
}

2
src/libstd/semver.rs
View File

@ -223,7 +223,7 @@ pub fn parse(s: &str) -> Option<Version> {
if ! str::is_ascii(s) {
return None;
}
let s = s.trim_DBGBRWD();
let s = s.trim();
let mut bad = false;
do bad_parse::cond.trap(|_| { debug!("bad"); bad = true }).in {
do io::with_str_reader(s) |rdr| {

10
src/libsyntax/parse/comments.rs
View File

@ -70,10 +70,10 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
/// remove whitespace-only lines from the start/end of lines
fn vertical_trim(lines: ~[~str]) -> ~[~str] {
let mut i = 0u, j = lines.len();
while i < j && lines[i].trim_DBGBRWD().is_empty() {
while i < j && lines[i].trim().is_empty() {
i += 1u;
}
while j > i && lines[j - 1u].trim_DBGBRWD().is_empty() {
while j > i && lines[j - 1u].trim().is_empty() {
j -= 1u;
}
return lines.slice(i, j).to_owned();
@ -84,7 +84,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
let mut i = max.get_or_default(uint::max_value);
for lines.each |line| {
if line.trim_DBGBRWD().is_empty() {
if line.trim().is_empty() {
loop;
}
for line.each_chari |j, c| {
@ -110,8 +110,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
if comment.starts_with(~"//") {
// FIXME #5475:
// return comment.slice(3u, comment.len()).trim_DBGBRWD().to_owned();
let r = comment.slice(3u, comment.len()); return r.trim_DBGBRWD().to_owned();
// return comment.slice(3u, comment.len()).trim().to_owned();
let r = comment.slice(3u, comment.len()); return r.trim().to_owned();
}

2
src/libsyntax/parse/lexer.rs
View File

@ -262,7 +262,7 @@ fn consume_whitespace_and_comments(rdr: @mut StringReader)
}
pub pure fn is_line_non_doc_comment(s: &str) -> bool {
s.trim_right_DBGBRWD().all(|ch| ch == '/')
s.trim_right().all(|ch| ch == '/')
}
// PRECONDITION: rdr.curr is not whitespace

2
src/test/bench/sudoku.rs
View File

@ -68,7 +68,7 @@ pub impl Sudoku {
let mut g = vec::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] });
while !reader.eof() {
let line = reader.read_line();
let comps = str::split_char(line.trim_DBGBRWD(), ',');
let comps = str::split_char(line.trim(), ',');
if vec::len(comps) == 3u {
let row = uint::from_str(comps[0]).get() as u8;
let col = uint::from_str(comps[1]).get() as u8;