test-rust-lib

test-rust-lib.rs

extern crate libc;                                                                                                                                                                                                
                                                                                                                                                                                                                  
use std::{boxed, ffi, ptr};                                                                                                                                                                                       
use libc::c_char;                                                                                                                                                                                                 
                                                                                                                                                                                                                  
#[repr(C)]                                                                                                                                                                                                        
#[derive(Copy)]                                                                                                                                                                                                   
pub struct Plugin {                                                                                                                                                                                               
    key: *const c_char,                                                                                                                                                                                           
}                                                                                                                                                                                                                 
                                                                                                                                                                                                                  
impl Clone for Plugin {                                                                                                                                                                                           
    fn clone(&self) -> Self { *self }                                                                                                                                                                             
}                                                                                                                                                                                                                 
                                                                                                                                                                                                                  
impl Plugin {                                                                                                                                                                                                     
    pub fn new(key: Option<&str>) -> Plugin {                                                                                                                                                                     
        let c_key: *const c_char = match key {                                                                                                                                                                    
            Some(ref k) => ffi::CString::new(*k).unwrap().as_ptr(),                                                                                                                                               
            None        => ptr::null(),                                                                                                                                                                           
        };                                                                                                                                                                                                        
                                                                                                                                                                                                                  
        Plugin {                                                                                                                                                                                                  
            key: c_key,                                                                                                                                                                                           
        }                                                                                                                                                                                                         
    }                                                                                                                                                                                                             
}                                                                                                                                                                                                                 
                                                                                                                                                                                                                  
#[no_mangle]                                                                                                                                                                                                      
pub extern fn get_plugins() -> boxed::Box<[Plugin]> {                                                                                                                                                             
    let plugins = [                                                                                                                                                                                               
        Plugin::new(Some("my.plugin.foo")),                                                                                                                                                                       
        Plugin::new(Some("my.other.plugin.bar")),                                                                                                                                                                 
        Plugin::new(None),                                                                                                                                                                                      
    ];                                                                                                                                                                                                            
                                                                                                                                                                                                                  
    boxed::Box::new(plugins)                                                                                                                                                                                      
}