Mutex.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/Mutex.hpp
// \brief common definitions for Os::Mutex
// ======================================================================
#ifndef Os_Mutex_hpp
#define Os_Mutex_hpp

#include <FpConfig.hpp>
#include <Os/Os.hpp>

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);

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

class Mutex final : public MutexInterface {
  public:
    Mutex();         
    ~Mutex() final;  

    MutexHandle* getHandle() override;

    Status take() override;            
    Status release() override;         
    void lock();                       
    void unLock();                     
    void unlock() { this->unLock(); }  

  private:
    // This section is used to store the implementation-defined mutex handle. To Os::Mutex and fprime, this type is
    // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store then handle in
    // the byte-array here and set `handle` to that address for storage.
    //
    alignas(FW_HANDLE_ALIGNMENT) MutexHandleStorage m_handle_storage;  
    MutexInterface& m_delegate;                                        
};
class ScopeLock {
  public:
    explicit ScopeLock(Mutex& mutex);

    ~ScopeLock();

    ScopeLock(const ScopeLock& other) = delete;

    ScopeLock(const ScopeLock* other) = delete;

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

  private:
    Mutex& m_mutex;  
};
}  // namespace Os

#endif