src/Raym/Object.h

   1 //\r
   2 // Object.h\r
   3 //\r
   4 \r
   5 #pragma once\r
   6 \r
   7 #include "Raym/Log.h"\r
   8 #define RAYM_MEMORY_CHECK\r
   9 //#define RAYM_MUTEX_CHECK\r
  10 \r
  11 #ifdef _WIN32\r
  12 #include <windows.h>\r
  13 #else\r
  14 #include <pthread.h>\r
  15 #endif\r
  16 #include <stdlib.h>\r
  17 #include <Raym/Runtime.h>\r
  18 \r
  19 #define SET_METHOD(P1, P2)  \\r
  20     if ((P1) != NULL)       \\r
  21     {                       \\r
  22         (P1)->release();    \\r
  23     }                       \\r
  24     (P1) = (P2);            \\r
  25     if ((P1) != NULL)       \\r
  26     {                       \\r
  27         (P1)->retain();     \\r
  28     }\r
  29 \r
  30 #define RELEASE(P1)         \\r
  31     if ((P1) != NULL)       \\r
  32     {                       \\r
  33         (P1)->release();    \\r
  34         (P1) = NULL;        \\r
  35     }\r
  36 \r
  37 #define isKindOfClass(CLS, OBJ) \\r
  38     (strcmp(#CLS, (OBJ)->className()) == 0)\r
  39 \r
  40 \r
  41 #ifdef _WIN32\r
  42 \r
  43 #define RAYM_LOCK_CREATE    InitializeCriticalSection(&_cs)\r
  44 #define RAYM_LOCK_DESTROY   DeleteCriticalSection(&_cs)\r
  45 #define RAYM_COND_CREATE    InitializeConditionVariable(&_cond)\r
  46 #define RAYM_COND_DESTROY   pthread_cond_destroy(&_cond)\r
  47 \r
  48 #define DEFINE_STATIC_MUTEX(variable)       \\r
  49 class STATIC_MUTEX_variable                 \\r
  50 {                                           \\r
  51 private:                                    \\r
  52     CRITICAL_SECTION _cs;                   \\r
  53                                             \\r
  54 public:                                     \\r
  55     STATIC_MUTEX_variable()                 \\r
  56     {                                       \\r
  57         InitializeCriticalSection(&_cs);    \\r
  58     }                                       \\r
  59     ~STATIC_MUTEX_variable()                \\r
  60     {                                       \\r
  61         DeleteCriticalSection(&_cs);        \\r
  62     }                                       \\r
  63     void lock()                             \\r
  64     {                                       \\r
  65         EnterCriticalSection(&_cs);         \\r
  66     }                                       \\r
  67     void unlock()                           \\r
  68     {                                       \\r
  69         LeaveCriticalSection(&_cs);         \\r
  70     }                                       \\r
  71 };                                          \\r
  72 static STATIC_MUTEX_variable variable;\r
  73 \r
  74 #else\r
  75 \r
  76 #define RAYM_LOCK_CREATE    {                                   \\r
  77     pthread_mutexattr_t attr;                                   \\r
  78     pthread_mutexattr_init(&attr);                              \\r
  79     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);  \\r
  80     pthread_mutex_init(&_lock, &attr);                          \\r
  81 }\r
  82 #define RAYM_LOCK_DESTROY   pthread_mutex_destroy(&_lock)\r
  83 #define RAYM_COND_CREATE    pthread_cond_init(&_cond, NULL)\r
  84 #define RAYM_COND_DESTROY   pthread_cond_destroy(&_cond)\r
  85 \r
  86 #define DEFINE_STATIC_MUTEX(variable)       \\r
  87 class STATIC_MUTEX_variable                 \\r
  88 {                                           \\r
  89 private:                                    \\r
  90     pthread_mutex_t _lock;                  \\r
  91                                             \\r
  92 public:                                     \\r
  93     STATIC_MUTEX_variable()                 \\r
  94     {                                       \\r
  95         pthread_mutexattr_t attr;                                   \\r
  96         pthread_mutexattr_init(&attr);                              \\r
  97         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);  \\r
  98         pthread_mutex_init(&_lock, &attr);                          \\r
  99     }                                       \\r
 100     ~STATIC_MUTEX_variable()                \\r
 101     {                                       \\r
 102         pthread_mutex_destroy(&_lock);        \\r
 103     }                                       \\r
 104     void lock()                             \\r
 105     {                                       \\r
 106         pthread_mutex_lock(&_lock);         \\r
 107     }                                       \\r
 108     void unlock()                           \\r
 109     {                                       \\r
 110         pthread_mutex_unlock(&_lock);         \\r
 111     }                                       \\r
 112 };                                          \\r
 113 static STATIC_MUTEX_variable variable;\r
 114 #endif\r
 115 \r
 116 namespace Raym\r
 117 {\r
 118 \r
 119 #ifdef RAYM_MEMORY_CHECK\r
 120 extern int global_raym_count_;\r
 121 extern int global_raym_init_count_;\r
 122 extern int global_raym_retain_count_;\r
 123 extern int global_raym_autorelease_count_;\r
 124 extern int global_raym_release_count_;\r
 125 #endif\r
 126 \r
 127 typedef unsigned int    uint;\r
 128 typedef unsigned char   uchar;\r
 129 \r
 130 class String;\r
 131 \r
 132 class Object\r
 133 {\r
 134 protected:\r
 135     Object();\r
 136     virtual ~Object();\r
 137 \r
 138     int                 _retainCount;\r
 139 \r
 140 #ifdef RAYM_MUTEX_CHECK\r
 141 public:\r
 142 #endif\r
 143 #ifdef _WIN32\r
 144     CRITICAL_SECTION    _cs;\r
 145     CONDITION_VARIABLE  _cond;\r
 146 #else\r
 147     pthread_mutex_t     _lock;\r
 148     pthread_cond_t      _cond;\r
 149 #endif\r
 150 \r
 151 public:\r
 152     //\r
 153     static Object *alloc();\r
 154 \r
 155     //\r
 156     Object *init();\r
 157     Object *retain();\r
 158     Object *autorelease();\r
 159     Object *autorelease(bool rootPool);\r
 160     void release();\r
 161 \r
 162     virtual String *description();\r
 163 \r
 164 //    virtual const char *className() = 0;\r
 165     virtual const char *className();\r
 166 \r
 167     friend void RaymLock(Object *);\r
 168     friend void RaymUnlock(Object *);\r
 169     friend void RaymCondWait(Object *);\r
 170     friend void RaymCondSignal(Object *);\r
 171     friend void RaymCondBroadcast(Object *);\r
 172 };\r
 173 \r
 174 #ifndef RAYM_MUTEX_CHECK\r
 175 inline void RaymLock(Object *obj)\r
 176 {\r
 177 #ifdef _WIN32\r
 178     EnterCriticalSection(&(obj->_cs));\r
 179 #else\r
 180 #endif\r
 181 }\r
 182 #else\r
 183 #ifdef _WIN32\r
 184 #define RaymLock(obj) \\r
 185     DebugLog3("before lock: %s %d", __FILE__, __LINE__); \\r
 186     EnterCriticalSection(&(obj->_cs)); \\r
 187     DebugLog3("after lock: %s %d", __FILE__, __LINE__);\r
 188 #else\r
 189 #endif\r
 190 #endif\r
 191 \r
 192 #ifndef RAYM_MUTEX_CHECK\r
 193 inline void RaymUnlock(Object *obj)\r
 194 {\r
 195 #ifdef _WIN32\r
 196     LeaveCriticalSection(&(obj->_cs));\r
 197 #else\r
 198 #endif\r
 199 }\r
 200 #else\r
 201 #ifdef _WIN32\r
 202 #define RaymUnlock(obj) \\r
 203     DebugLog3("before unlock: %s %d", __FILE__, __LINE__); \\r
 204     LeaveCriticalSection(&(obj->_cs)); \\r
 205     DebugLog3("after unlock: %s %d", __FILE__, __LINE__);\r
 206 #else\r
 207 #endif\r
 208 #endif\r
 209 \r
 210 #ifndef RAYM_MUTEX_CHECK\r
 211 inline void RaymCondWait(Object *obj)\r
 212 {\r
 213 #ifdef _WIN32\r
 214     SleepConditionVariableCS(&(obj->_cond), &(obj->_cs), INFINITE);\r
 215 #else\r
 216 #endif\r
 217 }\r
 218 #else\r
 219 #ifdef _WIN32\r
 220 #define RaymCondWait(obj) \\r
 221     DebugLog3("before wait: %s %d", __FILE__, __LINE__); \\r
 222     SleepConditionVariableCS(&(obj->_cond), &(obj->_cs), INFINITE); \\r
 223     DebugLog3("after wait: %s %d", __FILE__, __LINE__);\r
 224 #else\r
 225 #endif\r
 226 #endif\r
 227 \r
 228 #ifndef RAYM_MUTEX_CHECK\r
 229 inline void RaymCondSignal(Object *obj)\r
 230 {\r
 231 #ifdef _WIN32\r
 232     WakeConditionVariable(&(obj->_cond));\r
 233 #else\r
 234 #endif\r
 235 }\r
 236 #else\r
 237 #ifdef _WIN32\r
 238 #define RaymCondSignal(obj) \\r
 239     DebugLog3("before signal: %s %d", __FILE__, __LINE__); \\r
 240     WakeConditionVariable(&(obj->_cond)); \\r
 241     DebugLog3("after signal: %s %d", __FILE__, __LINE__);\r
 242 #else\r
 243 #endif\r
 244 #endif\r
 245 \r
 246 inline void RaymCondBroadcast(Object *obj)\r
 247 {\r
 248 #ifdef _WIN32\r
 249     WakeAllConditionVariable(&(obj->_cond));\r
 250 #else\r
 251 #endif\r
 252 }\r
 253 \r
 254 \r
 255 //#define RaymCriticalSection(OBJ, BLOCK) RaymLock(OBJ); BLOCK; RaymUnlock(OBJ);\r
 256 \r
 257 } // Raym\r
 258 \r