diff options
Diffstat (limited to 'vendor/io-lifetimes/examples/hello.rs')
-rw-r--r-- | vendor/io-lifetimes/examples/hello.rs | 129 |
1 files changed, 129 insertions, 0 deletions
diff --git a/vendor/io-lifetimes/examples/hello.rs b/vendor/io-lifetimes/examples/hello.rs new file mode 100644 index 000000000..4f6b1a4ed --- /dev/null +++ b/vendor/io-lifetimes/examples/hello.rs @@ -0,0 +1,129 @@ +//! A simple testcase that prints a few messages to the console, demonstrating +//! the io-lifetimes API. + +#![cfg_attr(not(rustc_attrs), allow(unused_imports))] +#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] + +#[cfg(feature = "close")] +use io_lifetimes::example_ffi::*; +#[cfg(feature = "close")] +use std::{ + fs::File, + io::{self, Write}, +}; + +#[cfg(all(unix, feature = "close"))] +use io_lifetimes::{AsFd, FromFd, OwnedFd}; + +#[cfg(windows)] +use io_lifetimes::{AsHandle, FromHandle, OwnedHandle}; +#[cfg(windows)] +use std::{convert::TryInto, os::windows::io::RawHandle, ptr::null_mut}; + +#[cfg(all(rustc_attrs, unix, feature = "close"))] +fn main() -> io::Result<()> { + let fd = unsafe { + // Open a file, which returns an `Option<OwnedFd>`, which we can + // maybe convert into an `OwnedFile`. + let fd: OwnedFd = open("/dev/stdout\0".as_ptr() as *const _, O_WRONLY | O_CLOEXEC) + .ok_or_else(io::Error::last_os_error)?; + + // Borrow the fd to write to it. + let result = write(fd.as_fd(), "hello, world\n".as_ptr() as *const _, 13); + match result { + -1 => return Err(io::Error::last_os_error()), + 13 => (), + _ => return Err(io::Error::new(io::ErrorKind::Other, "short write")), + } + + fd + }; + + // Convert into a `File`. No `unsafe` here! + let mut file = File::from_fd(fd); + writeln!(&mut file, "greetings, y'all")?; + + // We can borrow a `BorrowedFd` from a `File`. + unsafe { + let result = write(file.as_fd(), "sup?\n".as_ptr() as *const _, 5); + match result { + -1 => return Err(io::Error::last_os_error()), + 5 => (), + _ => return Err(io::Error::new(io::ErrorKind::Other, "short write")), + } + } + + // `OwnedFd` closes the fd in its `Drop` implementation. + + Ok(()) +} + +/// The Windows analog of the above. +#[cfg(all(windows, feature = "close"))] +fn main() -> io::Result<()> { + let handle = unsafe { + // Open a file, which returns an `HandleOrInvalid`, which we can fallibly + // convert into an `OwnedFile`. + let handle: OwnedHandle = CreateFileW( + ['C' as u16, 'O' as _, 'N' as _, 0].as_ptr(), + FILE_GENERIC_WRITE, + 0, + null_mut(), + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + null_mut() as RawHandle as HANDLE, + ) + .try_into() + .map_err(|_err| io::Error::last_os_error())?; + + // Borrow the handle to write to it. + let mut number_of_bytes_written = 0; + let result = WriteFile( + handle.as_handle(), + "hello, world\n".as_ptr() as *const _, + 13, + &mut number_of_bytes_written, + null_mut(), + ); + match (result, number_of_bytes_written) { + (0, _) => return Err(io::Error::last_os_error()), + (_, 13) => (), + (_, _) => return Err(io::Error::new(io::ErrorKind::Other, "short write")), + } + + handle + }; + + // Convert into a `File`. No `unsafe` here! + let mut file = File::from_handle(handle); + writeln!(&mut file, "greetings, y'all")?; + + // We can borrow a `BorrowedHandle` from a `File`. + unsafe { + let mut number_of_bytes_written = 0; + let result = WriteFile( + file.as_handle(), + "sup?\n".as_ptr() as *const _, + 5, + &mut number_of_bytes_written, + null_mut(), + ); + match (result, number_of_bytes_written) { + (0, _) => return Err(io::Error::last_os_error()), + (_, 5) => (), + (_, _) => return Err(io::Error::new(io::ErrorKind::Other, "short write")), + } + } + + // `OwnedHandle` closes the handle in its `Drop` implementation. + + Ok(()) +} + +#[cfg(all( + not(all(rustc_attrs, unix, feature = "close")), + not(all(windows, feature = "close")) +))] +fn main() { + println!("On Unix, this example requires Rust nightly (for `rustc_attrs`) and the \"close\" feature."); +} |