thread.cpp

#include "thread.h"

namespace n2nc {
namespace sync {

std::map<pthread_t,Thread*> Thread::m_runthreads ;
n2nc::sync::Mutex Thread::m_maplock ;

Thread::Thread()
{
  this->m_isrunning = false ;
  this->m_isstarted = false ;
  this->m_iscancelled = false ;
}

int Thread::pre_start(){
  // setup thread
  std::cerr << "pre_start\n" ;
}

int Thread::run(void *args){
  this->m_args = args ;
  typedef void*(*my_entry_point_t)(void*);
  my_entry_point_t startme = (my_entry_point_t)&Thread::_start ;
  pthread_create(&this->m_thread,NULL,startme,this);
}

int Thread::exit_point(){
  // shutdown code
  std::cerr << "exit_point, cancelled ?" << this->m_iscancelled << std::endl ; ;
  
}


int Thread::terminate(){
  if(!this->m_isstarted){ std::cerr << "Thread::terminate(). Not yet started thread" << std::endl ; return -1 ;}
  if(!this->m_isrunning){ std::cerr << "Thread::terminate(). Not running thread" << std::endl ; return -1 ;}
  if(this->m_isrunning) return pthread_cancel(this->m_thread);
}

int Thread::wait(void **retval){
  if(!this->m_isstarted){ std::cerr << "Thread::wait(). Not yet started thread" << std::endl ; return -1 ;}
  if(!this->m_isrunning){ std::cerr << "Thread::wait(). Not running thread" << std::endl ; return -1 ;}
  return pthread_join(this->m_thread,retval);
}

extern "C"
void* Thread::_start(Thread* caller){
  void *retval = NULL ;
  try {
    /* Setup variables */
    caller->m_isstarted = true ;
    caller->m_isrunning = true ;
    Thread::m_maplock.lock();
    Thread::m_runthreads.insert( std::pair<pthread_t,Thread*>(caller->m_thread,caller)  );
    Thread::m_maplock.unlock();
    /* virtual call to additional setup */
    caller->pre_start();
    
    /* pure virtual call */
    retval = caller->entry_point();
    caller->m_ret_args = retval ;
    caller->m_isrunning = false ;
    
    /* virtual call to additional shutdown */
    caller->exit_point();
    
    Thread::m_maplock.lock();
    Thread::m_runthreads.erase(caller->m_thread );
    Thread::m_maplock.unlock();
    
  
  }
  catch(const std::exception& e){
    std::cerr << "thread _start exception:" << e.what() << std::endl ;
    caller->m_iscancelled = true ;
    caller->exit_point();
    throw ;
  }
  catch(...){
    std::cerr << "thread cancelled\n" ;
    caller->m_iscancelled = true ;
    caller->exit_point();
    throw ;
  }
  return retval ;
}

Thread::~Thread(){
  //TODO terminate and clean up. exit_point -->
}

/* Only used to simulate the main thread */
bool Thread::init(){
  Thread *t = new MainThread();
  t->m_thread = pthread_self();
  Thread::m_runthreads.insert( std::pair<pthread_t,Thread*>(t->m_thread,t)  );
}

void Thread::setName(std::string name){
  this->m_name = name ;
}

Thread &Thread::getCurrent(){
  pthread_t t = pthread_self() ;
  std::map<pthread_t,Thread*>::iterator it ;
  it = Thread::m_runthreads.find(t);
  if(it == Thread::m_runthreads.end() ){
    std::cerr << "WARNING: Not found.main thread is not initialized: perhaps have you Thread::init() ?" << std::endl ;
    std::cerr << "i guess this caller is main thread, so do it for you!" << std::endl ;
    Thread::init();
    return Thread::getCurrent();
//     exit(1);
  }
  Thread &tref = *(it->second) ;
  return tref;
}

std::string Thread::toString(){
  return this->m_name ;
}

void* Thread::getRetVal(){
  if(this->m_isrunning){ std::cerr << "Thread::getRetVal(). Still running thread" << std::endl ; return NULL ;}
  return this->m_ret_args ;
}


}
}

// extern "C"
// int Thread::_terminate(Thread *caller){
//   try {
//     pthread_cancel(caller->m_thread);
// //     throw ;
//   }
//   catch(std::exception const&){
//     std::cerr << "wahoo1\n" ;
//     throw ;
//   }
//   catch(...){
//     std::cerr << "wahoo2\n" ;
//     throw ;
//   }
//   return -1 ;
// }

// extern "C"
// void Thread::cancel_handler(void *arg){
//   std::cerr << "wahoo3\n" ;
// }

---