#[derive(Clone, Debug)]

    pub fn new() -> Self {

        let (sender, receiver) = watch::channel(ShutdownState::Running);

        Self {

            sender,

            receiver: Mutex::new(Some(receiver)),

        }

    }

    pub async fn watcher(&self) -> Option<ShutdownStateWatcher> {

        let receiver = fast_async_lock!(self.receiver);

        receiver

            .clone()

            .map(|receiver| ShutdownStateWatcher { receiver })

    }

    async fn stop_watching(&self) {

        let mut receiver = fast_async_lock!(self.receiver);

        *receiver = None;

    }

    pub async fn graceful_shutdown(&self, timeout: Duration) {

        self.stop_watching().await;

        if self.sender.send(ShutdownState::GracefulShutdown).is_ok() {

            let timeout = tokio::time::sleep_until(Instant::now() + timeout);

            if !tokio::select! {

                _ = self.sender.closed() => true,

                _ = timeout => false,

            } {

            }

    }

    pub async fn shutdown(&self) {

        self.stop_watching().await;

        drop(self.sender.send(ShutdownState::Shutdown));

    }

    pub async fn wait_for_shutdown(&mut self) -> ShutdownState {

        if self.receiver.changed().await.is_ok() {

            self.receiver.borrow().clone()

    }