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 <list>
#include <memory>
#include <thread>
 
namespace fz {
class mutex;
class mutex_debug;

struct FZ_PUBLIC_SYMBOL lock_order final {
    std::vector<mutex*> mutexes_;
    std::vector<void*> backtrace_;
};

struct FZ_PUBLIC_SYMBOL mutex_debug final
{
    static void record_lock(void* m);
    static void record_unlock(void* m);
 
    size_t count_{};
    std::thread::id id_{};
    std::vector<std::list<lock_order>::iterator> own_orders_;
};
}
#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:
    mutex_debug debug_;
#endif
};

class FZ_PUBLIC_SYMBOL scoped_lock final
{
public:
    enum flag
    {
        try_lock
    };
 
    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
    }
 
    explicit scoped_lock(mutex& m, flag)
        : m_(&m.m_)
    {
        if (!m.try_lock()) {
            locked_ = false;
        }
    }
 
    ~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
    }
 
    explicit operator bool() const { return locked_; }
 
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