task_adaptors.hpp

Go to the documentation of this file.

#ifndef THREADPOOL_TASK_ADAPTERS_HPP_INCLUDED
#define THREADPOOL_TASK_ADAPTERS_HPP_INCLUDED


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


namespace boost { namespace threadpool
{

  typedef function0<void> task_func;




  class prio_task_func
  {
  private:
    unsigned int m_priority;  
    task_func m_function;     

  public:
    typedef void result_type; 

  public:
    prio_task_func(unsigned int const priority, task_func const & function)
      : m_priority(priority)
      , m_function(function)
    {
    }

    void operator() (void) const
    {
      if(m_function)
      {
        m_function();
      }
    }

    bool operator< (const prio_task_func& rhs) const
    {
      return m_priority < rhs.m_priority;
    }

  };  // prio_task_func








  class looped_task_func
  {
  private:
    function0<bool> m_function;   
#if BOOST_VERSION >= 15000
    boost::chrono::milliseconds m_break; 
#else
    unsigned int m_break_s;              
    unsigned int m_break_ns;             
#endif
  public:
    typedef void result_type; 

  public:
    looped_task_func(function0<bool> const & function, unsigned int const interval = 0)
      : m_function(function)
#if BOOST_VERSION >= 15000
      , m_break(interval)
#endif
    {
#if BOOST_VERSION < 15000
      m_break_s  = interval / 1000;
      m_break_ns = (interval - m_break_s * 1000) * 1000 * 1000;
#endif
    }

    void operator() (void) const
    {
      if(m_function)
      {
#if BOOST_VERSION >= 15000
        if(m_break > boost::chrono::milliseconds(0))
          boost::this_thread::sleep_for(m_break);
#else
        if(m_break_s > 0 || m_break_ns > 0)
        {
          // Sleep some time before first execution
          xtime xt;
          xtime_get(&xt, TIME_UTC);
          xt.nsec += m_break_ns;
          xt.sec += m_break_s;
          thread::sleep(xt);
        }
#endif
        while(m_function())
        {
#if BOOST_VERSION >= 15000
          if(m_break > boost::chrono::milliseconds(0))
            boost::this_thread::sleep_for(m_break);
#else
          if(m_break_s > 0 || m_break_ns > 0)
          {
            xtime xt;
            xtime_get(&xt, TIME_UTC);
            xt.nsec += m_break_ns;
            xt.sec += m_break_s;
            thread::sleep(xt);
          }
#endif
          else
          {
            thread::yield(); // Be fair to other threads
          }
        }
      }
    }

  }; // looped_task_func


} } // namespace boost::threadpool

#endif // THREADPOOL_TASK_ADAPTERS_HPP_INCLUDED