Added conversions between HSTRING and OsStr/OsString

crates/libs/windows/src/core/hstring.rs

@@ -48,6 +48,11 @@ impl HSTRING {
         alloc::string::String::from_utf16_lossy(self.as_wide())
     }
 
+    /// Get the contents of this `HSTRING` as a OsString.
+    pub fn to_os_string(&self) -> std::ffi::OsString {
+        std::os::windows::ffi::OsStringExt::from_wide(self.as_wide())
+    }
+
     /// Clear the contents of the string and free the memory if `self` holds the
     /// last reference to the string data.
     pub fn clear(&mut self) {
@@ -164,6 +169,24 @@ impl core::convert::From<&alloc::string::String> for HSTRING {
     }
 }
 
+impl core::convert::From<&std::ffi::OsStr> for HSTRING {
+    fn from(value: &std::ffi::OsStr) -> Self {
+        unsafe { Self::from_wide_iter(std::os::windows::ffi::OsStrExt::encode_wide(value), value.len() as u32) }
+    }
+}
+
+impl core::convert::From<std::ffi::OsString> for HSTRING {
+    fn from(value: std::ffi::OsString) -> Self {
+        value.as_os_str().into()
+    }
+}
+
+impl core::convert::From<&std::ffi::OsString> for HSTRING {
+    fn from(value: &std::ffi::OsString) -> Self {
+        value.as_os_str().into()
+    }
+}
+
 impl PartialEq for HSTRING {
     fn eq(&self, other: &Self) -> bool {
         *self.as_wide() == *other.as_wide()
@@ -242,6 +265,78 @@ impl PartialEq<&HSTRING> for alloc::string::String {
     }
 }
 
+impl PartialEq<std::ffi::OsString> for HSTRING {
+    fn eq(&self, other: &std::ffi::OsString) -> bool {
+        *self == **other
+    }
+}
+
+impl PartialEq<std::ffi::OsString> for &HSTRING {
+    fn eq(&self, other: &std::ffi::OsString) -> bool {
+        **self == **other
+    }
+}
+
+impl PartialEq<&std::ffi::OsString> for HSTRING {
+    fn eq(&self, other: &&std::ffi::OsString) -> bool {
+        *self == ***other
+    }
+}
+
+impl PartialEq<std::ffi::OsStr> for HSTRING {
+    fn eq(&self, other: &std::ffi::OsStr) -> bool {
+        self.as_wide().iter().copied().eq(std::os::windows::ffi::OsStrExt::encode_wide(other))
+    }
+}
+
+impl PartialEq<std::ffi::OsStr> for &HSTRING {
+    fn eq(&self, other: &std::ffi::OsStr) -> bool {
+        **self == *other
+    }
+}
+
+impl PartialEq<&std::ffi::OsStr> for HSTRING {
+    fn eq(&self, other: &&std::ffi::OsStr) -> bool {
+        *self == **other
+    }
+}
+
+impl PartialEq<HSTRING> for std::ffi::OsStr {
+    fn eq(&self, other: &HSTRING) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialEq<HSTRING> for &std::ffi::OsStr {
+    fn eq(&self, other: &HSTRING) -> bool {
+        *other == **self
+    }
+}
+
+impl PartialEq<&HSTRING> for std::ffi::OsStr {
+    fn eq(&self, other: &&HSTRING) -> bool {
+        **other == *self
+    }
+}
+
+impl PartialEq<HSTRING> for std::ffi::OsString {
+    fn eq(&self, other: &HSTRING) -> bool {
+        *other == **self
+    }
+}
+
+impl PartialEq<HSTRING> for &std::ffi::OsString {
+    fn eq(&self, other: &HSTRING) -> bool {
+        *other == ***self
+    }
+}
+
+impl PartialEq<&HSTRING> for std::ffi::OsString {
+    fn eq(&self, other: &&HSTRING) -> bool {
+        **other == **self
+    }
+}
+
 impl<'a> core::convert::TryFrom<&'a HSTRING> for alloc::string::String {
     type Error = alloc::string::FromUtf16Error;
 
@@ -258,6 +353,18 @@ impl core::convert::TryFrom<HSTRING> for alloc::string::String {
     }
 }
 
+impl<'a> core::convert::From<&'a HSTRING> for std::ffi::OsString {
+    fn from(hstring: &HSTRING) -> Self {
+        hstring.to_os_string()
+    }
+}
+
+impl core::convert::From<HSTRING> for std::ffi::OsString {
+    fn from(hstring: HSTRING) -> Self {
+        Self::from(&hstring)
+    }
+}
+
 #[cfg(feature = "alloc")]
 impl<'a> IntoParam<'a, HSTRING> for &str {
     fn into_param(self) -> Param<'a, HSTRING> {
@@ -272,6 +379,20 @@ impl<'a> IntoParam<'a, HSTRING> for alloc::string::String {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl<'a> IntoParam<'a, HSTRING> for &std::ffi::OsStr {
+    fn into_param(self) -> Param<'a, HSTRING> {
+        Param::Owned(self.into())
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> IntoParam<'a, HSTRING> for std::ffi::OsString {
+    fn into_param(self) -> Param<'a, HSTRING> {
+        Param::Owned(self.into())
+    }
+}
+
 const REFERENCE_FLAG: u32 = 1;
 
 #[repr(C)]

crates/tests/core/tests/hstrings.rs

@@ -53,6 +53,16 @@ fn from_empty_string() {
     assert!(format!("{}", h).is_empty());
 }
 
+#[test]
+fn from_os_string_string() {
+    let wide_data = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
+    use std::os::windows::prelude::OsStringExt;
+    let o = std::ffi::OsString::from_wide(wide_data);
+    let h = StringType::from(o);
+    let d = StringType::from_wide(wide_data);
+    assert_eq!(h, d);
+}
+
 #[test]
 fn hstring_to_string() {
     let h = StringType::from("test");
@@ -78,6 +88,16 @@ fn hstring_to_string_lossy() {
     assert_eq!(s, "𝄞mu�ic");
 }
 
+#[test]
+fn hstring_to_os_string() {
+    // 𝄞mu<invalid>ic
+    let wide_data = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
+    let h = StringType::from_wide(wide_data);
+    let s = h.to_os_string();
+    use std::os::windows::prelude::OsStringExt;
+    assert_eq!(s, std::ffi::OsString::from_wide(wide_data));
+}
+
 #[test]
 fn hstring_equality_combinations() {
     let h = StringType::from("test");
@@ -104,3 +124,32 @@ fn hstring_equality_combinations() {
     assert_eq!(ss, h);
     assert_eq!(ss, &h);
 }
+
+#[test]
+fn hstring_osstring_equality_combinations() {
+    let wide_data = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0xD800, 0x0069, 0x0063];
+    let h = StringType::from_wide(wide_data);
+    use std::os::windows::prelude::OsStringExt;
+    let s = std::ffi::OsString::from_wide(wide_data);
+    let ss = s.as_os_str();
+
+    assert_eq!(h, s);
+    assert_eq!(&h, s);
+    assert_eq!(h, &s);
+    assert_eq!(&h, &s);
+
+    assert_eq!(s, h);
+    assert_eq!(s, &h);
+    assert_eq!(&s, h);
+    assert_eq!(&s, &h);
+
+    assert_eq!(h, *ss);
+    assert_eq!(&h, *ss);
+    assert_eq!(h, ss);
+    assert_eq!(&h, ss);
+
+    assert_eq!(*ss, h);
+    assert_eq!(*ss, &h);
+    assert_eq!(ss, h);
+    assert_eq!(ss, &h);
+}