tflite 0.9.8

Rust bindings for TensorFlow Lite
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

#[allow(deprecated)]
impl Default for VectorOf{{{rust_type}}} {
    fn default() -> Self {
        let mut this = unsafe{ mem::zeroed() };
        let this_ref = &mut this;
        unsafe {
            cpp!([this_ref as "std::vector<{{{cpp_type}}}>*"] {
                new (this_ref) const std::vector<{{{cpp_type}}}>;
            })
        }
        this
    }
}

#[allow(deprecated)]
impl VectorSlice for VectorOf{{{rust_type}}} {
    type Item = {{{rust_type}}};

    fn get_ptr(&self) -> *const Self::Item {
        unsafe {
            cpp!([self as "const std::vector<{{{cpp_type}}}>*"]
                  -> *const {{{rust_type}}} as "const {{{cpp_type}}}*" {
                return self->data();
            })
        }
    }

    fn get_mut_ptr(&mut self) -> *mut Self::Item {
        unsafe {
            cpp!([self as "std::vector<{{{cpp_type}}}>*"]
                  -> *mut {{{rust_type}}} as "{{{cpp_type}}}*" {
                return self->data();
            })
        }
    }

    fn size(&self) -> usize {
        unsafe {
            cpp!([self as "const std::vector<{{{cpp_type}}}>*"] -> size_t as "size_t" {
                return self->size();
            })
        }
    }
}

#[allow(deprecated)]
impl VectorErase for VectorOf{{{rust_type}}} {
    fn erase_range(&mut self, offset: usize, size: usize) {
        let begin = offset as size_t;
        let end = offset + size as size_t;
        unsafe {
            cpp!([self as "std::vector<{{{cpp_type}}}>*", begin as "size_t", end as "size_t"] {
                self->erase(self->begin() + begin, self->begin() + end);
            });
        }
    }
}

#[allow(deprecated)]
impl VectorInsert<{{{rust_type}}}> for VectorOf{{{rust_type}}} {
    fn push_back(&mut self, mut v: Self::Item) {
        let vref = &mut v;
        unsafe {
            cpp!([self as "std::vector<{{{cpp_type}}}>*", vref as "{{{cpp_type}}}*"] {
                self->push_back(std::move(*vref));
            })
        }
        mem::forget(v);
    }
}

#[allow(deprecated)]
impl VectorExtract<{{{rust_type}}}> for VectorOf{{{rust_type}}} {
    fn extract(&mut self, index: usize) -> {{{rust_type}}} {
        assert!(index < self.size());
        let mut v: {{{rust_type}}} = unsafe { mem::zeroed() };
        let vref = &mut v;
        unsafe {
            cpp!([self as "std::vector<{{{cpp_type}}}>*", index as "size_t", vref as "{{{cpp_type}}}*"] {
                *vref = std::move((*self)[index]);
            })
        }
        v
    }
}

add_impl!(VectorOf{{{rust_type}}});