---

oscl_mutex.h

Go to the documentation of this file.

// -*- c++ -*-
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//                     O S C L _ M U T E X

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifndef OSCL_MUTEX_H_INCLUDED
#define OSCL_MUTEX_H_INCLUDED

#ifndef OSCLCONFIG_PROC_H_INCLUDED
#include "osclconfig_proc.h"
#endif
#ifndef OSCL_TYPES_H_INCLUDED
#include "oscl_types.h"
#endif
#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif
#ifndef OSCL_THREAD_H_INCLUDED
#include "oscl_thread.h"
#endif
#ifndef OSCL_LOCK_BASE_H_INCLUDED
#include "oscl_lock_base.h"
#endif


class OsclMutex : public OsclLockBase
{
    public:

        OSCL_IMPORT_REF OsclMutex();

        OSCL_IMPORT_REF virtual ~OsclMutex();

        OSCL_IMPORT_REF OsclProcStatus::eOsclProcError Create(void);


        OSCL_IMPORT_REF void Lock();

        OSCL_IMPORT_REF OsclProcStatus::eOsclProcError TryLock();


        OSCL_IMPORT_REF void Unlock();


        OSCL_IMPORT_REF OsclProcStatus::eOsclProcError Close(void);

    private:

        OsclProcStatus::eOsclProcError ErrorMapping(int32 Error);

        TOsclMutexObject    ObjMutex;
        bool bCreated;

};

#if !OSCL_HAS_NON_PREEMPTIVE_THREAD_SUPPORT
//In pre-emptive threading, OsclNoYieldMutex is identical to OsclMutex
typedef OsclMutex OsclNoYieldMutex;
#else
//In non-pre-emptive threading, OsclNoYieldMutex is a NO-OP.
class OsclNoYieldMutex : public OsclLockBase
{
    public:

        OsclNoYieldMutex()
        {
#ifndef NDEBUG
            iNumLock = 0;
            bCreated = false;
#endif
        }

        virtual ~OsclNoYieldMutex()
        {}

        OsclProcStatus::eOsclProcError Create(void)
        {
#ifndef NDEBUG
            if (bCreated)
                return OsclProcStatus::INVALID_OPERATION_ERROR;
            bCreated = true;
#endif
            return OsclProcStatus::SUCCESS_ERROR;
        }


        void Lock()
        {
#ifndef NDEBUG
            OSCL_ASSERT(bCreated);
            OSCL_ASSERT(iNumLock == 0);//detect deadlock condition.
            iNumLock++;
#endif
        }

        OsclProcStatus::eOsclProcError TryLock()
        {
#ifndef NDEBUG
            if (!bCreated)
                return OsclProcStatus::INVALID_OPERATION_ERROR;
            if (iNumLock)
                return OsclProcStatus::MUTEX_LOCKED_ERROR;
            else
                Lock();
            return OsclProcStatus::SUCCESS_ERROR;
#endif
        }


        void Unlock()
        {
#ifndef NDEBUG
            OSCL_ASSERT(bCreated);
            OSCL_ASSERT(iNumLock);
            if (iNumLock > 0)
                iNumLock--;
#endif
        }


        OsclProcStatus::eOsclProcError Close(void)
        {
#ifndef NDEBUG
            if (!bCreated)
                return OsclProcStatus::INVALID_OPERATION_ERROR;
            bCreated = false;
#endif
            return OsclProcStatus::SUCCESS_ERROR;
        }

    private:

#ifndef NDEBUG
        uint32 iNumLock;
        bool bCreated;
#endif

};
#endif //OSCL_HAS_NON_PREEMPTIVE_THREAD_SUPPORT

class OsclThreadLock: public OsclLockBase
{
    public:
        OSCL_IMPORT_REF OsclThreadLock();
        OSCL_IMPORT_REF virtual ~OsclThreadLock();
        OSCL_IMPORT_REF void Lock();
        OSCL_IMPORT_REF void Unlock();
    private:
        OsclMutex iMutex;
};

#endif

---