# Host files

File path: `out/dir/api.rs`

```rust
// Host code
/* Rust API */
#[derive(Debug)]
pub enum Commands {
    Test(test::Test),
}
pub mod test {
    /// This struct will be used later on (and this is also a struct doc comment test)
    #[allow(non_camel_case_types)]
    #[derive(Debug)]
    pub struct Callback {
        /// Very important field
        pub func: fn(String) -> String,
        /// Very important field for keeping time constant
        pub timeout: u32,
    }
    impl trixy::types::traits::convert_trait::Convertible for Callback {
        type Ptr = crate::test_c::Callback_c;
        fn into_ptr(self) -> Self::Ptr {
            Self::Ptr {
                func: self.func.into(),
                timeout: self.timeout.into(),
            }
        }
        fn from_ptr(
            ptr: Self::Ptr,
        ) -> Result<Self, trixy::types::error::TypeConversionError> {
            todo!()
        }
    }
    impl TryFrom<crate::test_c::Callback_c> for Callback {
        type Error = trixy::types::error::TypeConversionError;
        fn try_from(value: crate::test_c::Callback_c) -> Result<Self, Self::Error> {
            Ok(Self {
                func: value.func.try_into()?,
                timeout: value.timeout.try_into()?,
            })
        }
    }
    /// Same thing as above (and a enum doc comment test)
    #[allow(non_camel_case_types)]
    #[derive(Debug)]
    pub enum CallbackPriority {
        /// Callback **now**
        High,
        /// Maybe do a callback
        Medium,
        /// Calling back is ..
        /// really not important ..
        /// like not even think about doing it
        Low,
    }
    impl From<crate::test_c::CallbackPriority_c> for CallbackPriority {
        fn from(value: crate::test_c::CallbackPriority_c) -> Self {
            match value {
                CallbackPriority_c::High => Self::High,
                CallbackPriority_c::Medium => Self::Medium,
                CallbackPriority_c::Low => Self::Low,
            }
        }
    }
    #[derive(Debug)]
    pub enum Test {
        #[allow(non_camel_case_types)]
        execute_callback {
            callback: crate::test::Callback,
            priority: crate::test::CallbackPriority,
        },
    }
}
/* C API */
pub mod test_c {
    /// Same thing as above (and a enum doc comment test)
    #[allow(non_camel_case_types)]
    #[repr(C)]
    #[derive(Debug)]
    pub enum CallbackPriority_c {
        /// Callback **now**
        High,
        /// Maybe do a callback
        Medium,
        /// Calling back is ..
        /// really not important ..
        /// like not even think about doing it
        Low,
    }
    impl From<crate::test::CallbackPriority> for CallbackPriority_c {
        fn from(value: crate::test::CallbackPriority) -> Self {
            match value {
                CallbackPriority::High => Self::High,
                CallbackPriority::Medium => Self::Medium,
                CallbackPriority::Low => Self::Low,
            }
        }
    }
    /// This struct will be used later on (and this is also a struct doc comment test)
    #[allow(non_camel_case_types)]
    #[repr(C)]
    #[derive(Debug)]
    pub struct Callback_c {
        /// Very important field
        pub func: fn(String) -> String,
        /// Very important field for keeping time constant
        pub timeout: trixy::types::u32,
    }
}
#[no_mangle]
pub extern "C" fn test_execute_callback(
    callback: crate::test::Callback,
    priority: crate::test::CallbackPriority,
) -> core::ffi::c_int {
    callback_function(test_execute_callback);
    return 1;
}
// vim: filetype=rust
```

# Auxiliary files

File path: `dist/interface.h`

```c
#if !defined TRIXY_MAIN_HEADER
#define TRIXY_MAIN_HEADER

#include "errno.h"
#include "string.h"
#include "vec.h"

/**
Same thing as above (and a enum doc comment test)
*/
enum CallbackPriority
{
  /**
Callback **now**
*/
  High,
  /**
Maybe do a callback
*/
  Medium,
  /**
Calling back is ..
*/
  /**
  really not important ..
*/
  /**
  like not even think about doing it
*/
  Low,
};

/**
This struct will be used later on (and this is also a struct doc comment test)
*/
Callback
{
  /**
Very important field
*/ const char *(*name) (const char *name)func; /**
Very important field for keeping time constant
*/
  uint32_t timeout;
};
extern int test_execute_callback (struct Callback callback,
                                  enum CallbackPriority priority);

struct test
{
  int (*execute_callback) ();
};

const struct test test = {
  .execute_callback = test_execute_callback,
};

#endif // if !defined TRIXY_MAIN_HEADER
// vim: filetype=c
```