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

use proc_macro::TokenStream;
use quote::*;
use syn::*;

pub fn impl_load_trait(ast: &DeriveInput) -> TokenStream {
    let name = &ast.ident;

    let name_str = name.to_string();

    let load = Ident::new(format!("{}_{}", name_str, "load").as_str(), name.span());
    let loadMem = Ident::new(format!("{}_{}", name_str, "loadMem").as_str(), name.span());
    let loadMemEx = Ident::new(
        format!("{}_{}", name_str, "loadMemEx").as_str(),
        name.span(),
    );

    let gen = quote! {
        unsafe impl LoadExt for #name {
            fn load(&mut self, path: &std::path::Path) -> Result<(), SoloudError> {
                
                unsafe {
                    let path = std::ffi::CString::new(path.to_str().ok_or(SoloudError::Internal(SoloudErrorKind::FileLoadFailed))?)?;
                    let ret = soloud_sys::soloud::#load(self._inner, path.as_ptr());
                    if ret != 0 {
                        Err(SoloudError::Internal(SoloudErrorKind::from_i32(ret)))
                    } else {
                        Ok(())
                    }
                }
            }

            fn load_mem(&mut self, data: &[u8]) -> Result<(), SoloudError> {
                
                unsafe {
                    let ret = soloud_sys::soloud::#loadMemEx(self._inner, data.as_ptr(), data.len() as u32, 0, 0);
                    if ret != 0 {
                        Err(SoloudError::Internal(SoloudErrorKind::from_i32(ret)))
                    } else {
                        Ok(())
                    }
                }
            }

            unsafe fn load_mem_ex(&mut self, data: &[u8], copy: bool, take_ownership: bool) -> Result<(), SoloudError> {
                
                unsafe {
                    let ret = soloud_sys::soloud::#loadMemEx(self._inner, data.as_ptr(), data.len() as u32, copy as i32, take_ownership as i32);
                    if ret != 0 {
                        Err(SoloudError::Internal(SoloudErrorKind::from_i32(ret)))
                    } else {
                        Ok(())
                    }
                }
            }
        }
    };
    gen.into()
}