opendaq 0.1.0

// Generated by tools/generate_bindings.py -- do not edit by hand.

// Mechanical output: lint findings here are the generator's business.
#![allow(clippy::all, unused_imports, rustdoc::bare_urls)]

use crate::error::{check, Error, Result};
use crate::object::{BaseObject, Interface, Ref};
use crate::sys;
use crate::value::{Complex, Ratio, Value};
use crate::generated::*;
use std::ffi::c_char;

/// Represents a collection of @ref ILoggerComponent "Logger Components" with multiple
/// @ref ILoggerSink "Logger Sinks" and a single @ref ILoggerThreadPool "Logger Thread Pool"
/// shared between components.
/// Logger is used to create, manage and maintain Logger Components associated with different parts of
/// the openDAQ SDK. The Logger provides methods, allowing for components to be added and removed dynamically.
/// The components added within the same Logger object should have unique names. Each newly added
/// component inherits threshold log severity level from the Logger. Then this level can be changed
/// independently per component. The set of sinks is initialized on the Logger object creation
/// and cannot be changed after.
/// Additionally, Logger provides the ability to manage flushing policies for the added components,
/// see `flushOnLevel` method.
/// Wrapper over the openDAQ `daqLogger` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct Logger(pub(crate) BaseObject);

impl std::ops::Deref for Logger {
    type Target = BaseObject;
    fn deref(&self) -> &BaseObject { &self.0 }
}
impl crate::sealed::Sealed for Logger {}
unsafe impl Interface for Logger {
    const NAME: &'static str = "daqLogger";
    fn interface_id() -> Option<crate::IntfID> {
        let mut id = crate::IntfID { Data1: 0, Data2: 0, Data3: 0, Data4: 0 };
        unsafe { (crate::sys::api().daqLogger_getInterfaceId)(&mut id) };
        Some(id)
    }
    unsafe fn from_raw(ptr: *mut std::ffi::c_void) -> Option<Self> {
        Ref::from_owned(ptr).map(Self::__from_ref)
    }
    fn as_base_object(&self) -> &BaseObject { &self.0 }
}
impl Logger {
    #[doc(hidden)]
    pub(crate) fn __from_ref(r: Ref) -> Self { Logger(BaseObject(r)) }
}
impl std::fmt::Display for Logger {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.as_base_object(), f)
    }
}
impl From<&Logger> for Value {
    fn from(value: &Logger) -> Value { Value::Object(value.to_base_object()) }
}
impl From<Logger> for Value {
    fn from(value: Logger) -> Value { Value::Object(value.to_base_object()) }
}
impl crate::value::FromDaqOwned for Logger {
    unsafe fn from_daq_owned(ptr: *mut std::ffi::c_void, op: &'static str) -> Result<Self> {
        crate::value::cast_owned(ptr, op)
    }
}

/// Loads all available modules in a implementation-defined manner. User can also side-load custom modules via `addModule` call.
/// Wrapper over the openDAQ `daqModuleManager` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct ModuleManager(pub(crate) BaseObject);

impl std::ops::Deref for ModuleManager {
    type Target = BaseObject;
    fn deref(&self) -> &BaseObject { &self.0 }
}
impl crate::sealed::Sealed for ModuleManager {}
unsafe impl Interface for ModuleManager {
    const NAME: &'static str = "daqModuleManager";
    fn interface_id() -> Option<crate::IntfID> {
        let mut id = crate::IntfID { Data1: 0, Data2: 0, Data3: 0, Data4: 0 };
        unsafe { (crate::sys::api().daqModuleManager_getInterfaceId)(&mut id) };
        Some(id)
    }
    unsafe fn from_raw(ptr: *mut std::ffi::c_void) -> Option<Self> {
        Ref::from_owned(ptr).map(Self::__from_ref)
    }
    fn as_base_object(&self) -> &BaseObject { &self.0 }
}
impl ModuleManager {
    #[doc(hidden)]
    pub(crate) fn __from_ref(r: Ref) -> Self { ModuleManager(BaseObject(r)) }
}
impl std::fmt::Display for ModuleManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.as_base_object(), f)
    }
}
impl From<&ModuleManager> for Value {
    fn from(value: &ModuleManager) -> Value { Value::Object(value.to_base_object()) }
}
impl From<ModuleManager> for Value {
    fn from(value: ModuleManager) -> Value { Value::Object(value.to_base_object()) }
}
impl crate::value::FromDaqOwned for ModuleManager {
    unsafe fn from_daq_owned(ptr: *mut std::ffi::c_void, op: &'static str) -> Result<Self> {
        crate::value::cast_owned(ptr, op)
    }
}

/// A thread-pool scheduler that supports scheduling one-off functions as well as dependency graphs.
/// Wrapper over the openDAQ `daqScheduler` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct Scheduler(pub(crate) BaseObject);

impl std::ops::Deref for Scheduler {
    type Target = BaseObject;
    fn deref(&self) -> &BaseObject { &self.0 }
}
impl crate::sealed::Sealed for Scheduler {}
unsafe impl Interface for Scheduler {
    const NAME: &'static str = "daqScheduler";
    fn interface_id() -> Option<crate::IntfID> {
        let mut id = crate::IntfID { Data1: 0, Data2: 0, Data3: 0, Data4: 0 };
        unsafe { (crate::sys::api().daqScheduler_getInterfaceId)(&mut id) };
        Some(id)
    }
    unsafe fn from_raw(ptr: *mut std::ffi::c_void) -> Option<Self> {
        Ref::from_owned(ptr).map(Self::__from_ref)
    }
    fn as_base_object(&self) -> &BaseObject { &self.0 }
}
impl Scheduler {
    #[doc(hidden)]
    pub(crate) fn __from_ref(r: Ref) -> Self { Scheduler(BaseObject(r)) }
}
impl std::fmt::Display for Scheduler {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.as_base_object(), f)
    }
}
impl From<&Scheduler> for Value {
    fn from(value: &Scheduler) -> Value { Value::Object(value.to_base_object()) }
}
impl From<Scheduler> for Value {
    fn from(value: Scheduler) -> Value { Value::Object(value.to_base_object()) }
}
impl crate::value::FromDaqOwned for Scheduler {
    unsafe fn from_daq_owned(ptr: *mut std::ffi::c_void, op: &'static str) -> Result<Self> {
        crate::value::cast_owned(ptr, op)
    }
}

impl Logger {
    /// Creates a component with a given name and adds it to the Logger object.
    /// @param name The component's name.
    /// @param\[out\] component Added component.
    /// @retval OPENDAQ_ERR_INVALIDPARAMETER if @p name is empty string.
    /// Calls the openDAQ C function `daqLogger_addComponent()`.
    pub fn add_component(&self, name: &str) -> Result<Option<LoggerComponent>> {
        let __name = crate::marshal::make_string(name)?;
        let mut __component: *mut sys::daqLoggerComponent = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLogger_addComponent)(self.as_raw() as *mut _, __name.as_ptr() as *mut _, &mut __component) };
        check(__code, "daqLogger_addComponent")?;
        Ok(unsafe { crate::marshal::take_object::<LoggerComponent>(__component as *mut _) })
    }

    /// Calls the openDAQ C function `daqLogger_createLogger()`.
    pub fn new(sinks: impl Into<Value>, level: LogLevel) -> Result<Logger> {
        let __sinks = crate::value::to_daq(&sinks.into())?;
        let mut __obj: *mut sys::daqLogger = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLogger_createLogger)(&mut __obj, crate::value::opt_ref_ptr(&__sinks) as *mut _, level as u32) };
        check(__code, "daqLogger_createLogger")?;
        Ok(unsafe { crate::marshal::require_object::<Logger>(__obj as *mut _, "daqLogger_createLogger") }?)
    }

    /// Triggers writing out the messages stored in temporary buffers for added components and sinks associated with the Logger object.
    /// Calls the openDAQ C function `daqLogger_flush()`.
    pub fn flush(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqLogger_flush)(self.as_raw() as *mut _) };
        check(__code, "daqLogger_flush")?;
        Ok(())
    }

    /// Sets the minimum severity level of messages to be automatically flushed by components of Logger object.
    /// @param level The log severity level.
    /// Calls the openDAQ C function `daqLogger_flushOnLevel()`.
    pub fn flush_on_level(&self, level: LogLevel) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqLogger_flushOnLevel)(self.as_raw() as *mut _, level as u32) };
        check(__code, "daqLogger_flushOnLevel")?;
        Ok(())
    }

    /// Gets an added component by name.
    /// @param name The component's name.
    /// @param\[out\] component The logger component with the name equal to @p `name`.
    /// @retval OPENDAQ_ERR_NOTFOUND if a component with the specified @p name was not added.
    /// Calls the openDAQ C function `daqLogger_getComponent()`.
    pub fn component(&self, name: &str) -> Result<Option<LoggerComponent>> {
        let __name = crate::marshal::make_string(name)?;
        let mut __component: *mut sys::daqLoggerComponent = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLogger_getComponent)(self.as_raw() as *mut _, __name.as_ptr() as *mut _, &mut __component) };
        check(__code, "daqLogger_getComponent")?;
        Ok(unsafe { crate::marshal::take_object::<LoggerComponent>(__component as *mut _) })
    }

    /// Gets a list of added components.
    /// @param\[out\] components The list of added components.
    /// Calls the openDAQ C function `daqLogger_getComponents()`.
    pub fn components(&self) -> Result<Vec<LoggerComponent>> {
        let mut __components: *mut sys::daqList = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLogger_getComponents)(self.as_raw() as *mut _, &mut __components) };
        check(__code, "daqLogger_getComponents")?;
        Ok(unsafe { crate::marshal::take_list::<LoggerComponent>(__components as *mut _, "daqLogger_getComponents") }?)
    }

    /// Gets the default log severity level.
    /// @param\[out\] level The log severity level.
    /// Calls the openDAQ C function `daqLogger_getLevel()`.
    pub fn level(&self) -> Result<LogLevel> {
        let mut __level: u32 = 0;
        let __code = unsafe { (crate::sys::api().daqLogger_getLevel)(self.as_raw() as *mut _, &mut __level) };
        check(__code, "daqLogger_getLevel")?;
        Ok(crate::marshal::enum_out(LogLevel::from_raw(__level), "daqLogger_getLevel")?)
    }

    /// Gets an added component by name or creates a new one with a given name and adds it to the Logger object.
    /// @param name The component's name.
    /// @param\[out\] component The logger component with the name equal to @p `name`.
    /// @retval OPENDAQ_ERR_INVALIDPARAMETER if @p name is empty string.
    /// Calls the openDAQ C function `daqLogger_getOrAddComponent()`.
    pub fn or_add_component(&self, name: &str) -> Result<Option<LoggerComponent>> {
        let __name = crate::marshal::make_string(name)?;
        let mut __component: *mut sys::daqLoggerComponent = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLogger_getOrAddComponent)(self.as_raw() as *mut _, __name.as_ptr() as *mut _, &mut __component) };
        check(__code, "daqLogger_getOrAddComponent")?;
        Ok(unsafe { crate::marshal::take_object::<LoggerComponent>(__component as *mut _) })
    }

    /// Removes the component with a given name from the Logger object.
    /// @param name The component's name.
    /// @retval OPENDAQ_ERR_NOTFOUND if a component with the specified @p name was not added.
    /// Calls the openDAQ C function `daqLogger_removeComponent()`.
    pub fn remove_component(&self, name: &str) -> Result<()> {
        let __name = crate::marshal::make_string(name)?;
        let __code = unsafe { (crate::sys::api().daqLogger_removeComponent)(self.as_raw() as *mut _, __name.as_ptr() as *mut _) };
        check(__code, "daqLogger_removeComponent")?;
        Ok(())
    }

    /// Sets the default log severity level.
    /// @param level The log severity level.
    /// Calls the openDAQ C function `daqLogger_setLevel()`.
    pub fn set_level(&self, level: LogLevel) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqLogger_setLevel)(self.as_raw() as *mut _, level as u32) };
        check(__code, "daqLogger_setLevel")?;
        Ok(())
    }

}

impl ModuleManager {
    /// Side-load a custom module in run-time from memory that was not found by default.
    /// @param module The module to add.
    /// @retval OPENDAQ_ERR_DUPLICATEITEM When an identical @p module was already added.
    /// Calls the openDAQ C function `daqModuleManager_addModule()`.
    pub fn add_module(&self, module: &Module) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqModuleManager_addModule)(self.as_raw() as *mut _, module.as_raw() as *mut _) };
        check(__code, "daqModuleManager_addModule")?;
        Ok(())
    }

    /// Calls the openDAQ C function `daqModuleManager_createModuleManager()`.
    pub fn new(path: &str) -> Result<ModuleManager> {
        let __path = crate::marshal::make_string(path)?;
        let mut __obj: *mut sys::daqModuleManager = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqModuleManager_createModuleManager)(&mut __obj, __path.as_ptr() as *mut _) };
        check(__code, "daqModuleManager_createModuleManager")?;
        Ok(unsafe { crate::marshal::require_object::<ModuleManager>(__obj as *mut _, "daqModuleManager_createModuleManager") }?)
    }

    /// Calls the openDAQ C function `daqModuleManager_createModuleManagerMultiplePaths()`.
    pub fn multiple_paths(paths: impl Into<Value>) -> Result<ModuleManager> {
        let __paths = crate::value::to_daq(&paths.into())?;
        let mut __obj: *mut sys::daqModuleManager = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqModuleManager_createModuleManagerMultiplePaths)(&mut __obj, crate::value::opt_ref_ptr(&__paths) as *mut _) };
        check(__code, "daqModuleManager_createModuleManagerMultiplePaths")?;
        Ok(unsafe { crate::marshal::require_object::<ModuleManager>(__obj as *mut _, "daqModuleManager_createModuleManagerMultiplePaths") }?)
    }

    /// Retrieves all modules known to the manager. Whether they were found or side-loaded.
    /// @param\[out\] modules A list of known modules.
    /// Calls the openDAQ C function `daqModuleManager_getModules()`.
    pub fn modules(&self) -> Result<Vec<Module>> {
        let mut __modules: *mut sys::daqList = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqModuleManager_getModules)(self.as_raw() as *mut _, &mut __modules) };
        check(__code, "daqModuleManager_getModules")?;
        Ok(unsafe { crate::marshal::take_list::<Module>(__modules as *mut _, "daqModuleManager_getModules") }?)
    }

    /// Returns a dictionary of module IDs and the respective public keys of their vendors.
    /// @param\[out\] vendorKeys key (IString) - module ID, value (IString) - public vendor key
    /// Used to identify which authenticator/certificate was used to authenticate the module.
    /// Calls the openDAQ C function `daqModuleManager_getVendorKeys()`.
    pub fn vendor_keys(&self) -> Result<std::collections::HashMap<String, String>> {
        let mut __vendor_keys: *mut sys::daqDict = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqModuleManager_getVendorKeys)(self.as_raw() as *mut _, &mut __vendor_keys) };
        check(__code, "daqModuleManager_getVendorKeys")?;
        Ok(unsafe { crate::marshal::take_dict::<String, String>(__vendor_keys as *mut _, "daqModuleManager_getVendorKeys") }?)
    }

    /// Loads and adds a single module from the given absolute file system path.
    /// @param path The absolute path to the module file.
    /// @param\[out\] module The resulting loaded and added module object.
    /// This function should be used only after the default modules have been loaded using `loadModules`.
    /// The specified path must exist and reference a file with the proper extension.
    /// Calls the openDAQ C function `daqModuleManager_loadModule()`.
    pub fn load_module(&self, path: &str) -> Result<Option<Module>> {
        let __path = crate::marshal::make_string(path)?;
        let mut __module: *mut sys::daqModule = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqModuleManager_loadModule)(self.as_raw() as *mut _, __path.as_ptr() as *mut _, &mut __module) };
        check(__code, "daqModuleManager_loadModule")?;
        Ok(unsafe { crate::marshal::take_object::<Module>(__module as *mut _) })
    }

    /// Loads all modules from the directory path specified during manager construction. The Context is passed to all loaded modules for internal use.
    /// @param context The Context containing the Logger, Scheduler, Property Object Class Manager and Module Manager
    /// Calls the openDAQ C function `daqModuleManager_loadModules()`.
    pub fn load_modules(&self, context: &Context) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqModuleManager_loadModules)(self.as_raw() as *mut _, context.as_raw() as *mut _) };
        check(__code, "daqModuleManager_loadModules")?;
        Ok(())
    }

    /// Toggle whether this module manager will only load modules that can be authenticated.
    /// @param authenticatedOnly true - only authenticated modules are loaded, false - all modules are loaded
    /// Calls the openDAQ C function `daqModuleManager_setAuthenticatedOnly()`.
    pub fn set_authenticated_only(&self, authenticated_only: bool) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqModuleManager_setAuthenticatedOnly)(self.as_raw() as *mut _, u8::from(authenticated_only)) };
        check(__code, "daqModuleManager_setAuthenticatedOnly")?;
        Ok(())
    }

    /// Imports the module authenticator.
    /// @param authenticator A custom authenticator used to verify the signature/checksum of the modules.
    /// Calls the openDAQ C function `daqModuleManager_setModuleAuthenticator()`.
    pub fn set_module_authenticator(&self, authenticator: &ModuleAuthenticator) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqModuleManager_setModuleAuthenticator)(self.as_raw() as *mut _, authenticator.as_raw() as *mut _) };
        check(__code, "daqModuleManager_setModuleAuthenticator")?;
        Ok(())
    }

}

impl Scheduler {
    /// Calls the openDAQ C function `daqScheduler_createScheduler()`.
    pub fn new(logger: &Logger, num_workers: usize) -> Result<Scheduler> {
        let mut __obj: *mut sys::daqScheduler = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqScheduler_createScheduler)(&mut __obj, logger.as_raw() as *mut _, num_workers) };
        check(__code, "daqScheduler_createScheduler")?;
        Ok(unsafe { crate::marshal::require_object::<Scheduler>(__obj as *mut _, "daqScheduler_createScheduler") }?)
    }

    /// Calls the openDAQ C function `daqScheduler_createSchedulerWithMainLoop()`.
    pub fn with_main_loop(logger: &Logger, num_workers: usize, use_main_loop: bool) -> Result<Scheduler> {
        let mut __obj: *mut sys::daqScheduler = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqScheduler_createSchedulerWithMainLoop)(&mut __obj, logger.as_raw() as *mut _, num_workers, u8::from(use_main_loop)) };
        check(__code, "daqScheduler_createSchedulerWithMainLoop")?;
        Ok(unsafe { crate::marshal::require_object::<Scheduler>(__obj as *mut _, "daqScheduler_createSchedulerWithMainLoop") }?)
    }

    /// Checks if the main loop is currently set.
    /// @param\[out\] isSet Returns @c true if the main loop is set and running.
    /// This method does not gauarantee that the main loop is currently running, only that it has been set up.
    /// Calls the openDAQ C function `daqScheduler_isMainLoopSet()`.
    pub fn is_main_loop_set(&self) -> Result<bool> {
        let mut __is_set: u8 = 0;
        let __code = unsafe { (crate::sys::api().daqScheduler_isMainLoopSet)(self.as_raw() as *mut _, &mut __is_set) };
        check(__code, "daqScheduler_isMainLoopSet")?;
        Ok(__is_set != 0)
    }

    /// Returns whether more than one worker thread is used.
    /// @param\[out\] multiThreaded Returns @c true if more that one worker thread is used by the scheduler.
    /// Calls the openDAQ C function `daqScheduler_isMultiThreaded()`.
    pub fn is_multi_threaded(&self) -> Result<bool> {
        let mut __multi_threaded: u8 = 0;
        let __code = unsafe { (crate::sys::api().daqScheduler_isMultiThreaded)(self.as_raw() as *mut _, &mut __multi_threaded) };
        check(__code, "daqScheduler_isMultiThreaded")?;
        Ok(__multi_threaded != 0)
    }

    /// Starts and blocks the main event loop, executing scheduled tasks.
    /// @param loopTime The maximum time to block the loop, in milliseconds.
    /// This method runs the main loop, processing all enqueued work (including repetitive tasks)
    /// until @ref stopMainLoop is called. Typically executed on the main thread or in a dedicated loop thread.
    /// Calls the openDAQ C function `daqScheduler_runMainLoop()`.
    pub fn run_main_loop(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_runMainLoop)(self.as_raw() as *mut _, 1) };
        check(__code, "daqScheduler_runMainLoop")?;
        Ok(())
    }

    /// Starts and blocks the main event loop, executing scheduled tasks.
    /// @param loopTime The maximum time to block the loop, in milliseconds.
    /// This method runs the main loop, processing all enqueued work (including repetitive tasks)
    /// until @ref stopMainLoop is called. Typically executed on the main thread or in a dedicated loop thread.
    /// Calls the openDAQ C function `daqScheduler_runMainLoop()`.
    pub fn run_main_loop_with(&self, loop_time: usize) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_runMainLoop)(self.as_raw() as *mut _, loop_time) };
        check(__code, "daqScheduler_runMainLoop")?;
        Ok(())
    }

    /// Executes a single iteration of the main loop, processing scheduled tasks.
    /// This non-blocking method runs one iteration of the main loop, executing one-time tasks
    /// and advancing any repetitive tasks. Intended for cases where the main loop is polled manually,
    /// such as in GUI frameworks or embedded systems.
    /// Calls the openDAQ C function `daqScheduler_runMainLoopIteration()`.
    pub fn run_main_loop_iteration(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_runMainLoopIteration)(self.as_raw() as *mut _) };
        check(__code, "daqScheduler_runMainLoopIteration")?;
        Ok(())
    }

    /// Schedules the specified @p work function to run on the thread-pool. The call does not block but immediately returns an @p awaitable that represents the asynchronous execution. It can be waited upon and queried for status and result.
    /// @param function The function to schedule for execution.
    /// @param\[out\] awaitable The object representing the state and result of the execution.
    /// @retval OPENDAQ_ERR_SCHEDULER_STOPPED when the scheduler already stopped and is not accepting any more work.
    /// Calls the openDAQ C function `daqScheduler_scheduleFunction()`.
    pub fn schedule_function(&self, function: &FunctionObject) -> Result<Option<Awaitable>> {
        let mut __awaitable: *mut sys::daqAwaitable = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqScheduler_scheduleFunction)(self.as_raw() as *mut _, function.as_raw() as *mut _, &mut __awaitable) };
        check(__code, "daqScheduler_scheduleFunction")?;
        Ok(unsafe { crate::marshal::take_object::<Awaitable>(__awaitable as *mut _) })
    }

    /// Schedules the specified dependency @p graph to run on the thread-pool. The call does not block but immediately returns an @p awaitable that represents the asynchronous execution. It can be waited upon and queried for status and result. \<b\>Any exceptions that occur during the graph execution are silently ignored.\</b\>
    /// @param graph The dependency graph (acyclic directed graph) to schedule.
    /// @param\[out\] awaitable The object representing the state and result of the execution.
    /// @retval OPENDAQ_ERR_SCHEDULER_STOPPED when the scheduler already stopped and is not accepting any more work.
    /// Calls the openDAQ C function `daqScheduler_scheduleGraph()`.
    pub fn schedule_graph(&self, graph: &TaskGraph) -> Result<Option<Awaitable>> {
        let mut __awaitable: *mut sys::daqAwaitable = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqScheduler_scheduleGraph)(self.as_raw() as *mut _, graph.as_raw() as *mut _, &mut __awaitable) };
        check(__code, "daqScheduler_scheduleGraph")?;
        Ok(unsafe { crate::marshal::take_object::<Awaitable>(__awaitable as *mut _) })
    }

    /// Schedules the specified work callback to run on the thread-pool. The call does not block.
    /// @param work The function to schedule for execution.
    /// @retval OPENDAQ_ERR_SCHEDULER_STOPPED when the scheduler already stopped and is not accepting any more work.
    /// Work is a lightweight callback that returns no value and accepts no procedure. It has less overhead than
    /// function. The function does not return awaitable object.
    /// Calls the openDAQ C function `daqScheduler_scheduleWork()`.
    pub fn schedule_work(&self, work: &Work) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_scheduleWork)(self.as_raw() as *mut _, work.as_raw() as *mut _) };
        check(__code, "daqScheduler_scheduleWork")?;
        Ok(())
    }

    /// Schedules a task to be executed by the main loop.
    /// The provided work object is queued for execution during a call to either
    /// @ref runMainLoop or @ref runMainLoopIteration. This mechanism is commonly used
    /// to marshal tasks from background threads to the main loop thread.
    /// @param work A lightweight, non-blocking task object to be scheduled.
    /// Calls the openDAQ C function `daqScheduler_scheduleWorkOnMainLoop()`.
    pub fn schedule_work_on_main_loop(&self, work: &Work) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_scheduleWorkOnMainLoop)(self.as_raw() as *mut _, work.as_raw() as *mut _) };
        check(__code, "daqScheduler_scheduleWorkOnMainLoop")?;
        Ok(())
    }

    /// Cancels all outstanding work and waits for the remaining to complete. After this point the scheduler does not allow any new work or graphs for scheduling.
    /// Calls the openDAQ C function `daqScheduler_stop()`.
    pub fn stop(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_stop)(self.as_raw() as *mut _) };
        check(__code, "daqScheduler_stop")?;
        Ok(())
    }

    /// Signals the main loop to stop processing and return from @ref runMainLoop.
    /// This method unblocks the loop and requests graceful shutdown. It is typically called
    /// from another thread or in response to an application shutdown signal.
    /// Has no effect if the loop is not currently running.
    /// Calls the openDAQ C function `daqScheduler_stopMainLoop()`.
    pub fn stop_main_loop(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_stopMainLoop)(self.as_raw() as *mut _) };
        check(__code, "daqScheduler_stopMainLoop")?;
        Ok(())
    }

    /// Waits fo all current scheduled work and tasks to complete.
    /// Calls the openDAQ C function `daqScheduler_waitAll()`.
    pub fn wait_all(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqScheduler_waitAll)(self.as_raw() as *mut _) };
        check(__code, "daqScheduler_waitAll")?;
        Ok(())
    }

}