PosixMutex.hh

//********************************************************************
//*** Thread/PosixMutex.hh
//*** Copyright (c) 2002-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: PosixMutex.hh,v 1.22 2009-03-02 14:16:46 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool 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 2 of 
the License, or (at your option) any later version.

ResourcePool 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 ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef INCLUDED_POSIXMUTEX_H
#define INCLUDED_POSIXMUTEX_H

#ifndef INCLUDED_THREAD_LOCKSTATISTICSFWD_HH
#include "LockStatisticsFwd.hh"
#endif

namespace fatalmind {
    class DefaultPosixMutexSpecialization;

    template<class PosixMutexSpecialization = DefaultPosixMutexSpecialization
        , class Statistics = DefaultLockStatistics>
    class PosixMutex;
}

#ifndef INCLUDED_ERRNO_H
#include "Exceptions/Errno.hh"
#endif

// TODO, split so that this is not public -> make instantiations file
#include <pthread.h>

namespace fatalmind {

class DefaultPosixMutexSpecialization {
    protected:
        inline pthread_mutexattr_t* getAttr() {
            return NULL;
        }
};

template<class PosixMutexSpecialization, class Statistics>
std::ostream& operator<<(std::ostream& o
    , const PosixMutex<PosixMutexSpecialization, Statistics>& mutex
);

template<class PosixMutexSpecialization, class Statistics>
class PosixMutex : public PosixMutexSpecialization, public Statistics {
    public:
        PosixMutex() {
            Errno::ThrowOnError(
                pthread_mutex_init(&d_mutex, PosixMutexSpecialization::getAttr())
            );
        };


        void lock() {
            typename Statistics::_timer_t timingstat(Statistics::_waittime, true);
            Errno::ThrowOnError(
                pthread_mutex_lock(&d_mutex)
            );
            Statistics::stat_lock();
        };

        void unlock() {
            Statistics::stat_unlock();
            Errno::ThrowOnError(
                pthread_mutex_unlock(&d_mutex)
            );
        };

        ~PosixMutex() {
            int status = pthread_mutex_destroy(&d_mutex);
            while (status != 0) {
                lock();
                unlock();
                status = pthread_mutex_destroy(&d_mutex);
            }
        };

        void multiThreaded() {
        };
    friend 
        std::ostream& operator<< <>(std::ostream& o, const PosixMutex<PosixMutexSpecialization, Statistics>& mutex);

    private:
        PosixMutex(PosixMutex&); // copy is not allowed
        PosixMutex<PosixMutexSpecialization>& operator=(PosixMutex&); // assignment is not allowed

    protected:
        using Statistics::stat_lock;
        using Statistics::stat_unlock;

        pthread_mutex_t     d_mutex;
};

template<class PosixMutexSpecialization, class Statistics>
std::ostream& operator<<(std::ostream& o
    , const PosixMutex<PosixMutexSpecialization, Statistics>& mutex
) {
    return o << static_cast<const Statistics&>(mutex);
}

} // namespace fatalmind

#endif

---