arithmetic_mutexed.hxx

#pragma once
 
#include <StormByte/visibility.h>
#include <StormByte/mutexed.hxx>
 
namespace StormByte {
    template<typename T>
    class STORMBYTE_PUBLIC ArithmeticMutexed final: public Mutexed<T> {
        public:
            ArithmeticMutexed() noexcept                                            = default;
            
            ArithmeticMutexed(const T& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value = value;
            }
 
            ArithmeticMutexed(T&& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value = std::move(value);
            }
 
            ArithmeticMutexed(const ArithmeticMutexed& other) noexcept              = default;
 
            ArithmeticMutexed(ArithmeticMutexed&& other) noexcept                   = default;
 
            ArithmeticMutexed& operator=(const ArithmeticMutexed& other) noexcept   = default;
 
            ArithmeticMutexed& operator=(ArithmeticMutexed&& other) noexcept        = default;
 
            ArithmeticMutexed& operator=(const T& value) noexcept override {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value = value;
                return *this;
            }
 
            ArithmeticMutexed& operator=(T&& value) noexcept override {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value = std::move(value);
                return *this;
            }
 
            std::strong_ordering                                                    operator<=>(const ArithmeticMutexed& other) const noexcept {
                return Mutexed<T>::operator<=>(other);
            }
 
            bool                                                                    operator!=(const ArithmeticMutexed& other) const noexcept {
                return operator<=>(other) != std::strong_ordering::equal;
            }
 
            ArithmeticMutexed                                                       operator+(const ArithmeticMutexed& value) const noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                std::lock_guard<std::mutex> lock_other(value.m_mutex);
                return ArithmeticMutexed(this->m_value + value.m_value);
            }
 
            ArithmeticMutexed                                                       operator+(ArithmeticMutexed&& value) const noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                std::lock_guard<std::mutex> lock_other(value.m_mutex);
                return ArithmeticMutexed(this->m_value + std::move(value.m_value));
            }
 
            ArithmeticMutexed&                                                      operator+=(ArithmeticMutexed& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                std::lock_guard<std::mutex> lock_other(value.m_mutex);
                this->m_value += value.m_value;
                return *this;
            }
 
            ArithmeticMutexed&                                                      operator+=(ArithmeticMutexed&& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                std::lock_guard<std::mutex> lock_other(value.m_mutex);
                this->m_value += std::move(value.m_value);
                return *this;
            }
 
            T                                                                       operator+(const T& value) const noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                return this->m_value + value;
            }
        
            T                                                                       operator+(T&& value) const noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                return this->m_value + std::move(value);
            }
 
            T&                                                                      operator+=(T& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value += value;
                return this->m_value;
            }
 
            T&                                                                      operator+=(T&& value) noexcept {
                std::lock_guard<std::mutex> lock(this->m_mutex);
                this->m_value += std::move(value);
                return this->m_value;
            }
    };
}