=VLOOKUP(A12;Table1_data;MATCH(B12;Table1_headers;0);FALSE)

=VLOOKUP(coffee_type;Table1_data;MATCH(coffee_size;Table1_headers;0);FALSE)

=LAMBDA(coffee_type;coffee_size;VLOOKUP(coffee_type;Table1_data;MATCH(coffee_size;Table1_headers;0);FALSE))

=CalcCoffeePriceForSize(A12;B12)

xlsgen::IXlsWorksheetPtr worksheet = workbook->WorksheetByIndex[1];

// create a lambda function
xlsgen::IXlsDynamicRangePtr dynrange = worksheet->NewDynamicRange(L"CalcCoffeePriceForSize");
dynrange->Formula = L"=LAMBDA(coffee_type;coffee_size;VLOOKUP(coffee_type;Table1_data;MATCH(coffee_size;Table1_headers;0);FALSE))";
dynrange->UserDefinedFunction = TRUE;
dynrange->Description = L"CalcCoffeePriceForSize computes the price of a coffee for a given coffee type and a given coffee size.";

// use the lambda function
worksheet->Formula[12][3] = L"=CalcCoffeePriceForSize(A12;B12)";

// importing a sample JSON file

xlsgen::IXlsWorksheetPtr worksheet = workbook->AddWorksheet(L"Sheet1");

xlsgen::IXlsJSONImportPtr json = worksheet->Import->JSON;

json->Options->AutoFormatMapping = FALSE;
json->Options->FirstRow = worksheet->HorizontalPane->SplitLimit; // insert the data right after the split

json->ImportFile(L"input\\jsonfile3.json");

- src
   |
   |- main.rs (your code goes here)
   |- xlsgen.rs (xlsgen interface layer (available from the xlsgen install package))
- Cargo.toml (known dependency declaration (winapi))

cd \tmp\rust\simple
cargo build

cd \tmp\rust\simple
cargo run

  let _hr = unsafe { 
               (*p_worksheet).put_float(4, 2, 4.5);
            };	

use winapi::{Class, Interface};

macro_rules! new_pointer {
     ($param:ident, $type:ty) => {let mut $param: *mut $type = unsafe { std::mem::zeroed() };}
}

new_pointer!(p_engine, xlsgen::IXlsEngine);

use winapi::um::winnt::{LPWSTR};
use winapi::{Class, Interface};
use std::ffi::{OsStr, OsString};
use std::os::windows::ffi::OsStrExt;
use std::os::windows::ffi::OsStringExt;
use std::slice;

pub mod xlsgen;


// *** MACROS begin here ***

macro_rules! retVal {
    ($param:ident) => {&mut $param as *mut _ as *mut _}
}

macro_rules! new_pointer {
    ($param:ident, $type:ty) => {let mut $param: *mut $type = unsafe { std::mem::zeroed() };}
}

macro_rules! release_pointer {
    ($param:ident) => { unsafe { (&mut * $param).Release() }; }
}

macro_rules! release_bstr_string {
    ($param:ident) => { unsafe { winapi::um::oleauto::SysFreeString( $param as LPWSTR ) }; }
}


// *** MACROS end here ***

// unicode strings (Rust stores strings using UTF8 encoding, not UTF16) so we have to convert back and forth

fn to_wstring(string: &str) -> Vec<u16> {
    let mut v: Vec<u16> = OsStr::new(string).encode_wide().collect();
    v.push(0); // EOL
    v
}

fn from_wstring(string: LPWSTR) -> String {
    let string_slice = unsafe {
        let len = winapi::um::oleauto::SysStringLen(string);
        slice::from_raw_parts(string, len as usize)
    };

    OsString::from_wide(string_slice).into_string().unwrap()
}


fn main() {

    println!("step1");

    let _hr = unsafe { winapi::um::objbase::CoInitialize(std::ptr::null_mut()) };

    println!("step2");

    new_pointer!(p_engine, xlsgen::IXlsEngine);

    let _hr = unsafe { winapi::um::combaseapi::CoCreateInstance(
			&xlsgen::XlsEngine::uuidof(), 
			std::ptr::null_mut(), 
			winapi::shared::wtypesbase::CLSCTX_INPROC_SERVER, 
			&xlsgen::IXlsEngine::uuidof(), 
			retVal!(p_engine))
	        };

    println!("step3 {}", _hr);

    new_pointer!(p_workbook, xlsgen::IXlsWorkbook);

    let _hr = unsafe { (*p_engine).new(to_wstring("d:\\tmp\\eer.xlsx").as_ptr(), retVal!(p_workbook)) };

    new_pointer!(p_worksheet1, xlsgen::IXlsWorksheet);

    let _hr = unsafe { (*p_workbook).addworksheet(to_wstring("sheet 1").as_ptr(), retVal!(p_worksheet1)) };	

    new_pointer!(p_worksheet2, xlsgen::IXlsWorksheet);

    let _hr = unsafe { (*p_workbook).addworksheet(to_wstring("sheet 2").as_ptr(), retVal!(p_worksheet2)) };	

    println!("step4");

    let mut i_wksht_count : i32 = 0;

    let _hr = unsafe { (*p_workbook).get_worksheetcount(&mut i_wksht_count) };

    println!("step4a {}, wkshtCount = {}", _hr, i_wksht_count);

    unsafe { (*p_workbook).put_factorizedstringsmode(true) };

    let mut b_factorized : bool = false;

    let _hr = unsafe { (*p_workbook).get_factorizedstringsmode(&mut b_factorized) };

    println!("step4ab {}, bFactorized = {}", _hr, b_factorized);

    // write some content
    for r in 1..10 {
       let _hr = unsafe { (*p_worksheet1).put_label(r, 2, to_wstring("hello world").as_ptr()) };	
     }

    // read some content

    println!("step4b");

    new_pointer!(cell_string, LPWSTR);

    println!("step4c");

    let _hr = unsafe { (*p_worksheet1).get_label(3, 2, retVal!(cell_string)) };	

    println!("step5");

    println!("cell value is : {}", from_wstring(cell_string as LPWSTR));

    println!("step6");

    new_pointer!(p_richlabel, xlsgen::IXlsRichLabel);

    println!("step6b");

    let _hr = unsafe { (*p_worksheet1).newrichlabel(retVal!(p_richlabel)) };	

    println!("step6c {}", _hr);

    let _hr = unsafe { (*p_richlabel).put_htmllabel(to_wstring("<span>hello <b>world</b></span>").as_ptr()) };	

    println!("step6d");

    let _hr = unsafe { (*p_worksheet1).put_richlabel(1, 4, p_richlabel) };	

    println!("step6e");

    let _hr = unsafe { (*p_workbook).close(); };

    println!("step7");

    release_bstr_string!(cell_string);
    release_pointer!(p_worksheet1);
    release_pointer!(p_worksheet2);
    release_pointer!(p_workbook);
    release_pointer!(p_engine);

    unsafe { winapi::um::combaseapi::CoUninitialize() };

    println!("step8");

}

(...)

RIDL!{#[uuid(0xD97500CF,0x37CC,0x48fd,0x87,0x72,0x0E,0xBC,0x8F,0x8A,0x93,0x76)]
interface IXlsEngine(IXlsEngineVtbl): IDispatch(IDispatchVtbl) {
    fn new(    // creates a new .xls/.xlsx file with the name (filename or filepath) passed in parameter.
        excelfilename : LPCWSTR,
        workbook : *mut *mut IXlsWorkbook,
    ) -> HRESULT,

(...)

RIDL!{#[uuid(0x12B7B224,0xC026,0x4eb6,0xBA,0x94,0xC4,0x9B,0x91,0x6F,0x77,0x40)]
interface IXlsWorkbook(IXlsWorkbookVtbl): IDispatch(IDispatchVtbl) {
    fn addworksheet(    // creates a new worksheet with the name passed in parameter. The following characters are forbidden : / \\ : * [ ], and the name must be less than 32 characters long.
        name : LPCWSTR,
        worksheet : *mut *mut IXlsWorksheet,
    ) -> HRESULT,

(...)

RIDL!{#[uuid(0xB150D9DA,0x1F10,0x4850,0x9A,0xBB,0x76,0xD9,0x95,0x47,0x96,0xEE)]
interface IXlsWorksheet(IXlsWorksheetVtbl): IDispatch(IDispatchVtbl) {
    fn put_label(    // puts a label in a cell.
        row : i32,
        col : i32,
        label : LPCWSTR,
    ) -> HRESULT,

worksheet->Cell[2][1]->HtmlDate = L"<div format=\"[h]:mm:ss\">30:00:00</div>";

• read existing pivot tables
• write pivot charts (introduced in libre office 5.4.1)
• read cell data validations
• read auto filter and custom filters
• improved writing of custom filters