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;

/// Wrapper over the openDAQ `daqLastMessageLoggerSinkPrivate` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct LastMessageLoggerSinkPrivate(pub(crate) BaseObject);

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

/// Logs messages produced by a specific part of openDAC SDK. The messages are written into the @ref ILoggerSink "Logger Sinks" associated with the Logger Component object.
/// The set of associated sinks is initialized on the Logger Component object creation and cannot be
/// changed after.
/// Logger Component allows to set up a threshold log severity level, so the messages with lower level
/// will not be registered.
/// Additionally, it provides the ability to trigger writing out messages stored in temporary buffers or
/// set up the minimum severity level of messages to be written out automatically,
/// see `flushOnLevel` method.
/// Wrapper over the openDAQ `daqLoggerComponent` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct LoggerComponent(pub(crate) BaseObject);

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

/// Wrapper over the openDAQ `daqLoggerSink` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct LoggerSink(pub(crate) BaseObject);

impl std::ops::Deref for LoggerSink {
    type Target = BaseObject;
    fn deref(&self) -> &BaseObject { &self.0 }
}
impl crate::sealed::Sealed for LoggerSink {}
unsafe impl Interface for LoggerSink {
    const NAME: &'static str = "daqLoggerSink";
    fn interface_id() -> Option<crate::IntfID> { None }
    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 LoggerSink {
    #[doc(hidden)]
    pub(crate) fn __from_ref(r: Ref) -> Self { LoggerSink(BaseObject(r)) }
}
impl std::fmt::Display for LoggerSink {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.as_base_object(), f)
    }
}
impl From<&LoggerSink> for Value {
    fn from(value: &LoggerSink) -> Value { Value::Object(value.to_base_object()) }
}
impl From<LoggerSink> for Value {
    fn from(value: LoggerSink) -> Value { Value::Object(value.to_base_object()) }
}
impl crate::value::FromDaqOwned for LoggerSink {
    unsafe fn from_daq_owned(ptr: *mut std::ffi::c_void, op: &'static str) -> Result<Self> {
        crate::value::cast_owned(ptr, op)
    }
}

/// Container for messages queue and backing threads used for asynchronous logging.
/// Wrapper over the openDAQ `daqLoggerThreadPool` interface.
#[repr(transparent)]
#[derive(Clone, Debug)]
pub struct LoggerThreadPool(pub(crate) BaseObject);

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

impl LastMessageLoggerSinkPrivate {
    /// Get the last log message
    /// @param\[out\] lastMessage The last log message
    /// Calls the openDAQ C function `daqLastMessageLoggerSinkPrivate_getLastMessage()`.
    pub fn last_message(&self) -> Result<String> {
        let mut __last_message: *mut sys::daqString = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLastMessageLoggerSinkPrivate_getLastMessage)(self.as_raw() as *mut _, &mut __last_message) };
        check(__code, "daqLastMessageLoggerSinkPrivate_getLastMessage")?;
        Ok(unsafe { crate::marshal::take_string(__last_message) })
    }

    /// Wait for receiving a new log message
    /// @param timeoutMs The timeout in milliseconds until which wait for a new log message. If timeout set as 0 ms waiting will be skipped.
    /// @param\[out\] success The success will return true if there was a new unread log message before waiting or sink got a new logger message before timeout. False if timeout was reached.
    /// Calls the openDAQ C function `daqLastMessageLoggerSinkPrivate_waitForMessage()`.
    pub fn wait_for_message(&self, timeout_ms: usize) -> Result<bool> {
        let mut __success: u8 = 0;
        let __code = unsafe { (crate::sys::api().daqLastMessageLoggerSinkPrivate_waitForMessage)(self.as_raw() as *mut _, timeout_ms, &mut __success) };
        check(__code, "daqLastMessageLoggerSinkPrivate_waitForMessage")?;
        Ok(__success != 0)
    }

}

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

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

    /// Sets the minimum severity level of messages to be automatically written to the associated sinks bypassing the temporary buffers.
    /// @param level The severity level of messages.
    /// Calls the openDAQ C function `daqLoggerComponent_flushOnLevel()`.
    pub fn flush_on_level(&self, level: LogLevel) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqLoggerComponent_flushOnLevel)(self.as_raw() as *mut _, level as u32) };
        check(__code, "daqLoggerComponent_flushOnLevel")?;
        Ok(())
    }

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

    /// Gets the name of the component.
    /// @param\[out\] name The name of the component.
    /// Calls the openDAQ C function `daqLoggerComponent_getName()`.
    pub fn name(&self) -> Result<String> {
        let mut __name: *mut sys::daqString = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerComponent_getName)(self.as_raw() as *mut _, &mut __name) };
        check(__code, "daqLoggerComponent_getName")?;
        Ok(unsafe { crate::marshal::take_string(__name) })
    }

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

    /// Sets the custom formatter pattern for the component.
    /// @param pattern The format pattern string.
    /// Calls the openDAQ C function `daqLoggerComponent_setPattern()`.
    pub fn set_pattern(&self, pattern: &str) -> Result<()> {
        let __pattern = crate::marshal::make_string(pattern)?;
        let __code = unsafe { (crate::sys::api().daqLoggerComponent_setPattern)(self.as_raw() as *mut _, __pattern.as_ptr() as *mut _) };
        check(__code, "daqLoggerComponent_setPattern")?;
        Ok(())
    }

    /// Checks whether the messages with given log severity level will be logged or not.
    /// @param level The severity level of messages.
    /// @param\[out\] willLog True if the messages with @p level will be logged within the component; false otherwise.
    /// Calls the openDAQ C function `daqLoggerComponent_shouldLog()`.
    pub fn should_log(&self, level: LogLevel) -> Result<bool> {
        let mut __will_log: u8 = 0;
        let __code = unsafe { (crate::sys::api().daqLoggerComponent_shouldLog)(self.as_raw() as *mut _, level as u32, &mut __will_log) };
        check(__code, "daqLoggerComponent_shouldLog")?;
        Ok(__will_log != 0)
    }

}

impl LoggerSink {
    /// Calls the openDAQ C function `daqLoggerSink_createBasicFileLoggerSink()`.
    pub fn basic_file(file_name: &str) -> Result<LoggerSink> {
        let __file_name = crate::marshal::make_string(file_name)?;
        let mut __obj: *mut sys::daqLoggerSink = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerSink_createBasicFileLoggerSink)(&mut __obj, __file_name.as_ptr() as *mut _) };
        check(__code, "daqLoggerSink_createBasicFileLoggerSink")?;
        Ok(unsafe { crate::marshal::require_object::<LoggerSink>(__obj as *mut _, "daqLoggerSink_createBasicFileLoggerSink") }?)
    }

    /// Calls the openDAQ C function `daqLoggerSink_createRotatingFileLoggerSink()`.
    pub fn rotating_file(file_name: &str, max_file_byte_size: usize, max_files: usize) -> Result<LoggerSink> {
        let __file_name = crate::marshal::make_string(file_name)?;
        let mut __obj: *mut sys::daqLoggerSink = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerSink_createRotatingFileLoggerSink)(&mut __obj, __file_name.as_ptr() as *mut _, max_file_byte_size, max_files) };
        check(__code, "daqLoggerSink_createRotatingFileLoggerSink")?;
        Ok(unsafe { crate::marshal::require_object::<LoggerSink>(__obj as *mut _, "daqLoggerSink_createRotatingFileLoggerSink") }?)
    }

    /// Calls the openDAQ C function `daqLoggerSink_createStdErrLoggerSink()`.
    pub fn std_err() -> Result<LoggerSink> {
        let mut __obj: *mut sys::daqLoggerSink = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerSink_createStdErrLoggerSink)(&mut __obj) };
        check(__code, "daqLoggerSink_createStdErrLoggerSink")?;
        Ok(unsafe { crate::marshal::require_object::<LoggerSink>(__obj as *mut _, "daqLoggerSink_createStdErrLoggerSink") }?)
    }

    /// Calls the openDAQ C function `daqLoggerSink_createStdOutLoggerSink()`.
    pub fn std_out() -> Result<LoggerSink> {
        let mut __obj: *mut sys::daqLoggerSink = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerSink_createStdOutLoggerSink)(&mut __obj) };
        check(__code, "daqLoggerSink_createStdOutLoggerSink")?;
        Ok(unsafe { crate::marshal::require_object::<LoggerSink>(__obj as *mut _, "daqLoggerSink_createStdOutLoggerSink") }?)
    }

    /// Calls the openDAQ C function `daqLoggerSink_createWinDebugLoggerSink()`.
    pub fn win_debug() -> Result<LoggerSink> {
        let mut __obj: *mut sys::daqLoggerSink = std::ptr::null_mut();
        let __code = unsafe { (crate::sys::api().daqLoggerSink_createWinDebugLoggerSink)(&mut __obj) };
        check(__code, "daqLoggerSink_createWinDebugLoggerSink")?;
        Ok(unsafe { crate::marshal::require_object::<LoggerSink>(__obj as *mut _, "daqLoggerSink_createWinDebugLoggerSink") }?)
    }

    /// Calls the openDAQ C function `daqLoggerSink_flush()`.
    pub fn flush(&self) -> Result<()> {
        let __code = unsafe { (crate::sys::api().daqLoggerSink_flush)(self.as_raw() as *mut _) };
        check(__code, "daqLoggerSink_flush")?;
        Ok(())
    }

    /// Calls the openDAQ C function `daqLoggerSink_getLevel()`.
    pub fn level(&self) -> Result<LogLevel> {
        let mut __level: u32 = 0;
        let __code = unsafe { (crate::sys::api().daqLoggerSink_getLevel)(self.as_raw() as *mut _, &mut __level) };
        check(__code, "daqLoggerSink_getLevel")?;
        Ok(crate::marshal::enum_out(LogLevel::from_raw(__level), "daqLoggerSink_getLevel")?)
    }

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

    /// Calls the openDAQ C function `daqLoggerSink_setPattern()`.
    pub fn set_pattern(&self, pattern: &str) -> Result<()> {
        let __pattern = crate::marshal::make_string(pattern)?;
        let __code = unsafe { (crate::sys::api().daqLoggerSink_setPattern)(self.as_raw() as *mut _, __pattern.as_ptr() as *mut _) };
        check(__code, "daqLoggerSink_setPattern")?;
        Ok(())
    }

    /// Calls the openDAQ C function `daqLoggerSink_shouldLog()`.
    pub fn should_log(&self, level: LogLevel) -> Result<bool> {
        let mut __will_log: u8 = 0;
        let __code = unsafe { (crate::sys::api().daqLoggerSink_shouldLog)(self.as_raw() as *mut _, level as u32, &mut __will_log) };
        check(__code, "daqLoggerSink_shouldLog")?;
        Ok(__will_log != 0)
    }

}

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

}