latkit 0.2.1

Columnar data drawn as vertices, edges, lines, and areas on the GPU.
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

use std::ops::{Deref, Range};
use std::sync::Arc;

/// A shared, immutable slice: making one from a vector, cloning it, and slicing it never copy.
pub(crate) struct Buffer<T> {
    data: Arc<Vec<T>>,
    start: usize,
    end: usize,
}

impl<T> Clone for Buffer<T> {
    fn clone(&self) -> Buffer<T> {
        Buffer { data: self.data.clone(), start: self.start, end: self.end }
    }
}

impl<T> Buffer<T> {
    pub(crate) fn slice(&self, range: Range<usize>) -> Buffer<T> {
        assert!(range.start <= range.end && self.start + range.end <= self.end, "slice out of range");
        Buffer { data: self.data.clone(), start: self.start + range.start, end: self.start + range.end }
    }
}

impl<T> Default for Buffer<T> {
    fn default() -> Buffer<T> {
        Buffer::from(Vec::new())
    }
}

impl<T> Deref for Buffer<T> {
    type Target = [T];

    fn deref(&self) -> &[T] {
        &self.data[self.start..self.end]
    }
}

impl<T> From<Vec<T>> for Buffer<T> {
    fn from(values: Vec<T>) -> Buffer<T> {
        let end = values.len();
        Buffer { data: Arc::new(values), start: 0, end }
    }
}

impl<T: Clone> From<&[T]> for Buffer<T> {
    fn from(values: &[T]) -> Buffer<T> {
        Buffer::from(values.to_vec())
    }
}

impl<T> FromIterator<T> for Buffer<T> {
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Buffer<T> {
        iter.into_iter().collect::<Vec<T>>().into()
    }
}

impl<T: std::fmt::Debug> std::fmt::Debug for Buffer<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_list().entries(self.iter()).finish()
    }
}