use std::{
io::{BufRead, IsTerminal},
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
pub fn interactive() -> bool {
std::io::stdin().is_terminal()
}
struct Withdraw(Arc<AtomicBool>);
impl Drop for Withdraw {
fn drop(&mut self) {
self.0.store(true, Ordering::Relaxed);
}
}
pub async fn read_line() -> Option<String> {
let stop = Arc::new(AtomicBool::new(false));
let _withdraw = Withdraw(stop.clone());
tokio::task::spawn_blocking(move || read_line_until(&stop))
.await
.ok()
.flatten()
}
fn read_one() -> Option<String> {
let mut line = String::new();
match std::io::stdin().lock().read_line(&mut line) {
Ok(0) | Err(_) => None,
Ok(_) => Some(line),
}
}
#[cfg(unix)]
fn read_line_until(stop: &AtomicBool) -> Option<String> {
let mut fd = libc::pollfd {
fd: libc::STDIN_FILENO,
events: libc::POLLIN,
revents: 0,
};
while !stop.load(Ordering::Relaxed) {
let ready = unsafe { libc::poll(&mut fd, 1, 100) };
if ready > 0 {
return read_one();
}
let interrupted = std::io::Error::last_os_error().kind() == std::io::ErrorKind::Interrupted;
if ready < 0 && !interrupted {
return None;
}
}
None
}
#[cfg(not(unix))]
fn read_line_until(_stop: &AtomicBool) -> Option<String> {
read_one()
}