rust-oop 0.1.2

use macro to implement inheritance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93


use std::pin::Pin;

use rust_oop::{class, def_as_mut};

def_as_mut!();

#[test]
fn main_test() {
    let mut shape1 = Rectangle::new(1.0, 2.0);
    assert_eq!(&shape1.name(), "Rectangle");
    assert_eq!(shape1.cal_size(), 2.0);
    as_mut!(shape1).set_width(3.0);
    assert_eq!(shape1.cal_size(), 6.0);
    
    let mut shape2 = Square::with(3.0);

    assert_eq!(&shape2.name(), "Square");
    assert_eq!(shape2.cal_size(), 9.0);
    as_mut!(shape2).set_length(2.0);
    assert_eq!(shape2.cal_size(), 4.0);
}


trait WithSize {
    fn cal_size(&self) -> f32;
}

class!{
    struct Shape {}
    impl Shape {
        fn name(&self) -> String {
            unimplemented!();
        }
    }
    impl WithSize for Shape {
        fn cal_size(&self) -> f32 {
            unimplemented!();
        }
    }
}

class!{
    extends Shape;
    struct Rectangle {
        width: f32,
        height: f32
    }
    impl Rectangle {
        fn name(&self) -> String {
            String::from("Rectangle")
        }
        fn set_width(&mut self, width: f32) where Self: Sized {
            this.width = width;
        }
        fn set_height(&mut self, height: f32) where Self: Sized {
            this.height = height;
        }
    }
    impl WithSize for Rectangle {
        fn cal_size(&self) -> f32 {
            this.width * this.height
        }
    }
}

class!{
    extends Rectangle;
    struct Square { }
    impl Square {
        fn name(&self) -> String {
            String::from("Square")
        }

        fn with(len: f32) -> Pin<Box<Self>> where Self: Sized {
            Self::new(len, len)
        }

        #[allow(unused_variables)]
        fn set_width(&mut self, width: f32) where Self: Sized {
            panic!("don't use set_width on square.");
        }
        #[allow(unused_variables)]
        fn set_height(&mut self, height: f32) where Self: Sized {
            panic!("don't use set_height on square.");
        }

        fn set_length(&mut self, len: f32) where Self: Sized {
            _super_mut.set_width(len);
            _super_mut.set_height(len);
        }
    }
}