Source/Base/Threading/OSGMPBase.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2003 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include "OSGConfig.h"
  43
  44 #include <iostream>
  45
  46 #include "OSGMPBase.h"
  47 #include "OSGTypeFactory.h"
  48 #include "OSGBaseFunctions.h"
  49 #include "OSGThreadManager.h"
  50
  51 OSG_USING_NAMESPACE
  52
  53 //---------------------------------------------------------------------------
  54 //  Class
  55 //---------------------------------------------------------------------------
  56
  57 /*! \class OSG::MPType
  58  */
  59
  60 MPType::MPType(const Char8  *szName,
  61                const Char8  *szParentName,
  62                const UInt32  uiNamespace ) :
  63     Inherited(szName,
  64               szParentName,
  65               uiNamespace )
  66 {
  67 }
  68
  69
  70 MPType::~MPType(void)
  71 {
  72 }
  73
  74
  75
  76
  77 //---------------------------------------------------------------------------
  78 //  Class
  79 //---------------------------------------------------------------------------
  80
  81 /*! \class OSG::MPThreadType
  82  */
  83
  84 UInt32 MPThreadType::_uiThreadCount = 0;
  85
  86
  87 MPThreadType::MPThreadType(const Char8          *szName,
  88                            const Char8          *szParentName,
  89                                  CreateThreadF   fCreateThread,
  90                                  InitThreadingF  fInitThreading,
  91                            const UInt32          uiNamespace   ) :
  92      Inherited    (szName, szParentName, uiNamespace),
  93     _fCreateThread(fCreateThread                    )
  94 {
  95     ThreadManager::the()->registerThreadType(this);
  96
  97     if(fInitThreading != NULL)
  98         fInitThreading();
  99 }
 100
 101
 102 MPThreadType::~MPThreadType(void)
 103 {
 104 }
 105
 106
 107 BaseThread *MPThreadType::create(const Char8 *szName, bool bGlobal)
 108 {
 109     Char8      *szTmp;
 110     UInt32      uiNewId     = _uiThreadCount++;
 111     BaseThread *returnValue = NULL;
 112
 113     if(szName == NULL)
 114     {
 115         szTmp = new Char8[32];
 116         sprintf(szTmp, "OSGThread_%u", uiNewId);
 117     }
 118     else
 119     {
 120         szTmp = const_cast<Char8 *>(szName);
 121     }
 122
 123     if(_fCreateThread != NULL)
 124         returnValue =  _fCreateThread(szTmp, uiNewId, bGlobal);
 125
 126     if(szTmp != szName)
 127         delete [] szTmp;
 128
 129     return returnValue;
 130 }
 131
 132
 133 //---------------------------------------------------------------------------
 134 //  Class
 135 //---------------------------------------------------------------------------
 136
 137 /*! \class OSG::MPCondVarType
 138  */
 139
 140 UInt32 MPCondVarType::_uiCondVarCount = 0;
 141
 142
 143 MPCondVarType::MPCondVarType(const Char8       *szName,
 144                              const Char8       *szParentName,
 145                              CreateCondVarF     fCreateCondVar,
 146                              const UInt32       uiNamespace ) :
 147      Inherited  (szName, szParentName, uiNamespace),
 148     _fCreateCondVar(fCreateCondVar                      )
 149 {
 150     ThreadManager::the()->registerCondVarType(this);
 151 }
 152
 153
 154 MPCondVarType::~MPCondVarType(void)
 155 {
 156 }
 157
 158
 159 CondVar *MPCondVarType::create(const Char8 *szName, bool bGlobal)
 160 {
 161     Char8   *szTmp;
 162     UInt32   uiNewId     = _uiCondVarCount++;
 163     CondVar *returnValue = NULL;
 164
 165     if(szName == NULL)
 166     {
 167         szTmp = new Char8[32];
 168         sprintf(szTmp, "OSGCondVar_%u", uiNewId);
 169     }
 170     else
 171     {
 172         szTmp = const_cast<Char8 *>(szName);
 173     }
 174
 175     if(_fCreateCondVar != NULL)
 176         returnValue = _fCreateCondVar(szTmp, uiNewId, bGlobal);
 177
 178     if(szTmp != szName)
 179         delete [] szTmp;
 180
 181     return returnValue;
 182 }
 183
 184
 185
 186 //---------------------------------------------------------------------------
 187 //  Class
 188 //---------------------------------------------------------------------------
 189
 190 /*! \class OSG::MPBarrierType
 191  */
 192
 193 UInt32 MPBarrierType::_uiBarrierCount = 0;
 194
 195
 196 MPBarrierType::MPBarrierType(const Char8          *szName,
 197                              const Char8          *szParentName,
 198                                    CreateBarrierF  fCreateBarrier,
 199                              const UInt32          uiNamespace   ) :
 200      Inherited     (szName, szParentName, uiNamespace),
 201     _fCreateBarrier(fCreateBarrier                   )
 202 {
 203     ThreadManager::the()->registerBarrierType(this);
 204 }
 205
 206
 207 MPBarrierType::~MPBarrierType(void)
 208 {
 209 }
 210
 211
 212 Barrier *MPBarrierType::create(const Char8 *szName, bool bGlobal)
 213 {
 214     Char8   *szTmp;
 215     UInt32   uiNewId     = _uiBarrierCount++;
 216     Barrier *returnValue = NULL;
 217
 218     if(szName == NULL)
 219     {
 220         szTmp = new Char8[32];
 221         sprintf(szTmp, "OSGBarrier_%u", uiNewId);
 222     }
 223     else
 224     {
 225         szTmp = const_cast<Char8 *>(szName);
 226     }
 227
 228     if(_fCreateBarrier != NULL)
 229         returnValue =  _fCreateBarrier(szTmp, uiNewId, bGlobal);
 230
 231     if(szTmp != szName)
 232         delete [] szTmp;
 233
 234     return returnValue;
 235 }
 236
 237
 238
 239
 240 //---------------------------------------------------------------------------
 241 //  Class
 242 //---------------------------------------------------------------------------
 243
 244 /*! \class OSG::MPLockType
 245  */
 246
 247 UInt32 MPLockType::_uiLockCount = 0;
 248
 249
 250 MPLockType::MPLockType(const Char8       *szName,
 251                        const Char8       *szParentName,
 252                              CreateLockF  fCreateLock,
 253                        const UInt32       uiNamespace ) :
 254      Inherited  (szName, szParentName, uiNamespace),
 255     _fCreateLock(fCreateLock                      )
 256 {
 257     ThreadManager::the()->registerLockType(this);
 258 }
 259
 260
 261 MPLockType::~MPLockType(void)
 262 {
 263 }
 264
 265
 266 Lock *MPLockType::create(const Char8 *szName, bool bGlobal)
 267 {
 268     Char8   *szTmp;
 269     UInt32  uiNewId     = _uiLockCount++;
 270     Lock   *returnValue = NULL;
 271
 272     if(szName == NULL)
 273     {
 274         szTmp = new Char8[32];
 275         sprintf(szTmp, "OSGLock_%u", uiNewId);
 276     }
 277     else
 278     {
 279         szTmp = const_cast<Char8 *>(szName);
 280     }
 281
 282     if(_fCreateLock != NULL)
 283         returnValue = _fCreateLock(szTmp, uiNewId, bGlobal);
 284
 285     if(szTmp != szName)
 286         delete [] szTmp;
 287
 288     return returnValue;
 289 }
 290
 291
 292
 293
 294 //---------------------------------------------------------------------------
 295 //  Class
 296 //---------------------------------------------------------------------------
 297
 298 /*! \class OSG::MPLockPoolType
 299  */
 300
 301 UInt32 MPLockPoolType::_uiLockPoolCount = 0;
 302
 303
 304 MPLockPoolType::MPLockPoolType(
 305     const Char8           *szName,
 306     const Char8           *szParentName,
 307           CreateLockPoolF  fCreateLockPool,
 308     const UInt32           uiNamespace    ) :
 309
 310      Inherited      (szName, szParentName, uiNamespace),
 311     _fCreateLockPool(fCreateLockPool                  )
 312 {
 313     ThreadManager::the()->registerLockPoolType(this);
 314 }
 315
 316
 317 MPLockPoolType::~MPLockPoolType(void)
 318 {
 319 }
 320
 321
 322 LockPool *MPLockPoolType::create(const Char8 *szName, bool bGlobal)
 323 {
 324     Char8    *szTmp;
 325     UInt32    uiNewId     = _uiLockPoolCount++;
 326     LockPool *returnValue = NULL;
 327
 328     if(szName == NULL)
 329     {
 330         szTmp = new Char8[32];
 331         sprintf(szTmp, "OSGThread_%u", uiNewId);
 332     }
 333     else
 334     {
 335         szTmp = const_cast<Char8 *>(szName);
 336     }
 337
 338     if(_fCreateLockPool != NULL)
 339         returnValue =  _fCreateLockPool(szTmp, uiNewId, bGlobal);
 340
 341     if(szTmp != szName)
 342         delete [] szTmp;
 343
 344     return returnValue;
 345 }
 346
 347
 348
 349 //---------------------------------------------------------------------------
 350 //  Class
 351 //---------------------------------------------------------------------------
 352
 353 /*! \class OSG::MPSemaphoreType
 354  */
 355
 356 UInt32 MPSemaphoreType::_uiSemaphoreCount = 0;
 357
 358
 359 MPSemaphoreType::MPSemaphoreType(const Char8            *szName,
 360                                  const Char8            *szParentName,
 361                                        CreateSemaphoreF  fCreateSemaphore,
 362                                  const UInt32            uiNamespace ) :
 363      Inherited       (szName, szParentName, uiNamespace),
 364     _fCreateSemaphore(fCreateSemaphore                 )
 365 {
 366     ThreadManager::the()->registerSemaphoreType(this);
 367 }
 368
 369
 370 MPSemaphoreType::~MPSemaphoreType(void)
 371 {
 372 }
 373
 374
 375 Semaphore *MPSemaphoreType::create(const Char8 *szName, bool bGlobal)
 376 {
 377     Char8      *szTmp;
 378     UInt32      uiNewId     = _uiSemaphoreCount++;
 379     Semaphore  *returnValue = NULL;
 380
 381     if(szName == NULL)
 382     {
 383         szTmp = new Char8[32];
 384         sprintf(szTmp, "OSGSemaphore_%u", uiNewId);
 385     }
 386     else
 387     {
 388         szTmp = const_cast<Char8 *>(szName);
 389     }
 390
 391     if(_fCreateSemaphore != NULL)
 392         returnValue = _fCreateSemaphore(szTmp, uiNewId, bGlobal);
 393
 394     if(szTmp != szName)
 395         delete [] szTmp;
 396
 397     return returnValue;
 398 }
 399
 400
 401 //---------------------------------------------------------------------------
 402 //  Class
 403 //---------------------------------------------------------------------------
 404
 405 /*! \class OSG::MPBase
 406  */
 407
 408 MPType MPBase::_type("OSGMPBase", NULL);
 409
 410
 411 const MPType &MPBase::getStaticType(void)
 412 {
 413     return _type;
 414 }
 415
 416
 417 UInt32 MPBase::getStaticTypeId(void)
 418 {
 419     return 0;
 420 }
 421
 422
 423 MPType &MPBase::getType(void)
 424 {
 425     return _type;
 426 }
 427
 428
 429 const MPType &MPBase::getType(void) const
 430 {
 431     return _type;
 432 }
 433
 434
 435 UInt32 MPBase::getTypeId(void)
 436 {
 437     return getType().getId();
 438 }
 439
 440
 441 const Char8 *MPBase::getCName(void) const
 442 {
 443     return _szName;
 444 }
 445
 446
 447 MPBase::MPBase(const Char8 *szName, bool bGlobal) :
 448      Inherited(       ),
 449
 450     _szName   (NULL   ),
 451     _bGlobal  (bGlobal)
 452 {
 453     osgStringDup(szName, _szName);
 454 }
 455
 456
 457 MPBase::~MPBase(void)
 458 {
 459     delete [] _szName;
 460 }
 461