thread.h

#ifndef N2NC_SYNCTHREAD_H
#define N2NC_SYNCTHREAD_H

#include "nixsys.h"
#include "mutex.h"

namespace n2nc {
namespace sync {

class Thread{
  
  public:
    
    int run(void *args);
    int wait(void **retval);
    void* getRetVal();
    int terminate();
    int getID();
    bool isEquals(Thread *t);
    std::string toString();
    
    void setName(std::string name);
    
    static bool compare(Thread &t1, Thread &t2);
//     static Thread& compare(Thread *t1, Thread *t2);
    static bool init();
    static Thread& getCurrent();
    
  protected:
    Thread();
    ~Thread();
    
    virtual int pre_start();
    virtual void* entry_point()=0 ;
    virtual int exit_point();
    
    void *m_args ;
    void *m_ret_args ;
    pthread_t m_thread ;
  private:
    static void* _start(Thread* caller);
    
    bool m_isstarted ;
    bool m_isrunning ;
    bool m_iscancelled ;
    std::string m_name ;
//     static std::set<Thread&> m_threads ;
    static std::map<pthread_t,Thread*> m_runthreads ;
    static n2nc::sync::Mutex m_maplock ;
    
};

class MainThread : public Thread {
  private:
    MainThread() : Thread() {
      /* NOTE Set the running state */
      this->pre_start();
      this->setName("Main");
    }
    ~MainThread(){}
    virtual void* entry_point(){}
//     virtual int pre_start(){}
//     virtual int exit_point(){}
  
  
  
  friend class Thread ;

};

class InlineThread : public Thread {
  public:
    typedef void *(*m_start_routine)(void*) ;
    typedef int (*m_stop_routine)(void*) ;
    InlineThread(m_start_routine fnc,m_stop_routine fncstop = NULL) : Thread() {
      this->m_runfnc = fnc ;
      this->m_stopfnc = fncstop ;
    }
    ~InlineThread(){}
  private:
    virtual void* entry_point(){
      return this->m_runfnc(this->m_args);
    }
    virtual int exit_point(){
      if ( this->m_stopfnc == NULL )  return 0 ;
      return this->m_stopfnc(this->m_ret_args);
    }

  m_start_routine m_runfnc ;
  m_stop_routine m_stopfnc ;
};

}
}

#endif

---