隐藏和接收通用T对象

Question

给出了以下Rust代码：

struct Wrapper<T> {
    data: Vec<T>, // more attributes...
}

trait DataWrapper<T> {
    fn get_column(&self) -> &Vec<T>;
    fn get_data(&self, row: usize) -> &T;
}

impl<T> DataWrapper<T> for Wrapper<T> {
    fn get_column(&self) -> &Vec<T> {
        &self.data
    }

    fn get_data(&self, row: usize) -> &T {
        &self.data[row]
    }
}

struct Inter<T> {
    inter_value: Wrapper<T>,
}

trait GetInter {
    fn get_count(&self) -> &str;
}

impl GetInter for Inter<i32> {
    fn get_count(&self) -> &str {
        "i32"
    }
}

impl GetInter for Inter<f64> {
    fn get_count(&self) -> &str {
        "f64"
    }
}

fn create_vector() -> Vec<Box<GetInter>> {
    // Add some sample data
    let x = Wrapper { data: vec![1, 2, 3] };
    let y = Wrapper { data: vec![1.1, 2.2, 3.3] };

    let mut vec: Vec<Box<GetInter>> = Vec::new();

    let m = Inter { inter_value: x };
    let m = Box::new(m);
    let m = m as Box<GetInter>;
    vec.push(m);

    let n = Inter { inter_value: y };
    let n = Box::new(n);
    let n = n as Box<GetInter>;
    vec.push(n);

    vec
}

struct ColumnWrapper {
    columns: Vec<Box<GetInter>>, // more attributes
}

fn create_column_wrapper() -> ColumnWrapper {
    let result = create_vector();

    ColumnWrapper { columns: result }
}

fn main() {
    let result = create_column_wrapper();

    for iter1 in result.columns {
        println!("1: {}", iter1.get_count());
    }
}

Wrapper<T>存储通用Vec ，详细地是列存储中的数据列。 相应的实现返回Vec或特定元素作为参考。

Inter<T>和GetInter特性的想法是隐藏通用T对象，该对象来自包装器的Vec<T>通用数据类型。 get_count()方法仅用于测试目的。

create_vector()使用一些样本数据创建两个新的Vec 。 结果将转换为GetInter ，包装到Box并存储在Vec<Box<GetInter>> 。 最后，调用者将创建一个新的ColumnWrapper元素。 现在给出了通用数据表示。

编译并运行后，将给出正确的结果：

i32 
f64

现在真正的问题开始了。 我尝试访问存储在Wrapper<T>的原始数据。

我的第一个想法是使用Rust的动态调度功能。 它应该在运行时检测实际数据类型。

main()函数被修改：

fn main() { 
    let result = create_column_wrapper();

    for iter1 in result.columns {
        println!("1: {}", iter1.get_count());

        for iter2 in dyn_dispatch(*iter1) {
            println!("2: {}", iter2);
        }
    }
}

相应的未经测试的dyn_dispatch()函数：

trait Foo<T> {
    fn method(x: &Inter<T>) -> &Vec<T>;
}

impl<i32> Foo<i32> for Inter<i32> {
    fn method(x: &Inter<i32>) -> &Vec<i32> {
        &x.inter_value.data
    }
}

impl<f64> Foo<f64> for Inter<f64> {
    fn method(x: &Inter<f64>) -> &Vec<f64> {
        &x.inter_value.data
    }
}

fn dyn_dispatch<T>(x: &GetInter) -> &Vec<T> {
    Foo::method(&x as &Inter<T>)
}

编译失败并抛出错误：

85：2错误：类型Inter<_>的特征Foo<_>实现相互冲突：[E0119]

有什么主意如何解决编译错误，还是有另一种更容易隐藏和访问通用T对象的主意？

Answer 1

这里有两个问题。

第一个错误：

错误： 类型Inter < >的特征Foo < >的实现相互冲突：[E0119]

实际上指的是这些：

impl<i32> Foo<i32> for Inter<i32> { ... }
impl<f64> Foo<f64> for Inter<f64> { ... }

由于i32和f64是参数，因此它们都等效于：

impl<T> Foo<T> for Inter<T> { ... }

也就是说， 对于任何T ， Inter<T>的Foo<T>的实现都是冲突的实现。 解决方法是将它们写为：

impl Foo<i32> for Inter<i32> { ... }

下一个问题是您实际上没有在进行动态调度。 您的dyn_dispatch函数必须在编译时指定T或进行推断； 每次都不能返回不同的类型； 同样，您不能像这样从GetInter向下转换到Inter<T> 。 您需要以与完成GetInter::get_count相同的方式进行GetInter::get_count 。