Section: Creating a string
*/
-/// Consumes a vector of bytes to create a new utf-8 string.
-///
-/// Returns `Err` with the original vector if the vector contains invalid
-/// UTF-8.
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let hello_vec = vec![104, 101, 108, 108, 111];
-/// let string = str::from_utf8_owned(hello_vec);
-/// assert_eq!(string, Ok("hello".to_string()));
-/// ```
+/// Deprecated. Replaced by `String::from_utf8`
#[deprecated = "Replaced by `String::from_utf8`"]
pub fn from_utf8_owned(vv: Vec<u8>) -> Result<String, Vec<u8>> {
String::from_utf8(vv)
}
-/// Convert a byte to a UTF-8 string
-///
-/// # Failure
-///
-/// Fails if invalid UTF-8
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let string = str::from_byte(104);
-/// assert_eq!(string.as_slice(), "h");
-/// ```
+/// Deprecated. Replaced by `String::from_byte`
#[deprecated = "Replaced by String::from_byte"]
pub fn from_byte(b: u8) -> String {
assert!(b < 128u8);
String::from_char(1, b as char)
}
-/// Convert a char to a string
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let string = str::from_char('b');
-/// assert_eq!(string.as_slice(), "b");
-/// ```
+/// Deprecated. Use `String::from_char` or `char::to_string()` instead
#[deprecated = "use String::from_char or char.to_string()"]
pub fn from_char(ch: char) -> String {
String::from_char(1, ch)
}
-/// Convert a vector of chars to a string
-///
-/// # Example
-///
-/// ```rust
-/// let chars = ['h', 'e', 'l', 'l', 'o'];
-/// let string = String::from_chars(chars);
-/// assert_eq!(string.as_slice(), "hello");
-/// ```
+/// Deprecated. Replaced by `String::from_chars`
#[deprecated = "use String::from_chars instead"]
pub fn from_chars(chs: &[char]) -> String {
chs.iter().map(|c| *c).collect()
#[test]
fn test_from_buf_len() {
use slice::ImmutableVector;
- use str::StrAllocating;
unsafe {
let a = vec![65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
use std::default::Default;
use std::char::Char;
use std::clone::Clone;
- use std::cmp::{Equal, Greater, Less, Ord, Eq, PartialOrd, PartialEq, Equiv};
- use std::result::{Ok, Err};
+ use std::cmp::{Equal, Greater, Less, Ord, PartialOrd, Equiv};
use std::option::{Some, None};
use std::ptr::RawPtr;
use std::iter::{Iterator, DoubleEndedIterator};
let mut pos = 0;
for ch in v.iter() {
assert!(s.char_at(pos) == *ch);
- pos += from_char(*ch).len();
+ pos += String::from_char(1, *ch).len();
}
}
let mut pos = s.len();
for ch in v.iter().rev() {
assert!(s.char_at_reverse(pos) == *ch);
- pos -= from_char(*ch).len();
+ pos -= String::from_char(1, *ch).len();
}
}
mod bench {
use test::Bencher;
use super::*;
- use vec::Vec;
use std::iter::{Iterator, DoubleEndedIterator};
use std::collections::Collection;
- use std::slice::Vector;
#[bench]
fn char_iterator(b: &mut Bencher) {
///
/// ```rust
/// let input = b"Hello \xF0\x90\x80World";
- /// let output = std::str::from_utf8_lossy(input);
+ /// let output = String::from_utf8_lossy(input);
/// assert_eq!(output.as_slice(), "Hello \uFFFDWorld");
/// ```
pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> {
Owned(res.into_string())
}
- /// Decode a UTF-16 encoded vector `v` into a string, returning `None`
+ /// Decode a UTF-16 encoded vector `v` into a `String`, returning `None`
/// if `v` contains any invalid data.
///
/// # Example
///
/// ```rust
- /// // ð\9d„žmusic
+ /// // 𝄞music
/// let mut v = [0xD834, 0xDD1E, 0x006d, 0x0075,
/// 0x0073, 0x0069, 0x0063];
- /// assert_eq!(String::from_utf16(v), Some("ð\9d„žmusic".to_string()));
+ /// assert_eq!(String::from_utf16(v), Some("𝄞music".to_string()));
///
- /// // ð\9d„žmu<invalid>ic
+ /// // 𝄞mu<invalid>ic
/// v[4] = 0xD800;
/// assert_eq!(String::from_utf16(v), None);
/// ```
///
/// # Example
/// ```rust
- /// // ð\9d„žmus<invalid>ic<invalid>
+ /// // 𝄞mus<invalid>ic<invalid>
/// let v = [0xD834, 0xDD1E, 0x006d, 0x0075,
/// 0x0073, 0xDD1E, 0x0069, 0x0063,
/// 0xD834];
///
/// assert_eq!(String::from_utf16_lossy(v),
- /// "ð\9d„žmus\uFFFDic\uFFFD".to_string());
+ /// "𝄞mus\uFFFDic\uFFFD".to_string());
/// ```
pub fn from_utf16_lossy(v: &[u16]) -> String {
str::utf16_items(v).map(|c| c.to_char_lossy()).collect()
use Mutable;
use str;
- use str::{Str, StrSlice, MaybeOwned, Owned, Slice};
+ use str::{Str, StrSlice, Owned, Slice};
use super::String;
+ use vec::Vec;
#[test]
fn test_from_str() {
#[test]
fn test_from_utf8() {
let xs = Vec::from_slice(b"hello");
- assert_eq!(String::from_utf8(xs), Ok("hello".to_string()));
+ assert_eq!(String::from_utf8(xs), Ok(String::from_str("hello")));
- let xs = Vec::from_slice("ศไทยä¸å\8dŽViệt Nam".as_bytes());
- assert_eq!(String::from_utf8(xs), Ok("ศไทยä¸å\8dŽViệt Nam".to_string()));
+ let xs = Vec::from_slice("ศไทย中华Việt Nam".as_bytes());
+ assert_eq!(String::from_utf8(xs), Ok(String::from_str("ศไทย中华Việt Nam")));
let xs = Vec::from_slice(b"hello\xFF");
assert_eq!(String::from_utf8(xs),
let xs = b"hello";
assert_eq!(String::from_utf8_lossy(xs), Slice("hello"));
- let xs = "ศไทยä¸å\8dŽViệt Nam".as_bytes();
- assert_eq!(String::from_utf8_lossy(xs), Slice("ศไทยä¸å\8dŽViệt Nam"));
+ let xs = "ศไทย中华Việt Nam".as_bytes();
+ assert_eq!(String::from_utf8_lossy(xs), Slice("ศไทย中华Việt Nam"));
let xs = b"Hello\xC2 There\xFF Goodbye";
- assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("Hello\uFFFD There\uFFFD Goodbye")));
+ assert_eq!(String::from_utf8_lossy(xs),
+ Owned(String::from_str("Hello\uFFFD There\uFFFD Goodbye")));
let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
assert_eq!(String::from_utf8_lossy(xs),
Owned(String::from_str("Hello\uFFFD\uFFFD There\uFFFD Goodbye")));
let xs = b"\xF5foo\xF5\x80bar";
- assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("\uFFFDfoo\uFFFD\uFFFDbar")));
+ assert_eq!(String::from_utf8_lossy(xs),
+ Owned(String::from_str("\uFFFDfoo\uFFFD\uFFFDbar")));
let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
- assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("\uFFFDfoo\uFFFDbar\uFFFDbaz")));
+ assert_eq!(String::from_utf8_lossy(xs),
+ Owned(String::from_str("\uFFFDfoo\uFFFDbar\uFFFDbaz")));
let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
assert_eq!(String::from_utf8_lossy(xs),
#[test]
fn test_from_utf16() {
let pairs =
- [(String::from_str("ðÂ\90Â\8dâ\80¦Ã°Â\90Å\92¿ðÂ\90Å\92»ðÂ\90Â\8dâ\80 ðÂ\90Å\92¹ðÂ\90Å\92»ðÂ\90Å\92°\n"),
+ [(String::from_str("ð\90\8d\85ð\90\8c¿ð\90\8c»ð\90\8d\86ð\90\8c¹ð\90\8c»ð\90\8c°\n"),
vec![0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
0xd800_u16, 0xdf30_u16, 0x000a_u16]),
- (String::from_str("ðÂ\90Â\90â\80\99ðÂ\90â\80\98â\80°Ã°Â\90Â\90®ðÂ\90â\80\98â\82¬Ã°Â\90Â\90²ðÂ\90â\80\98â\80¹ ðÂ\90Â\90Â\8fðÂ\90Â\90²ðÂ\90â\80\98Â\8d\n"),
+ (String::from_str("ð\90\90\92ð\90\91\89ð\90\90®ð\90\91\80ð\90\90²ð\90\91\8b ð\90\90\8fð\90\90²ð\90\91\8d\n"),
vec![0xd801_u16, 0xdc12_u16, 0xd801_u16,
0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
0x000a_u16]),
- (String::from_str("ð\90Œ€ð\90Œ–ð\90Œ‹ð\90Œ„ð\90Œ‘ð\90Œ‰Â·ð\90ŒŒð\90Œ„ð\90Œ•ð\90Œ„ð\90Œ‹ð\90Œ‰ð\90Œ‘\n"),
+ (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
vec![0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
- (String::from_str("ð\90’‹ð\90’˜ð\90’ˆð\90’‘ð\90’›ð\90’’ ð\90’•ð\90’“ ð\90’ˆð\90’šð\90’\8d ð\90’\8fð\90’œð\90’’ð\90’–ð\90’† ð\90’•ð\90’†\n"),
+ (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
vec![0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
// general
assert_eq!(String::from_utf16_lossy([0xD800, 0xd801, 0xdc8b, 0xD800]),
- String::from_str("\uFFFDð\90’‹\uFFFD"));
+ String::from_str("\uFFFD𐒋\uFFFD"));
}
#[test]
#[bench]
fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
- let s = "ð\90Œ€ð\90Œ–ð\90Œ‹ð\90Œ„ð\90Œ‘ð\90Œ‰à¸›à¸£Ø¯ÙˆÙ„Ø© الكويتทศไทยä¸å\8dŽð\90\8d…ð\90Œ¿ð\90Œ»ð\90\8d†ð\90Œ¹ð\90Œ»ð\90Œ°".as_bytes();
+ let s = "ð\90Œ€ð\90Œ–ð\90Œ‹ð\90Œ„ð\90Œ‘ð\90Œ‰à¸›à¸£Ø¯ÙˆÙ„Ø©\
+ الكويتทศไทยä¸å\8dŽð\90\8d…ð\90Œ¿ð\90Œ»ð\90\8d†ð\90Œ¹ð\90Œ»ð\90Œ°".as_bytes();
assert_eq!(100, s.len());
b.iter(|| {
let _ = String::from_utf8_lossy(s);
use std::fmt;
use std::iter;
use std::num;
-use std::str;
/// Static data containing Unicode ranges for general categories and scripts.
use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
#![allow(non_snake_case_functions)]
use std::rand::{Rng, task_rng};
-use std::str;
use stdtest::Bencher;
use regex::{Regex, NoExpand};
use std::any::AnyRefExt;
use std::io;
use std::os;
-use std::str;
use std::task::TaskBuilder;
use syntax::ast;
use std::hash;
use std::io::MemWriter;
use std::mem;
-use std::str;
use std::collections::HashMap;
use syntax::abi;
use syntax::ast::*;
Public => 'y',
Inherited => 'i',
};
- ebml_w.wr_str(ch.to_str().as_slice());
+ ebml_w.wr_str(ch.to_string().as_slice());
ebml_w.end_tag();
}
tcx: tcx,
abbrevs: &RefCell::new(HashMap::new())
}, t);
- str::from_utf8(wr.get_ref()).unwrap().to_string()
+ String::from_utf8(wr.unwrap()).unwrap()
}
//! This module uses libsyntax's lexer to provide token-based highlighting for
//! the HTML documentation generated by rustdoc.
-use std::str;
use std::io;
use syntax::parse;
// Remove the utf-8 BOM if any
let contents = if contents.starts_with("\ufeff") {
- contents.as_slice().slice_from(3)
+ contents.slice_from(3)
} else {
- contents.as_slice()
+ contents
};
// Create the intermediate directories
use std::io;
use std::io::{File, MemWriter};
-use std::str;
use std::gc::Gc;
use serialize::{json, Decodable, Encodable};
use externalfiles::ExternalHtml;
use option::{Option, Some, None};
use slice::{ImmutableVector, MutableVector, Vector};
use str::{OwnedStr, Str, StrAllocating, StrSlice};
-use str;
use string::String;
use to_str::{IntoStr};
use vec::Vec;
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
- assert_eq!((from_u32(i).unwrap()).to_str().as_slice().to_ascii_upper(),
- (from_u32(upper).unwrap()).to_str())
+ assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_upper(),
+ (from_u32(upper).unwrap()).to_string())
i += 1;
}
}
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
- assert_eq!((from_u32(i).unwrap()).to_str().as_slice().to_ascii_lower(),
- (from_u32(lower).unwrap()).to_str())
+ assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_lower(),
+ (from_u32(lower).unwrap()).to_string())
i += 1;
}
}
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
- assert_eq!((from_u32(i).unwrap()).to_str().into_ascii_upper(),
- (from_u32(upper).unwrap()).to_str())
+ assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_upper(),
+ (from_u32(upper).unwrap()).to_string())
i += 1;
}
}
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
- assert_eq!((from_u32(i).unwrap()).to_str().into_ascii_lower(),
- (from_u32(lower).unwrap()).to_str())
+ assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lower(),
+ (from_u32(lower).unwrap()).to_string())
i += 1;
}
}
let c = i;
let lower = if 'A' as u32 <= c && c <= 'Z' as u32 { c + 'a' as u32 - 'A' as u32 }
else { c };
- assert!((from_u32(i).unwrap()).to_str().as_slice().eq_ignore_ascii_case(
- (from_u32(lower).unwrap()).to_str().as_slice()));
+ assert!((from_u32(i).unwrap()).to_string().as_slice().eq_ignore_ascii_case(
+ (from_u32(lower).unwrap()).to_string().as_slice()));
i += 1;
}
}
use io::Writer;
use io;
use result::{Ok, Err};
-use str::{Str, StrAllocating};
-use str;
use string;
-use slice::Vector;
pub use core::fmt::{Formatter, Result, FormatWriter, rt};
pub use core::fmt::{Show, Bool, Char, Signed, Unsigned, Octal, Binary};
pub fn format(args: &Arguments) -> string::String{
let mut output = io::MemWriter::new();
let _ = write!(&mut output, "{}", args);
- String::from_utf8(output.unwrap()).unwrap()
+ string::String::from_utf8(output.unwrap()).unwrap()
}
impl<'a> Writer for Formatter<'a> {
use prelude::*;
-use str;
use fmt;
use os;
use io::{IoResult, IoError};
use slice::{MutableVector, ImmutableVector};
use string::String;
use str::StrSlice;
- use str;
use vec::Vec;
pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD)
mod test {
use prelude::*;
use io::MemWriter;
- use str;
macro_rules! t( ($a:expr, $b:expr) => ({
let mut m = MemWriter::new();
use std::gc::Gc;
use std::io::File;
use std::rc::Rc;
-use std::str;
// These macros all relate to the file system; they either return
// the column/row/filename of the expression, or they include
use std::io::{IoResult, MemWriter};
use std::io;
use std::mem;
-use std::str;
pub enum AnnNode<'a> {
NodeBlock(&'a ast::Block),
use std::collections::HashMap;
use std::io;
-use std::str;
use super::super::TermInfo;
// These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
use std::io::File;
use std::os::getenv;
-use std::{os, str};
+use std::os;
/// Return path to database entry for `term`
pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
// Look for the terminal in all of the search directories
for p in dirs_to_search.iter() {
if p.exists() {
- let f = first_char.to_str();
+ let f = first_char.to_string();
let newp = p.join_many([f.as_slice(), term]);
if newp.exists() {
return Some(box newp);
use stats::write_5_number_summary;
use stats::write_boxplot;
use std::io;
- use std::str;
use std::f64;
macro_rules! assert_approx_eq(
use std::io::BufReader;
use std::num;
use std::string::String;
-use std::str;
static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
use std::rand;
use std::rand::Rng;
use std::slice;
-use std::str;
use serialize::{Encoder, Encodable, Decoder, Decodable};
// Extern mod controls linkage. Use controls the visibility of names to modules that are
// already linked in. Using WriterUtil allows us to use the write_line method.
-use std::str;
use std::slice;
use std::fmt;
projects / rust.git / commitdiff