Struct PCWSTRGuard 

pub struct PCWSTRGuard { /* private fields */ }

Prevents Self from being dropped before the finish of a FFI call.

Implementations

impl PCWSTRGuard

pub fn new(string: U16CString) -> Self

pub unsafe fn as_ptr(&self) -> PCWSTR

Safety

You must ensure that the PCWSTRGuard outlives any usage of the pointer.

pub fn as_wide(&self) -> &[u16]

Methods from Deref<Target = U16CString>

pub const NUL_TERMINATOR: u16 = 0u16

pub fn as_ucstr(&self) -> &U16CStr

Converts to a wide C string slice.

Methods from Deref<Target = U16CStr>

pub const NUL_TERMINATOR: u16 = 0u16

pub fn to_ucstring(&self) -> U16CString

Copies the string reference to a new owned wide C string.

pub fn to_ustring(&self) -> U16String

Copies the string reference to a new owned wide string.

The resulting wide string will not have a nul terminator.

Examples

use widestring::U16CString;
let wcstr = U16CString::from_str("MyString").unwrap();
// Convert U16CString to a U16String
let wstr = wcstr.to_ustring();

// U16CString will have a terminating nul
let wcvec = wcstr.into_vec_with_nul();
assert_eq!(wcvec[wcvec.len()-1], 0);
// The resulting U16String will not have the terminating nul
let wvec = wstr.into_vec();
assert_ne!(wvec[wvec.len()-1], 0);

pub fn as_slice(&self) -> &[u16]

Converts to a slice of the underlying elements.

The slice will not include the nul terminator.

pub unsafe fn as_mut_slice(&mut self) -> &mut [u16]

Converts to a mutable slice of the underlying elements.

The slice will not include the nul terminator.

Safety

This method is unsafe because you can violate the invariants of this type when mutating the slice (i.e. by adding interior nul values).

pub fn as_slice_with_nul(&self) -> &[u16]

Converts to a slice of the underlying elements, including the nul terminator.

pub fn as_ptr(&self) -> *const u16

Returns a raw pointer to the string.

The caller must ensure that the string outlives the pointer this function returns, or else it will end up pointing to garbage.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the string, use as_mut_ptr.

Modifying the container referenced by this string may cause its buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_mut_ptr(&mut self) -> *mut u16

Returns a mutable raw pointer to the string.

The caller must ensure that the string outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this string may cause its buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_ptr_range(&self) -> Range<*const u16>

Returns the two raw pointers spanning the string slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

pub fn as_mut_ptr_range(&mut self) -> Range<*mut u16>

Returns the two unsafe mutable pointers spanning the string slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_mut_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

pub fn len(&self) -> usize

Returns the length of the string as number of elements (not number of bytes) not including nul terminator.

pub fn is_empty(&self) -> bool

Returns whether this string contains no data (i.e. is only the nul terminator).

pub fn as_ustr(&self) -> &U16Str

Returns a wide string slice to this wide C string slice.

The wide string slice will not include the nul-terminator.

pub fn as_ustr_with_nul(&self) -> &U16Str

Returns a wide string slice to this wide C string slice.

The wide string slice will include the nul-terminator.

pub unsafe fn as_mut_ustr(&mut self) -> &mut U16Str

Returns a mutable wide string slice to this wide C string slice.

The wide string slice will not include the nul-terminator.

Safety

This method is unsafe because you can violate the invariants of this type when mutating the string (i.e. by adding interior nul values).

pub fn display(&self) -> Display<'_, U16CStr>

Returns an object that implements Display for printing strings that may contain non-Unicode data.

A wide C string might data of any encoding. This function assumes the string is encoded in UTF-16, and returns a struct implements the Display trait in a way that decoding the string is lossy but no heap allocations are performed, such as by to_string_lossy.

By default, invalid Unicode data is replaced with U+FFFD REPLACEMENT CHARACTER (�). If you wish to simply skip any invalid Uncode data and forego the replacement, you may use the alternate formatting with {:#}.

Examples

Basic usage:

use widestring::U16CStr;

// 𝄞mus<invalid>ic<invalid>
let s = U16CStr::from_slice(&[
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834, 0x0000,
]).unwrap();

assert_eq!(format!("{}", s.display()),
"𝄞mus�ic�"
);

Using alternate formatting style to skip invalid values entirely:

use widestring::U16CStr;

// 𝄞mus<invalid>ic<invalid>
let s = U16CStr::from_slice(&[
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834, 0x0000,
]).unwrap();

assert_eq!(format!("{:#}", s.display()),
"𝄞music"
);

pub fn get<I>(&self, i: I) -> Option<&U16Str>

where I: SliceIndex<[u16], Output = [u16]>,

Returns a subslice of the string.

This is the non-panicking alternative to indexing the string. Returns None whenever equivalent indexing operation would panic.

pub unsafe fn get_mut<I>(&mut self, i: I) -> Option<&mut U16Str>

where I: SliceIndex<[u16], Output = [u16]>,

Returns a mutable subslice of the string.

This is the non-panicking alternative to indexing the string. Returns None whenever equivalent indexing operation would panic.

Safety

This method is unsafe because you can violate the invariants of this type when mutating the memory the pointer points to (i.e. by adding interior nul values).

pub unsafe fn get_unchecked<I>(&self, i: I) -> &U16Str

where I: SliceIndex<[u16], Output = [u16]>,

Returns an unchecked subslice of the string.

This is the unchecked alternative to indexing the string.

Safety

Callers of this function are responsible that these preconditions are satisfied:

• The starting index must not exceed the ending index;
• Indexes must be within bounds of the original slice.

Failing that, the returned string slice may reference invalid memory.

pub unsafe fn get_unchecked_mut<I>(&mut self, i: I) -> &mut U16Str

where I: SliceIndex<[u16], Output = [u16]>,

Returns aa mutable, unchecked subslice of the string.

This is the unchecked alternative to indexing the string.

Safety

Callers of this function are responsible that these preconditions are satisfied:

• The starting index must not exceed the ending index;
• Indexes must be within bounds of the original slice.

Failing that, the returned string slice may reference invalid memory.

This method is unsafe because you can violate the invariants of this type when mutating the memory the pointer points to (i.e. by adding interior nul values).

pub fn split_at(&self, mid: usize) -> (&U16Str, &U16Str)

Divide one string slice into two at an index.

The argument, mid, should be an offset from the start of the string.

The two slices returned go from the start of the string slice to mid, and from mid to the end of the string slice.

To get mutable string slices instead, see the split_at_mut method.

pub unsafe fn split_at_mut(&mut self, mid: usize) -> (&mut U16Str, &mut U16Str)

Divide one mutable string slice into two at an index.

The argument, mid, should be an offset from the start of the string.

The two slices returned go from the start of the string slice to mid, and from mid to the end of the string slice.

To get immutable string slices instead, see the split_at method.

Safety

This method is unsafe because you can violate the invariants of this type when mutating the memory the pointer points to (i.e. by adding interior nul values).

pub fn repeat(&self, n: usize) -> U16CString

Creates a new owned string by repeating this string n times.

Panics

This function will panic if the capacity would overflow.

pub fn to_os_string(&self) -> OsString

Copys a string to an owned OsString.

This makes a string copy of the U16CStr. Since U16CStr makes no guarantees that it is valid UTF-16, there is no guarantee that the resulting OsString will be valid data. The OsString will not have a nul terminator.

Note that the encoding of OsString is platform-dependent, so on some platforms this may make an encoding conversions, while on other platforms (such as windows) no changes to the string will be made.

Examples

use widestring::U16CString;
use std::ffi::OsString;
let s = "MyString";
// Create a wide string from the string
let wstr = U16CString::from_str(s).unwrap();
// Create an OsString from the wide string
let osstr = wstr.to_os_string();

assert_eq!(osstr, OsString::from(s));

pub fn to_string(&self) -> Result<String, Utf16Error>

Copies the string to a String if it contains valid UTF-16 data.

This method assumes this string is encoded as UTF-16 and attempts to decode it as such. It will *not have a nul terminator.

Errors

Returns an error if the string contains any invalid UTF-16 data.

Examples

use widestring::U16CString;
let s = "MyString";
// Create a wide string from the string
let wstr = U16CString::from_str(s).unwrap();
// Create a regular string from the wide string
let s2 = wstr.to_string().unwrap();

assert_eq!(s2, s);

pub fn to_string_lossy(&self) -> String

Decodes the string reference to a String even if it is invalid UTF-16 data.

This method assumes this string is encoded as UTF-16 and attempts to decode it as such. Any invalid sequences are replaced with U+FFFD REPLACEMENT CHARACTER, which looks like this: �. It will *not have a nul terminator.

Examples

use widestring::U16CString;
let s = "MyString";
// Create a wide string from the string
let wstr = U16CString::from_str(s).unwrap();
// Create a regular string from the wide string
let s2 = wstr.to_string_lossy();

assert_eq!(s2, s);

pub fn chars(&self) -> CharsUtf16<'_>

Returns an iterator over the chars of a string slice.

As this string has no defined encoding, this method assumes the string is UTF-16. Since it may consist of invalid UTF-16, the iterator returned by this method is an iterator over Result<char, DecodeUtf16Error> instead of chars directly. If you would like a lossy iterator over charss directly, instead use chars_lossy.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

pub fn chars_lossy(&self) -> CharsLossyUtf16<'_>

Returns a lossy iterator over the chars of a string slice.

As this string has no defined encoding, this method assumes the string is UTF-16. Since it may consist of invalid UTF-16, the iterator returned by this method will replace unpaired surrogates with U+FFFD REPLACEMENT CHARACTER (�). This is a lossy version of chars.

It’s important to remember that char represents a Unicode Scalar Value, and may not match your idea of what a ‘character’ is. Iteration over grapheme clusters may be what you actually want. That functionality is not provided by by this crate.

pub fn char_indices(&self) -> CharIndicesUtf16<'_>

Returns an iterator over the chars of a string slice, and their positions.

As this string has no defined encoding, this method assumes the string is UTF-16. Since it may consist of invalid UTF-16, the iterator returned by this method is an iterator over is an iterator over Result<char, DecodeUtf16Error> as well as their positions, instead of chars directly. If you would like a lossy indices iterator over charss directly, instead use char_indices_lossy.

The iterator yields tuples. The position is first, the char is second.

pub fn char_indices_lossy(&self) -> CharIndicesLossyUtf16<'_>

Returns a lossy iterator over the chars of a string slice, and their positions.

As this string slice may consist of invalid UTF-16, the iterator returned by this method will replace unpaired surrogates with U+FFFD REPLACEMENT CHARACTER (�), as well as the positions of all characters. This is a lossy version of char_indices.

The iterator yields tuples. The position is first, the char is second.

Trait Implementations

impl AsRef<PCWSTRGuard> for PCWSTRGuard

Included for postfix .as_ref() convenience.

fn as_ref(&self) -> &PCWSTRGuard

Converts this type into a shared reference of the (usually inferred) input type.

impl Deref for PCWSTRGuard

type Target = U16CString

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Param<PCWSTR> for &PCWSTRGuard

MUST NOT implement this for PCWSTRGuard itself, only for &PCWSTRGuard, to ensure the data the PCWSTR points to is valid for the lifetime of the parameter.