ConditionVariableInterface.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/ConditionVariableInterface.hpp
// \brief Os::ConditionVariableHandle and Os::ConditionVariableInterface definitions
// ======================================================================
#ifndef OS_CONDITIONVARIABLEINTERFACE_HPP_
#define OS_CONDITIONVARIABLEINTERFACE_HPP_

#include <type_traits>

#include "Fw/Types/Assert.hpp"
#include "Os/Mutex.hpp"
#include "Os/Os.hpp"
#include "config/OsSelection.hpp"  // defines Os::ConditionVariable alias and OS_CONDITION_VARIABLE_HEADER consumed by Os/Condition.hpp; do not remove

namespace Os {

class DelegateMutex;
class DelegateConditionVariable;

// A condition variable implementation operates on the handle of the configured Os::Mutex. Selecting a
// compile-time Mutex while leaving Os::ConditionVariable on the link-time delegate (or vice versa) hands the
// CMake-chosen implementation a handle of the wrong type, so both must be delegates or neither may be.
static_assert(std::is_same<Os::Mutex, Os::DelegateMutex>::value ==
                  std::is_same<Os::ConditionVariable, Os::DelegateConditionVariable>::value,
              "Os::Mutex and Os::ConditionVariable must be overridden together in config/OsSelection.hpp");

class ConditionVariableHandle {};

class ConditionVariableInterface {
  public:
    enum Status {
        OP_OK,                  
        ERROR_MUTEX_NOT_HELD,   
        ERROR_DIFFERENT_MUTEX,  
        ERROR_NOT_IMPLEMENTED,  
        NOT_SUPPORTED,          
        ERROR_OTHER             
    };

    ConditionVariableInterface() = default;
    virtual ~ConditionVariableInterface() = default;

    ConditionVariableInterface(const ConditionVariableInterface& other) = delete;

    virtual ConditionVariableInterface& operator=(const ConditionVariableInterface& other) = delete;

    virtual Status pend(Os::Mutex& mutex) = 0;

    virtual void notify() = 0;

    virtual void notifyAll() = 0;

    virtual ConditionVariableHandle* getHandle() = 0;

    static ConditionVariableInterface* getDelegate(ConditionVariableHandleStorage& aligned_new_memory);

    // ------------------------------------------------------------------
    // Common (non-virtual) functions built on top of pend(). Defined inline
    // on the interface so they are available regardless of which
    // implementation Os::ConditionVariable is configured to be.
    // ------------------------------------------------------------------

    void wait(Os::Mutex& mutex) {
        const Status status = this->pend(mutex);
        FW_ASSERT(status == Status::OP_OK,
                  static_cast<FwAssertArgType>(reinterpret_cast<PlatformPointerCastType>(this)), status);
    }
};

}  // namespace Os

#endif  // OS_CONDITIONVARIABLEINTERFACE_HPP_