added logging

Author: rex-schilasky

rustecal-core/src/core.rs

@@ -1,27 +1,29 @@
 //! Core lifecycle control for the eCAL runtime.
 //!
 //! This module provides safe Rust wrappers around initializing and finalizing
-//! the eCAL communication system, as well as querying its state.
+//! the eCAL communication system, as well as querying its state and version.
 //!
 //! The main entry point is the [`Ecal`] struct which provides:
 //! - [`Ecal::initialize`] to start the middleware
 //! - [`Ecal::finalize`] to shut it down
 //! - [`Ecal::ok`] to query if eCAL is currently running
+//! - [`Ecal::is_initialized`] and [`Ecal::is_component_initialized`] for introspection
+//! - [`Ecal::version_string`], [`Ecal::version_date_string`] and [`Ecal::version_struct`] for version info
 //!
 //! Typically, you will call [`Ecal::initialize`] once at the beginning of your
 //! application and [`Ecal::finalize`] at shutdown.
 
-use std::ffi::CString;
+use std::ffi::{CStr, CString};
 use crate::components::EcalComponents;
-use rustecal_sys;
+use crate::types::Version;
 
-/// Provides access to the core initialization and finalization functions of eCAL.
+/// Provides access to the core initialization, shutdown, and state-checking functions of eCAL.
 pub struct Ecal;
 
 impl Ecal {
     /// Initializes the eCAL runtime system.
     ///
-    /// This function must be called before using any publisher or subscriber functionality.
+    /// This function must be called before using any publisher, subscriber, or service functionality.
     ///
     /// # Arguments
     ///
@@ -48,7 +50,7 @@ impl Ecal {
 
     /// Finalizes and shuts down the eCAL runtime system.
     ///
-    /// After calling this function, all publishers and subscribers are invalidated.
+    /// After calling this function, all publishers, subscribers, and services are invalidated.
     pub fn finalize() {
         unsafe {
             rustecal_sys::eCAL_Finalize();
@@ -65,4 +67,65 @@ impl Ecal {
     pub fn ok() -> bool {
         unsafe { rustecal_sys::eCAL_Ok() != 0 }
     }
+
+    /// Checks if the eCAL system has been initialized.
+    ///
+    /// This function checks whether any components of the middleware have been initialized.
+    ///
+    /// # Returns
+    ///
+    /// `true` if initialization has occurred, `false` otherwise.
+    pub fn is_initialized() -> bool {
+        unsafe { rustecal_sys::eCAL_IsInitialized() != 0 }
+    }
+
+    /// Checks if specific components of eCAL are initialized.
+    ///
+    /// This allows querying the status of individual middleware components like pub/sub, monitoring, etc.
+    ///
+    /// # Arguments
+    ///
+    /// * `components` - Bitmask of components to check.
+    ///
+    /// # Returns
+    ///
+    /// `true` if the given components are initialized, `false` otherwise.
+    pub fn is_component_initialized(components: EcalComponents) -> bool {
+        unsafe { rustecal_sys::eCAL_IsComponentInitialized(components.bits()) != 0 }
+    }
+
+    /// Returns the version string of the eCAL runtime.
+    ///
+    /// # Returns
+    ///
+    /// A static string slice with the full version string, e.g. `"5.11.0"`.
+    pub fn version_string() -> &'static str {
+        unsafe {
+            CStr::from_ptr(rustecal_sys::eCAL_GetVersionString())
+                .to_str()
+                .unwrap_or("unknown")
+        }
+    }
+
+    /// Returns the build date string of the eCAL runtime.
+    ///
+    /// # Returns
+    ///
+    /// A static string slice with the build date string, e.g. `"Apr 2025"`.
+    pub fn version_date_string() -> &'static str {
+        unsafe {
+            CStr::from_ptr(rustecal_sys::eCAL_GetVersionDateString())
+                .to_str()
+                .unwrap_or("unknown")
+        }
+    }
+
+    /// Returns the version of the eCAL runtime as structured integers.
+    ///
+    /// # Returns
+    ///
+    /// A [`Version`] struct with fields `major`, `minor`, and `patch`.
+    pub fn version_struct() -> Version {
+        unsafe { rustecal_sys::eCAL_GetVersion().into() }
+    }
 }

rustecal-core/src/core_types/logging.rs

@@ -0,0 +1,42 @@
+//! Rust-safe wrapper for `eCAL_Logging_SLogMessage`.
+//!
+//! This type represents individual log entries emitted by eCAL.
+
+use crate::log_level::LogLevel;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+/// Represents a single log message emitted by eCAL.
+#[derive(Debug, Clone)]
+pub struct LogMessage {
+    pub level: LogLevel,
+    pub timestamp: i64,
+    pub host_name: String,
+    pub process_name: String,
+    pub process_id: i32,
+    pub thread_name: String,
+    pub content: String,
+}
+
+impl From<rustecal_sys::eCAL_Logging_SLogMessage> for LogMessage {
+    fn from(raw: rustecal_sys::eCAL_Logging_SLogMessage) -> Self {
+        Self {
+            level: LogLevel::from(raw.level),
+            timestamp: raw.time,
+            host_name: cstr_to_string(raw.host_name),
+            process_name: cstr_to_string(raw.process_name),
+            process_id: raw.process_id,
+            thread_name: cstr_to_string(raw.unit_name), // or rename field to unit_name
+            content: cstr_to_string(raw.content),
+        }
+    }
+}
+
+/// Converts a C string pointer to a Rust `String`.
+fn cstr_to_string(ptr: *const c_char) -> String {
+    if ptr.is_null() {
+        String::new()
+    } else {
+        unsafe { CStr::from_ptr(ptr).to_string_lossy().into_owned() }
+    }
+}

rustecal-core/src/core_types/mod.rs

@@ -0,0 +1,3 @@
+//! Common eCAL types shared across pubsub and service layers.
+
+pub mod logging;

rustecal-core/src/lib.rs

@@ -1,9 +1,18 @@
-//! rustecal-core: eCAL initialization & shared types
+//! rustecal-core: eCAL initialization, shared components, logging, and core types.
+//!
+//! This crate provides safe Rust wrappers for the core system of eCAL,
+//! including runtime lifecycle management, logging, and reusable data structures.
 
 pub mod core;
 pub mod components;
 pub mod types;
+pub mod log;
+pub mod log_level;
+pub mod core_types;
 
 // Re‑exports for ergonomic access:
 pub use core::Ecal;
 pub use components::EcalComponents;
+pub use log::Log;
+pub use log_level::LogLevel;
+pub use core_types::logging::LogMessage;

rustecal-core/src/log.rs

@@ -0,0 +1,66 @@
+//! Core logging functions for emitting messages through eCAL.
+//!
+//! This module wraps the C API from `ecal_c/log.h` and provides access to
+//! logging at various severity levels, as well as retrieval of current log entries.
+
+use crate::core_types::logging::LogMessage;
+use crate::log_level::LogLevel;
+
+use std::ffi::CString;
+use std::ptr;
+use std::slice;
+
+/// Provides logging functions to emit and retrieve messages via the eCAL runtime.
+pub struct Log;
+
+impl Log {
+    /// Emits a message to the eCAL logging system with a specified severity.
+    ///
+    /// # Arguments
+    ///
+    /// * `level` - Log severity (e.g., [`LogLevel::Info`], [`LogLevel::Error`])
+    /// * `message` - The log content to emit
+    pub fn log(level: LogLevel, message: &str) {
+        let cstr = CString::new(message)
+            .unwrap_or_else(|_| CString::new("<invalid UTF-8>").unwrap());
+
+        unsafe {
+            rustecal_sys::eCAL_Logging_Log(level.into(), cstr.as_ptr());
+        }
+    }
+
+    /// Fetches all current log messages stored in the eCAL runtime.
+    ///
+    /// This function uses the C API `eCAL_Logging_GetLogging` to retrieve
+    /// structured log messages and ensures the memory is released with `eCAL_Free`.
+    ///
+    /// # Returns
+    ///
+    /// A vector of [`LogMessage`] entries, or an empty vector if retrieval failed.
+    pub fn get_logging() -> Vec<LogMessage> {
+        let mut raw_ptr: *mut rustecal_sys::eCAL_Logging_SLogging = ptr::null_mut();
+
+        let success = unsafe { rustecal_sys::eCAL_Logging_GetLogging(&mut raw_ptr) };
+
+        if success != 0 || raw_ptr.is_null() {
+            return vec![];
+        }
+
+        let logging = unsafe { &*raw_ptr };
+        let raw_messages = logging.log_messages;
+        let len = logging.log_messages_length;
+
+        let logs = unsafe {
+            slice::from_raw_parts(raw_messages, len)
+                .iter()
+                .map(|msg| LogMessage::from(*msg))
+                .collect()
+        };
+
+        unsafe {
+            rustecal_sys::eCAL_Free(raw_ptr as *mut _);
+        }
+
+        logs
+    }
+}

rustecal-core/src/log_level.rs

@@ -0,0 +1,35 @@
+//! eCAL logging severity levels.
+//!
+//! This mirrors the C enum `eCAL_Logging_eLogLevel` and is used in logging APIs.
+
+#[repr(i32)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogLevel {
+    None    = 0,
+    Fatal   = 1,
+    Error   = 2,
+    Warning = 3,
+    Info    = 4,
+    Debug   = 5,
+    Verbose = 6,
+}
+
+impl From<i32> for LogLevel {
+    fn from(value: i32) -> Self {
+        match value {
+            1 => LogLevel::Fatal,
+            2 => LogLevel::Error,
+            3 => LogLevel::Warning,
+            4 => LogLevel::Info,
+            5 => LogLevel::Debug,
+            6 => LogLevel::Verbose,
+            _ => LogLevel::None,
+        }
+    }
+}
+
+impl From<LogLevel> for i32 {
+    fn from(level: LogLevel) -> Self {
+        level as i32
+    }
+}

rustecal-core/src/types.rs

@@ -1,7 +1,6 @@
 //! Common eCAL types shared across pubsub and service layers.
 
-use rustecal_sys::*;
-use std::ffi::{CStr};
+use std::ffi::CStr;
 use std::os::raw::c_char;
 
 /// Represents a globally unique entity in eCAL.
@@ -12,8 +11,8 @@ pub struct EntityId {
     pub host_name: String,
 }
 
-impl From<eCAL_SEntityId> for EntityId {
-    fn from(raw: eCAL_SEntityId) -> Self {
+impl From<rustecal_sys::eCAL_SEntityId> for EntityId {
+    fn from(raw: rustecal_sys::eCAL_SEntityId) -> Self {
         Self {
             entity_id: raw.entity_id,
             process_id: raw.process_id,
@@ -30,8 +29,8 @@ pub struct DataTypeInfo {
     pub descriptor: Vec<u8>,
 }
 
-impl From<eCAL_SDataTypeInformation> for DataTypeInfo {
-    fn from(info: eCAL_SDataTypeInformation) -> Self {
+impl From<rustecal_sys::eCAL_SDataTypeInformation> for DataTypeInfo {
+    fn from(info: rustecal_sys::eCAL_SDataTypeInformation) -> Self {
         let type_name = cstr_to_string(info.name);
         let encoding = cstr_to_string(info.encoding);
         let descriptor = if info.descriptor.is_null() || info.descriptor_length == 0 {
@@ -59,8 +58,8 @@ pub struct Version {
     pub patch: i32,
 }
 
-impl From<eCAL_SVersion> for Version {
-    fn from(raw: eCAL_SVersion) -> Self {
+impl From<rustecal_sys::eCAL_SVersion> for Version {
+    fn from(raw: rustecal_sys::eCAL_SVersion) -> Self {
         Self {
             major: raw.major,
             minor: raw.minor,