Question

我想要一个LinkedList特征对象包装器结构。内部将是Ssl或非Ssl流的流类型。我的希望是传递struct wrapper，只要内部符合相同的特性，无论使用哪种内部流类型，一切都会好的。

简单示例：

use std::sync::{Arc, Mutex};
use std::collections::LinkedList;
use std::os::unix::io::{RawFd, AsRawFd};

pub trait HRecv {}
pub trait HSend {}
pub trait HStream: HRecv + HSend + AsRawFd + Clone {}
pub struct Stream<T: HStream> {
    pub inner: T
}

pub type StreamList = Arc<Mutex<LinkedList<Stream<HStream>>>>;

fn main() {
    let mut list = Arc::new(Mutex::new(LinkedList::<Stream<HStream>>::new()));
}

产生以下错误：

error: the trait 'core::marker::Sized' is not implemented for the type 'HStream' [E0277]
let mut list = Arc::new(Mutex::new(LinkedList::<Stream<HStream>>::new()));
                                                ^~~~~~~~~~~~~~~

我尝试将+ Sized添加到HStream的定义中，并使inner成为Box<T>，两者都会产生相同的错误。

目前可以用Rust做到这一点吗？如果是这样，语法是什么？

Answer 1

好的，这里有一些问题。解决编译器错误列表：

<anon>:15:53: 15:68 error: the trait `core::marker::Sized` is not implemented for the type `HStream` [E0277]
<anon>:15     let mut list = Arc::new(Mutex::new(LinkedList::<Stream<HStream>>::new()));
                                                              ^~~~~~~~~~~~~~~
<anon>:15:53: 15:68 help: see the detailed explanation for E0277
<anon>:15:53: 15:68 note: `HStream` does not have a constant size known at compile-time
<anon>:15:53: 15:68 note: required by `Stream`

由于HStream没有编译时可计算的大小，因此无法替换类型参数T。所有类型参数隐式地要求替换类型为编译时大小。如果要允许动态大小的类型，则需要通过以下内容明确地选择退出此隐式绑定：

<T: ?Sized + HStream>

<anon>:15:53: 15:68 error: the trait `HStream` is not implemented for the type `HStream` [E0277]
<anon>:15     let mut list = Arc::new(Mutex::new(LinkedList::<Stream<HStream>>::new()));
                                                              ^~~~~~~~~~~~~~~
<anon>:15:53: 15:68 help: see the detailed explanation for E0277
<anon>:15:53: 15:68 note: required by `Stream`

特质并没有实现。您是否要求提供实施 HStream的类型，但HStream并未自行实施（如何实现？）

您必须提供所做的类型。

<anon>:15:53: 15:68 error: the trait `HStream` cannot be made into an object [E0038]
<anon>:15     let mut list = Arc::new(Mutex::new(LinkedList::<Stream<HStream>>::new()));
                                                              ^~~~~~~~~~~~~~~
<anon>:15:53: 15:68 help: see the detailed explanation for E0038
<anon>:15:53: 15:68 note: the trait cannot require that `Self : Sized`

以下是K-O问题：HStream 无法与动态调度期间一起使用。这不是对象安全的。这很可能是因为Clone要求。

＆＃34;修复＆＃34;以上所有内容都是重新设计您的类型，以便问题不存在。这是不可能知道的，因为这里没有足够的背景来说明你想要做什么。

然而，在盲目的刺中，这里看起来没有仿制品（无论如何你似乎并没有使用）：

use std::sync::{Arc, Mutex};
use std::collections::LinkedList;
use std::os::unix::io::{RawFd, AsRawFd};

pub trait HRecv {}
pub trait HSend {}
pub trait HStream: HRecv + HSend + AsRawFd + CloneHStream {}

pub trait CloneHStream { fn clone_h_stream(&self) -> Box<HStream>; }

impl<T> CloneHStream for T where T: 'static + Clone + HStream {
    fn clone_h_stream(&self) -> Box<HStream> {
        Box::new(self.clone())
    }
}

pub struct Stream {
    pub inner: Box<HStream>
}

pub type StreamList = Arc<Mutex<LinkedList<Stream>>>;

fn main() {
    let mut list = Arc::new(Mutex::new(LinkedList::<Stream>::new()));
}

Answer 2

您无法直接使用HStream类型;它并不代表任何东西。它仅用于构造派生指针类型，例如&HStream和Box<HStream>。

最简单的解决方案是拥有LinkedList Stream<Box<HStream>>。

fn main() {
    let mut list = Arc::new(Mutex::new(LinkedList::<Stream<Box<HStream>>>::new()));
}

然后，我们只需为HStream实施Box<HStream>。

impl<'a> HRecv for Box<HStream + 'a> {}
impl<'a> HSend for Box<HStream + 'a> {}
impl<'a> AsRawFd for Box<HStream + 'a> {
    fn as_raw_fd(&self) -> RawFd { (&**self).as_raw_fd() }
}
impl<'a> HStream for Box<HStream + 'a> {}

请注意，这缺少一个特质...... Clone。

Clone不是对象安全的，这意味着无法为该特征创建特征对象类型，例如&Clone或Box<Clone>。 Clone不是对象安全的，因为它的clone方法返回Self，它表示实现者的具体类型。如果您通过trait对象使用此方法，编译器将无法事先知道结果的类型（它可能是Clone的任何实现者！）。

由于HStream是Clone的子广告，HStream也不是对象安全的。结果是我们根本无法实现Clone，而像Box<HStream>这样的类型则不合法使用。

但是，我们可以通过制作我们自己的，对象安全的特性来解决这个问题。我们甚至可以在实现标准Clone特征的类型上自动实现它。

pub trait BoxedHStreamClone {
    fn boxed_clone(&self) -> Box<HStream>;
}

// Implementation for all types that implement HStream and Clone and don't hold any borrows
impl<T: HStream + Clone + 'static> BoxedHStreamClone for T {
    fn boxed_clone(&self) -> Box<HStream> {
        Box::new(self.clone()) as Box<HStream>
    }
}

// Implementation for Box<HStream + 'a>, which cannot implement Clone
impl<'a> BoxedHStreamClone for Box<HStream + 'a> {
    fn boxed_clone(&self) -> Box<HStream> {
        Box::new((&**self).boxed_clone()) as Box<HStream>
    }
}

将Clone上绑定的HStream特征替换为BoxedHStreamClone，您就可以了！

pub trait HStream: HRecv + HSend + AsRawFd + BoxedHStreamClone {}

Here's the final code:

use std::sync::{Arc, Mutex};
use std::collections::LinkedList;
use std::os::unix::io::{RawFd, AsRawFd};

pub trait BoxedHStreamClone {
    fn boxed_clone(&self) -> Box<HStream>;
}

impl<T: HStream + Clone + 'static> BoxedHStreamClone for T {
    fn boxed_clone(&self) -> Box<HStream> {
        Box::new(self.clone()) as Box<HStream>
    }
}

pub trait HRecv {}
pub trait HSend {}
pub trait HStream: HRecv + HSend + AsRawFd + BoxedHStreamClone {}
pub struct Stream<T: HStream> {
    pub inner: T
}

pub type StreamList = Arc<Mutex<LinkedList<Stream<Box<HStream>>>>>;

impl<'a> HRecv for Box<HStream + 'a> {}
impl<'a> HSend for Box<HStream + 'a> {}

impl<'a> AsRawFd for Box<HStream + 'a> {
    fn as_raw_fd(&self) -> RawFd { (&**self).as_raw_fd() }
}

impl<'a> BoxedHStreamClone for Box<HStream + 'a> {
    fn boxed_clone(&self) -> Box<HStream> {
        Box::new((&**self).boxed_clone()) as Box<HStream>
    }
}

impl<'a> HStream for Box<HStream + 'a> {}

fn main() {
    let mut list = Arc::new(Mutex::new(LinkedList::<Stream<Box<HStream>>>::new()));
}

使用需要大小的特征对象

2 个答案: