创建一个返回空结构实现的工厂类

Question

I'd like to create a common interface for formatters, that will take the input and format it according to their purpose.

Currently I'm returning a Box containing the formatter implementation (wrapped into a Result). But I don't think this is the best way to do it. Since the Formatter implementations are empty structs, allocating heap memory for a Box doesn't make sense.

pub trait Formatter {
    fn format_information(&self, information: Result<Information, Error>) -> Result<String, Error>;
    fn format_information_collection(&self, information: InformationCollection) -> Result<String, Error>;
}

pub struct JsonFormatter;
impl Formatter for JsonFormatter {...}

pub struct XmlFormatter;
impl Formatter for XmlFormatter {...}


// Factory to create a formatter
pub struct Factory;
impl Factory {
    pub fn get_formatter(format: &str) -> Result<Box<Formatter>, Error> {
        match format {
            "json" => Ok(Box::new(JsonFormatter {})),
            "xml" => Ok(Box::new(XmlFormatter {})),
            _ => Err(Error::new(format!("No formatter found for format {}", format)))
        }
    }
}

// Use the factory
let formatter_box = Factory::get_formatter(format).unwrap();
let formatter = &*formatter_box as &Formatter;

What's the correct way to do this in Rust?

Answer 1

Since the Formatter implementations are empty structs, allocating heap memory for a Box doesn't make sense.

And since it doesn't make any sense, heap memory won't be allocated at all. Let's try it ( Playground ):

// `()` doesn't occupy any space, like e.g. your `JsonFormatter`
let b1 = Box::new(());
let b2 = Box::new(());

println!("{:p}\n{:p}", &*b1, &*b2);

This produces the output:

0x1
0x1

ZSTs (zero sized types) are often treated in a special way. So at least you know you aren't paying for heap allocations here. Note however, that the memory layout of your Box<Formatter> is a fat pointer and looks like this: (*mut Formatter, *mut VTable) . The first pointer always being 0x1 , the second one pointing to a statically allocated dispatch table which contains function pointer ( vtable - Wikipedia ). This is probably fine in your situation.

---

Another possibility is to create an enum like this:

enum FormatterSd {
    Json(JsonFormatter),
    Xml(XmlFormatter),
}

And now you can implement Formatter for FormatterSd ; in this implementation you will use simple match blocks to do dispatch. That way you don't need to use Box .

---

Lastly: you don't need to have a factory type! It seems a bit like you are trying to bring ideas from a strongly OO programming language into Rust. Often, this is not the best or most idiomatic solution. For example, there are free functions in Rust. So you can simply write:

fn get_formatter(format: &str) -> Result<Box<Formatter>, Error> {
    // ...
}

Yes, without the Factory type! Empty types are a lot less common in Rust than empty classes (meaning: without any fields). You can just use free function for this kind of stuff, there is no need to associate it with a type.

And lastly lastly: you don't need to manually obtain a reference from a Box :

let formatter = &*formatter_box as &Formatter;

You can simple say formatter_box.format_information(...); , thanks to deref coercions.