Rust 我可以拥有一个既可以从一个片构造又可以从拥有的缓冲区构造的结构吗？

我会尽量说清楚的。让我们假设我有：

struct Foo<'a> {
    buffer: &'a [u8],
}

impl<'a> Foo<'a> {
    fn create_builder() -> FooBuilder {
        FooBuilder::new()
    }

    fn from_slice(slice: &[u8]) -> Foo {
        Foo { buffer: slice }
    }
}

struct FooBuilder {
    in_progress_buffer: Vec<u8>,
}

impl FooBuilder {
    fn new() -> FooBuilder {
        FooBuilder { in_progress_buffer: Vec::new() }
    }

    fn push(&mut self, item: u8) {
        self.in_progress_buffer.push(item);
    }

    fn build_foo(self) -> Foo {
        Foo { buffer: self.in_progress_buffer }
    }
}

fn main() {
    // Option1: Gradually construct Foo from FooBuilder
    let mut foo_builder = FooBuilder::new();
    foo_builder.push(7);
    let foo = foo_builder.build_foo();

    // Option2: Construct Foo from a slice
    let v = vec![7];
    let foo2 = Foo::from_slice(&v);
}

这种模式可能吗？如何修复编译错误？

---

我不确定要给出什么生命周期说明符，因为在

FooBuilder

版本中，

FooBuilder

拥有缓冲区，我不想强制

Foo

用户在整个使用期间将

FooBuilder

保持在范围内

Foo

可以使用

std:：borrow:：Cow

；作为国家：

它可以封闭和提供对借用数据的不可变访问，并在需要变异或所有权时延迟克隆数据

使用std:：borrow:：Cow；
结构富，
}
恳求{
fn create_builder（）->FooBuilder{
FooBuilder:：new（）
}
fn来自_切片（切片：&[u8]）->Foo{
Foo{buffer:slice.into（）}//note.into（）
}
}
结构FooBuilder{
正在进行的缓冲区：Vec，
}
恳求{
Foo{buffer:self.in\u progress\u buffer.into（）}//note.into（）
}
}

---

此外，您需要使

foo_builder

可变，以便能够在其上执行

push

。

乍一看，您似乎可以使用：为什么Foo不拥有缓冲区？@Boiethios我想允许从切片反序列化Foo。Foo提供了检查切片的方法（例如，缓冲区中有多少项设置为42），但它从不改变缓冲区

use std::borrow::Cow;

struct Foo<'a> {
    buffer: Cow<'a, [u8]>,
}

impl<'a> Foo<'a> {
    fn create_builder() -> FooBuilder {
        FooBuilder::new()
    }

    fn from_slice(slice: &[u8]) -> Foo {
        Foo { buffer: slice.into() } // note .into()
    }
}

struct FooBuilder {
    in_progress_buffer: Vec<u8>,
}

impl<'a> FooBuilder {
    fn new() -> FooBuilder {
        FooBuilder { in_progress_buffer: Vec::new() }
    }

    fn push(&mut self, item: u8) {
        self.in_progress_buffer.push(item);
    }

    fn build_foo(self) -> Foo<'a> {
            Foo { buffer: self.in_progress_buffer.into() } // note .into()
    }
}