libs/cmt/include/mace/cmt/thread.hpp

Go to the documentation of this file.

#ifndef MACE_CMT_THREAD_HPP
#define MACE_CMT_THREAD_HPP
#include <mace/cmt/task.hpp>
#include <boost/chrono.hpp>
#include <mace/cmt/abstract_thread.hpp>

namespace mace { 
namespace cmt {
   using boost::chrono::microseconds;
   using boost::chrono::system_clock;

   struct context;

   priority    current_priority();
   inline void usleep( uint64_t us );
   inline void sleep_until( const system_clock::time_point& tp );

   boost::posix_time::ptime to_system_time( const system_clock::time_point& t );
   system_clock::time_point to_time_point( const boost::posix_time::ptime& from );

  class thread : public abstract_thread {
    public:
    static thread& current();

    const char* name()const;

    void    set_name( const char* n );

    static thread* create( const char* name = ""  );


    template<typename Functor>
    auto schedule( Functor&& f, const system_clock::time_point& when, 
                   priority prio = priority() ) -> future<decltype(f())> {
         typedef decltype(f()) Result;
         typename promise<Result>::ptr p(new promise<Result>());
         task::ptr tsk( new rtask<Functor,Result>( std::forward<Functor>(f),p,when,std::max(current_priority(),prio)) );
         p->set_task(tsk);
         async_task(tsk);
         return p;
    }


    template<typename Functor>
    auto async( Functor&& f, priority prio = priority()) -> future<decltype(f())> {
       typedef decltype(f()) Result;
       typename promise<Result>::ptr p(new promise<Result>());
       task::ptr tsk( new rtask<Functor,Result>( std::forward<Functor>(f),p,std::max(current_priority(),prio)) );
       p->set_task(tsk);
       async_task(tsk);
       return p;
    }

    template<typename Functor>
    void post( Functor&& f, const system_clock::time_point& when, 
                        priority prio = priority()) {
      task::ptr tsk( new vtask<Functor>(std::forward<Functor>(f),when,std::max(current_priority(),prio)) );
      async_task(tsk);
    }

    template<typename Functor>
    void post( Functor&& f, priority p = priority() ) {
      task::ptr tsk( new vtask<Functor>(std::forward<Functor>(f),std::max(current_priority(),p)) );
      async_task(tsk);
    }
    
    void quit();

    void exec();
    
    bool is_running()const;

    priority current_priority()const;
    ~thread();

    private:
      void set_boost_thread( boost::thread* t );
      friend class thread_private;
      friend class mutex;


      friend void mace::cmt::yield();
      friend void mace::cmt::usleep( uint64_t );
      friend void mace::cmt::sleep_until( const system_clock::time_point& );

      // these methods may only be called from the current thread
      void yield( bool reschedule = true );
      void yield_until( const system_clock::time_point& tp, bool reschedule = true );
      void usleep( uint64_t us );
      void sleep_until( const system_clock::time_point& tp );

      void wait( const promise_base::ptr& p, const microseconds& timeout_us );
      void wait( const promise_base::ptr& p, const system_clock::time_point& timeout );
      void notify( const promise_base::ptr& p );

      cmt::context* current_context()const;

      void          unblock( cmt::context* c );

    private:
      thread();

      friend class promise_base;
      void async_task( const task::ptr& t );
      class thread_private* my;
   };

   template<typename Functor>
   auto async( Functor&& f, priority prio=priority()) -> cmt::future<decltype(f())> {
    return cmt::thread::current().async(std::forward<Functor>(f),(std::max)(current_priority(),prio));
   }
   void async( const boost::function<void()>& t, priority prio=priority() ); 

   int  exec();

   inline void usleep( uint64_t us ) {
    mace::cmt::thread::current().usleep(us);
   }
   inline void sleep_until( const system_clock::time_point& tp ) {
    mace::cmt::thread::current().sleep_until(tp);
   }
   void yield();

   inline void quit() { cmt::thread::current().quit(); }
} } // mace::cmt

#endif // MACE_CMT_THREAD_HPP