RWlock.h

#pragma once


#include <libutl/host_thread.h>
#include <libutl/NamedObjectMI.h>


UTL_NS_BEGIN;


class Mutex;

// RWlock //////////////////////////////////////////////////////////////////////////////////////////


class RWlock : public Object, public NamedObjectMI
{
    UTL_CLASS_DECL(RWlock, Object);
    UTL_CLASS_NO_COPY;

public:
    bool haveWriteLock() const;

    void
    lock(uint_t mode)
    {
        (mode == io_rd) ? rdlock() : wrlock();
    }

    void rdlock();

    void wrlock();

    bool
    trylock(uint_t mode)
    {
        return (mode == io_rd) ? tryrdlock() : trywrlock();
    }

    bool tryrdlock();

    bool trywrlock();

    void unlock();

private:
    void init();
    void deInit();

private:
#if UTL_HOST_OS == UTL_OS_MINGW
    void* _readEvent;
    Mutex* _writeMutex;
    volatile long _numReaders;
    uint_t _mode;
#else
    pthread_rwlock_t _rwlock;
#endif
    thread_handle_t _writeLockOwner;
    size_t _depth;
};

// RWlockGuard /////////////////////////////////////////////////////////////////////////////////////


class RWlockGuard
{
public:
    RWlockGuard()
        : _locked(false)
        , _rwlock(nullptr)
    {
    }

    RWlockGuard(RWlock* rwlock, uint_t mode)
        : _locked(false)
        , _rwlock(rwlock)
    {
        _lock(mode);
    }

    ~RWlockGuard()
    {
        unlock();
    }

    void
    lock(RWlock* rwlock, uint_t mode)
    {
        unlock();
        _rwlock = rwlock;
        _lock(mode);
    }

    void
    lock(uint_t mode)
    {
        (mode == io_rd) ? rdlock() : wrlock();
    }

    void
    rdlock(RWlock* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        _rdlock();
    }

    void
    wrlock(RWlock* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        _wrlock();
    }

    void
    rdlock()
    {
        unlock();
        _rdlock();
    }

    void
    wrlock()
    {
        unlock();
        _wrlock();
    }

    bool
    trylock(RWlock* rwlock, uint_t mode)
    {
        unlock();
        _rwlock = rwlock;
        return _trylock(mode);
    }

    bool
    trylock(uint_t mode)
    {
        return (mode == io_rd) ? tryrdlock() : trywrlock();
    }

    bool
    tryrdlock(RWlock* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        return _tryrdlock();
    }

    bool
    trywrlock(RWlock* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        return _trywrlock();
    }

    bool
    tryrdlock()
    {
        unlock();
        return _tryrdlock();
    }

    bool
    trywrlock()
    {
        unlock();
        return _trywrlock();
    }

    inline void
    unlock()
    {
        if (_locked) _unlock();
    }

private:
    void
    _lock(uint_t mode)
    {
        (mode == io_rd) ? _rdlock() : _wrlock();
    }

    void
    _rdlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        _rwlock->rdlock();
        _locked = true;
    }

    void
    _wrlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        _rwlock->wrlock();
        _locked = true;
    }

    bool
    _trylock(uint_t mode)
    {
        return (mode == io_rd) ? _tryrdlock() : _trywrlock();
    }

    bool
    _tryrdlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        if (_rwlock->tryrdlock()) _locked = true;
        return _locked;
    }

    bool
    _trywrlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        if (_rwlock->trywrlock()) _locked = true;
        return _locked;
    }

    void
    _unlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(_locked);
        _rwlock->unlock();
        _locked = false;
    }

private:
    bool _locked;
    RWlock* _rwlock;
};


UTL_NS_END;