robot_handle.hpp

// Copyright 2026 Intelligent Robotics Lab
//
// This file is part of the project EasyFleet
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef EASYFLEET_MISSION_MANAGER__ROBOT_HANDLE_HPP_
#define EASYFLEET_MISSION_MANAGER__ROBOT_HANDLE_HPP_
 
#include <chrono>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "easyfleet_mission_manager/capability_info.hpp"
#include "easyfleet_mission_manager/capability_state.hpp"
#include "easyfleet_mission_manager/detail/running_capability.hpp"
#include "easyfleet_mission_manager/mission_helpers.hpp"
 
namespace easyfleet
{
 
class FleetSession;


class RobotHandle
{
public:
  explicit RobotHandle(std::string name);

  const std::string & name() const noexcept;

  bool has_capability(const std::string & capability_type) const;


  template<typename ActionT>
  void run_capability(
    const std::string & capability_type,
    const typename ActionT::Goal & goal = typename ActionT::Goal(),
    std::chrono::seconds timeout = easyfleet_mission_manager::kRunTimeout);

  void stop_capability(const std::string & capability_type);

  bool is_capability_running(const std::string & capability_type) const;

  CapabilityState capability_state(const std::string & capability_type) const;

  bool is_alive(const std::string & capability_type) const;

  void print_capabilities() const;

  const std::vector<easyfleet_mission_manager::CapabilityInfo> & capabilities() const noexcept;
 
private:
  friend class FleetSession;

  void attach(FleetSession & session);
  void set_capabilities(std::vector<easyfleet_mission_manager::CapabilityInfo> capabilities);

  void note_heartbeat(
    const std::string & capability_type,
    std::chrono::steady_clock::time_point when);

  void check_timeouts();
 
  std::string name_;
  std::vector<easyfleet_mission_manager::CapabilityInfo> capabilities_;
  std::map<std::string,
    std::unique_ptr<easyfleet_mission_manager::detail::RunningCapabilityBase>> running_;
  std::map<std::string, std::chrono::steady_clock::time_point> last_heartbeat_;
  // Deliberately a raw pointer, not a reference: unlike every other
  // non-owning back-reference in this codebase, this one is genuinely
  // nullable (a RobotHandle can exist before attach() ever runs -- e.g.
  // right after `RobotHandle robot_1("robot_1");`, before it's added to
  // any FleetSession) *and* set exactly once, later, by attach() -- a
  // reference member could do neither (never null, never reseatable).
  FleetSession * session_{nullptr};
};
 
}  // namespace easyfleet
 
#endif  // EASYFLEET_MISSION_MANAGER__ROBOT_HANDLE_HPP_