Log

Cargo.toml

@@ -88,6 +88,7 @@ members = [
     "atom",
     "core",
     "core/derive",
+    "log",
     "midi",
     "state",
     "sys",

log/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "lv2-log"
+version = "0.1.0"
+authors = ["Yruama_Lairba <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+lv2-sys = "2.0.0"
+lv2-core = "3.0.0"
+urid = "0.1.0"

log/src/lib.rs

@@ -0,0 +1,167 @@
+use lv2_core::feature::{Feature, ThreadingClass};
+//use std::ffi::CString;
+use std::os::raw::*; //get all common c_type
+use urid::*;
+
+pub struct EntryClass;
+unsafe impl UriBound for EntryClass {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__Entry;
+}
+
+/// UriBound for an error message.
+pub struct ErrorClass;
+unsafe impl UriBound for ErrorClass {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__Error;
+}
+
+/// UriBound for an informative message.
+pub struct NoteClass;
+unsafe impl UriBound for NoteClass {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__Note;
+}
+
+/// UriBound for a debuging message.
+pub struct TraceClass;
+unsafe impl UriBound for TraceClass {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__Trace;
+}
+
+/// Uribound for an error message.
+pub struct WarningClass;
+unsafe impl UriBound for WarningClass {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__Warning;
+}
+
+/// Marker for URID representing the nature of a log message.
+// Note : it's may be better to have a URID trait to define a common interface
+pub unsafe trait EntryType
+where
+    Self: Copy,
+{
+}
+
+unsafe impl EntryType for URID<ErrorClass> {}
+unsafe impl EntryType for URID<NoteClass> {}
+unsafe impl EntryType for URID<TraceClass> {}
+unsafe impl EntryType for URID<WarningClass> {}
+
+/// Errors potentially generated by [`Log`](struct.Log.html) methods.
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+pub enum LogError {
+    /// An error occured when sending message to the host
+    PrintError,
+    /// The provided string don't have a `'\0'` to indicate it's end
+    NoNullTerminator,
+    /// No callback was provided by the host
+    ///
+    /// This can only happen with a faulty host
+    NoCallback,
+}
+
+/// The Log feature.
+#[repr(transparent)]
+pub struct Log<'a> {
+    internal: &'a lv2_sys::LV2_Log_Log,
+}
+
+unsafe impl<'a> UriBound for Log<'a> {
+    const URI: &'static [u8] = lv2_sys::LV2_LOG__log;
+}
+
+unsafe impl<'a> Feature for Log<'a> {
+    // Note: this feature can be used in any threading class but:
+    // * i have a doubt about it's thread safety, can we assume the host provide this thread safety
+    // since this feature can be used anywhere ?.
+    // * i shouldn't be used in context where rt is a concern, that mean is audiothreadclass in
+    // practice, but it's acceptable to use it for debugging purpose
+    // So, at this time, i just giving access to it instanciation class
+    unsafe fn from_feature_ptr(feature: *const c_void, class: ThreadingClass) -> Option<Self> {
+        match class {
+            ThreadingClass::Audio => {
+                panic!("The log feature is not allowed in the audio threading class")
+            }
+            _ => (feature as *const lv2_sys::LV2_Log_Log)
+                .as_ref()
+                .map(|internal| Self { internal }),
+        }
+    }
+}
+
+impl<'a> Log<'a> {
+    /// Send a log message to the host.
+    ///
+    /// The `entry_type` parameter is an URID representing the kind of log message. There are four
+    /// kind of message:
+    /// * **note:** an informative message.
+    /// * **warning:** a warning message.
+    /// * **error:** an error message.
+    /// * **trace:** a debugging trace. These entries should not be displayed during normal
+    /// operation, but the host may implement an option to display them for debugging purposes.
+    /// This entry type is special in that it may be written to in a real-time thread. It is
+    /// assumed that if debug tracing is enabled, real-time considerations are not a concern.
+    pub fn print(&self, entry_type: URID<impl EntryType>, message: &str) -> Result<(), LogError> {
+        let printf = if let Some(printf) = self.internal.printf {
+            printf
+        } else {
+            return Err(LogError::NoCallback);
+        };
+        let message = String::from(message) + "\0";
+
+        let res = unsafe {
+            (printf)(
+                self.internal.handle,
+                entry_type.get(),
+                "%s\0" as *const _ as *const c_char,
+                message.as_str() as *const _ as *const c_char,
+            )
+        };
+        if res > 0 {
+            Ok(())
+        } else {
+            Err(LogError::PrintError)
+        }
+    }
+    /// Send a message to the host with a new line at the end.
+    ///
+    /// It same as [print](struct.Log.html#method.print) but add a newline a the end of message.
+    /// See [print](struct.Log.html#method.print) documentation for details.
+    pub fn println(&self, entry_type: URID<impl EntryType>, message: &str) -> Result<(), LogError> {
+        let printf = if let Some(printf) = self.internal.printf {
+            printf
+        } else {
+            return Err(LogError::NoCallback);
+        };
+        let message = String::from(message) + "\n\0";
+
+        let res = unsafe {
+            (printf)(
+                self.internal.handle,
+                entry_type.get(),
+                "%s\0" as *const _ as *const c_char,
+                message.as_str() as *const _ as *const c_char,
+            )
+        };
+        if res > 0 {
+            Ok(())
+        } else {
+            Err(LogError::PrintError)
+        }
+    }
+}
+
+/// A URID cache containing all log properties.
+#[derive(URIDCollection, Debug)]
+pub struct LogURIDCollection {
+    pub entry_class: URID<EntryClass>,
+    pub error_class: URID<ErrorClass>,
+    pub note_class: URID<NoteClass>,
+    pub trace_class: URID<TraceClass>,
+    pub warning_class: URID<WarningClass>,
+    //pub log: URID<Log<'a>>,
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {}
+}