Thread.hpp

// Copyright 2015 GEOSYSTEMS SRL
// All Rights Reserved.

#ifndef FIRE_GEAR_THREADING_THREAD_HPP_INCLUDED
#define FIRE_GEAR_THREADING_THREAD_HPP_INCLUDED

#include "fire/export.hpp"

#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/thread.hpp>

#include <exception>
#include <memory>
#include <cstddef>
#include <string>

#include "fire/Object.hpp"
#include "fire/gear/threading/Runnable.hpp"

namespace fire {
namespace gear {
namespace threading {
class FIRE_ENGINE_DLL Thread : public fire::Object {
 private:
  class Callable {
   private:
    boost::shared_ptr< fire::gear::threading::Runnable > runnable;
   public:
    explicit Callable(boost::shared_ptr< fire::gear::threading::Runnable > runnable) {
      try {
        this->runnable = runnable;
      } catch (const std::exception& exception) {
        throw exception;
      }
    }
    virtual ~Callable() {
      try {
      } catch (const std::exception& exception) {
        throw exception;
      }
    }
    void operator()() {
      try {
        this->runnable->run();
      } catch (const std::exception& exception) {
        throw exception;
      }
    }
  };
  class Guard {
   private:
    boost::shared_ptr< boost::thread > thread;
   public:
    explicit Guard(boost::shared_ptr< boost::thread > thread) {
      try {
        this->thread = thread;
      } catch (const std::exception& exception) {
        throw exception;
      }
    }
    virtual ~Guard() {
      try {
        this->thread->join();
      } catch (const std::exception& exception) {
        throw exception;
      }
    }
  };

 private:
  boost::shared_ptr< fire::gear::threading::Runnable > runnable;
  std::auto_ptr< fire::gear::threading::Thread::Callable > callable;
  boost::shared_ptr< boost::thread > thread;
  std::auto_ptr< fire::gear::threading::Thread::Guard > guard;
  std::auto_ptr< boost::this_thread::disable_interruption > interruptionsDisabled;
  std::auto_ptr< boost::this_thread::restore_interruption > interruptionsEnabled;

 protected:
  void disableInterruptions();
  void enableInterruptions();
  bool isInterruptable() const;
  void setInterruptionPoint();

 public:
  static unsigned getCoresCount();
  static unsigned getVirtualCoresCount();
  static std::string getThreadId();
  static void sleepFor(std::size_t milliseconds);
  Thread();
  explicit Thread(fire::gear::threading::Runnable* runnable);
  virtual ~Thread();
  std::string getId() const;
  void start(bool guarded = false);
  virtual void run();
  void detach();
  bool isJoinable() const;
  void join() const;
  void joinFor(std::size_t milliseconds) const;
  void interrupt();
};
}  // namespace threading
}  // namespace gear
}  // namespace fire

#endif