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_;
    bool unchecked_{};
};
}
#endif

namespace fz {
enum class mutex_flags
{
    recursive,

#ifdef LFZ_DEBUG_MUTEXES
    debug_unchecked,
#endif
};
inline bool operator&(mutex_flags lhs, mutex_flags rhs) {
    return (static_cast<std::underlying_type_t<mutex_flags>>(lhs) & static_cast<std::underlying_type_t<mutex_flags>>(rhs)) != 0;
}
inline mutex_flags operator|(mutex_flags lhs, mutex_flags rhs)
{
    return static_cast<mutex_flags>(static_cast<std::underlying_type_t<mutex_flags>>(lhs) | static_cast<std::underlying_type_t<mutex_flags>>(rhs));
}

class FZ_PUBLIC_SYMBOL mutex final
{
public:
    explicit mutex(bool recursive = true);
    explicit mutex(mutex_flags flags);
    ~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