blok 0.0.23

Types and traits for graphlike 3D arrays, designed for visual thinkers.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133


pub mod build;
pub mod partial;
pub mod clone;

use crate::{ Block, Layout };


/// Holds a grid of blocks in a single vector, 
/// with the layout tracked separately.
#[derive(Debug, Default, Clone)]
pub struct Layer<B: Block> {
    /// Represents the organization of blocks in the array.
    pub(crate) layout: Layout,
    /// Blok assumes you want to store the block array contiguously in memory.
    pub(crate) blocks: Vec<B>
}

/// Field access methods:
impl<B: Block> Layer<B> {

    /// Create an empty layer.
    pub fn new() -> Self {
        Self::default()
    }

    /// Get a reference to the blocks of the layer.
    pub fn blocks(&self) -> &Vec<B> { 
        &self.blocks 
    }

    /// Get a mutable reference to the blocks of the layer.
    pub(crate) fn blocks_mut(&mut self) -> &mut Vec<B> { 
        &mut self.blocks 
    }

    /// Get a reference to the layout of the layer.
    pub fn layout(&self) -> &Layout { 
        &self.layout 
    }

    /// Get a mutable reference to the layout of the layer.
    pub(crate) fn layout_mut(&mut self) -> &mut Layout { 
        &mut self.layout 
    }

    /// Set layer data arbitrarily.
    pub fn set_from_layout(
        &mut self, 
        layout: Layout, 
        blocks: Vec<B>
    ) -> anyhow::Result<()> { // TODO Error
        
        if layout.total() != blocks.len() { 
            return Err(anyhow::anyhow!("Size mismatch"))
            // TODO: Error
        }

        *self.layout_mut() = layout;
        *self.blocks_mut() = blocks;

        Ok(())
    }
    
    /// Create a new Layer of a different type of blocks using the rows from this layer.
    pub fn map<C: Block, T: Fn(&B) -> C>(&self, t: T) -> Layer<C> {
        let mapped_blocks: Vec<C> = self.blocks()
            .iter()
            .map(t)
            .collect();

        let mut mapped_layer = Layer::<C>::new();
        mapped_layer.layout = self.layout.clone();
        mapped_layer.blocks = mapped_blocks;

        mapped_layer
    }

}



/*  UNIT TESTS  */
#[cfg(test)] pub(crate) mod test {

    use super::*;
    use crate::{ layout, Layout };
    use crate::block::{ Block, test::TestBlock };
    
    /// Test for setting layer from given values.
    pub(crate) fn test_layer() -> Layer<TestBlock> {
        let mut layer = Layer::<TestBlock>::new();
        let layout = layout![1, 2];
        let mut blocks = vec![TestBlock::create(&"test".to_string()); 3];

        // Name the blocks using their index in order to differentiate them.
        for (b, block) in blocks.iter_mut().enumerate() {
            block.id = b.to_string()
        }

        layer.set_from_layout(layout, blocks)
            .expect("Set layer successful");

        layer
    }

    /// Test for creating new layer.
    #[test] fn new_layer_test() {
        let layer = Layer::<TestBlock>::new();
        let layout = layer.layout();
        let blocks = layer.blocks();
        assert!(layout.is_empty() && blocks.is_empty(), "Default layer is empty");
    }
    
    /// Test for setting layer from given values.
    #[test] fn set_layer_test() {
        test_layer();
    }
    
    /// Test for setting layer from given values.
    #[test] #[should_panic(expected = "Set layer fails")] fn bad_set_layer_test() {
        let mut layer = Layer::<TestBlock>::new();
        let layout = layout![1, 2];
        // The number of blocks is fewer than the layout total:
        let blocks = vec![TestBlock::create(&"test".to_string()); 2];

        layer.set_from_layout(layout, blocks)
            .expect("Set layer fails");
    }
    
}