Unique.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/Misc/Enum.h"
#include "Honey/Misc/ScopeGuard.h"
#include "Honey/Chrono/Clock.h"
#include "Honey/Thread/Lock/Mutex.h"

namespace honey
{

template<class Lockable> class SharedLock;

namespace lock
{
    enum class Op
    {
        lock,       
        tryLock,    
        adopt,      
        defer       
    };

    template<class Lock>
    function<void ()> lockGuard(Lock& lock)                     { return [&] { lock.lock(); }; }
    template<class Lock>
    function<void ()> unlockGuard(Lock& lock)                   { return [&] { lock.unlock(); }; }
    template<class Lock>
    function<void ()> releaseGuard(Lock& lock)                  { return [&] { lock.release(); }; }
}


template<class Lockable_>
class UniqueLock : mt::NoCopy
{
public:
    typedef Lockable_ Lockable;

    UniqueLock()                                                : _lock(nullptr), _owns(false) {}

    UniqueLock(Lockable& lock, lock::Op op = lock::Op::lock)    : _lock(&lock), _owns(false)
    {
        switch (op)
        {
        case lock::Op::lock:
            this->lock();
            break;
        case lock::Op::tryLock:
            tryLock();
            break;
        case lock::Op::adopt:
            _owns = true;
            break;
        case lock::Op::defer:
            break;
        }
    }

    template<class Rep, class Period>
    UniqueLock(Lockable& lock, Duration<Rep,Period> time)       : _lock(&lock), _owns(false) { tryLock(time); }
    template<class Clock, class Dur>
    UniqueLock(Lockable& lock, TimePoint<Clock,Dur> time)       : _lock(&lock), _owns(false) { tryLock(time); }
    
    UniqueLock(UniqueLock&& rhs) noexcept                       { operator=(move(rhs)); }
    UniqueLock(SharedLock<Lockable>&& rhs)                      { operator=(move(rhs)); }

    ~UniqueLock()                                               { if (_owns) unlock(); }

    UniqueLock& operator=(UniqueLock&& rhs)
    {
        _lock = rhs._lock; _owns = rhs._owns;
        rhs._lock = nullptr; rhs._owns = false;
        return *this;
    }

    UniqueLock& operator=(SharedLock<Lockable>&& rhs)
    {
        _lock = &rhs.mutex(); _owns = true;
        _lock->unlockShared();
        _lock->lock();
        rhs.release();
        return *this;
    }

    void lock()
    {
        assert(_lock, "Lock has been released");
        assert(!_owns, "Lock already held");
        _lock->lock();
        _owns = true;
    }

    void unlock()
    {
        assert(_lock, "Lock has been released");
        assert(_owns, "Lock not held");
        _lock->unlock();
        _owns = false;
    }

    bool tryLock()
    {
        assert(_lock, "Lock has been released");
        assert(!_owns, "Lock already held");
        return _owns = _lock->tryLock();
    }

    template<class Rep, class Period>
    bool tryLock(Duration<Rep,Period> time)
    {
        assert(_lock, "Lock has been released");
        assert(!_owns, "Lock already held");
        return _owns = _lock->tryLock(time);
    }

    template<class Clock, class Dur>
    bool tryLock(TimePoint<Clock,Dur> time)
    {
        assert(_lock, "Lock has been released");
        assert(!_owns, "Lock already held");
        return _owns = _lock->tryLock(time);
    }

    bool owns() const                                           { return _owns; }
    explicit operator bool() const                              { return owns(); }
    
    Lockable& mutex()
    {
        assert(_lock, "Lock has been released");
        return *_lock;
    }

    Lockable& release()
    {
        Lockable& ret = mutex();
        _lock = nullptr;
        _owns = false;
        return ret;
    }

private:
    Lockable* _lock;
    bool _owns;
};

}