event_base.hpp

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <string>
#include <functional>
 
#include <rclcpp/rclcpp.hpp>
#include <capabilities2_events/event_parameters.hpp>
#include <capabilities2_msgs/msg/capability.hpp>
#include <capabilities2_msgs/msg/capability_event.hpp>
#include <capabilities2_msgs/msg/capability_event_code.hpp>
 
namespace capabilities2_events
{
struct event_exception : public std::runtime_error
{
  using std::runtime_error::runtime_error;
 
  event_exception(const std::string& what) : std::runtime_error(what)
  {
  }
 
  virtual const char* what() const noexcept override
  {
    return std::runtime_error::what();
  }
};
 
class EventBase
{
public:
  typedef std::string capability_str_t;
  typedef capabilities2_events::EventParameters parameter_t;
  typedef std::string access_id_t;
  typedef std::string target_instance_id_t;
  typedef std::function<void(const access_id_t&, const capability_str_t&, const target_instance_id_t&, parameter_t)> event_callback_t;
 
public:
  EventBase()
  {
  }
 
  ~EventBase() = default;
 
  virtual void emit(const std::string& connection_id, const uint8_t& event_code,
                    const capabilities2_msgs::msg::Capability& source,
                    const capabilities2_msgs::msg::Capability& target, event_callback_t callback)
  {
    // extract bond_id from connection_id (format: "bond_id/instance_id/target_instance_id")
    size_t first_pos = connection_id.find('/');
 
    std::string bond_id = (first_pos != std::string::npos) ? connection_id.substr(0, first_pos) : connection_id;
 
    // do callback with bond_id for access control
    if (callback)
    {
      callback(bond_id, target.capability, target.instance_id, capabilities2_events::EventParameters(target));
    }
  }
 
  virtual void on_server_ready(const std::string& msg) = 0;
 
  virtual void on_process_launched(const std::string& pid) = 0;
 
  virtual void on_process_terminated(const std::string& pid) = 0;
 
  virtual void on_triggered(const std::string& trigger_id) = 0;
 
  virtual void on_connected(const std::string& source, const std::string& target) = 0;
 
  virtual void on_disconnected(const std::string& source, const std::string& target) = 0;
};
 
}  // namespace capabilities2_events