CriticalSection.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//

#ifndef CMR_CRITICAL_SECTION_INCLUDED
#define CMR_CRITICAL_SECTION_INCLUDED

#include "Commore.h"

namespace commore
{
    class CMREXD CriticalSection
    {
    public :
        CriticalSection();
        ~CriticalSection();

    public:
        void  enter();
        void  leave();
        bool  try_enter();

    private:
        CriticalSection(const CriticalSection&);
        CriticalSection& operator=(const CriticalSection&);

    private:
#ifdef WIN32
#ifdef _M_X64
        char  cs_[64];
        enum { CS_LAST_IDX = 63 };
#else
        char  cs_[32];
        enum { CS_LAST_IDX = 31 };
#endif
#else
        char  cs_[64];
        enum { CS_LAST_IDX = 63 };
#endif
    };

    class CMREXD Mutex
    {
    public:
        Mutex();
        Mutex(const AChar* name, bool create);
        ~Mutex();
    public:
        bool create(const AChar* name);
        bool open(const AChar* name);
        bool lock();
        bool try_lock();
        bool lock(const TimePeriod& timeout);
        bool unlock();
        bool is_ok();
    private:
        class Impl;
        Impl* impl_;
    };


    class Lock
    {
    public:
        Lock(CriticalSection& spcs) : spcs_(&spcs), mtx_(0)
        {
            if (spcs_)
            {
                spcs_->enter();
            }
        }
        Lock(CriticalSection* spcs) : spcs_(spcs), mtx_(0)
        {
            if (spcs_)
            {
                spcs_->enter();
            }
        }
        Lock(Mutex& mtx) : spcs_(0), mtx_(&mtx)
        {
            if (mtx_)
            {
                mtx_->lock();
            }
        }
        Lock(Mutex* mtx) : spcs_(0), mtx_(mtx)
        {
            if (mtx_)
            {
                mtx_->lock();
            }
        }
        ~Lock()
        {
            if (spcs_)
            {
                spcs_->leave();
            }
            else if (mtx_)
            {
                mtx_->unlock();
            }
        }

    private:
        Lock(const Lock&);
        Lock& operator=(const Lock&);

    private:
        CriticalSection* spcs_;
        Mutex* mtx_;

    };

    class TryLock
    {
    public:
        TryLock(CriticalSection& spcs) : spcs_(&spcs)
        {
            if (spcs_ && !spcs_->try_enter())
            {
                spcs_ = 0;
            }
        }
        TryLock(CriticalSection* spcs) : spcs_(spcs)
        {
            if (spcs_ && !spcs_->try_enter())
            {
                spcs_ = 0;
            }
        }
        TryLock(Mutex& mtx) : spcs_(0), mtx_(&mtx)
        {
            if (mtx_ && !mtx_->try_lock())
            {
                mtx_ = 0;
            }
        }
        TryLock(Mutex* mtx) : spcs_(0), mtx_(mtx)
        {
            if (mtx_ && !mtx_->try_lock())
            {
                mtx_ = 0;
            }
        }
        ~TryLock()
        {
            if (spcs_)
            {
                spcs_->leave();
            }
        }

    public:
        bool  entered() const
        {
            return spcs_ != 0 || mtx_ != 0;
        }
        operator bool () const
        {
            return entered();
        }

    private:
        TryLock(const Lock&);             // Copy forbiden.
        TryLock& operator=(const Lock&);  // Copy forbiden

    private:
        CriticalSection* spcs_;
        Mutex* mtx_;

    }; // class TryLock
};

#endif