# 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: extern "C" fn(trixy::types::String) -> trixy::types::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 {
                crate::test_c::CallbackPriority_c::High => Self::High,
                crate::test_c::CallbackPriority_c::Medium => Self::Medium,
                crate::test_c::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 {
    #[allow(unused_imports)]
    use crate::callback_function;
    /// 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 {
                crate::test::CallbackPriority::High => Self::High,
                crate::test::CallbackPriority::Medium => Self::Medium,
                crate::test::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: extern "C" fn(trixy::types::String) -> trixy::types::String,
        /// Very important field for keeping time constant
        pub timeout: trixy::types::u32,
    }
    impl TryFrom<crate::test::Callback> for Callback_c {
        type Error = trixy::types::error::TypeConversionError;
        fn try_from(value: crate::test::Callback) -> Result<Self, Self::Error> {
            Ok(Self {
                func: value.func.try_into()?,
                timeout: value.timeout.try_into()?,
            })
        }
    }
}
#[no_mangle]
pub extern "C" fn test_execute_callback(
    callback: crate::test_c::Callback_c,
    priority: crate::test_c::CallbackPriority_c,
) -> core::ffi::c_int {
    callback_function(
        crate::Commands::Test(crate::test::Test::execute_callback {
            callback: match callback.try_into() {
                Ok(ok) => ok,
                Err(err) => {
                    trixy::types::traits::errno::set(err.into());
                    return 0;
                }
            },
            priority: match priority.try_into() {
                Ok(ok) => ok,
                Err(err) => {
                    trixy::types::traits::errno::set(err.into());
                    return 0;
                }
            },
        }),
    );
    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)
 */
struct Callback
{
  /**
   * Very important field
   */
  const char *(*func) (const char *);
  /**
   * 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) (struct Callback, enum CallbackPriority);
};

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

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