ugly_smart_lib 0.1.1

//! src/smart_pub.rs
//!
//! `smart_pub` 是一个公共文件
//!
//! 它包含以下结构。
//! - 一些公共声明

/// 使用 Lazy_static 来创建一个线程安全的单例  
use lazy_static::lazy_static;

/// 返回标准库错误
pub type StdResult<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;

/// 共享指针
pub type StdArc<T> = std::sync::Arc<T>;
/// 共享指针
pub type StdBox<T> = std::boxed::Box<T>;
/// 锁 互斥量
pub type StdMutex<T> = std::sync::Mutex<T>;
/// 条件变量
pub type StdCond = std::sync::Condvar;
/// 共享锁
pub type ArcMutex<T> = StdArc<StdMutex<T>>;
/// 读写锁
pub type StdLock<T> = std::sync::RwLock<T>;

/// tokio锁
pub type TokiokMutex<T> = tokio::sync::Mutex<T>;
/// 标准库时间段
pub type StdDuration = std::time::Duration;
/// tokio库时间段
pub type TokioDuration = tokio::time::Duration;

/// 多生产者，单消费者，同步数据 `Sender`
pub type MpscSyncSender<T> = tokio::sync::mpsc::Sender<T>;
/// 多生产者，单消费者，同步数据 `Receiver`
pub type MpscSyncReceiver<T> = tokio::sync::mpsc::Receiver<T>;
/// 多生产者，单消费者，异步数据 `Sender`
pub type MpscAsyncSender<T> = tokio::sync::mpsc::UnboundedSender<T>;
/// 多生产者，单消费者，异步数据 `Receiver`
pub type MpscAsyncReceiver<T> = tokio::sync::mpsc::UnboundedReceiver<T>;

/// 单生产者，多消费者 `Sender`
/// watch channel 是一种可以发送多次消息的 channel。它的特点是可以有多个接收端，每个接收端都可以接收到发送端发送的最新消息。
/// watch channel 适用于以下场景：
/// 1. 线程之间需要传递多次消息。
/// 2. 线程之间需要订阅最新消息。
///
/// watch channel 的业务特点如下：
/// 1. 可以发送多次消息，适用于需要多次传递消息的场景。
/// 2. 可以有多个接收端，适用于需要订阅最新消息的场景。
/// 3. 发送和接收操作都是非阻塞的，可以提高程序的并发性能。
///
/// 缺点包括：
/// 1. 无法保证消息的顺序性。
/// 2. 需要额外的处理逻辑来处理多个接收端的情况。
pub type WatchSender<T> = tokio::sync::watch::Sender<T>;
/// 单生产者，多消费者 `Receiver`
pub type WatchReceiver<T> = tokio::sync::watch::Receiver<T>;

/// 单生产者，单消费者 `Sender`
/// oneshot channel 是一种只能发送一次消息的 channel。它的特点是发送端只能发送一次消息，接收端只能接收一次消息。一旦消息被发送或接收，channel 就会被关闭。
///
/// oneshot channel 适用于以下场景：
/// 1. 线程之间需要传递一次性的消息。
/// 2. 线程之间需要传递一个返回值。
/// 3. 线程之间需要传递一个事件通知。
///
/// oneshot channel 的业务特点如下：
/// 1. 只能发送一次消息，保证了消息的唯一性。
/// 2. 只能接收一次消息，保证了消息的完整性。
/// 3. 发送和接收操作都是非阻塞的，可以提高程序的并发性能。
///
/// oneshot channel 的优点包括：
/// 1. 简单易用，只需要发送和接收消息即可。
/// 2. 安全可靠，保证了消息的唯一性和完整性。
/// 3. 高效性能，发送和接收操作都是非阻塞的。
///
/// 缺点包括：
/// 1. 只能发送一次消息，不适用于需要多次传递消息的场景。
/// 2. 无法处理多个接收端的情况。
pub type OneshotSender<T> = tokio::sync::oneshot::Sender<T>;
/// 单生产者，单消费者 `Receiver`
pub type OneshotReceiver<T> = tokio::sync::oneshot::Receiver<T>;

/// 广播
/// broadcast channel 是一种可以发送多次消息的 channel。它的特点是可以有多个接收端，每个接收端都可以接收到发送端发送的所有消息。
///
/// broadcast channel 适用于以下场景：
/// 1. 线程之间需要传递多次消息。
/// 2. 线程之间需要广播消息。
///
/// broadcast channel 的业务特点如下：
/// 1. 可以发送多次消息，适用于需要多次传递消息的场景。
/// 2. 可以有多个接收端，适用于需要广播消息的场景。
/// 3. 发送和接收操作都是非阻塞的，可以提高程序的并发性能。
///
/// broadcast channel 的优点包括：
/// 1. 可以发送多次消息，适用于需要多次传递消息的场景。
/// 2. 可以有多个接收端，适用于需要广播消息的场景。
/// 3. 高效性能，发送和接收操作都是非阻塞的。
///
/// 缺点包括：
/// 1. 无法保证消息的顺序性。
/// 2. 需要额外的处理逻辑来处理多个接收端的情况。
pub type BroadcastSender<T> = tokio::sync::broadcast::Sender<T>;
pub type BroadcastReceiver<T> = tokio::sync::broadcast::Receiver<T>;

/// 单生产者，多消费者
pub struct SWatchChannel<T>(WatchSender<T>, WatchReceiver<T>);

impl<T> SWatchChannel<T> {
    fn new(int: T) -> Self {
        let (tx, rx) = tokio::sync::watch::channel(int);
        SWatchChannel(tx, rx)
    }

    pub fn sender_ref(&self) -> &WatchSender<T> {
        &self.0
    }

    pub fn receiver_ref(&self) -> &WatchReceiver<T> {
        &self.1
    }

    pub fn receiver_inner(&self) -> WatchReceiver<T> {
        self.1.clone()
    }

    pub fn send(&self, value: T) {
        let _ = self.0.send(value);
    }
}

lazy_static! {
    pub static ref WATCH_CHANNEL_INSTANCE: SWatchChannel<bool> = SWatchChannel::new(false);
}