src/core/threadmanager.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2006 David Brodsky                                      *
   4  *                                                                         *
   5  *   This library is free software; you can redistribute it and/or         *
   6  *   modify it under the terms of the GNU Library General Public           *
   7  *   License as published by the Free Software Foundation and appearing    *
   8  *   in the file LICENSE.LGPL included in the packaging of this file.      *
   9  *                                                                         *
  10  *   This library is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
  13  *   Library General Public License for more details.                      *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _tairon_core_threadmanager_h
  18 #define _tairon_core_threadmanager_h
  19
  20 #include <map>
  21 #include <pthread.h>
  22
  23 #include "string.h"
  24
  25 namespace Tairon
  26 {
  27
  28 namespace Core
  29 {
  30
  31 class Mutex;
  32 class Thread;
  33
  34 /** \brief Holds informations about all created threads.
  35  *
  36  * This class is a singleton.
  37  */
  38 class ThreadManager
  39 {
  40         public:
  41                 /** Initializes the manager.
  42                  */
  43                 ThreadManager();
  44
  45                 /** Destroys the manager.
  46                  */
  47                 ~ThreadManager();
  48
  49                 /** Returns the thread object identified by its ID.
  50                  */
  51                 Thread *getThreadByID(pthread_t id);
  52
  53                 /** Returns the thread object identified by its name.
  54                  */
  55                 Thread *getThreadByName(const String &name);
  56
  57                 /** Returns pointer to the instance of this class.
  58                  */
  59                 static ThreadManager *self() {
  60                         return threadManager;
  61                 };
  62
  63                 /** Sets main program's thread.
  64                  */
  65                 void setMainThread(Thread *thread);
  66
  67         private:
  68                 /** Registers a new thread.
  69                  *
  70                  * \param name Name of the new thread.
  71                  * \param thread Thread object to register.
  72                  */
  73                 void registerThread(const String &name, Thread *thread);
  74
  75                 /** Registers an ID of a thread.
  76                  */
  77                 void registerThreadID(pthread_t id, Thread *thread);
  78
  79                 /** Unregisters a thread.
  80                  *
  81                  * \param name Name of the thread to unregister.
  82                  */
  83                 void unregisterThread(const String &name);
  84
  85                 /** Unregisters an ID.
  86                  */
  87                 void unregisterThreadID(pthread_t id);
  88
  89         private:
  90                 /** Main program's thread.
  91                  */
  92                 Thread *mainThread;
  93
  94                 /** Mapping from an ID to the thread.
  95                  */
  96                 std::map<pthread_t, Thread *> threadIDs;
  97
  98                 /** Mutex protecting access to the threadIDs.
  99                  */
 100                 Mutex *threadIDsMutex;
 101
 102                 /** Holds pointer to the instance of this class.
 103                  */
 104                 static ThreadManager *threadManager;
 105
 106                 /** Mapping from a name to the thread.
 107                  */
 108                 std::map<String, Thread *> threadNames;
 109
 110                 /** Mutex protecting access to the threadNames.
 111                  */
 112                 Mutex *threadNamesMutex;
 113
 114         friend class Thread;
 115 };
 116
 117 }; // namespace Core
 118
 119 }; // namespace Tairon
 120
 121 #endif
 122
 123 // vim: ai sw=4 ts=4 noet fdm=marker