使用Rust gzp crate时，如何实现压缩与未压缩输出的无缝写入？

下面给出几种可行的实现模式，解决ParCompress必须调用finish()的接口限制，同时支持可选的未压缩输出：

方案1：枚举封装+自动Drop收尾 #

用枚举统一压缩/未压缩两种Writer类型，实现标准Write trait，并通过Drop trait自动触发ParCompress的finish()，上层代码无需手动处理收尾逻辑。

use gzp::ParCompress;
use std::io::{self, Write};
use std::sync::Arc;

// 统一封装两种输出Writer
enum OutputWriter {
    Gzp(ParCompress<Arc<dyn Write + Send>>),
    Raw(Box<dyn Write + Send>),
}

// 实现Write trait，转发调用到内部Writer
impl Write for OutputWriter {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        match self {
            OutputWriter::Gzp(writer) => writer.write(buf),
            OutputWriter::Raw(writer) => writer.write(buf),
        }
    }

    fn flush(&mut self) -> io::Result<()> {
        match self {
            OutputWriter::Gzp(writer) => writer.flush(),
            OutputWriter::Raw(writer) => writer.flush(),
        }
    }
}

// 实现Drop，自动完成gzp压缩收尾
impl Drop for OutputWriter {
    fn drop(&mut self) {
        if let OutputWriter::Gzp(writer) = self {
            // 可根据需求处理finish的错误，这里忽略
            let _ = writer.finish();
        }
    }
}

使用时只需根据是否需要压缩，创建对应的OutputWriter实例即可，作用域结束时会自动完成压缩收尾，完全兼容标准Write接口的调用方式。

方案2：自定义结构体+手动/自动双模式收尾 #

如果需要手动控制finish()的时机（比如要严格处理收尾错误），可以封装结构体明确管理两种Writer，同时保留自动收尾的选项：

use gzp::ParCompress;
use std::io::{self, Write};
use std::sync::Arc;

struct ManagedWriter {
    inner: InnerWriter,
}

enum InnerWriter {
    Gzp(ParCompress<Arc<dyn Write + Send>>),
    Raw(Box<dyn Write + Send>),
}

impl ManagedWriter {
    // 创建压缩Writer
    pub fn new_gzp(writer: ParCompress<Arc<dyn Write + Send>>) -> Self {
        Self { inner: InnerWriter::Gzp(writer) }
    }

    // 创建未压缩Writer
    pub fn new_raw(writer: Box<dyn Write + Send>) -> Self {
        Self { inner: InnerWriter::Raw(writer) }
    }

    // 手动调用收尾，仅对gzp生效
    pub fn finish(&mut self) -> io::Result<()> {
        match &mut self.inner {
            InnerWriter::Gzp(writer) => writer.finish(),
            InnerWriter::Raw(_) => Ok(()),
        }
    }
}

// 实现Write trait
impl Write for ManagedWriter {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        match &mut self.inner {
            InnerWriter::Gzp(writer) => writer.write(buf),
            InnerWriter::Raw(writer) => writer.write(buf),
        }
    }

    fn flush(&mut self) -> io::Result<()> {
        match &mut self.inner {
            InnerWriter::Gzp(writer) => writer.flush(),
            InnerWriter::Raw(writer) => writer.flush(),
        }
    }
}

// 可选：实现Drop自动收尾，和手动finish二选一或结合使用
impl Drop for ManagedWriter {
    fn drop(&mut self) {
        let _ = self.finish();
    }
}

这种方案兼顾灵活性与安全性：可以选择在合适的时机手动调用finish()处理错误，也可以依赖Drop自动收尾，避免遗漏。

方案3：自定义Trait+动态分发 #

通过自定义Trait扩展标准Write，让两种Writer都能统一到同一个Trait对象下，适合需要动态分发的场景：

use gzp::ParCompress;
use std::io::{self, Write};
use std::sync::Arc;

// 自定义Trait，包含Write和finish方法
trait CompressibleWrite: Write + Send {
    fn finish(&mut self) -> io::Result<()>;
}

// 为ParCompress实现自定义Trait
impl CompressibleWrite for ParCompress<Arc<dyn Write + Send>> {
    fn finish(&mut self) -> io::Result<()> {
        self.finish()
    }
}

// 为普通Write+Send实现自定义Trait，finish空实现
impl<T: Write + Send + ?Sized> CompressibleWrite for Box<T> {
    fn finish(&mut self) -> io::Result<()> {
        Ok(())
    }
}

// 创建统一的Writer实例
fn build_output_writer(compress: bool, output: Box<dyn Write + Send>) -> Box<dyn CompressibleWrite + Send> {
    if compress {
        Box::new(ParCompress::new(output.into()))
    } else {
        output
    }
}

上层代码可以通过Box<dyn CompressibleWrite + Send>统一操作，调用finish()时会自动适配对应的Writer类型，未压缩Writer的finish()不会执行任何操作。

方案选择建议 #

• 优先选方案1：类型安全、实现简单，自动收尾能减少手动出错概率，适合大多数场景；
• 需要手动控制收尾时机或处理错误时选方案2；
• 依赖动态分发的复杂场景选方案3。

内容的提问来源于stack exchange，提问作者DHP