Abstract Factory in Rust

Design patterns / Creational patterns

//abstract factory
trait Factory {
    fn create_a(&self) -> Box<dyn ProductA>;
    fn create_b(&self) -> Box<dyn ProductB>;
}

//concrete factory 1
struct Factory1 {}

impl Factory for Factory1 {
    fn create_a(&self) -> Box<dyn ProductA> {
        Box::from(ProductA1{})
    }

    fn create_b(&self) -> Box<dyn ProductB> {
        Box::from(ProductB1{})
    }
}

//concrete factory 2
struct Factory2 {}

impl Factory for Factory2 {
    fn create_a(&self) -> Box<dyn ProductA> {
        Box::from(ProductA2{})
    }

    fn create_b(&self) -> Box<dyn ProductB> {
        Box::from(ProductB2{})
    }
}

//abstract product A
trait ProductA {
    fn test_a(&self);
}

//abstract product B
trait ProductB {
    fn test_b(&self);
}

//concrete product A1
struct ProductA1{}

impl ProductA for ProductA1 {
    fn test_a(&self) {
        println!("test A1");
    }
}

//concrete product A2
struct ProductA2{}

impl ProductA for ProductA2 {
    fn test_a(&self) {
        println!("test A2");
    }
}

//concrete product B1
struct ProductB1{}

impl ProductB for ProductB1 {
    fn test_b(&self) {
        println!("test B1");
    }
}

//concrete product B2
struct ProductB2{}

impl ProductB for ProductB2 {
    fn test_b(&self) {
        println!("test B2");
    }
}

//client code
fn test_factory(factory: Box<dyn Factory>) {
    let product_a = factory.create_a();
    let product_b = factory.create_b();
    product_a.test_a();
    product_b.test_b();
}

test_factory(Box::new(Factory1{}));
//printed: test A1
//         test B1
test_factory(Box::new(Factory2{}));
//printed: test A2
//         test B2

Provides an interface for creating families of objects whose interfaces are known but concrete classes are not.

The problem. A program draws its windows in two styles, light and dark. Each style needs its own button and its own menu. If the code creates them directly, it can mix a light button with a dark menu by mistake. A third style would also mean a search for every place where a button or a menu is created.

The idea. An abstract factory is an interface with one creation method for each kind of product. Each concrete factory implements it for one family. One factory creates the light button and the light menu; another creates the dark ones. The client receives a factory and creates every product through it. It never names a concrete product, so the products it gets always belong to one family. To change the whole family, you give the client a different factory.

How to read the example. There are two kinds of product, A and B. A concrete factory makes one family: one product of each kind, marked with the same number. The client receives a factory, asks it for one product of each kind and uses both. The client does not know which family it got, but the output shows it. Some languages declare no interfaces at all, but the roles stay the same.

When to use it. Use Abstract Factory when products must work together and there are several families of them, such as visual themes or operating systems. Do not use it when there is only one family. It is also not needed when the products do not depend on each other: a constructor or a Factory Method is enough.

A common mistake. Choosing this pattern while the kinds of product still change often. Each new kind adds a method to the abstract factory and to every concrete factory.