mutex.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_MUTEX_HEADER
#define LIBFILEZILLA_MUTEX_HEADER
 
#include "libfilezilla.hpp"
#include "time.hpp"
 
#ifdef FZ_WINDOWS
#include "glue/windows.hpp"
#else
#include <pthread.h>
#endif
 
//#define LFZ_DEBUG_MUTEXES
#ifdef LFZ_DEBUG_MUTEXES
 
#include <memory>
 
namespace fz {
class mutex;
struct FZ_PUBLIC_SYMBOL mutex_debug final
{
    mutex_debug(mutex* mtx)
        : mtx_(mtx)
    {}
 
    static void record_lock(void* m);
    static void record_unlock(void* m);
 
    size_t count_{};
    mutex* mtx_{};
 
    std::vector<std::tuple<std::weak_ptr<mutex_debug>, std::vector<void*>>> order_;
};
}
#endif
 
namespace fz {
class FZ_PUBLIC_SYMBOL mutex final
{
public:
    explicit mutex(bool recursive = true);
    ~mutex();
 
    mutex(mutex const&) = delete;
    mutex& operator=(mutex const&) = delete;
 
    void lock();
 
    void unlock();
 
    bool try_lock();
 
private:
    friend class condition;
    friend class scoped_lock;
 
#ifdef FZ_WINDOWS
    CRITICAL_SECTION m_;
#else
    pthread_mutex_t m_;
#endif
#ifdef LFZ_DEBUG_MUTEXES
public:
    std::shared_ptr<mutex_debug> h_;
#endif
};
 
class FZ_PUBLIC_SYMBOL scoped_lock final
{
public:
    explicit scoped_lock(mutex& m)
        : m_(&m.m_)
    {
#ifdef FZ_WINDOWS
        EnterCriticalSection(m_);
#else
        pthread_mutex_lock(m_);
#endif
#ifdef LFZ_DEBUG_MUTEXES
        mutex_debug::record_lock(m_);
#endif
    }
 
    ~scoped_lock()
    {
        if (locked_) {
#ifdef LFZ_DEBUG_MUTEXES
        mutex_debug::record_unlock(m_);
#endif
#ifdef FZ_WINDOWS
            LeaveCriticalSection(m_);
#else
            pthread_mutex_unlock(m_);
#endif
        }
 
    }
 
    scoped_lock(scoped_lock const&) = delete;
    scoped_lock& operator=(scoped_lock const&) = delete;
 
    scoped_lock(scoped_lock && op) noexcept
    {
        m_ = op.m_;
        op.m_ = 0;
        locked_ = op.locked_;
        op.locked_ = false;
    }
 
    scoped_lock& operator=(scoped_lock && op) noexcept
    {
        if (this != &op) {
            m_ = op.m_;
            op.m_ = 0;
            locked_ = op.locked_;
            op.locked_ = false;
        }
        return *this;
    }
 
    void lock()
    {
        locked_ = true;
#ifdef FZ_WINDOWS
        EnterCriticalSection(m_);
#else
        pthread_mutex_lock(m_);
#endif
#ifdef LFZ_DEBUG_MUTEXES
        mutex_debug::record_lock(m_);
#endif
 
    }
 
    void unlock()
    {
        locked_ = false;
#ifdef LFZ_DEBUG_MUTEXES
        mutex_debug::record_unlock(m_);
#endif
#ifdef FZ_WINDOWS
        LeaveCriticalSection(m_);
#else
        pthread_mutex_unlock(m_);
#endif
    }
 
private:
    friend class condition;
 
#ifdef FZ_WINDOWS
    CRITICAL_SECTION * m_;
#else
    pthread_mutex_t * m_;
#endif
    bool locked_{true};
};
 
class FZ_PUBLIC_SYMBOL condition final
{
public:
    condition();
    ~condition();
 
    condition(condition const&) = delete;
    condition& operator=(condition const&) = delete;
 
    void wait(scoped_lock& l);
 
    bool wait(scoped_lock& l, duration const& timeout);
 
    void signal(scoped_lock& l);
 
    bool signalled(scoped_lock const&) const { return signalled_; }
private:
#ifdef FZ_WINDOWS
    CONDITION_VARIABLE cond_;
#else
    pthread_cond_t cond_;
#endif
    bool signalled_{};
};
 
}
#endif