mutex.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_MUTEX_H
#define ARCHON_UTILITIES_MUTEX_H

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

#include <archon/util/exception.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct Thread;
    struct Condition;

    struct Mutex
    {
      Mutex()
      {
        const int e = pthread_mutex_init(&mutex, 0);
        if(e != 0)
          ARCHON_THROW1(ResourceException,
                        "Mutex initialization failed");
      }

      ~Mutex()
      {
        const int e = pthread_mutex_destroy(&mutex);
        if(e != 0)
        {
          if(e == EBUSY)
            ARCHON_THROW1(StateException,
                          "Attempt to delete a locked mutex");
          ARCHON_THROW1(InternalException,
                        "Mutex destruction failed");
        }
      }

      struct Lock
      {
        Lock(): mutex(0) {}

        Lock(const Mutex &m): mutex(&m)
        {
          m.lock();
        }

        ~Lock()
        {{ // The extra scope is needed to work around gcc3.2 bug #8287
          release();
        }}

        void aquire(const Mutex &m)
        {
          release();
          m.lock();
          mutex = &m;
        }

        void release()
        {
          if(!mutex) return;
          mutex->unlock();
          mutex = 0;
        }

      private:
        friend struct Thread;

        const Mutex *mutex;

        Lock(const Lock &); // Hide
        Lock &operator=(const Lock &); // Hide
      };

    private:
      friend struct Condition;

      pthread_mutex_t mutex;

      Mutex(const Mutex &); // Hide
      Mutex &operator=(const Mutex &); // Hide

      void lock() const
      {
        const int e =
          pthread_mutex_lock(const_cast<pthread_mutex_t *>(&mutex));
        if(e == 0) return;
        if(e == EDEADLK)
          ARCHON_THROW1(StateException,
                        "Attempt to lock a locked mutex");
        if(e == EINVAL)
          ARCHON_THROW1(InternalException,
                        "Attempt to lock uninitialized mutex");
        ARCHON_THROW1(InternalException,
                      "Attempt to lock mutex failed");
      }

      void unlock() const
      {
        const int e =
          pthread_mutex_unlock(const_cast<pthread_mutex_t *>(&mutex));
        if(e == 0) return;
        if(e == EPERM)
          ARCHON_THROW1(StateException,
                        "Attempt to unlock mutex that is locked by another thread");
        if(e == EINVAL)
          ARCHON_THROW1(InternalException,
                        "Attempt to unlock uninitialized mutex");
        ARCHON_THROW1(InternalException,
                      "Attempt to unlock mutex failed");
      }
    };
  }
}

#endif // ARCHON_UTILITIES_MUTEX_H

---