borrow 2.0.0

Zero-overhead, safe implementation of partial borrows. This crate allows you to borrow selected fields from a struct and split structs into non-overlapping sets of borrowed fields.
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

// ============
// === Data ===
// ============

#[derive(Debug, Default)]
pub struct Geometry {
    label: String,
}

#[derive(Debug, Default)]
pub struct Material {
    label: String,
}

#[derive(Debug, Default)]
pub struct Mesh {
    pub geometry: usize,
    pub material: usize,
}

#[derive(Debug, Default)]
pub struct Scene {
    pub meshes: Vec<usize>,
}

// ==================
// === Registries ===
// ==================

#[derive(Debug, Default)]
pub struct GeometryCtx {
    pub data: Vec<Geometry>,
}

#[derive(Debug, Default)]
pub struct MaterialCtx {
    pub data: Vec<Material>,
}

#[derive(Debug, Default)]
pub struct MeshCtx {
    pub data: Vec<Mesh>,
}

#[derive(Debug, Default)]
pub struct SceneCtx {
    pub data: Vec<Scene>,
}

// =====================
// === Root Registry ===
// =====================

#[derive(Debug, Default, borrow::Partial)]
#[module(crate::data)]
pub struct Ctx {
    pub geometry: GeometryCtx,
    pub material: MaterialCtx,
    pub mesh: MeshCtx,
    pub scene: SceneCtx,
}

impl Ctx {
    pub fn new_geometry(&mut self, label: &str) -> usize {
        let label = label.to_string();
        self.geometry.data.push(Geometry { label });
        self.geometry.data.len() - 1
    }

    pub fn new_material(&mut self, label: &str) -> usize {
        let label = label.to_string();
        self.material.data.push(Material { label });
        self.material.data.len() - 1
    }

    pub fn new_mesh(&mut self, geometry: usize, material: usize) -> usize {
        self.mesh.data.push(Mesh { geometry, material });
        self.mesh.data.len() - 1
    }

    pub fn new_scene(&mut self, meshes: &[usize]) -> usize {
        let meshes = meshes.to_vec();
        self.scene.data.push(Scene { meshes });
        self.scene.data.len() - 1
    }

    pub fn mock() -> Self {
        let mut ctx = Self::default();
        let geo1 = ctx.new_geometry("geo1");
        let geo2 = ctx.new_geometry("geo2");
        let mat1 = ctx.new_material("mat1");
        let mat2 = ctx.new_material("mat2");
        let mesh1 = ctx.new_mesh(geo1, mat1);
        let mesh2 = ctx.new_mesh(geo2, mat2);
        let _scene1 = ctx.new_scene(&[mesh1, mesh2]);
        ctx
    }
}