ngcbTHREAD.hpp

Go to the documentation of this file.

#ifndef ngcbTHREAD_H
#define ngcbTHREAD_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#ifndef _REENTRANT
#define _REENTRANT    
#endif
 
/* 
 * System Headers 
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>

extern int ngcbInSignalHandler;

struct ngcbSEM_T
{
  pthread_mutex_t mutex_v;

  pthread_cond_t lck;

  size_t val;
};

typedef pthread_t ngcbTHREAD_T;

extern "C" void *ngcbTHREAD_ExecProc(void *arg);

class ngcbSEM {
public:
  ngcbSEM();

  explicit ngcbSEM(unsigned int count);

  ngcbSEM(unsigned int count, int check);

  virtual ~ngcbSEM(); 

  int Create(ngcbSEM_T *sp, unsigned int count, int check, char *erms = NULL);

  int Create(ngcbSEM_T *sp, unsigned int count, char *erms = NULL);

  int Destroy(ngcbSEM_T *sp, char *erms = NULL);

  int Lock(ngcbSEM_T *sp);

  int Unlock(ngcbSEM_T *sp);

  int TryLock(ngcbSEM_T *sp);

  int Post(ngcbSEM_T *sp);

  int Set(ngcbSEM_T *sp, unsigned int cnt);
  
  size_t WaitCnt(ngcbSEM_T *sp, size_t cnt);

  int Wait(ngcbSEM_T *sp);

  int TryWait(ngcbSEM_T *sp);

  size_t Cnt(ngcbSEM_T *sp);

  int Lock();

  int Unlock();

  int TryLock();
  
  int Post();

  int Set(unsigned int cnt);
  
  size_t WaitCnt(size_t cnt);

  int Wait();

  int TryWait();

  size_t Cnt();
 
protected:
 
private:
  int self_;

  ngcbSEM_T sem_;
};

class ngcbSEMC: public ngcbSEM
{
public:
  explicit ngcbSEMC(unsigned int count) : ngcbSEM(count, 1) {}

  virtual ~ngcbSEMC() {}
 
protected:
 
private:
 
};

class ngcbTHREAD;

typedef void (ngcbTHREAD::*ngcbPROCESS_T)(ngcbTHREAD *thread, void *arg);

class ngcbTHREAD {
public:
  ngcbTHREAD();
  
  ngcbTHREAD(ngcbTHREAD *app, ngcbPROCESS_T process, void *arg, 
         size_t stack = 0);

  virtual ~ngcbTHREAD();
  
  virtual ngcbTHREAD *NewThread(ngcbTHREAD *app, ngcbPROCESS_T process, 
                void *arg, size_t stack = 0);

  int ThrCreate(ngcbTHREAD *app, ngcbPROCESS_T process, void *arg, 
        ngcbTHREAD_T *threadId, size_t stack, char *erms = NULL);
  
  void ThrExit(); 

  int ThrKill(ngcbTHREAD_T threadId, int sig, char *erms = NULL);

  int ThrKill(int sig, char *erms = NULL);

  int ThrJoin(ngcbTHREAD_T threadId, char *erms = NULL); 

  int ThrJoin(char *erms = NULL);
  
  ngcbTHREAD_T ThreadId();

  int ThrEqual(ngcbTHREAD_T t1, ngcbTHREAD_T t2);

  int Initialized();

  int FdOut();

  int FdIn(); 

  void *ExecProc();
 
protected:
 
private:
  ngcbPROCESS_T appProc_;

  ngcbTHREAD *appClass_;

  void *appArg_;

  ngcbTHREAD_T thread_;

  int self_;

  int joined_;

  int initialized_;

  int pipe_[2];
};

class ngcbTIMER: public ngcbTHREAD
{
public:
  ngcbTIMER &operator=(const ngcbTIMER &other);

  ngcbTIMER(const ngcbTIMER &other);

  explicit ngcbTIMER(int ms);

  ngcbTIMER(int ms, int id);
  
  ngcbTIMER(int periodic, int ms, int id);
  
  ngcbTIMER(int after, int periodic, int ms, int id);
  
  virtual ~ngcbTIMER();

  int Fd();
  
  int RecvId();
 
protected:
private:
  int wakeup_;

  unsigned char id_;

  int periodic_;

  int after_;

  ngcbTHREAD *thr_;

  ngcbTHREAD *Start_();

  void Timer_(ngcbTHREAD *thr, void *arg);
};

class ngcbPTIMER: public ngcbTIMER
{
public:
  explicit ngcbPTIMER(int ms):ngcbTIMER(1, ms, 0) {}

  ngcbPTIMER(int ms, int id):ngcbTIMER(1, ms, id) {}
  
  ngcbPTIMER(int after, int ms, int id):ngcbTIMER(after, 1, ms, id) {}
  
  virtual ~ngcbPTIMER() {}
protected:
private:
};
 
#endif