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


use crate::{ Block, Row };

/// Methods for referencing interior elements:
impl<B: Block> Row<B> {

    /// Get a reference to the block at the given index.
    /// Returns None if the block does not exist in the row.
    pub fn get_block_ref(&self, i: usize) -> Option<&B> {
        self.get(i)
    }

    /// Get a mutable reference to the block at the given index.
    /// Returns None if the block does not exist in the row.
    pub fn get_block_mut(&mut self, i: usize) -> Option<&mut B> {
        self.get_mut(i)
    }

    /// Get a vector of references to consecutive blocks.
    /// Returns None if the range does not exist in the row.
    /// Use this for operations on a collection of blocks, not for building row structure.
    /// (Adding to this vector will not add blocks to the row.)
    pub fn get_range_ref(
        &self,
        start: usize,
        end: usize
    ) -> Option<Vec<&B>> {

        // Check for bounds.
        if !range_boundary_check_helper(self.blocks.len(), start, end) {
            return None
        }

        // No need to repeat range checks.
        let blocks = self.blocks[start..=end].iter().collect();
        Some(blocks)
    }

    /// Get a vector of mutable references to consecutive blocks.
    /// Returns None if the range does not exist in the row.
    /// Use this for operations on a collection of blocks, not for building row structure.
    /// (Adding to this vector will not add blocks to the row.)
    pub fn get_range_mut(
        &mut self,
        start: usize,
        end: usize
    ) -> Option<Vec<&mut B>> {

        // Check for bounds.
        if !range_boundary_check_helper(self.blocks.len(), start, end) {
            return None
        }

        // No need to repeat range checks.
        let blocks = self.blocks[start..=end].iter_mut().collect();
        Some(blocks)
    }

    /// Get a vector of references to all blocks.
    /// Returns an empty Vec if the row is empty.
    /// Use this for operations on a collection of blocks, not for building row structure.
    /// (Adding to this vector will not add blocks to the row.)
    pub fn get_all_ref(&self) -> Vec<&B> {
        self.iter().collect()
    }

    /// Get a vector of mutable references to all blocks.
    /// Returns an empty Vec if the row is empty.
    /// Use this for operations on a collection of blocks, not for building row structure.
    /// (Adding to this vector will not add blocks to the row.)
    pub fn get_all_mut(&mut self) -> Vec<&mut B> {
        self.iter_mut().collect()
    }

}

/// Check whether the range falls within the total number of blocks.
fn range_boundary_check_helper(total: usize, start: usize, end: usize) -> bool {
    if start > end || end >= total { false } 
    else { true }
}