#[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()

            && tokio::time::timeout(timeout, self.sender.closed())

                .await

                .is_err()

        }

    }

    pub async fn shutdown(&self) {

        self.stop_watching().await;

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

    }

    pub fn should_shutdown(&self) -> bool {

        matches!(&*self.sender.borrow(), ShutdownState::Shutdown)

    }

#[derive(Clone)]

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

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

            self.receiver.borrow().clone()

    }