capability_client.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_CORE__CAPABILITY_CLIENT_HPP_
#define EASYFLEET_CORE__CAPABILITY_CLIENT_HPP_
 
#include <chrono>
#include <functional>
#include <memory>
#include <string>
 
#include "rclcpp/rclcpp.hpp"
 
#include "easyfleet_core/action_client.hpp"
 
namespace easyfleet_core
{


template<typename ActionT>
class CapabilityClient
{
public:
  using SharedPtr = std::shared_ptr<CapabilityClient<ActionT>>;
  using Goal = typename ActionT::Goal;
  using Feedback = typename ActionT::Feedback;
  using Result = typename ActionT::Result;
  using FeedbackCallback = std::function<void (std::shared_ptr<const Feedback>)>;

  using Outcome = typename ActionClient<ActionT>::GoalOutcome;

  struct Response
  {
    Outcome outcome{Outcome::ABORTED};
    typename Result::SharedPtr result;
  };

  using ResponseCallback = std::function<void (const Response &)>;

  static SharedPtr create(
    rclcpp::Node & node,
    const std::string & capability_name,
    std::chrono::milliseconds default_wait_timeout = std::chrono::seconds(5));
 
  CapabilityClient(const CapabilityClient &) = delete;
  CapabilityClient & operator=(const CapabilityClient &) = delete;

  bool wait_for_capability();
  bool wait_for_capability(std::chrono::milliseconds timeout);

  void request(
    const Goal & goal,
    ResponseCallback on_response,
    FeedbackCallback on_feedback = nullptr);

  Response request_and_wait(
    const Goal & goal,
    FeedbackCallback on_feedback = nullptr,
    std::chrono::milliseconds timeout = std::chrono::milliseconds(0));

  void cancel();
 
private:
  explicit CapabilityClient(typename ActionClient<ActionT>::SharedPtr action_client);
 
  typename ActionClient<ActionT>::SharedPtr action_client_;
};
 
}  // namespace easyfleet_core
 
#include "easyfleet_core/detail/capability_client_impl.hpp"
 
#endif  // EASYFLEET_CORE__CAPABILITY_CLIENT_HPP_