cinosmutex.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#if !defined( INC_CINOSMUTEX_H )
#define INC_CINOSMUTEX_H
 
//------------------------------------------------------------------------------
//--- class CINOSMutex ---------------------------------------------------------
//------------------------------------------------------------------------------
 
class CINOSMutex
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public : 
        // mutex flags
        enum EFlags{
            // none
            eFlgNone = 0x00000000,
            // classical (old style) non recursive behaviour
            eFlgClassic = 0x00000001,
            // reclaim lock at request
            eFlgReclaimLock = 0x00000002,
        };
    
        explicit CINOSMutex(EFlags aeFlags);
 
        CINOSMutex(const char* apName = 0, EFlags aeFlags = eFlgNone);
 
        ~CINOSMutex();
 
        ICACHE uint32 Request(uint32 aTimeout=INOS_WAIT_FOREVER);
        ICACHE void lock() {
            Request();
        }
 
        /* \brief Requests the given two mutexes using a deadlock avoidance
         * algorithm to avoid deadlock. Inspired by std::lock
         */
        static void RequestBoth(CINOSMutex& aMutex1, CINOSMutex& aMutex2);
 
        bool TryRequest();
        bool try_lock() {
            return TryRequest();
        }
 
        ICACHE void Release(bool aSuspend=false, uint32 auState = defINOSTaskPureSuspended);
        ICACHE void unlock() {
            Release();
        }
 
        ICACHE class CINOSTask* GetOwner()
            { return m_idOwner; };
 
        const char* GetName()
            { return m_pName; };
 
        volatile uint32* GetLockAdr()
            { return m_Lock.GetAddr(); };
 
        void SetFlag(EFlags aeFlag);
 
        void ClrFlag(EFlags aeFlag);
 
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSTask;
 
    // protected members
    protected :
        const char* m_pName;        
        tTaskId m_idOwner;          
        tTaskId m_idFstWaiting;     
        tTaskId m_idLstWaiting;     
        uint32 m_uCounter;          
        SINOSCoreLock m_Lock;       
        uint32 m_uFlags;            
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSMutex);
    // objects of CINOSMutex need to be created very early during startup, when
    // the CTORs have not been executed. Therefore, in order to create such
    // objects, we need to provide the placement operator new.
    DECLARE_DYNAMIC_PLACEMENT(CINOSMutex);
};
 
//------------------------------------------------------------------------------
//--- class CINOSLock ----------------------------------------------------------
//------------------------------------------------------------------------------
 
class CINOSLock
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public :
        explicit CINOSLock(CINOSMutex& aMutex)
            { aMutex.Request(); m_pMutex = &aMutex;};
 
        ~CINOSLock()
            { if(m_pMutex) m_pMutex->Release(); };
 
        void EarlyUnlock()
            { m_pMutex->Release(); m_pMutex = NULL; };
 
    //--- internals --------------------------------------------------------
 
    // protected members
    protected :
        CINOSMutex* m_pMutex;
};
 
class CINOSTryLock
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public:
        explicit CINOSTryLock(CINOSMutex& aMutex)
            : m_pMutex(aMutex.TryRequest() ? &aMutex : nullptr)
        {
        }
 
        ~CINOSTryLock()
        {
            EarlyUnlock();
        }
 
        void EarlyUnlock()
        {
            if(m_pMutex)
            {
                m_pMutex->Release();
                m_pMutex = nullptr;
            }
        }
 
        operator bool() const {
            return (m_pMutex != nullptr);
        }
    //--- internals --------------------------------------------------------
 
    // protected members
    protected:
        CINOSMutex* m_pMutex;
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSMUTEX_h