l_mt_mutexlock.h

Go to the documentation of this file.

/*
 * $Id: l_mt_mutexlock.h 17461 2014-09-05 21:08:33Z predoehl $
 */

#ifndef MUTEXLOCK_H_INCLUDED_IVILAB_2013AUG09
#define MUTEXLOCK_H_INCLUDED_IVILAB_2013AUG09

#include <l_mt/l_mt_pthread.h>
#include <l_cpp/l_exception.h>

namespace kjb
{

class Mutex_lock;

class Pthread_mutex
{
    kjb_c::kjb_pthread_mutex_t mutex_;

    Pthread_mutex(const Pthread_mutex&);            // uncopyable
    Pthread_mutex& operator=(const Pthread_mutex&); // unassignable

    friend class Mutex_lock;

    void fp_abort(const char*);

public:
    Pthread_mutex(void (Pthread_mutex::* pmf)() = 0)
    {
#ifndef KJB_HAVE_PTHREAD
        KJB_THROW_2(Missing_dependency, "built without pthread");
#endif
        ETX(kjb_c::kjb_pthread_mutex_init(&mutex_, 0));

        if (pmf)
        {
            (this ->* pmf)();
        }
    }

    virtual ~Pthread_mutex()
    {
        if (kjb_c::ERROR == kjb_c::kjb_pthread_mutex_destroy(&mutex_))
        {
            fp_abort(kjb::kjb_get_error().c_str());
        }
    }

    void lock()
    {
        ETX(kjb_c::kjb_pthread_mutex_lock(&mutex_));
    }

    void unlock()
    {
        ETX(kjb_c::kjb_pthread_mutex_unlock(&mutex_));
    }

    int try_lock()
    {
        return kjb_c::kjb_pthread_mutex_trylock(&mutex_);
    }
};


struct Pthread_locked_mutex : public Pthread_mutex
{
    Pthread_locked_mutex() : Pthread_mutex(& Pthread_mutex::lock) {}
};


class Mutex_lock
{
    kjb_c::kjb_pthread_mutex_t* mutex_;
    Mutex_lock(const Mutex_lock&);              // uncopyable
    Mutex_lock& operator=(const Mutex_lock&);   // unassignable

    void lock()
    {
        NTX(mutex_);
        ETX(kjb_c::kjb_pthread_mutex_lock(mutex_));
    }

    void fp_abort(const char*);

public:
    Mutex_lock(kjb_c::kjb_pthread_mutex_t* m)
    :   mutex_(m)
    {
        lock();
    }

    Mutex_lock(Pthread_mutex& m)
    :    mutex_(& m.mutex_)
    {
        lock();
    }

    Mutex_lock(Pthread_mutex* m)
    :    mutex_(m ? & m -> mutex_ : 0)
    {
        lock();
    }

    void release()
    {
        if (mutex_)
        {
            if (kjb_c::ERROR == kjb_c::kjb_pthread_mutex_unlock(mutex_))
            {
                fp_abort("unlock");
            }
            mutex_ = 0;
        }
    }

    ~Mutex_lock()
    {
        release();
    }
};



}


#endif