Function initialize 

pub unsafe fn initialize(data: WolframLibraryData) -> Result<(), ()>

Initialize static data for the current Wolfram library.

This function should be called during the execution of the WolframLibrary_initialize() hook provided by this library.

This function initializes the lazy Wolfram Runtime Library bindings in the rtl module.

Safety

The following conditions must be met for a call to this function to be valid:

• data must be a valid and fully initialized sys::WolframLibraryData instance created by the Wolfram Kernel and passed into the current LibraryLink function.
• The call to initialize() must happen from the main Kernel thread. This is true for all LibraryLink functions called directly by the Kernel.

Relation to #[init]

If the #[init] annotation is used to designate a library initialization function, initialize() will be called automatically.

Example

Note: Prefer to use #[init] to designate an initialization function, instead of manually defining an unsafe initialization function as shown in this example.

When a dynamic library is loaded by the Wolfram Language (for example, via LibraryFunctionLoad), the system will call the function WolframLibrary_initialize() if one is provided by the library. This function is used to initialize callbacks from the library into functions provided by the Wolfram runtime.

use std::os::raw::c_int;
use wolfram_library_link::{sys, initialize};

#[no_mangle]
extern "C" fn WolframLibrary_initialize(data: sys::WolframLibraryData) -> c_int {
    match unsafe { initialize(data) } {
        Ok(()) => return 0,
        Err(()) => return 1,
    }
}

Examples found in repository

examples/tests/test_data_store.rs (line 11)

pub unsafe extern "C" fn WolframLibrary_initialize(lib: WolframLibraryData) -> c_int {
    match wll::initialize(lib) {
        Ok(()) => return 0,
        Err(()) => return 1,
    }
}

examples/async/async_file_watcher_raw.rs (line 35)

pub extern "C" fn start_file_watcher(
    lib_data: sys::WolframLibraryData,
    arg_count: mint,
    args: *mut MArgument,
    res: MArgument,
) -> c_uint {
    let args = unsafe { std::slice::from_raw_parts(args, arg_count as usize) };

    if args.len() != 2 {
        return LIBRARY_FUNCTION_ERROR;
    }

    if unsafe { wll::initialize(lib_data) }.is_err() {
        return LIBRARY_FUNCTION_ERROR;
    }

    let task_arg = unsafe {
        FileWatcherArgs {
            pause_interval_ms: u64::try_from(*args[0].integer)
                .expect("i64 interval overflows u64"),
            path: {
                let cstr = CStr::from_ptr(*args[1].utf8string);
                match cstr.to_str() {
                    Ok(s) => PathBuf::from(s),
                    Err(_) => return LIBRARY_FUNCTION_ERROR,
                }
            },
        }
    };

    // FIXME: This box is being leaked. Where is an appropriate place to drop it?
    let task_arg = Box::into_raw(Box::new(task_arg)) as *mut c_void;

    // Spawn a new thread, which will run in the background and check for file
    // modifications.
    unsafe {
        let task_id: mint = wll::rtl::createAsynchronousTaskWithThread(
            Some(file_watch_thread_function),
            task_arg,
        );
        *res.integer = task_id;
    }

    LIBRARY_NO_ERROR
}