threads.h

Go to the documentation of this file.

#ifndef LWPP_THREADS_H
#define LWPP_THREADS_H

#include "lwmtutil.h"
#include "lwpp/global.h"

namespace lwpp 
{

  enum MutexID {MUTEX0 = 0, MUTEX1, MUTEX2, MUTEX3, MUTEX4, MUTEX5, MUTEX6, MUTEX7, MUTEX8, MUTEX9};

  class MTUtilBase : public GlobalBase<LWMTUtilFuncs>
  {
  public:
    MTUtilBase(void) {  ; }
    virtual ~MTUtilBase() {;}
    virtual int Lock (const MutexID mutex) const = 0;
    virtual int UnLock (const MutexID mutex) const = 0;
  };

  class LWMTUtil_Pre9 : public MTUtilBase
  {
  private:
    LWMTUtilID  id;
  public:
    LWMTUtil_Pre9(void) : id(0)
    {
      id = globPtr->create();
    }
    virtual ~LWMTUtil_Pre9()
    {
      if (id) globPtr->destroy(id);
    }
    virtual int Lock (const MutexID mutex) const
    {
      return globPtr->lock(id, mutex);
    }
    virtual int UnLock (const MutexID mutex) const
    {
      return globPtr->unlock(id, mutex);
    }
  };

  class LWMTUtil9 : public MTUtilBase
  {
  private:
    LWMTGroupID mtgroup;
  public:
    LWMTUtil9(void) : mtgroup(0)
    {
      mtgroup = globPtr->groupCreate(1);
    }
    virtual ~LWMTUtil9()
    {
      if (mtgroup) globPtr->groupDestroy(mtgroup);
    }
    virtual int Lock (const MutexID mutex) const
    {
      return globPtr->groupLockMutex(mtgroup, mutex);
    }
    virtual int UnLock (const MutexID mutex) const
    {
      return globPtr->groupUnlockMutex(mtgroup, mutex);
    }
  };

  class LWMTUtil
  {
  private:
    MTUtilBase  *MTUtil;
  public:
    LWMTUtil() : MTUtil(0)
    {
      if (lwpp::LightWave::Major() > 8)
        MTUtil = new LWMTUtil9;
      else
        MTUtil = new LWMTUtil_Pre9;
    }
    virtual ~LWMTUtil()
    {
      if (MTUtil) delete MTUtil;
    }
    virtual int Lock (const MutexID mutex) const
    {
      return MTUtil->Lock(mutex);
    }
    virtual int UnLock (const MutexID mutex) const
    {
      return MTUtil->UnLock(mutex);
    }
  };

  class AutoMutex {
      MutexID id;
      LWMTUtil *mt_util;
    public:

      AutoMutex(LWMTUtil *u, const MutexID m) :
        mt_util(u),
        id(m)
      {
        mt_util->Lock(id);
      }
      AutoMutex(LWMTUtil *u, int m) :
        mt_util(u),
        id((MutexID)m)
      {
        mt_util->Lock(id);
      }
      virtual ~AutoMutex()
      {
        mt_util->UnLock(id);
      }
  };

  //typedef int (*LWMTThreadFunc)(void *arg);
  class ThreadUtils : public GlobalBase<LWMTUtilFuncs>
  {
  public:
    LWMTThreadID getID() 
    {
      return globPtr->threadGetID();
    }

    void setData(void* ptr) 
    {
      globPtr->threadSetData(ptr);
    }

    void* getData() 
    {
      return globPtr->threadGetData();
    }

    void* getArg() 
    {
      return globPtr->threadGetArg();
    }

    void* getArgByID(LWMTThreadID thrdid) 
    {
      return globPtr->threadGetArgByID(thrdid);
    }

    int getIndex()
    {
      return globPtr->threadGetIndex();
    }

    int getIndexByID(LWMTThreadID thrdid)
    {
      return globPtr->threadGetIndexByID(thrdid);
    }

    int getThreadCount(LWMTThreadID thrdid)
    {
      return globPtr->threadGetThreadCount(thrdid);
    }

    LWMTGroupID getGroupID(LWMTThreadID thrdid)
    {
      return globPtr->threadGetGroupID(thrdid);
    }

    int checkAbort(void)
    {
      return globPtr->threadCheckAbort();
    }

    int checkAbortByID(LWMTThreadID thrdid)
    {
      return globPtr->threadCheckAbortByID(thrdid);
    }

    void sleep(int delay)
    {
      globPtr->threadSleep(delay);
    }
    void setArg(void* ptr)
    {
      globPtr->threadSetArg(ptr);
    }
    void setIndex(int in_index)
    {
      globPtr->threadSetIndex(in_index);
    }
  };


  class Thread : public GlobalBase<LWMTUtilFuncs>
  {
  protected:
    LWMTThreadID getID() 
    {
      return globPtr->threadGetID();
    }
    void setData(void* ptr) 
    {
      globPtr->threadSetData(ptr);
    }
    void* getData() 
    {
      return globPtr->threadGetData();
    }
    int getIndex()
    {
      return globPtr->threadGetIndex();
    }
    LWMTGroupID getGroupID()
    {
      return globPtr->threadGetGroupID(getID());
    }


    bool checkAbort(void)
    {
      return (globPtr->threadCheckAbort() != 0);
    }

    void sleep(int delay)
    {
      globPtr->threadSleep(delay);
    }
    virtual int Run() = 0;
  public:
    static int LWMTThreadFunc(void *arg)
    {
      Thread *func = static_cast<Thread *>(arg);
      return func->Run();
    }
  };

  class ThreadGroup : public GlobalBase<LWMTUtilFuncs>
  {
    LWMTGroupID mtgrpid;
  public:
    ThreadGroup(int _count)
      : mtgrpid(0)
    {
      mtgrpid = globPtr->groupCreate(_count);
    }
    

    ~ThreadGroup()
    {
      if (mtgrpid) 
        globPtr->groupDestroy(mtgrpid);
      mtgrpid = 0;
    }

    int lockMutex(int mutexID)
    {
      if (mtgrpid) 
        return globPtr->groupLockMutex(mtgrpid, mutexID);
      return 0;
    }
    int unlockMutex(int mutexID)
    {
      if (mtgrpid) 
        return globPtr->groupUnlockMutex(mtgrpid, mutexID);
      return 0;
    }

    LWMTThreadID addThread(LWMTThreadFunc func, int size, void *arg)
    {
      if (mtgrpid) 
      {
        return globPtr->groupAddThread(mtgrpid, func, size, arg);
      }
      return 0;
    }
    LWMTThreadID addThread(Thread *func)
    {
      return addThread(Thread::LWMTThreadFunc, 0, func);
    }
    LWMTThreadID getThreadID(int in_index)
    {
      if (mtgrpid) 
      {
        return globPtr->groupGetThreadID(mtgrpid,in_index);
      }
      return 0;
    }
    int getThreadCount()
    {
      if (mtgrpid) 
      {
        return globPtr->groupGetThreadCount(mtgrpid);
      }
      return 0;
    }

    bool run()
    {
      if (mtgrpid) 
      {
        return (globPtr->groupRun(mtgrpid) != 0);
      }
      return false;
    }

    bool begin()
    {
      if (mtgrpid) 
      {
        return (globPtr->groupBegin(mtgrpid) != 0);
      }
      return false;
    }

    void sync()
    {
      if (mtgrpid) 
      {
        globPtr->groupSync(mtgrpid);
      }
    }

    void abort()
    {
      if (mtgrpid) 
      {
        globPtr->groupAbort(mtgrpid);
      }
    }

    void kill()
    {
      if (mtgrpid) 
      {
        globPtr->groupKill(mtgrpid);
      }
    }

    bool isDone()
    {
      if (mtgrpid) 
      {
        return (globPtr->groupIsDone(mtgrpid) != 0);
      }
      return true;
    }

    bool isAborted()
    {
      if (mtgrpid) 
      {
        return (globPtr->groupIsAborted(mtgrpid) != 0);
      }
      return true;
    }

    int threadResult(int in_index)
    {
      if (mtgrpid) 
      {
        return globPtr->groupThreadResult(mtgrpid, in_index);
      }
      return 0;
    }
  };
}

#endif // LWPP_THREADS_H