1use core::slice;
 2
 3#[repr(C)]
 4pub struct Buffer {
 5    ptr: *const u8,
 6    len: usize,
 7}
 8
 9/// Allocates a buffer with an exact size.
10/// We don't return the size because it has to be passed in anyway.
11#[no_mangle]
12pub extern "C" fn __alloc_buffer(len: usize) -> *const u8 {
13    let vec = vec![0; len];
14    let buffer = unsafe { Buffer::from_vec(vec) };
15    return buffer.ptr;
16}
17
18/// Frees a given buffer, requires the size.
19#[no_mangle]
20pub extern "C" fn __free_buffer(ptr: *const u8, len: usize) {
21    let buffer = Buffer { ptr, len };
22    let vec = unsafe { buffer.to_vec() };
23    std::mem::drop(vec);
24}
25
26impl Buffer {
27    pub unsafe fn to_vec(&self) -> Vec<u8> {
28        slice::from_raw_parts(self.ptr, self.len).to_vec()
29    }
30
31    pub unsafe fn from_vec(mut vec: Vec<u8>) -> Buffer {
32        vec.shrink_to(0);
33        let ptr = vec.as_ptr();
34        let len = vec.len();
35        std::mem::forget(vec);
36        Buffer { ptr, len }
37    }
38
39    pub fn leak_to_heap(self) -> *const Buffer {
40        let boxed = Box::new(self);
41        let ptr = Box::<Buffer>::into_raw(boxed) as *const Buffer;
42        return ptr;
43    }
44}
45
46#[no_mangle]
47pub extern "C" fn banana(ptr: *const u8, len: usize) -> *const Buffer {
48    // setup
49    let buffer = Buffer { ptr, len };
50    let data = unsafe { buffer.to_vec() };
51    // operation
52    // let reversed: Vec<u8> = data.into_iter().rev().collect();
53    let number: f64 = bincode::deserialize(&data).unwrap();
54    let new_number = number * 2.0;
55    let new_data = bincode::serialize(&new_number).unwrap();
56    // teardown
57    let new_buffer = unsafe { Buffer::from_vec(new_data) };
58    return new_buffer.leak_to_heap();
59}
60
61pub fn main() -> () {
62    ()
63}