mutexed.hxx

#pragma once
 
#include <mutex>
 
namespace StormByte {
    template<typename T>
    class Mutexed {
        public:
            Mutexed() noexcept = default;
            
            Mutexed(const T& value) noexcept : m_value(value) {}
 
            Mutexed(const Mutexed<T>& other) noexcept {
                std::lock_guard<std::mutex> lock(m_mutex);
                std::lock_guard<std::mutex> lock_other(other.m_mutex);
                m_value = other.m_value;
            }
 
            Mutexed(Mutexed<T>&& other) noexcept {
                std::lock_guard<std::mutex> lock(m_mutex);
                std::lock_guard<std::mutex> lock_other(other.m_mutex);
                m_value = std::move(other.m_value);
            }
 
            Mutexed<T>& operator=(const Mutexed<T>& other) noexcept {
                if (this != &other) {
                    std::lock_guard<std::mutex> lock(m_mutex);
                    std::lock_guard<std::mutex> lock_other(other.m_mutex);
                    m_value = other.m_value;
                }
                return *this;
            }
 
            Mutexed<T>& operator=(Mutexed<T>&& other) noexcept {
                if (this != &other) {
                    std::lock_guard<std::mutex> lock(m_mutex);
                    std::lock_guard<std::mutex> lock_other(other.m_mutex);
                    m_value = std::move(other.m_value);
                }
                return *this;
            }
 
            virtual Mutexed<T>& operator=(const T& value) noexcept {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_value = value;
                return *this;
            }
 
            virtual Mutexed<T>& operator=(T&& value) noexcept {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_value = std::move(value);
                return *this;
            }
 
            virtual ~Mutexed() noexcept = default;
 
            std::strong_ordering operator<=>(const Mutexed& other) const noexcept {
                // Lock both mutexes for thread-safe comparison
                std::lock_guard<std::mutex> lock_this(m_mutex);
                std::lock_guard<std::mutex> lock_other(other.m_mutex);
                
                // Compare values manually to return strong ordering
                if (m_value == other.m_value) {
                    return std::strong_ordering::equal;
                } else if (m_value < other.m_value) {
                    return std::strong_ordering::less;
                } else {
                    return std::strong_ordering::greater;
                }
            }
 
            bool operator!=(const Mutexed& other) const noexcept {
                return operator<=>(other) != std::strong_ordering::equal;
            }
 
            virtual T& operator*() noexcept {
                return m_value;
            }
 
            virtual const T& operator*() const noexcept {
                return m_value;
            }
 
            virtual T* operator->() noexcept {
                return &m_value;
            }
 
            virtual const T* operator->() const noexcept {
                return &m_value;
            }
 
            void Lock() const {
                m_mutex.lock();
            }
 
            void Unlock() const {
                m_mutex.unlock();
            }
 
        protected:
            T m_value; 
            mutable std::mutex m_mutex; 
    };
}