executorActivity.hpp

Go to the documentation of this file.

 
#ifndef RAD_EXECUTOR_ACTIVITY_HPP
#define RAD_EXECUTOR_ACTIVITY_HPP
#define BOOST_THREAD_PROVIDES_FUTURE
 
#include <string>
#include <boost/thread/future.hpp>
#include <boost/asio/post.hpp>
 
#include <scxml4cpp/Activity.h>
#include <rad/stopToken.hpp>
 
 
namespace rad {
 
template <class Executor, class Func>
class ExecutorActivity : public scxml4cpp::Activity {
public:
    explicit ExecutorActivity(const std::string& id, Executor ex, Func&& func)
        : Activity(id), m_executor(std::move(ex)), m_func(std::move(func)), m_done(), m_stop_source() {
    }
    ExecutorActivity(const ExecutorActivity&) = delete;             
    ExecutorActivity& operator=(const ExecutorActivity&) = delete;  
 
 
    void start(scxml4cpp::Context* c) override;
 
    void stop(scxml4cpp::Context* c) override;
 
  private:
    Executor m_executor;
    Func m_func;
    boost::future<void> m_done;
    StopSource m_stop_source;
};
 
 
//
// Implementation
//
template <class Executor, class Func>
void ExecutorActivity<Executor, Func>::start(scxml4cpp::Context*) {
    if (m_done.valid()) {
        // There's already an activity running that needs to be stopped first.
        return;
    }
 
    // Create a new stop source to guarantee that it was not already stopped.
    m_stop_source = StopSource();
 
    boost::promise<void> p;
    m_done = p.get_future();
    boost::asio::post(m_executor, [f = m_func, ex=m_executor, token=m_stop_source.GetToken(), done = std::move(p)]() mutable {
                      RAD_ASSERT(token.StopPossible());
        std::invoke(f, ex, token);
        done.set_value();
    });
}
 
template<class Executor, class Func>
void
ExecutorActivity<Executor, Func>::stop(scxml4cpp::Context*) {
    if (!m_stop_source.StopPossible()) {
        // Activity not started
        return;
    }
 
    // Stop
    m_stop_source.RequestStop();
 
    try {
        std::cout << "Await stop of activity\n";
        m_done.get();
        std::cout << "stop of activity\n";
    } catch (boost::future_uninitialized const&) {
        // No activity was running
    } catch (boost::broken_promise const&) {
        // Activity finished, but might have crashed
    } catch (...) {
        // Unknown error
    }
}
 
}  // namespace rad
 
#endif  // RAD_EXECUTOR_ACTIVITY_HPP