Skip to content

Commit 560944b

Browse files
author
Clar Charr
committed
Add From<Box<..>> implementations.
1 parent f573db4 commit 560944b

File tree

9 files changed

+136
-21
lines changed

9 files changed

+136
-21
lines changed

‎src/libcollections/string.rs

+16
Original file line numberDiff line numberDiff line change
@@ -1974,6 +1974,22 @@ impl<'a> From<&'a str> for String {
19741974
}
19751975
}
19761976

1977+
// note: test pulls in libstd, which causes errors here
1978+
#[cfg(not(test))]
1979+
#[stable(feature = "string_from_box", since = "1.17.0")]
1980+
impl From<Box<str>> for String {
1981+
fn from(s: Box<str>) -> String {
1982+
s.into_string()
1983+
}
1984+
}
1985+
1986+
#[stable(feature = "box_from_str", since = "1.17.0")]
1987+
impl Into<Box<str>> for String {
1988+
fn into(self) -> Box<str> {
1989+
self.into_boxed_str()
1990+
}
1991+
}
1992+
19771993
#[stable(feature = "string_from_cow_str", since = "1.14.0")]
19781994
impl<'a> From<Cow<'a, str>> for String {
19791995
fn from(s: Cow<'a, str>) -> String {

‎src/libcollections/vec.rs

+16
Original file line numberDiff line numberDiff line change
@@ -1897,6 +1897,22 @@ impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {
18971897
}
18981898
}
18991899

1900+
// note: test pulls in libstd, which causes errors here
1901+
#[cfg(not(test))]
1902+
#[stable(feature = "vec_from_box", since = "1.17.0")]
1903+
impl<T> From<Box<[T]>> for Vec<T> {
1904+
fn from(s: Box<[T]>) -> Vec<T> {
1905+
s.into_vec()
1906+
}
1907+
}
1908+
1909+
#[stable(feature = "box_from_vec", since = "1.17.0")]
1910+
impl<T> Into<Box<[T]>> for Vec<T> {
1911+
fn into(self) -> Box<[T]> {
1912+
self.into_boxed_slice()
1913+
}
1914+
}
1915+
19001916
#[stable(feature = "rust1", since = "1.0.0")]
19011917
impl<'a> From<&'a str> for Vec<u8> {
19021918
fn from(s: &'a str) -> Vec<u8> {

‎src/libstd/ffi/c_str.rs

+26-7
Original file line numberDiff line numberDiff line change
@@ -304,7 +304,7 @@ impl CString {
304304
}
305305

306306
/// Converts this `CString` into a boxed `CStr`.
307-
#[unstable(feature = "into_boxed_c_str", issue = "0")]
307+
#[unstable(feature = "into_boxed_c_str", issue = "40380")]
308308
pub fn into_boxed_c_str(self) -> Box<CStr> {
309309
unsafe { mem::transmute(self.into_inner()) }
310310
}
@@ -394,6 +394,20 @@ impl<'a> From<&'a CStr> for Box<CStr> {
394394
}
395395
}
396396

397+
#[stable(feature = "c_string_from_box", since = "1.17.0")]
398+
impl From<Box<CStr>> for CString {
399+
fn from(s: Box<CStr>) -> CString {
400+
s.into_c_string()
401+
}
402+
}
403+
404+
#[stable(feature = "box_from_c_string", since = "1.17.0")]
405+
impl Into<Box<CStr>> for CString {
406+
fn into(self) -> Box<CStr> {
407+
self.into_boxed_c_str()
408+
}
409+
}
410+
397411
#[stable(feature = "default_box_extra", since = "1.17.0")]
398412
impl Default for Box<CStr> {
399413
fn default() -> Box<CStr> {
@@ -694,6 +708,12 @@ impl CStr {
694708
pub fn to_string_lossy(&self) -> Cow<str> {
695709
String::from_utf8_lossy(self.to_bytes())
696710
}
711+
712+
/// Converts a `Box<CStr>` into a `CString` without copying or allocating.
713+
#[unstable(feature = "into_boxed_c_str", issue = "40380")]
714+
pub fn into_c_string(self: Box<CStr>) -> CString {
715+
unsafe { mem::transmute(self) }
716+
}
697717
}
698718

699719
#[stable(feature = "rust1", since = "1.0.0")]
@@ -888,12 +908,11 @@ mod tests {
888908
fn into_boxed() {
889909
let orig: &[u8] = b"Hello, world!\0";
890910
let cstr = CStr::from_bytes_with_nul(orig).unwrap();
891-
let cstring = cstr.to_owned();
892-
let box1: Box<CStr> = Box::from(cstr);
893-
let box2 = cstring.into_boxed_c_str();
894-
assert_eq!(cstr, &*box1);
895-
assert_eq!(box1, box2);
896-
assert_eq!(&*box2, cstr);
911+
let boxed: Box<CStr> = Box::from(cstr);
912+
let cstring = cstr.to_owned().into_boxed_c_str().into_c_string();
913+
assert_eq!(cstr, &*boxed);
914+
assert_eq!(&*boxed, &*cstring);
915+
assert_eq!(&*cstring, cstr);
897916
}
898917

899918
#[test]

‎src/libstd/ffi/os_str.rs

+27-7
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ impl OsString {
206206
}
207207

208208
/// Converts this `OsString` into a boxed `OsStr`.
209-
#[unstable(feature = "into_boxed_os_str", issue = "0")]
209+
#[unstable(feature = "into_boxed_os_str", issue = "40380")]
210210
pub fn into_boxed_os_str(self) -> Box<OsStr> {
211211
unsafe { mem::transmute(self.inner.into_box()) }
212212
}
@@ -442,6 +442,13 @@ impl OsStr {
442442
self.inner.inner.len()
443443
}
444444

445+
/// Converts a `Box<OsStr>` into an `OsString` without copying or allocating.
446+
#[unstable(feature = "into_boxed_os_str", issue = "40380")]
447+
pub fn into_os_string(self: Box<OsStr>) -> OsString {
448+
let inner: Box<Slice> = unsafe { mem::transmute(self) };
449+
OsString { inner: Buf::from_box(inner) }
450+
}
451+
445452
/// Gets the underlying byte representation.
446453
///
447454
/// Note: it is *crucial* that this API is private, to avoid
@@ -458,6 +465,20 @@ impl<'a> From<&'a OsStr> for Box<OsStr> {
458465
}
459466
}
460467

468+
#[stable(feature = "os_string_from_box", since = "1.17.0")]
469+
impl<'a> From<Box<OsStr>> for OsString {
470+
fn from(boxed: Box<OsStr>) -> OsString {
471+
boxed.into_os_string()
472+
}
473+
}
474+
475+
#[stable(feature = "box_from_c_string", since = "1.17.0")]
476+
impl Into<Box<OsStr>> for OsString {
477+
fn into(self) -> Box<OsStr> {
478+
self.into_boxed_os_str()
479+
}
480+
}
481+
461482
#[stable(feature = "box_default_extra", since = "1.17.0")]
462483
impl Default for Box<OsStr> {
463484
fn default() -> Box<OsStr> {
@@ -766,12 +787,11 @@ mod tests {
766787
fn into_boxed() {
767788
let orig = "Hello, world!";
768789
let os_str = OsStr::new(orig);
769-
let os_string = os_str.to_owned();
770-
let box1: Box<OsStr> = Box::from(os_str);
771-
let box2 = os_string.into_boxed_os_str();
772-
assert_eq!(os_str, &*box1);
773-
assert_eq!(box1, box2);
774-
assert_eq!(&*box2, os_str);
790+
let boxed: Box<OsStr> = Box::from(os_str);
791+
let os_string = os_str.to_owned().into_boxed_os_str().into_os_string();
792+
assert_eq!(os_str, &*boxed);
793+
assert_eq!(&*boxed, &*os_string);
794+
assert_eq!(&*os_string, os_str);
775795
}
776796

777797
#[test]

‎src/libstd/path.rs

+27-7
Original file line numberDiff line numberDiff line change
@@ -1196,7 +1196,7 @@ impl PathBuf {
11961196
}
11971197

11981198
/// Converts this `PathBuf` into a boxed `Path`.
1199-
#[unstable(feature = "into_boxed_path", issue = "0")]
1199+
#[unstable(feature = "into_boxed_path", issue = "40380")]
12001200
pub fn into_boxed_path(self) -> Box<Path> {
12011201
unsafe { mem::transmute(self.inner.into_boxed_os_str()) }
12021202
}
@@ -1210,6 +1210,20 @@ impl<'a> From<&'a Path> for Box<Path> {
12101210
}
12111211
}
12121212

1213+
#[stable(feature = "path_buf_from_box", since = "1.17.0")]
1214+
impl<'a> From<Box<Path>> for PathBuf {
1215+
fn from(boxed: Box<Path>) -> PathBuf {
1216+
boxed.into_path_buf()
1217+
}
1218+
}
1219+
1220+
#[stable(feature = "box_from_path_buf", since = "1.17.0")]
1221+
impl Into<Box<Path>> for PathBuf {
1222+
fn into(self) -> Box<Path> {
1223+
self.into_boxed_path()
1224+
}
1225+
}
1226+
12131227
#[stable(feature = "box_default_extra", since = "1.17.0")]
12141228
impl Default for Box<Path> {
12151229
fn default() -> Box<Path> {
@@ -2089,6 +2103,13 @@ impl Path {
20892103
pub fn is_dir(&self) -> bool {
20902104
fs::metadata(self).map(|m| m.is_dir()).unwrap_or(false)
20912105
}
2106+
2107+
/// Converts a `Box<Path>` into a `PathBuf` without copying or allocating.
2108+
#[unstable(feature = "into_boxed_path", issue = "40380")]
2109+
pub fn into_path_buf(self: Box<Path>) -> PathBuf {
2110+
let inner: Box<OsStr> = unsafe { mem::transmute(self) };
2111+
PathBuf { inner: OsString::from(inner) }
2112+
}
20922113
}
20932114

20942115
#[stable(feature = "rust1", since = "1.0.0")]
@@ -3703,12 +3724,11 @@ mod tests {
37033724
fn into_boxed() {
37043725
let orig: &str = "some/sort/of/path";
37053726
let path = Path::new(orig);
3706-
let path_buf = path.to_owned();
3707-
let box1: Box<Path> = Box::from(path);
3708-
let box2 = path_buf.into_boxed_path();
3709-
assert_eq!(path, &*box1);
3710-
assert_eq!(box1, box2);
3711-
assert_eq!(&*box2, path);
3727+
let boxed: Box<Path> = Box::from(path);
3728+
let path_buf = path.to_owned().into_boxed_path().into_path_buf();
3729+
assert_eq!(path, &*boxed);
3730+
assert_eq!(&*boxed, &*path_buf);
3731+
assert_eq!(&*path_buf, path);
37123732
}
37133733

37143734
#[test]

‎src/libstd/sys/redox/os_str.rs

+6
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,12 @@ impl Buf {
9999
pub fn into_box(self) -> Box<Slice> {
100100
unsafe { mem::transmute(self.inner.into_boxed_slice()) }
101101
}
102+
103+
#[inline]
104+
pub fn from_box(boxed: Box<Slice>) -> Buf {
105+
let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
106+
Buf { inner: inner.into_vec() }
107+
}
102108
}
103109

104110
impl Slice {

‎src/libstd/sys/unix/os_str.rs

+6
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,12 @@ impl Buf {
9999
pub fn into_box(self) -> Box<Slice> {
100100
unsafe { mem::transmute(self.inner.into_boxed_slice()) }
101101
}
102+
103+
#[inline]
104+
pub fn from_box(boxed: Box<Slice>) -> Buf {
105+
let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
106+
Buf { inner: inner.into_vec() }
107+
}
102108
}
103109

104110
impl Slice {

‎src/libstd/sys/windows/os_str.rs

+6
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,12 @@ impl Buf {
9393
pub fn into_box(self) -> Box<Slice> {
9494
unsafe { mem::transmute(self.inner.into_box()) }
9595
}
96+
97+
#[inline]
98+
pub fn from_box(boxed: Box<Slice>) -> Buf {
99+
let inner: Box<Wtf8> = unsafe { mem::transmute(boxed) };
100+
Buf { inner: Wtf8Buf::from_box(inner) }
101+
}
96102
}
97103

98104
impl Slice {

‎src/libstd/sys_common/wtf8.rs

+6
Original file line numberDiff line numberDiff line change
@@ -346,6 +346,12 @@ impl Wtf8Buf {
346346
pub fn into_box(self) -> Box<Wtf8> {
347347
unsafe { mem::transmute(self.bytes.into_boxed_slice()) }
348348
}
349+
350+
/// Converts a `Box<Wtf8>` into a `Wtf8Buf`.
351+
pub fn from_box(boxed: Box<Wtf8>) -> Wtf8Buf {
352+
let bytes: Box<[u8]> = unsafe { mem::transmute(boxed) };
353+
Wtf8Buf { bytes: bytes.into_vec() }
354+
}
349355
}
350356

351357
/// Create a new WTF-8 string from an iterator of code points.

0 commit comments

Comments
 (0)