ObjectMoveHandler.hpp

#ifndef KINEMATICS_OBJECT_MOVE_HANDLER_HPP
#define KINEMATICS_OBJECT_MOVE_HANDLER_HPP

#include <ros/ros.h>
#include "HLR/ObjectMove.h"
#include "HLR/Progress.h"

#include <condition_variable>
#include <mutex>
#include <queue>
#include <thread>

namespace HLR
{
namespace Kinematics
{
class ObjectMoveHandler
{
public:
    ObjectMoveHandler();

    virtual ~ObjectMoveHandler();

    ObjectMoveHandler(const ObjectMoveHandler& omh) = delete;

    ObjectMoveHandler(ObjectMoveHandler&& omh) = delete;

    ObjectMoveHandler& operator=(const ObjectMoveHandler& omh) = delete;

    ObjectMoveHandler& operator=(ObjectMoveHandler&& omh) = delete;

    bool object_move_start(HLR::ObjectMove::Request& req,
                           HLR::ObjectMove::Response& res);

    bool object_move_cancel(HLR::ObjectMove::Request& req,
                            HLR::ObjectMove::Response& res);

    bool object_move_continue(HLR::ObjectMove::Request& req,
                              HLR::ObjectMove::Response& res);

    bool object_move_stop(HLR::ObjectMove::Request& req,
                          HLR::ObjectMove::Response& res);

private:
    enum class State
    {
        idle = 0,
        cont = 1,
        stop = 2,
        cancel = 3,
        exit = 4
    };

    void object_move_worker();

    ros::NodeHandle nh;

    ros::Publisher progress_pub;

    ros::ServiceServer service_move_start;

    ros::ServiceServer service_move_stop;

    ros::ServiceServer service_move_continue;

    ros::ServiceServer service_move_cancel;

    std::thread worker_thread;

    HLR::Progress progress;

    std::condition_variable cv;

    std::queue<size_t> queue;

    std::mutex queue_m;

    State worker_state;

    std::mutex worker_state_m;
};

} // namespace Kinematics
} // namespace HLR

#endif /* KINEMATICS_OBJECT_MOVE_HANDLER_HPP */