1
Fork 0

Add From<Box<..>> implementations.

This commit is contained in:
Clar Charr 2017-02-13 20:37:42 -05:00
parent f573db4f80
commit 560944b982
9 changed files with 136 additions and 21 deletions

View file

@ -1974,6 +1974,22 @@ impl<'a> From<&'a str> for String {
}
}
// note: test pulls in libstd, which causes errors here
#[cfg(not(test))]
#[stable(feature = "string_from_box", since = "1.17.0")]
impl From<Box<str>> for String {
fn from(s: Box<str>) -> String {
s.into_string()
}
}
#[stable(feature = "box_from_str", since = "1.17.0")]
impl Into<Box<str>> for String {
fn into(self) -> Box<str> {
self.into_boxed_str()
}
}
#[stable(feature = "string_from_cow_str", since = "1.14.0")]
impl<'a> From<Cow<'a, str>> for String {
fn from(s: Cow<'a, str>) -> String {

View file

@ -1897,6 +1897,22 @@ impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {
}
}
// note: test pulls in libstd, which causes errors here
#[cfg(not(test))]
#[stable(feature = "vec_from_box", since = "1.17.0")]
impl<T> From<Box<[T]>> for Vec<T> {
fn from(s: Box<[T]>) -> Vec<T> {
s.into_vec()
}
}
#[stable(feature = "box_from_vec", since = "1.17.0")]
impl<T> Into<Box<[T]>> for Vec<T> {
fn into(self) -> Box<[T]> {
self.into_boxed_slice()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> From<&'a str> for Vec<u8> {
fn from(s: &'a str) -> Vec<u8> {

View file

@ -304,7 +304,7 @@ impl CString {
}
/// Converts this `CString` into a boxed `CStr`.
#[unstable(feature = "into_boxed_c_str", issue = "0")]
#[unstable(feature = "into_boxed_c_str", issue = "40380")]
pub fn into_boxed_c_str(self) -> Box<CStr> {
unsafe { mem::transmute(self.into_inner()) }
}
@ -394,6 +394,20 @@ impl<'a> From<&'a CStr> for Box<CStr> {
}
}
#[stable(feature = "c_string_from_box", since = "1.17.0")]
impl From<Box<CStr>> for CString {
fn from(s: Box<CStr>) -> CString {
s.into_c_string()
}
}
#[stable(feature = "box_from_c_string", since = "1.17.0")]
impl Into<Box<CStr>> for CString {
fn into(self) -> Box<CStr> {
self.into_boxed_c_str()
}
}
#[stable(feature = "default_box_extra", since = "1.17.0")]
impl Default for Box<CStr> {
fn default() -> Box<CStr> {
@ -694,6 +708,12 @@ impl CStr {
pub fn to_string_lossy(&self) -> Cow<str> {
String::from_utf8_lossy(self.to_bytes())
}
/// Converts a `Box<CStr>` into a `CString` without copying or allocating.
#[unstable(feature = "into_boxed_c_str", issue = "40380")]
pub fn into_c_string(self: Box<CStr>) -> CString {
unsafe { mem::transmute(self) }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
@ -888,12 +908,11 @@ mod tests {
fn into_boxed() {
let orig: &[u8] = b"Hello, world!\0";
let cstr = CStr::from_bytes_with_nul(orig).unwrap();
let cstring = cstr.to_owned();
let box1: Box<CStr> = Box::from(cstr);
let box2 = cstring.into_boxed_c_str();
assert_eq!(cstr, &*box1);
assert_eq!(box1, box2);
assert_eq!(&*box2, cstr);
let boxed: Box<CStr> = Box::from(cstr);
let cstring = cstr.to_owned().into_boxed_c_str().into_c_string();
assert_eq!(cstr, &*boxed);
assert_eq!(&*boxed, &*cstring);
assert_eq!(&*cstring, cstr);
}
#[test]

View file

@ -206,7 +206,7 @@ impl OsString {
}
/// Converts this `OsString` into a boxed `OsStr`.
#[unstable(feature = "into_boxed_os_str", issue = "0")]
#[unstable(feature = "into_boxed_os_str", issue = "40380")]
pub fn into_boxed_os_str(self) -> Box<OsStr> {
unsafe { mem::transmute(self.inner.into_box()) }
}
@ -442,6 +442,13 @@ impl OsStr {
self.inner.inner.len()
}
/// Converts a `Box<OsStr>` into an `OsString` without copying or allocating.
#[unstable(feature = "into_boxed_os_str", issue = "40380")]
pub fn into_os_string(self: Box<OsStr>) -> OsString {
let inner: Box<Slice> = unsafe { mem::transmute(self) };
OsString { inner: Buf::from_box(inner) }
}
/// Gets the underlying byte representation.
///
/// Note: it is *crucial* that this API is private, to avoid
@ -458,6 +465,20 @@ impl<'a> From<&'a OsStr> for Box<OsStr> {
}
}
#[stable(feature = "os_string_from_box", since = "1.17.0")]
impl<'a> From<Box<OsStr>> for OsString {
fn from(boxed: Box<OsStr>) -> OsString {
boxed.into_os_string()
}
}
#[stable(feature = "box_from_c_string", since = "1.17.0")]
impl Into<Box<OsStr>> for OsString {
fn into(self) -> Box<OsStr> {
self.into_boxed_os_str()
}
}
#[stable(feature = "box_default_extra", since = "1.17.0")]
impl Default for Box<OsStr> {
fn default() -> Box<OsStr> {
@ -766,12 +787,11 @@ mod tests {
fn into_boxed() {
let orig = "Hello, world!";
let os_str = OsStr::new(orig);
let os_string = os_str.to_owned();
let box1: Box<OsStr> = Box::from(os_str);
let box2 = os_string.into_boxed_os_str();
assert_eq!(os_str, &*box1);
assert_eq!(box1, box2);
assert_eq!(&*box2, os_str);
let boxed: Box<OsStr> = Box::from(os_str);
let os_string = os_str.to_owned().into_boxed_os_str().into_os_string();
assert_eq!(os_str, &*boxed);
assert_eq!(&*boxed, &*os_string);
assert_eq!(&*os_string, os_str);
}
#[test]

View file

@ -1196,7 +1196,7 @@ impl PathBuf {
}
/// Converts this `PathBuf` into a boxed `Path`.
#[unstable(feature = "into_boxed_path", issue = "0")]
#[unstable(feature = "into_boxed_path", issue = "40380")]
pub fn into_boxed_path(self) -> Box<Path> {
unsafe { mem::transmute(self.inner.into_boxed_os_str()) }
}
@ -1210,6 +1210,20 @@ impl<'a> From<&'a Path> for Box<Path> {
}
}
#[stable(feature = "path_buf_from_box", since = "1.17.0")]
impl<'a> From<Box<Path>> for PathBuf {
fn from(boxed: Box<Path>) -> PathBuf {
boxed.into_path_buf()
}
}
#[stable(feature = "box_from_path_buf", since = "1.17.0")]
impl Into<Box<Path>> for PathBuf {
fn into(self) -> Box<Path> {
self.into_boxed_path()
}
}
#[stable(feature = "box_default_extra", since = "1.17.0")]
impl Default for Box<Path> {
fn default() -> Box<Path> {
@ -2089,6 +2103,13 @@ impl Path {
pub fn is_dir(&self) -> bool {
fs::metadata(self).map(|m| m.is_dir()).unwrap_or(false)
}
/// Converts a `Box<Path>` into a `PathBuf` without copying or allocating.
#[unstable(feature = "into_boxed_path", issue = "40380")]
pub fn into_path_buf(self: Box<Path>) -> PathBuf {
let inner: Box<OsStr> = unsafe { mem::transmute(self) };
PathBuf { inner: OsString::from(inner) }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
@ -3703,12 +3724,11 @@ mod tests {
fn into_boxed() {
let orig: &str = "some/sort/of/path";
let path = Path::new(orig);
let path_buf = path.to_owned();
let box1: Box<Path> = Box::from(path);
let box2 = path_buf.into_boxed_path();
assert_eq!(path, &*box1);
assert_eq!(box1, box2);
assert_eq!(&*box2, path);
let boxed: Box<Path> = Box::from(path);
let path_buf = path.to_owned().into_boxed_path().into_path_buf();
assert_eq!(path, &*boxed);
assert_eq!(&*boxed, &*path_buf);
assert_eq!(&*path_buf, path);
}
#[test]

View file

@ -99,6 +99,12 @@ impl Buf {
pub fn into_box(self) -> Box<Slice> {
unsafe { mem::transmute(self.inner.into_boxed_slice()) }
}
#[inline]
pub fn from_box(boxed: Box<Slice>) -> Buf {
let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
Buf { inner: inner.into_vec() }
}
}
impl Slice {

View file

@ -99,6 +99,12 @@ impl Buf {
pub fn into_box(self) -> Box<Slice> {
unsafe { mem::transmute(self.inner.into_boxed_slice()) }
}
#[inline]
pub fn from_box(boxed: Box<Slice>) -> Buf {
let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
Buf { inner: inner.into_vec() }
}
}
impl Slice {

View file

@ -93,6 +93,12 @@ impl Buf {
pub fn into_box(self) -> Box<Slice> {
unsafe { mem::transmute(self.inner.into_box()) }
}
#[inline]
pub fn from_box(boxed: Box<Slice>) -> Buf {
let inner: Box<Wtf8> = unsafe { mem::transmute(boxed) };
Buf { inner: Wtf8Buf::from_box(inner) }
}
}
impl Slice {

View file

@ -346,6 +346,12 @@ impl Wtf8Buf {
pub fn into_box(self) -> Box<Wtf8> {
unsafe { mem::transmute(self.bytes.into_boxed_slice()) }
}
/// Converts a `Box<Wtf8>` into a `Wtf8Buf`.
pub fn from_box(boxed: Box<Wtf8>) -> Wtf8Buf {
let bytes: Box<[u8]> = unsafe { mem::transmute(boxed) };
Wtf8Buf { bytes: bytes.into_vec() }
}
}
/// Create a new WTF-8 string from an iterator of code points.