fieldwork-borrow 0.1.0

Field-level borrow splitting for Rust
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
94
95
96
97
98
99
100
101

//! e7: method returning Option, accessing multiple fields

use fieldwork_borrow::with_;

pub struct Database {
    pub animations: Vec<Animation>,
}

pub struct Connection {
    pub models: Vec<ModelConnection>,
}

pub struct ModelConnection {
    pub animations: Vec<usize>,
}

pub struct Animation {
    pub objects_curves: Vec<TRSCurves>,
}

pub struct TRSCurves {
    value: f64,
}

impl TRSCurves {
    pub fn sample_at(&self) -> f64 {
        self.value
    }
}

pub struct Viewer {
    db: Database,
    conn: Connection,
    model_id: usize,
    object_mats: Vec<f64>,
}

impl Viewer {
    // Original problem code (won't compile):
    // fn problem(&mut self) {
    //     if let Some(anim) = self.cur_animation() {
    //         for i in 0..self.object_mats.len() {
    //             self.object_mats[i] = anim.objects_curves[i].sample_at();
    //         }
    //     }
    // }

    fn problem(&mut self) {
        with_!(self, {
            methods {
                cur_animation(&db, &conn, copy model_id) -> Option<&Animation> {
                    conn.models[model_id].animations.get(0).map(|&id| &db.animations[id])
                }
            }
            fields {
                mut object_mats
            }
            body {
                if let Some(anim) = self.cur_animation() {
                    for i in 0..object_mats.len() {
                        object_mats[i] = anim.objects_curves[i].sample_at();
                    }
                }
            }
        });
    }

    // Original methods for reference
    fn _cur_animation(&self) -> Option<&Animation> {
        Some(&self.db.animations[self._animation_id()?])
    }

    fn _animation_id(&self) -> Option<usize> {
        Some(self.conn.models[self.model_id].animations[0])
    }
}

#[test]
fn test_e7() {
    let mut viewer = Viewer {
        db: Database {
            animations: vec![Animation {
                objects_curves: vec![
                    TRSCurves { value: 1.0 },
                    TRSCurves { value: 2.0 },
                ],
            }],
        },
        conn: Connection {
            models: vec![ModelConnection {
                animations: vec![0], // points to animations[0]
            }],
        },
        model_id: 0,
        object_mats: vec![0.0, 0.0],
    };

    viewer.problem();

    assert_eq!(viewer.object_mats, vec![1.0, 2.0]);
}