mutex.hpp

Go to the documentation of this file.

#ifndef __FRIOS_POSIX_THREADS_MUTEX_HPP__
#define __FRIOS_POSIX_THREADS_MUTEX_HPP__

#include <frios/posix/error.hpp>
#include <frios/posix/threads/mutex_attr.hpp>

#include <pthread.h>

namespace frios {
namespace posix {

class cond;


class mutex
{
private:
    unique<pthread_mutex_t> _mutex;

    friend class cond;

    mutex(const mutex&) = delete;
public:

    struct init_error : error
    {
        init_error(int error_code)
         : error(error_code)
        { }
    };


    mutex(void)
    {
        int fail = pthread_mutex_init(&_mutex, 0);
        if(fail) throw init_error(fail);
    }


    mutex(const mutex_attr& attributes)
    {
        int fail = pthread_mutex_init(&_mutex, &attributes._attr);
        if(fail) throw init_error(fail);
    }

    mutex(mutex&& tmp)
     : _mutex(std::move(tmp._mutex))
    { }

    ~mutex(void)
    {
        if(_mutex.valid())
            pthread_mutex_destroy(&_mutex);
    }


    struct lock_error : error
    {
        lock_error(int error_code)
         : error(error_code)
        { }
    };


    struct unlock_error : lock_error
    {
        unlock_error(int error_code)
         : lock_error(error_code)
        { }
    };



    struct locked : error
    {
        locked(int error_code)
         : error(error_code)
        { }
    };


    class lock
    {
    private:
        pthread_mutex_t* _p_mutex;

        friend class cond;
    public:

        lock(mutex& mutex)
         : _p_mutex(&mutex._mutex)
        {
            int fail = pthread_mutex_lock(_p_mutex);
            if(fail) throw lock_error(fail);
        }

        lock(mutex& mutex, bool)
         : _p_mutex(&mutex._mutex)
        {
            int fail = pthread_mutex_trylock(_p_mutex);
            if(fail == EBUSY) throw locked(EBUSY);
            else if(fail) throw lock_error(fail);
        }

        ~lock(void)
        {
            int fail = pthread_mutex_unlock(_p_mutex);
            assert(!fail);
        }
    };



    class unlock
    {
    private:
        pthread_mutex_t* _p_mutex;
    public:

        unlock(mutex& mutex)
         : _p_mutex(&mutex._mutex)
        {
            int fail = pthread_mutex_unlock(_p_mutex);
            if(fail) throw unlock_error(fail);
        }

        ~unlock(void)
        {
            int fail = pthread_mutex_lock(_p_mutex);
            assert(!fail);
        }
    };


    struct try_lock : lock
    {

        try_lock(mutex& mutex)
         : lock(mutex, true)
        { }
    };
};

} // namespace posix
} // namespace frios

#endif // include guard