Arc 包装的同一实例的多个特征对象<mutex<_> > </mutex<_>

Question

目标是让 object ( callback_handler ) 实现特征A 、 B和C ，这些特征可以传递给不同的函数，例如期望类型为A或B的特征 object 。

这需要callback_handler和 trait 对象由同一个Mutex保护（因为，例如，trait A期望&mut self ）。 此外，要使此设置生效，必须将此Mutex包装在Arc或Rc中：

use std::sync::{Arc, Mutex};

trait A {
    fn a(&mut self) {}
}
trait B {}
trait C: A + B {}

struct Foo {}

impl A for Foo {}
impl B for Foo {}
impl C for Foo {}

fn register_for_A(callback_handler: Arc<Mutex<Box<dyn A>>>) {
    // Register for callbacks defined in `A`.
    // Store the passed handler somewhere.
}

fn register_for_B(callback_handler: Arc<Mutex<Box<dyn B>>>) {
    // Register for callbacks defined in `B`.
    // Store the passed handler somewhere.
}

fn main() {
    let callback_handler = Arc::new(Mutex::new(Box::new(Foo{})));
    // Register for callbacks using different trait objects of the same "origin" object.
    // For this to be safe, all objects must be protected by the same ("shared") mutex.
    // !!! This will not work since there must be some steps to cast this to the right type. !!!
    register_for_A(Arc::clone(&callback_handler));
    register_for_B(Arc::clone(&callback_handler));

    // We can still use `callback_handler` to call methods on Foo ourself
}

现在，问题是，如何将Arc<Mutex<Box<Foo>>>类型的原点 object callback_hanlder转换/转换为Arc<Mutex<Box<dyn A>>>和Arc<Mutex<Box<dyn B>>> ？ 虽然我没有看到为什么这不可能的技术原因，但我不知道如何执行这样的转换以及它是否可行。 虽然一种解决方案是使用Any特性，但我希望有一种解决方案可以保留函数register_for_A和register_for_B的编译时类型安全性。

Answer 1

你被智能指针Box + Arc的双重使用绊倒了你可以简单地将Arc<Mutex<Foo>>转换为Arc<Mutex<dyn A>>使用as ，真的没有必要另外将它Box :

use std::sync::{Arc, Mutex};

trait A {
    fn a(&mut self) {}
}
trait B {}

struct Foo {}

impl A for Foo {}
impl B for Foo {}

fn register_for_A(callback_handler: Arc<Mutex<dyn A>>) {
    // Register for callbacks defined in `A`.
    // Store the passed handler somewhere.
}

fn register_for_B(callback_handler: Arc<Mutex<dyn B>>) {
    // Register for callbacks defined in `B`.
    // Store the passed handler somewhere.
}

fn main() {
    let callback_handler = Arc::new(Mutex::new(Foo{}));
    // Register for callbacks using different trait objects of the same "origin" object.
    // For this to be safe, all objects must be protected by the same ("shared") mutex.
    // !!! This will not work since there must be some steps to cast this to the right type. !!!
    register_for_A(Arc::clone(&callback_handler) as _);
    register_for_B(Arc::clone(&callback_handler) as _);

    // We can still use `callback_handler` to call methods on Foo ourself
}