preemptive_threads/

safe_api.rs

use crate::error::{ThreadError, ThreadResult};
use crate::thread::ThreadId;
use core::marker::PhantomData;

/// Safe thread handle that ensures proper cleanup
pub struct ThreadHandle {
    id: ThreadId,
    joined: bool,
}

impl ThreadHandle {
    #[allow(dead_code)]
    fn new(id: ThreadId) -> Self {
        Self { id, joined: false }
    }

    /// Join this thread, waiting for it to complete
    pub fn join(mut self) -> ThreadResult<()> {
        self.joined = true;
        // TODO: Implement actual join logic
        Ok(())
    }

    /// Get the thread ID
    pub fn id(&self) -> ThreadId {
        self.id
    }
}

impl Drop for ThreadHandle {
    fn drop(&mut self) {
        if !self.joined {
            // Thread wasn't joined - this is a programming error
            // In a real implementation, we'd want to detach or panic
        }
    }
}

/// Safe thread builder with compile-time checks
pub struct ThreadBuilder<'a> {
    stack_size: usize,
    priority: u8,
    name: Option<&'a str>,
    _phantom: PhantomData<&'a ()>,
}

impl<'a> Default for ThreadBuilder<'a> {
    fn default() -> Self {
        Self::new()
    }
}

impl<'a> ThreadBuilder<'a> {
    /// Create a new thread builder
    pub fn new() -> Self {
        Self {
            stack_size: 64 * 1024, // 64KB default
            priority: 5,           // Medium priority
            name: None,
            _phantom: PhantomData,
        }
    }

    /// Set stack size (must be at least 16KB)
    pub fn stack_size(mut self, size: usize) -> Self {
        assert!(size >= 16 * 1024, "Stack size must be at least 16KB");
        self.stack_size = size;
        self
    }

    /// Set thread priority (0-7, higher is more priority)
    pub fn priority(mut self, priority: u8) -> Self {
        assert!(priority < 8, "Priority must be 0-7");
        self.priority = priority;
        self
    }

    /// Set thread name for debugging
    pub fn name(mut self, name: &'a str) -> Self {
        self.name = Some(name);
        self
    }

    /// Spawn the thread with a closure
    ///
    /// This is the safe API that doesn't require users to manage stacks manually
    pub fn spawn<F>(self, _f: F) -> ThreadResult<ThreadHandle>
    where
        F: FnOnce() + Send + 'static,
    {
        // In a real implementation, we'd allocate the stack dynamically
        // For now, we return an error since we can't safely do this in no_std
        Err(ThreadError::NotImplemented)
    }
}

/// Thread-local storage key
pub struct ThreadLocal<T> {
    #[allow(dead_code)]
    key: usize,
    _phantom: PhantomData<T>,
}

impl<T> Default for ThreadLocal<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T> ThreadLocal<T> {
    /// Create a new thread-local storage key
    pub const fn new() -> Self {
        // In a real implementation, this would allocate a TLS key
        Self {
            key: 0,
            _phantom: PhantomData,
        }
    }

    /// Get the value for the current thread
    pub fn get(&self) -> Option<&T> {
        // TODO: Implement TLS lookup
        None
    }

    /// Set the value for the current thread
    pub fn set(&self, _value: T) {
        // TODO: Implement TLS storage
    }
}

/// Safe thread pool for managing multiple threads
pub struct ThreadPool {
    max_threads: usize,
    active_threads: usize,
}

impl ThreadPool {
    /// Create a new thread pool
    pub fn new(max_threads: usize) -> Self {
        assert!(
            max_threads > 0 && max_threads <= 32,
            "Thread pool size must be 1-32"
        );

        Self {
            max_threads,
            active_threads: 0,
        }
    }

    /// Execute a task in the thread pool
    pub fn execute<F>(&mut self, _task: F) -> ThreadResult<()>
    where
        F: FnOnce() + Send + 'static,
    {
        if self.active_threads >= self.max_threads {
            return Err(ThreadError::SchedulerFull);
        }

        // TODO: Implement actual thread pool execution
        Err(ThreadError::NotImplemented)
    }

    /// Get the number of active threads
    pub fn active_count(&self) -> usize {
        self.active_threads
    }

    /// Shut down the thread pool, waiting for all threads to complete
    pub fn shutdown(self) {
        // TODO: Implement graceful shutdown
    }
}

/// Safe mutex implementation
pub struct Mutex<T> {
    data: core::cell::UnsafeCell<T>,
    locked: core::sync::atomic::AtomicBool,
}

unsafe impl<T: Send> Sync for Mutex<T> {}
unsafe impl<T: Send> Send for Mutex<T> {}

impl<T> Mutex<T> {
    /// Create a new mutex
    pub const fn new(data: T) -> Self {
        Self {
            data: core::cell::UnsafeCell::new(data),
            locked: core::sync::atomic::AtomicBool::new(false),
        }
    }

    /// Lock the mutex
    pub fn lock(&self) -> MutexGuard<T> {
        // Spin lock implementation
        while self
            .locked
            .compare_exchange_weak(
                false,
                true,
                core::sync::atomic::Ordering::Acquire,
                core::sync::atomic::Ordering::Relaxed,
            )
            .is_err()
        {
            core::hint::spin_loop();
        }

        MutexGuard { mutex: self }
    }

    /// Try to lock the mutex
    pub fn try_lock(&self) -> Option<MutexGuard<T>> {
        if self
            .locked
            .compare_exchange(
                false,
                true,
                core::sync::atomic::Ordering::Acquire,
                core::sync::atomic::Ordering::Relaxed,
            )
            .is_ok()
        {
            Some(MutexGuard { mutex: self })
        } else {
            None
        }
    }
}

/// RAII guard for mutex
pub struct MutexGuard<'a, T> {
    mutex: &'a Mutex<T>,
}

impl<'a, T> core::ops::Deref for MutexGuard<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.mutex.data.get() }
    }
}

impl<'a, T> core::ops::DerefMut for MutexGuard<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.mutex.data.get() }
    }
}

impl<'a, T> Drop for MutexGuard<'a, T> {
    fn drop(&mut self) {
        self.mutex
            .locked
            .store(false, core::sync::atomic::Ordering::Release);
    }
}

/// Safe yield function
pub fn yield_now() {
    crate::sync::yield_thread();
}

/// Safe exit function
pub fn exit_thread() {
    crate::sync::exit_thread();
}