What is a Rust equivalent to C++'s virtual overwriting to prevent code rewriting?

user_13684332 0
Viewed 106

In C++, I've written this code:

class MessageHandler {
    virtual MediaPlayer::Ptr handle_message(...);
    virtual RtspServer::Ptr decideRtspServer(...);
    virtual RtspClient::Ptr decideRtspClient(...);
    virtual Decoder::Ptr decideDecoder(...);
    virtual Renderer::Ptr decideRenderer(...);
};

This class handles a message that informs which RtspServer, RtspClient, Decoder, Renderer to use, and returns a MediaPlayer. I want to write MessageHandlers for lots of devices: Android, Windows, Linux, etc, so I can override each decision. For example, I can override decideRenderer to decide an specific renderer that is only available in Linux, but the rest should not be overridden as it's the same in all devices.

I'm looking to do the same in Rust: have default decisions but the ability to "override" one if needed, when implementing a MessageHandler for an specific device.

How can I achieve something similar in Rust? I don't care if it looks like OOP or not, I just want to prevent rewriting the same code.

rust
1 Answers

What speaks against trait objects? Something along the lines of this:

trait MessageHandler {
    handle_message(...) -> Box<MediaPlayer> {
        Box::new(DefaultMediaPlayer{})
    }
    decideRtspServer(...) -> Box<RtspServer> {
        Box::ne(DefaultRtspServer{})
    }
    // and others
};

struct LinuxMessageHandler {...}
impl MessageHandler for LinuxMessageHandler {
    handle_message(...) -> Box<MediaPlayer> {
        Box::new(LinuxSpecificMediaPlayer{})
    }
    // do not implement any other method: instead, automatically "inherit" them from MessageHandler
}

Then, these "trait objects" are passed around as e.g. Box<dyn MessageHandler>.

user_2556880
Related