Rust语言从入门到精通系列 - 玩转“装饰器模式”

1
trait Order {
2
    fn get_price(&self) -> f64;
3
}
4

5
struct BaseOrder {
6
    price: f64,
7
}
8

9
impl BaseOrder {
10
    fn new(price: f64) -> Self {
11
        Self { price }
12
    }
13
}
14

15
impl Order for BaseOrder {
16
    fn get_price(&self) -> f64 {
17
        self.price }
18
}
19

20
struct DiscountOrder<'a> {
21
    order: &'a dyn Order,
22
    discount: f64,
23
}
24

25
impl<'a> DiscountOrder<'a> {
26
    fn new(order: &'a dyn Order, discount: f64) -> Self {
27
        Self { order, discount }
28
    }
29
}
30

31
impl<'a> Order for DiscountOrder<'a> {
32
    fn get_price(&self) -> f64 {
33
        self.order.get_price() * self.discount
34
    }
35
}
36

37
struct AddTaxOrder<'a> {
38
    order: &'a dyn Order,
39
    tax: f64,
40
}
41

42
impl<'a> AddTaxOrder<'a> {
43
    fn new(order: &'a dyn Order, tax: f64) -> Self {
44
        Self { order, tax }
45
    }
46
}
47

48
impl<'a> Order for AddTaxOrder<'a> {
49
    fn get_price(&self) -> f64 {
50
        self.order.get_price() * (1.0 + self.tax)
51
    }
52
}
53

54
fn main() {
55
    let order = BaseOrder::new(100.0);
56
    let discount_order = DiscountOrder::new(&order, 0.9);
57
    let tax_order = AddTaxOrder::new(&discount_order, 0.1);
58
    println!("Order Price: {}", tax_order.get_price());
59
}

1
struct AddFooterOrder<'a> {
2
    order: &'a dyn Order,
3
    footer: String,
4
}
5

6
impl<'a> AddFooterOrder<'a> {
7
    fn new(order: &'a dyn Order, footer: String) -> Self {
8
        Self { order, footer }
9
    }
10
}
11

12
impl<'a> Order for AddFooterOrder<'a> {
13
    fn get_price(&self) -> f64 {
14
        self.order.get_price()
15
    }
16
}
17

18
struct AddHeaderOrder<'a> {
19
    order: &'a dyn Order,
20
    header: String,
21
}
22

23
impl<'a> AddHeaderOrder<'a> {
24
    fn new(order: &'a dyn Order, header: String) -> Self {
25
        Self { order, header }
26
    }
27
}
28

29
impl<'a> Order for AddHeaderOrder<'a> {
30
    fn get_price(&self) -> f64 {
31
        self.order.get_price()
32
    }
33
}
34

35
fn main() {
36
    let order = BaseOrder::new(100.0);
37
    let discount_order = DiscountOrder::new(&order, 0.9);
38
    let tax_order = AddTaxOrder::new(&discount_order, 0.1);
39
    let header_order = AddHeaderOrder::new(&tax_order, "OrderHeader".to_string());
40
    let footer_order = AddFooterOrder::new(&header_order, "OrderFooter".to_string());
41
    println!("Order Price: {}", footer_order.get_price());
42
}

1
trait OrderDecorate {
2
    fn discount(self, discount: f64) -> DiscountOrder<Self>
3
    where
4
        Self: Sized,
5
    {
6
        DiscountOrder::new(&self, discount)
7
    }
8

9
    fn add_tax(self, tax: f64) -> AddTaxOrder<Self>
10
    where Self: Sized,
11
    {
12
        AddTaxOrder::new(&self, tax)
13
    }
14

15
    fn add_header(self, header: String) -> AddHeaderOrder<Self>
16
    where
17
        Self: Sized,
18
    {
19
        AddHeaderOrder::new(&self, header)
20
    }
21

22
    fn add_footer(self, footer: String) -> AddFooterOrder<Self>
23
    where
24
        Self: Sized,
25
    {
26
        AddFooterOrder::new(&self, footer)
27
    }
28
}
29

30
impl<T> OrderDecorate for T where T: Order {}
31

32
fn main() {
33
    let order = BaseOrder::new(100.0);
34
    let price = order .discount(0.9)
35
        .add_tax(0.1)
36
        .add_header("OrderHeader".to_string())
37
        .add_footer("OrderFooter".to_string())
38
        .get_price();
39
    println!("Order Price: {}", price);
40
}