use std::sync::atomic::{AtomicBool, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum HaltReason {
#[default]
None,
ShutdownSignal,
UserRequest,
Timeout,
}
pub struct DownloadControlFlags {
halt_requested: AtomicBool,
force_halt_requested: AtomicBool,
pause_requested: AtomicBool,
force_pause_requested: AtomicBool,
restart_requested: AtomicBool,
close_file_requested: AtomicBool,
save_control_requested: AtomicBool,
remove_control_requested: AtomicBool,
}
impl DownloadControlFlags {
pub fn new() -> Self {
Self {
halt_requested: AtomicBool::new(false),
force_halt_requested: AtomicBool::new(false),
pause_requested: AtomicBool::new(false),
force_pause_requested: AtomicBool::new(false),
restart_requested: AtomicBool::new(false),
close_file_requested: AtomicBool::new(false),
save_control_requested: AtomicBool::new(false),
remove_control_requested: AtomicBool::new(false),
}
}
pub fn request_halt(&self) {
self.halt_requested.store(true, Ordering::Release);
self.pause_requested.store(false, Ordering::Release);
}
pub fn request_force_halt(&self) {
self.halt_requested.store(true, Ordering::Release);
self.force_halt_requested.store(true, Ordering::Release);
self.pause_requested.store(false, Ordering::Release);
}
pub fn is_halt_requested(&self) -> bool {
self.halt_requested.load(Ordering::Acquire)
}
pub fn is_force_halt_requested(&self) -> bool {
self.force_halt_requested.load(Ordering::Acquire)
}
pub fn clear_halt(&self) {
self.halt_requested.store(false, Ordering::Release);
self.force_halt_requested.store(false, Ordering::Release);
}
pub fn request_pause(&self) {
self.pause_requested.store(true, Ordering::Release);
}
pub fn request_force_pause(&self) {
self.pause_requested.store(true, Ordering::Release);
self.force_pause_requested.store(true, Ordering::Release);
}
pub fn is_pause_requested(&self) -> bool {
self.pause_requested.load(Ordering::Acquire)
}
pub fn is_force_pause_requested(&self) -> bool {
self.force_pause_requested.load(Ordering::Acquire)
}
pub fn clear_pause(&self) {
self.pause_requested.store(false, Ordering::Release);
self.force_pause_requested.store(false, Ordering::Release);
}
pub fn request_restart(&self) {
self.restart_requested.store(true, Ordering::Release);
}
pub fn is_restart_requested(&self) -> bool {
self.restart_requested.load(Ordering::Acquire)
}
pub fn clear_restart(&self) {
self.restart_requested.store(false, Ordering::Release);
}
pub fn clear_all(&self) {
self.halt_requested.store(false, Ordering::Release);
self.force_halt_requested.store(false, Ordering::Release);
self.pause_requested.store(false, Ordering::Release);
self.force_pause_requested.store(false, Ordering::Release);
self.restart_requested.store(false, Ordering::Release);
self.close_file_requested.store(false, Ordering::Release);
self.save_control_requested.store(false, Ordering::Release);
self.remove_control_requested
.store(false, Ordering::Release);
}
pub fn any_requested(&self) -> bool {
self.is_halt_requested() || self.is_pause_requested() || self.is_restart_requested()
}
pub fn request_close_file(&self) {
self.close_file_requested.store(true, Ordering::Release);
}
pub fn is_close_file_requested(&self) -> bool {
self.close_file_requested.load(Ordering::Acquire)
}
pub fn clear_close_file(&self) {
self.close_file_requested.store(false, Ordering::Release);
}
pub fn request_save_control(&self) {
self.save_control_requested.store(true, Ordering::Release);
}
pub fn is_save_control_requested(&self) -> bool {
self.save_control_requested.load(Ordering::Acquire)
}
pub fn clear_save_control(&self) {
self.save_control_requested.store(false, Ordering::Release);
}
pub fn request_remove_control(&self) {
self.remove_control_requested.store(true, Ordering::Release);
}
pub fn is_remove_control_requested(&self) -> bool {
self.remove_control_requested.load(Ordering::Acquire)
}
pub fn clear_remove_control(&self) {
self.remove_control_requested
.store(false, Ordering::Release);
}
}
impl Default for DownloadControlFlags {
fn default() -> Self {
Self::new()
}
}
impl std::fmt::Debug for DownloadControlFlags {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DownloadControlFlags")
.field("halt_requested", &self.is_halt_requested())
.field("force_halt_requested", &self.is_force_halt_requested())
.field("pause_requested", &self.is_pause_requested())
.field("force_pause_requested", &self.is_force_pause_requested())
.field("restart_requested", &self.is_restart_requested())
.field("close_file_requested", &self.is_close_file_requested())
.field("save_control_requested", &self.is_save_control_requested())
.field(
"remove_control_requested",
&self.is_remove_control_requested(),
)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_halt_request() {
let flags = DownloadControlFlags::new();
assert!(!flags.is_halt_requested());
assert!(!flags.is_force_halt_requested());
flags.request_halt();
assert!(flags.is_halt_requested());
assert!(!flags.is_force_halt_requested());
flags.clear_halt();
assert!(!flags.is_halt_requested());
}
#[test]
fn test_force_halt_request() {
let flags = DownloadControlFlags::new();
flags.request_force_halt();
assert!(flags.is_halt_requested());
assert!(flags.is_force_halt_requested());
}
#[test]
fn test_halt_clears_pause() {
let flags = DownloadControlFlags::new();
flags.request_pause();
assert!(flags.is_pause_requested());
flags.request_halt();
assert!(!flags.is_pause_requested());
assert!(flags.is_halt_requested());
}
#[test]
fn test_pause_request() {
let flags = DownloadControlFlags::new();
assert!(!flags.is_pause_requested());
flags.request_pause();
assert!(flags.is_pause_requested());
assert!(!flags.is_force_pause_requested());
flags.clear_pause();
assert!(!flags.is_pause_requested());
}
#[test]
fn test_force_pause_request() {
let flags = DownloadControlFlags::new();
flags.request_force_pause();
assert!(flags.is_pause_requested());
assert!(flags.is_force_pause_requested());
}
#[test]
fn test_restart_request() {
let flags = DownloadControlFlags::new();
assert!(!flags.is_restart_requested());
flags.request_restart();
assert!(flags.is_restart_requested());
flags.clear_restart();
assert!(!flags.is_restart_requested());
}
#[test]
fn test_any_requested() {
let flags = DownloadControlFlags::new();
assert!(!flags.any_requested());
flags.request_pause();
assert!(flags.any_requested());
flags.clear_all();
assert!(!flags.any_requested());
}
#[test]
fn test_clear_all() {
let flags = DownloadControlFlags::new();
flags.request_halt();
flags.request_pause();
flags.request_restart();
flags.clear_all();
assert!(!flags.is_halt_requested());
assert!(!flags.is_pause_requested());
assert!(!flags.is_restart_requested());
}
}