SharedMutex.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Thread/Thread.h"
#include "Honey/Thread/Condition/Lock.h"

namespace honey
{

template<class Lockable> class SharedLock;


class SharedMutex
{
public:
    typedef UniqueLock<SharedMutex> Scoped;
    typedef SharedLock<SharedMutex> SharedScoped;

    SharedMutex()                                           { init(); }
    SharedMutex(const SharedMutex&)                         { init(); }

    ~SharedMutex() {}

    SharedMutex& operator=(const SharedMutex&)              { return *this; }

    void lock();
    void unlock();

    bool tryLock();
    bool tryLock(MonoClock::Duration time)                  { return tryLock(time == time.max() ? MonoClock::TimePoint::max() : MonoClock::now() + time); }
    bool tryLock(MonoClock::TimePoint time);

    void lockShared();
    void unlockShared();

    bool tryLockShared();
    bool tryLockShared(MonoClock::Duration time)            { return tryLockShared(time == time.max() ? MonoClock::TimePoint::max() : MonoClock::now() + time); }
    bool tryLockShared(MonoClock::TimePoint time);

    void unlockAndLockShared();

private:
    void init();

    struct State { enum t {
        unlock  = 0,
        unique  = 1,
        shared  = 2
    }; };

    bool tryLock_priv(Thread::ThreadId threadId);
    bool tryLockShared_priv();

    bool isShared() const                                   { return (_state & ~State::unique) != 0; }

    Atomic<int>                 _state;
    ConditionLock               _cond;
    Atomic<Thread::ThreadId>    _owner;
    int                         _holdCount;
    Atomic<int>                 _waitCount;
};


}