/home/raskolnikov/dev/psynth/trunk/src/psynth/old/mutex.hpp

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   PSYCHOSYNTH                                                           *
 *   ===========                                                           *
 *                                                                         *
 *   Copyright (C) 2007 by Juan Pedro Bolivar Puente                       *
 *                                                                         *
 *   This program is free software: you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation, either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 *                                                                         *
 ***************************************************************************/

#ifndef PSYNTH_MUTEX_H
#define PSYNTH_MUTEX_H

#include <pthread.h>
#include <errno.h>

namespace psynth
{

class mutex
{
    friend class condition;
    
    pthread_mutex_t m_mutex;
    pthread_mutexattr_t attr;
    
    void init (int type) {
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, type);
        pthread_mutex_init(&m_mutex, &attr);
    }

    void destroy () {
        pthread_mutexattr_destroy(&attr);
        pthread_mutex_destroy(&m_mutex);
    }
    
public:

    enum type {
        DEFAULT = PTHREAD_MUTEX_DEFAULT,
        FAST = PTHREAD_MUTEX_NORMAL,
        RECURSIVE = PTHREAD_MUTEX_RECURSIVE,
        ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK
    };

    mutex (int type = DEFAULT) {
        init(type);
    }

    ~mutex () {
        destroy();
    }
    
    void reset (int type = DEFAULT) {
        destroy();
        init(type);
    }

    bool lock () const {
        if (pthread_mutex_lock((pthread_mutex_t*) &m_mutex) == EDEADLK)
            return true;
        return false;
    }

    bool try_lock () const {
        if (pthread_mutex_trylock((pthread_mutex_t*)&m_mutex) == EBUSY)
            return false;
        return true;
    }

#if 0
    bool timed_lock (const timespec& delay) const {
        if (pthread_mutex_timedlock_np((pthread_mutex_t*)&m_mutex, &delay) == EBUSY)
            return false;
        return true;
    }
#endif

    void unlock() const {
        pthread_mutex_unlock((pthread_mutex_t*)&m_mutex);
    }
};

class rwlock
{
    pthread_rwlock_t m_rwlock;
    // pthread_rwlockattr_t attr;
    
    void init (int type) {
        /*
        pthread_rwlockattr_init(&attr);
        pthread_rwlockattr_settype(&attr, type);
        */
        pthread_rwlock_init(&m_rwlock, NULL);
    }

    void destroy () {
        /*
        pthread_rwlockattr_destroy(&attr);
        */
        pthread_rwlock_destroy(&m_rwlock);
    }
    
public:
    enum type {
        DEFAULT
#if 0

        DEFAULT = PTHREAD_RWLOCK_DEFAULT,
        PREFER_READER = PTHREAD_RWLOCK_PREFER_READER,
        PREFER_WRITER = PTHREAD_RWLOCK_PREFER_WRITER,
        N_TYPE
#endif
    };

    rwlock(int type = DEFAULT) {
        init(type);
    }

    ~rwlock() {
        destroy();
    }

    void read_lock() const {
        pthread_rwlock_rdlock((pthread_rwlock_t*)&m_rwlock);
    }

    void write_lock() const {
        pthread_rwlock_wrlock((pthread_rwlock_t*)&m_rwlock);
    }

    bool try_read_lock() const {
        if (pthread_rwlock_tryrdlock((pthread_rwlock_t*)&m_rwlock) == EBUSY)
            return false;
        return true;
    }

    bool try_write_lock() {
        if (pthread_rwlock_trywrlock((pthread_rwlock_t*)&m_rwlock) == EBUSY)
            return false;
        return true;
    }

#if 0
    bool timed_read_lock(const struct timespec* delay) const {
        if (pthread_rwlock_timedrdlock_np((pthread_rwlock_t*)&m_rwlock, delay) == EBUSY)
            return false;
        return true;
    }
    
    bool timed_write_lock(const timespec& delay) const {
        if (pthread_rwlock_timedwrlock_np((pthread_rwlock_t*)&m_rwlock, &delay) == EBUSY)
            return false;
        return true;
    }
#endif

    void unlock () const {
        pthread_rwlock_unlock((pthread_rwlock_t*)&m_rwlock);
    }
};

class condition
{
    pthread_cond_t cond;

public:
    condition () {
        pthread_cond_init(&cond, NULL);
    }

    ~condition () {
        pthread_cond_destroy(&cond);
    }

    void broadcast () const {
        pthread_cond_broadcast((pthread_cond_t*)&cond);
    }

    void signal () const {
        pthread_cond_signal((pthread_cond_t*)&cond);
    }

    void wait (mutex& mutex) const {
        pthread_cond_wait((pthread_cond_t*)&cond,
                          (pthread_mutex_t*)&mutex.m_mutex);
    }

    bool timed_wait(mutex& mutex, const timespec& abstime) const {
        if (pthread_cond_timedwait((pthread_cond_t*)&cond,
                                   (pthread_mutex_t*)&mutex.m_mutex,
                                   &abstime) == ETIMEDOUT)
            return false;
        return true;
    }

#if 0
    static void calc_expiration(const timespec& delta,
                               timespec& abstime) const {
        pthread_get_expiration_np(&delta, &abstime);
    }
#endif
};

} /* namespace psynth */

#endif /* PSYNTH_MUTEX_H */