MutexInterface.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/MutexInterface.hpp
// \brief Os::MutexHandle, Os::MutexInterface, and Os::ScopeLock definitions
// ======================================================================
#ifndef OS_MUTEXINTERFACE_HPP_
#define OS_MUTEXINTERFACE_HPP_

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Assert.hpp>
#include <Os/Os.hpp>
#include "config/OsDelegateMutex.hpp"  // defines Os::Mutex alias and OS_MUTEX_HEADER consumed by Os/Mutex.hpp; do not remove

namespace Os {

struct MutexHandle {};

class MutexInterface {
  public:
    enum Status {
        OP_OK,           
        ERROR_BUSY,      
        ERROR_DEADLOCK,  
        NOT_SUPPORTED,   
        ERROR_OTHER      
    };

    MutexInterface() = default;

    virtual ~MutexInterface() = default;

    MutexInterface(const MutexInterface& other) = delete;

    MutexInterface(const MutexInterface* other) = delete;

    MutexInterface& operator=(const MutexInterface& other) = delete;

    virtual MutexHandle* getHandle() = 0;

    static MutexInterface* getDelegate(MutexHandleStorage& aligned_new_memory);

    // ------------------------------------------------------------------
    // Mutex operations to be implemented by an OSAL implementation
    // ------------------------------------------------------------------

    virtual Status take() = 0;     
    virtual Status release() = 0;  

    // ------------------------------------------------------------------
    // Common (non-virtual) functions built on top of take()/release().
    // Defined inline on the interface (per fprime#5249) so they are available
    // regardless of which implementation Os::Mutex is configured to be, and so
    // that under compile-time selection the call site can devirtualize take()/
    // release() and inline the whole acquisition without relying on LTO.
    // ------------------------------------------------------------------

    void lock() {
        const Status status = this->take();
        FW_ASSERT(status == Status::OP_OK,
                  static_cast<FwAssertArgType>(reinterpret_cast<PlatformPointerCastType>(this)), status);
    }

    void unLock() {
        const Status status = this->release();
        FW_ASSERT(status == Status::OP_OK,
                  static_cast<FwAssertArgType>(reinterpret_cast<PlatformPointerCastType>(this)), status);
    }

    void unlock() { this->unLock(); }
};

class ScopeLock {
  public:
    explicit ScopeLock(MutexInterface& mutex) : m_mutex(mutex) { this->m_mutex.lock(); }

    ~ScopeLock() { this->m_mutex.unLock(); }

    ScopeLock(const ScopeLock& other) = delete;

    ScopeLock(const ScopeLock* other) = delete;

    ScopeLock& operator=(const ScopeLock& other) = delete;

  private:
    MutexInterface& m_mutex;  
};

}  // namespace Os

#endif  // OS_MUTEXINTERFACE_HPP_