# crabi_test2

**crabi_test2** is an experimental Rust library designed to facilitate advanced exploration and understanding of Application Binary Interface (ABI) concepts, particularly as they relate to cross-language interoperability and Rust’s Foreign Function Interface (FFI).

## Key Features

- **Data Structure Layouts**: Examples of `#[repr(C)]` data structures to understand how Rust data can be made ABI-compliant.
- **Cross-Language Function Calls**: `extern "C"` functions that show how data is passed and modified between Rust and other languages.
- **Function Callbacks**: Examples of passing function pointers between Rust and C for event-driven programming.
- **Error Handling**: Demonstrations of handling errors gracefully when interfacing with C.
- **Memory Management**: Examples covering safe memory management practices across the FFI boundary.
- **Practical Tests**: Built-in tests to validate behavior and illustrate common pitfalls in ABI design and implementation.

## Use Cases

crabi_test2 is suitable for:

- Developers interested in systems programming and understanding how Rust can interface with C and other languages.
- Experiments and educational purposes, offering a foundation to explore the implications of ABI stability or the lack thereof in Rust.

## Installation

To install `crabi_test2`, add it to your `Cargo.toml`:

```toml
[dependencies]
crabi_test2 = "0.1.0"
thiserror = "1.0"
```
## Example Usage

```rust
use crabi_test2::{SimpleData, modify_simple_data, CallbackData, register_callback, trigger_callback, ComplexData, process_complex_data};

fn main() {
    // Example usage of SimpleData and modify_simple_data
    let mut data = SimpleData {
        value: 0,
        flag: false,
    };

    // Call the function to modify the data
    modify_simple_data(&mut data as *mut _);

    // Print the modified data
    println!("Value: {}, Flag: {}", data.value, data.flag);

    // Example usage of CallbackData
    extern "C" fn callback_fn(val: i32) {
        println!("Callback called with value: {}", val);
    }

    let mut callback_data = CallbackData {
        value: 42,
        callback: None,
    };

    // Register and trigger the callback
    register_callback(&mut callback_data as *mut _, callback_fn);
    trigger_callback(&mut callback_data as *mut _);

    // Example usage of ComplexData and process_complex_data
    extern "C" fn complex_callback(data: *const ComplexData) {
        unsafe {
            println!("ComplexData Callback with ID: {}", (*data).id);
        }
    }

    let mut complex_data = ComplexData {
        id: 1,
        name: "Example".as_ptr(),
        name_len: 7,
        values: [1.0, 2.0, 3.0, 4.0, 5.0],
        callback: Some(complex_callback),
    };

    process_complex_data(&mut complex_data as *mut
```
## License
Distributed under the MIT or Apache 2.0 license.

## Author
Ben Santora <bensatlantik@gmail.com>

## Donate
https://bensatlantik.github.io/