exceptions.hpp

//
//  exceptions.hpp
//  cpp-pthread
//
//  Created by herbert koelman on 18/03/2016.
//
//

#ifndef PTHREAD_EXCEPTIONS_HPP
#define PTHREAD_EXCEPTIONS_HPP

#include <pthread.h>

#include <cerrno>
#include <string>    // std::string
#include <cstring>
#include <exception> // std::exception


namespace pthread {

//  using namespace std ;

  class pthread_exception: public std::exception {

  public:

    pthread_exception( const std::string &message, const int pthread_errno = -1 );

    virtual ~pthread_exception();

#if __cplusplus < 201103L
    virtual const char *what() const throw() ;
#else
    virtual const char *what() const noexcept override ;
#endif

    virtual int pthread_errno() ;

    virtual const char *pthread_errmsg() ;

  private:
    std::string  _message;
    //const char  *_message;
    int          _pthread_errno;

  };

  class timeout_exception: public pthread_exception{
  public:
    explicit timeout_exception(const std::string &message);

  };

  class mutex_exception: public pthread_exception {
  public:

    explicit mutex_exception( const std::string &message, const int pthread_errno = -1) ;

  };

  class read_write_lock_exception: public pthread_exception {
  public:

    explicit read_write_lock_exception( const std::string &message, const int pthread_errno = -1) ;

  };

  class condition_variable_exception: public pthread_exception {
  public:

    condition_variable_exception( const std::string &message, const int pthread_errno = -1);

    virtual ~condition_variable_exception(){
      // Intentionally unimplemented...
    };
  };

  class thread_exception: public pthread_exception {
  public:
    thread_exception(const std::string &message, const int pthread_error = -1);
  };

  namespace util {

    class queue_exception : public std::exception {
    public:
      explicit queue_exception(const std::string &msg = "queue_error occured.");

      virtual ~queue_exception(){
        // intintional...
      };

#if __cplusplus < 201103L
      virtual const char *what() const throw();
#else
      virtual const char *what() const noexcept override;
#endif

    protected:
      std::string _message; 
    };

    class queue_full: public queue_exception{
    public:
      explicit queue_full(const std::string &msg = "synchronized_queue full.");

    };

    class queue_timeout: public queue_exception{
    public:
      explicit queue_timeout(const std::string &msg = "synchronized_queue get/put timed out.");

    };
  }; // namespace util

} // namespace pthread

#endif