Compiler Explorer

Source code

use std::io::{Read, Result};
use std::net::{TcpListener, TcpStream};

/// 模拟 TLS 流（在真实项目中通常来自 `native_tls`、`rustls` 等库）
///
/// - Rust 中可以很容易地为泛型类型手动实现功能；这里我们只需要一个包装器来表现“TLS 层”。
/// - `FakeTlsStream<T>` 持有一个底层流 `T`，用于展示“枚举成员关联不同类型”的能力。
#[derive(Debug)]
struct FakeTlsStream<T>(T);

/// 为 FakeTlsStream 实现 `Read` trait，使其行为与底层流一致。
///
/// Rust 重度依赖 trait 来抽象接口；类似 C++ 的纯虚基类。
/// 这里 `impl<T: Read> Read for FakeTlsStream<T>` 表示：
/**
 *  - 对于任何实现了 `Read` 的类型 `T`，`FakeTlsStream<T>` 也实现 `Read`。
 *  - 因此枚举在匹配其变体时，可以统一调用 `read`。
 */
impl<T: Read> Read for FakeTlsStream<T> {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        // 直接把调用委托给被包装的底层流。
        // 真实的 TLS 实现会在这里进行解密等操作。
        self.0.read(buf)
    }
}

/// 枚举封装不同底层连接：TCP 和 TLS。
///
/// 与 C++ 中使用 `std::variant` 的思路相同，但 Rust 的枚举（`enum`）原生支持模式匹配，
/**
 *   并且每个变体可以携带不同类型的数据。
 *
 * 这里：`Websocket::Tcp` 持有 `TcpStream`，`Websocket::Tls` 持有 `FakeTlsStream<TcpStream>`。
 */
#[derive(Debug)]
enum Websocket {
    Tcp(TcpStream),
    Tls(FakeTlsStream<TcpStream>),
}

impl Websocket {
    /// 示例方法：统一读取一行数据。
    ///
    /// - `&mut self`：在 Rust 中，方法的第一个参数类似 `self`，但你要显式声明借用方式（可变 / 不可变）。
    /// - 通过 `match` 对枚举进行模式匹配，分别处理 TCP/TLS 两种情况，但整体逻辑统一。
    fn read_line(&mut self) -> Result<String> {
        let mut buf = [0_u8; 64]; // 定长缓冲区，演示用途
        let n = match self {
            // `match` 类似 C++17 的 `std::visit`，但更强大且语法简洁。
            Websocket::Tcp(stream) => stream.read(&mut buf)?,
            Websocket::Tls(stream) => stream.read(&mut buf)?,
        };
        Ok(String::from_utf8_lossy(&buf[..n]).to_string())
    }
}

/// 接受原始连接并根据条件包装成统一的枚举类型。
///
/// - 参数 `stream` 的所有权被移动进函数，这是 Rust 的所有权模型：函数结束前它一直归我们所有。
/// - 返回的 `Websocket` 枚举同样拥有底层流的所有权（无需手动 `new` / `delete`）。
fn accept_connection(stream: TcpStream, use_tls: bool) -> Websocket {
    if use_tls {
        let tls_stream = FakeTlsStream(stream);
        Websocket::Tls(tls_stream)
    } else {
        Websocket::Tcp(stream)
    }
}

/// 使用统一逻辑处理任意类型的 WebSocket 连接。
///
/// - 函数参数 `ws` 接受一个枚举值，调用端无需关注它具体是哪种流。
/// - Rust 会在编译期验证所有匹配情况是否覆盖全面，避免遗漏。
fn handle_websocket(mut ws: Websocket) -> Result<()> {
    println!("Incoming connection: {ws:?}");
    let line = ws.read_line()?;
    println!("Received: {line}");
    Ok(())
}

/// 程序入口：监听本地 TCP 端口并模拟处理 TCP/TLS 两种连接。
///
/// - `?` 运算符：若 `Result` 是 `Err`，直接向上传播错误，类似 C++ 中手动检查并返回。
/// - `listener.incoming()` 返回迭代器，每个元素都是一个 `Result<TcpStream>`。
fn main() -> Result<()> {
    // 绑定监听地址；如果失败（例如端口被占用），错误会通过 `?` 返回。
    let listener = TcpListener::bind("127.0.0.1:4000")?;
    println!("Listening on 127.0.0.1:4000");

// 枚举所有进入的连接；`enumerate` 为每个连接附带一个递增编号。
    for (idx, stream) in listener.incoming().enumerate() {
        let stream = stream?; // 处理 `Result`，失败时早返回。
        let use_tls = idx % 2 == 0; // 简单地模拟：偶数序号的连接走 “TLS” 分支。
        let ws = accept_connection(stream, use_tls);
        handle_websocket(ws)?;
    }
    Ok(())
}