Struct Plugin

pub struct Plugin<State> { /* private fields */ }

Implementations

impl<State> Plugin<State>

pub fn new(state: State, fullpath: &str) -> Box<Plugin<State>>

Examples found in repository

examples/basic_host.rs (line 18)

fn main() {
    let mut plugin_name = env::current_exe().expect("Failed to get current path");
    println!("Path of this executable is: {}", plugin_name.display());
    plugin_name.set_file_name("libbasic_guest.so");
    // build the libbasic_guest.so file from the samples of cr.h
    println!("Call cr_plugin_load(ctx, {:?})", plugin_name);
    let mut plugin = BasicPlugin::new(BasicState { counter: 0 }, plugin_name.to_str().unwrap());

    let mut err_cnt = 0;
    loop {
        println!("Run Update:");
        let rc = plugin.update(true);
        println!("cr_plugin_update(ctx, true) = {}", rc);
        if rc != 0 {
            println!("Plugin error: {:?}", plugin.get_failure());
            err_cnt += 1;
            if err_cnt > 10 {
                break;
            }
        }
        thread::sleep(Duration::from_millis(200));
    }
    println!("Call cr_plugin_close(ctx)");
    drop(plugin);
    println!("exit");
}

examples/basic_guest.rs (line 21)

pub fn plugin_main(ctx: &mut BasicPlugin, cr_op: cr::cr_op) -> i32 {
    // Test "guest" feature.
    #[cfg(not(feature = "guest"))]
    {
        println!("Guest compiled with host-side code.");
        // This code will only run if the "guest" feature is not used.
        let plugin = BasicPlugin::new(BasicState { counter: 0 }, "test");
        println!("- plugin = {:?}", plugin);
    }

    println!("test recompile. test1");
    //panic!("test");
    // Test crash.
    // Rollback to the previous version seems to work once.
    // Then on the next reload it gets stuck in a setjmp/longjmp loop?
    /*
    unsafe {
        let ptr
            = std::ptr::null_mut() as *mut std::os::raw::c_int;
        // invalid read.
        println!("Read from null pointer: {:?}", *ptr);
        // invalid write.
        *ptr = 0x1234;
    }
    // */
    match cr_op {
        CR_LOAD => {
            println!("Plugin load. version = {}", ctx.get_version());
        }
        CR_STEP => {
            let version = ctx.get_version();
            let state = ctx.state_mut();
            state.counter += 1;
            println!(
                "Plugin step. count = {}. version = {}",
                state.counter, version
            );

            // slow down the printing.
            thread::sleep(Duration::from_millis(200));
        }
        CR_UNLOAD => {
            println!("Plugin unload. version = {}", ctx.get_version());
        }
        CR_CLOSE => {
            println!("Plugin close. version = {}", ctx.get_version());
        }
    }

    return 0;
}

pub fn from_ctx(ctx: &mut cr_plugin) -> &mut Plugin<State>

pub fn set_temporary_path(&mut self, path: &str)

pub fn update(&mut self, reload_check: bool) -> i32

Examples found in repository

examples/basic_host.rs (line 23)

fn main() {
    let mut plugin_name = env::current_exe().expect("Failed to get current path");
    println!("Path of this executable is: {}", plugin_name.display());
    plugin_name.set_file_name("libbasic_guest.so");
    // build the libbasic_guest.so file from the samples of cr.h
    println!("Call cr_plugin_load(ctx, {:?})", plugin_name);
    let mut plugin = BasicPlugin::new(BasicState { counter: 0 }, plugin_name.to_str().unwrap());

    let mut err_cnt = 0;
    loop {
        println!("Run Update:");
        let rc = plugin.update(true);
        println!("cr_plugin_update(ctx, true) = {}", rc);
        if rc != 0 {
            println!("Plugin error: {:?}", plugin.get_failure());
            err_cnt += 1;
            if err_cnt > 10 {
                break;
            }
        }
        thread::sleep(Duration::from_millis(200));
    }
    println!("Call cr_plugin_close(ctx)");
    drop(plugin);
    println!("exit");
}

pub fn get_version(&self) -> u32

Examples found in repository

examples/basic_guest.rs (line 42)

pub fn plugin_main(ctx: &mut BasicPlugin, cr_op: cr::cr_op) -> i32 {
    // Test "guest" feature.
    #[cfg(not(feature = "guest"))]
    {
        println!("Guest compiled with host-side code.");
        // This code will only run if the "guest" feature is not used.
        let plugin = BasicPlugin::new(BasicState { counter: 0 }, "test");
        println!("- plugin = {:?}", plugin);
    }

    println!("test recompile. test1");
    //panic!("test");
    // Test crash.
    // Rollback to the previous version seems to work once.
    // Then on the next reload it gets stuck in a setjmp/longjmp loop?
    /*
    unsafe {
        let ptr
            = std::ptr::null_mut() as *mut std::os::raw::c_int;
        // invalid read.
        println!("Read from null pointer: {:?}", *ptr);
        // invalid write.
        *ptr = 0x1234;
    }
    // */
    match cr_op {
        CR_LOAD => {
            println!("Plugin load. version = {}", ctx.get_version());
        }
        CR_STEP => {
            let version = ctx.get_version();
            let state = ctx.state_mut();
            state.counter += 1;
            println!(
                "Plugin step. count = {}. version = {}",
                state.counter, version
            );

            // slow down the printing.
            thread::sleep(Duration::from_millis(200));
        }
        CR_UNLOAD => {
            println!("Plugin unload. version = {}", ctx.get_version());
        }
        CR_CLOSE => {
            println!("Plugin close. version = {}", ctx.get_version());
        }
    }

    return 0;
}

pub fn get_failure(&self) -> cr_failure

Examples found in repository

examples/basic_host.rs (line 26)

fn main() {
    let mut plugin_name = env::current_exe().expect("Failed to get current path");
    println!("Path of this executable is: {}", plugin_name.display());
    plugin_name.set_file_name("libbasic_guest.so");
    // build the libbasic_guest.so file from the samples of cr.h
    println!("Call cr_plugin_load(ctx, {:?})", plugin_name);
    let mut plugin = BasicPlugin::new(BasicState { counter: 0 }, plugin_name.to_str().unwrap());

    let mut err_cnt = 0;
    loop {
        println!("Run Update:");
        let rc = plugin.update(true);
        println!("cr_plugin_update(ctx, true) = {}", rc);
        if rc != 0 {
            println!("Plugin error: {:?}", plugin.get_failure());
            err_cnt += 1;
            if err_cnt > 10 {
                break;
            }
        }
        thread::sleep(Duration::from_millis(200));
    }
    println!("Call cr_plugin_close(ctx)");
    drop(plugin);
    println!("exit");
}

pub fn state(&self) -> &State

pub fn state_mut(&mut self) -> &mut State

Examples found in repository

examples/basic_guest.rs (line 46)

pub fn plugin_main(ctx: &mut BasicPlugin, cr_op: cr::cr_op) -> i32 {
    // Test "guest" feature.
    #[cfg(not(feature = "guest"))]
    {
        println!("Guest compiled with host-side code.");
        // This code will only run if the "guest" feature is not used.
        let plugin = BasicPlugin::new(BasicState { counter: 0 }, "test");
        println!("- plugin = {:?}", plugin);
    }

    println!("test recompile. test1");
    //panic!("test");
    // Test crash.
    // Rollback to the previous version seems to work once.
    // Then on the next reload it gets stuck in a setjmp/longjmp loop?
    /*
    unsafe {
        let ptr
            = std::ptr::null_mut() as *mut std::os::raw::c_int;
        // invalid read.
        println!("Read from null pointer: {:?}", *ptr);
        // invalid write.
        *ptr = 0x1234;
    }
    // */
    match cr_op {
        CR_LOAD => {
            println!("Plugin load. version = {}", ctx.get_version());
        }
        CR_STEP => {
            let version = ctx.get_version();
            let state = ctx.state_mut();
            state.counter += 1;
            println!(
                "Plugin step. count = {}. version = {}",
                state.counter, version
            );

            // slow down the printing.
            thread::sleep(Duration::from_millis(200));
        }
        CR_UNLOAD => {
            println!("Plugin unload. version = {}", ctx.get_version());
        }
        CR_CLOSE => {
            println!("Plugin close. version = {}", ctx.get_version());
        }
    }

    return 0;
}

Trait Implementations

impl<State: Debug> Debug for Plugin<State>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<State> Drop for Plugin<State>

fn drop(&mut self)

Executes the destructor for this type.