Semaphore.H

Go to the documentation of this file.

#ifndef MY_SEMAPHORE_
#define MY_SEMAPHORE_

extern "C"
{
  #include <sys/fcntl.h>
  #include <sys/errno.h>
  #include <limits.h>
}


#ifdef CYGWIN_COMPAT
extern "C"
{
  // strange: using "" instead of <> for cygwin
  #include "/usr/include/semaphore.h"
}
#else
extern "C"
{
  #include <semaphore.h>
}
#endif


class CSemaphore_exception : public std::exception
{
 private:
  const std::string Message;

 public:
  explicit CSemaphore_exception(const std::string& Msg) throw()
   : Message(Msg)
   {
#if defined(VERBOSE) || defined(DEBUG)
     cerr << "throwing exception: " << Msg << endl;
#endif
   }
 
  virtual ~CSemaphore_exception() throw() { }
  
  virtual const char* what() const throw()
   {
     return Message.c_str();
   }  
};


class CSemaphore : private ForbidAssignment
{
 private:
  sem_t resource_counter;
 public:
  CSemaphore(const unsigned int my_resource_counter)
   {
     if (my_resource_counter>static_cast<unsigned long int>(SEM_VALUE_MAX))
      throw CSemaphore_exception("CSemaphore::constructor: my_resource_counter>SEM_VALUE_MAX");
     if (sem_init(&resource_counter, 0, my_resource_counter))
      throw CSemaphore_exception("CSemaphore::constructor: initialization failed!");
   }
  ~CSemaphore()
   {
     if (sem_destroy(&resource_counter))
      throw CSemaphore_exception("CSemaphore::destructor: failed!");
   }
  void post()
   {
     if (sem_post(&resource_counter)) throw CSemaphore_exception("CSemaphore_post");
   }
  void wait()
   {
     if (sem_wait(&resource_counter)) throw CSemaphore_exception("CSemaphore_wait");
   }
  bool trywait()
   {
     int retval=(sem_trywait(&resource_counter));
     if (retval==-1 && errno!=EAGAIN) throw CSemaphore_exception("CSemaphore_trywait");
     return (retval==0);
   }
  int getvalue()
   {
     int retval;
     if (sem_getvalue(&resource_counter,&retval)) throw CSemaphore_exception("CSemaphore_getvalue");
     return retval;
   }
};


class CNamedSemaphore : private ForbidAssignment
{
 private:
  sem_t *p_resource_counter;
 public:
  CNamedSemaphore(const char *const name, const unsigned int my_resource_counter)
   {
     if (my_resource_counter>static_cast<unsigned long int>(SEM_VALUE_MAX))
      throw CSemaphore_exception("CNamedSemaphore::constructor: my_resource_counter>SEM_VALUE_MAX");
     p_resource_counter = sem_open(name, O_CREAT, S_IRWXU|S_IRWXG, my_resource_counter);
     if (p_resource_counter == SEM_FAILED)
      throw CSemaphore_exception("CNamedSemaphore::constructor: initialization failed!");
   }
  ~CNamedSemaphore()
   {
     if (sem_close(p_resource_counter))
      throw CSemaphore_exception("CNamedSemaphore::destructor: failed!");
   }
  void post()
   {
     if (sem_post(p_resource_counter)) throw CSemaphore_exception("CNamedSemaphore_post");
   }
  void wait()
   {
     if (sem_wait(p_resource_counter)) throw CSemaphore_exception("CNamedSemaphore_wait");
   }
  bool trywait()
   {
     int retval=(sem_trywait(p_resource_counter));
     if (retval==-1 && errno!=EAGAIN) throw CSemaphore_exception("CNamedSemaphore_trywait");
     return (retval==0);
   }
  int getvalue()
   {
     int retval;
     if (sem_getvalue(p_resource_counter,&retval)) throw CSemaphore_exception("CNamedSemaphore_getvalue");
     return retval;
   }
};


class CConditionalNamedSemaphorePostAtDestruction : private ForbidAssignment
{
 private:
  CNamedSemaphore &Sem;
  bool condition;
 public:
  CConditionalNamedSemaphorePostAtDestruction(CNamedSemaphore &mySem, const bool initial_condition)
   : Sem(mySem), condition(initial_condition) { }
  ~CConditionalNamedSemaphorePostAtDestruction() { if (condition) Sem.post(); }
  void set_condition(const bool new_condition = true) { condition=new_condition; }
};


#endif /* MY_SEMAPHORE_ */

---