thread.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_THREAD_H
#define ARCHON_UTILITIES_THREAD_H

#include <list>

#include <sys/select.h> // fd_set

#include <archon/util/exception.H>
#include <archon/util/time.H>
#include <archon/util/condition.H>
#include <archon/util/ref.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct Thread: virtual RefObjectBase
    {
      struct ThreadException: virtual Exception {};

      struct AlreadyStartedException: ThreadException
      {
        AlreadyStartedException(string l): Exception(l) {}
      };

      struct NotStartedException: ThreadException
      {
        NotStartedException(string l): Exception(l) {}
      };


      template<typename T>
      static Ref<Thread> run(Ref<T>, void (T::*)(), bool start = true);

      template<typename T, typename U>
      static Ref<Thread> run(Ref<T>, void (T::*)(U), U, bool start = true);

      template<typename T>
      static Ref<Thread> run(void (*)(T), T, bool start = true);

      static Ref<Thread> run(void (*)(), bool start = true);

      static void start(Ref<Thread>) throw(AlreadyStartedException);

      void wait() throw(NotStartedException, UnexpectedException);

      void terminate();

      static Ref<Thread> self();

      static void sleep(const Time &period) throw(UnexpectedException);

      static void sleepUntil(const Time &timeout) throw(UnexpectedException);

      static void acceptTermination() throw(UnexpectedException);

      static void selfResurrect();

      static void mainExitWait();

    protected:
      virtual void main() = 0;

      Thread();

      virtual ~Thread();

    private:
      friend struct Condition;

      struct SelfThread;

      pthread_t pthread;
      bool started;
      bool terminated;
      Condition termination;

      volatile bool terminateRequest;
      Mutex waitConditionMutex;
      Condition *waitCondition;

      static void selfKeyDestroy(void *) throw();
      static void selfKeyAlloc() throw();
      static void registerSelf(Thread *);

      static void *entry(Thread *thread) throw();

      static void activate(Thread *);
      static void deactivate(Thread *);

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



    struct Semaphore
    {
      Semaphore(int initialValue=1): value(initialValue), nonZero(mutex) {}

      void down() throw(UnexpectedException);

      void up();

    private:
      int value;
      Mutex mutex;
      Condition nonZero;
    };




    template<typename T> struct MethodVoidRunner: Thread
    {
      Ref<T> o;
      void (T::*m)();
      MethodVoidRunner(Ref<T> o, void (T::*m)()): o(o), m(m) {}
      void main()
      {
        // std::swap is used to arrange for the destruction of the
        // objects o upon exit of this method.
        Ref<T> p;
        p.swap(o);
        (p.get()->*m)();
      }
    };

    template<typename T>
    Ref<Thread> Thread::run(Ref<T> o, void (T::*m)(), bool s)
    {
      Ref<MethodVoidRunner<T> > r = new MethodVoidRunner<T>(o, m);
      if(s) Thread::start(r);
      return r;
    }



    template<typename T, typename U> struct MethodArgRunner: Thread
    {
      Ref<T> o;
      void (T::*m)(U);
      U a;
      MethodArgRunner(Ref<T> o, void (T::*m)(U), U a): o(o), m(m), a(a) {}

      void main()
      {
        // std::swap is used to arrange for the destruction of the
        // objects o and a upon exit of this method.
        Ref<T> p;
        U b;
        std::swap(o, p);
        std::swap(a, b);
        (p.get()->*m)(b);
      }
    };

    template<typename T, typename U>
    Ref<Thread> Thread::run(Ref<T> o, void (T::*m)(U), U a, bool s)
    {
      Ref<MethodArgRunner<T, U> > r = new MethodArgRunner<T, U>(o, m, a);
      if(s) Thread::start(r);
      return r;
    }



    struct FuncVoidRunner: Thread
    {
      void (*f)();
      FuncVoidRunner(void (*f)()): f(f) {}
      void main() { (*f)(); }
    };

    inline Ref<Thread> Thread::run(void (*f)(), bool s)
    {
      Ref<FuncVoidRunner> r = new FuncVoidRunner(f);
      if(s) Thread::start(r);
      return r;
    }



    template<typename T> struct FuncArgRunner: Thread
    {
      void (*f)(T);
      T a;
      FuncArgRunner(void (*f)(T), T a): f(f), a(a) {}
      void main()
      {
        // std::swap is used to arrange for the destruction of the
        // objects a upon exit of this method.
        T b;
        std::swap(a, b);
        (*f)(b);
      }
    };

    template<typename T>
    Ref<Thread> Thread::run(void (*f)(T), T a, bool s)
    {
      Ref<FuncArgRunner<T> > r = new FuncArgRunner<T>(f, a);
      if(s) Thread::start(r);
      return r;
    }
  }
}

#endif // ARCHON_UTILITIES_THREAD_H

---