组合根

use std::cell::RefCell;
use std::rc::Rc;

//entity
struct Order {
    id: i64,
    total: i64,
}

impl Order {
    fn payable(&self) -> i64 {
        if self.total >= 200 {
            self.total - self.total / 10
        } else {
            self.total
        }
    }
}

//gateway
trait Catalog {
    fn price(&self, sku: &str) -> Option<i64>;
}

//repository
trait Orders {
    fn save(&self, order: Order);
    fn count(&self) -> usize;
}

//output port
trait Report {
    fn say(&self, text: &str);
}

//use case: asks for its parts, never builds them
struct PlaceOrder {
    catalog: Box<dyn Catalog>,
    orders: Rc<dyn Orders>,
    report: Box<dyn Report>,
    next_id: i64,
}

impl PlaceOrder {
    fn place(&mut self, items: &[(&str, i64)]) {
        let mut total = 0;
        for (sku, count) in items {
            match self.catalog.price(sku) {
                Some(price) => total += price * count,
                None => {
                    self.report.say(&format!("no {}", sku));
                    return;
                }
            }
        }
        let order = Order {
            id: self.next_id,
            total,
        };
        self.next_id += 1;
        let text = format!("order {} for {}",
                           order.id, order.payable());
        self.orders.save(order);
        self.report.say(&text);
    }
}

//adapters
struct MemoryCatalog;

impl Catalog for MemoryCatalog {
    fn price(&self, sku: &str) -> Option<i64> {
        [("pen", 30), ("lamp", 190)].iter()
            .find(|(name, _)| *name == sku)
            .map(|(_, price)| *price)
    }
}

struct MemoryOrders {
    rows: RefCell<Vec<Order>>,
}

impl Orders for MemoryOrders {
    fn save(&self, order: Order) {
        self.rows.borrow_mut().push(order);
    }

    fn count(&self) -> usize {
        self.rows.borrow().len()
    }
}

struct ConsoleReport;

impl Report for ConsoleReport {
    fn say(&self, text: &str) {
        println!("{}", text);
    }
}

struct SilentReport;

impl Report for SilentReport {
    fn say(&self, _text: &str) {}
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built.
//in Rust it is also where ownership is settled: the
//catalog and the report are MOVED into the use case as
//Box, while the store is SHARED with the root as Rc
struct ShopApp {
    use_case: PlaceOrder,
    orders: Rc<dyn Orders>,
}

impl ShopApp {
    fn build(report: Box<dyn Report>) -> ShopApp {
        let orders: Rc<dyn Orders> = Rc::new(MemoryOrders {
            rows: RefCell::new(Vec::new()),
        });
        ShopApp {
            use_case: PlaceOrder {
                catalog: Box::new(MemoryCatalog),
                orders: orders.clone(),
                report,
                next_id: 1001,
            },
            orders,
        }
    }

    fn loud() -> ShopApp {
        ShopApp::build(Box::new(ConsoleReport))
    }

    fn quiet() -> ShopApp {
        ShopApp::build(Box::new(SilentReport))
    }
}

//client code
let mut app = ShopApp::loud();
app.use_case.place(&[("pen", 2), ("lamp", 1)]);
app.use_case.place(&[("chair", 1)]);

//a second root builds the same use case differently
let mut night = ShopApp::quiet();
night.use_case.place(&[("lamp", 1)]);
println!("saved {}", night.orders.count());
//printed: order 1001 for 225
//         no chair
//         saved 1