thread.hpp

//
//  thread.hpp
//  cpp-pthread
//
//  Created by herbert koelman on 18/03/2016.
//  Copyright © 2016 urbix-software. All rights reserved.
//

#ifndef PTHREAD_THREAD_HPP
#define PTHREAD_THREAD_HPP

// must be include as first hearder file of each source code file (see IBM's
// recommandation for more info p.285 §8.3.1).
#include <pthread.h>

#include <iostream>
#include <string>
#include <functional>
#include <memory> // std::auto_ptr, std::unique_ptr
#include <list>
#include <cstddef>

#include "pthread/config.h"
#include "pthread/exceptions.hpp"
#include "pthread/mutex.hpp"
#include "pthread/lock_guard.hpp"


namespace pthread {

  void *thread_startup_runnable (void *);

  enum class thread_status{
    not_a_thread, 
    a_thread      
  };

  class runnable {
  private:

  public:
#if __cplusplus < 201103L
    virtual void run () throw() = 0 ;
#else
    virtual void run () noexcept = 0 ;
#endif

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

  class thread {
  public:

    thread();

    thread( const runnable &runner, const std::size_t stack_size = 0 );

    thread( thread&& other); // NOSONAR this is std interface and cannot be changed

    thread(const thread &) = delete ;

    virtual ~thread();

    void join();

    bool joinable() const { return _thread != 0 ;};

    int cancel();

    inline thread_status status() { return _status ;};

    thread& operator=(const thread&) = delete ;

    thread& operator=(thread&& other); // NOSONAR this is a std method signature

  private:

    void swap ( thread& other );

    pthread_t      _thread; 
    pthread_attr_t _attr;   

    thread_status  _status; 
  };

  class abstract_thread: public runnable {
  public:
    explicit abstract_thread(const std::size_t stack_size = 0);
    virtual ~abstract_thread();

    void start();

    void join() ;

    bool joinable() const ;


  private:
    pthread::thread *_thread;
    std::size_t      _stack_size ;
  };

  class thread_group{
  public:
#if __cplusplus < 201103L
    explicit thread_group( bool destructor_joins_first = false ) throw();
#else
    explicit thread_group( bool destructor_joins_first = false ) noexcept;
#endif

    virtual ~thread_group();

    void add(abstract_thread *thread);

    void start();

    void join();

    unsigned long size();

    const bool destructor_joins_first(){ return _destructor_joins_first;};

  private:
    std::list<pthread::abstract_thread*> _threads;
    bool                                 _destructor_joins_first;
  };

  namespace this_thread{
    void sleep_for(const int millis);

    pthread_t get_id() ;
  }

} // namespace pthread

#endif /* thread_hpp */