.. _program_listing_file_include_service_wrapper.hpp:

Program Listing for File service_wrapper.hpp
============================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_service_wrapper.hpp>` (``include/service_wrapper.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #ifndef RIG_RECONFIGURE_SERVICE_WRAPPER_HPP
   #define RIG_RECONFIGURE_SERVICE_WRAPPER_HPP
   
   #include <utility>
   #include <vector>
   #include <string>
   #include <chrono>
   #include <rclcpp/rclcpp.hpp>
   #include "queue.hpp"
   #include "requests.hpp"
   #include "responses.hpp"
   
   struct FutureTimeoutContainer {
       FutureTimeoutContainer() {
           timeSent = std::chrono::system_clock::now();
       }
   
       std::chrono::time_point<std::chrono::system_clock> timeSent;
       bool handled = false;
       bool timeoutReached = false;
   };
   
   class ServiceWrapper {
     public:
       explicit ServiceWrapper(bool ignoreDefaultParameters_ = true);
   
       void terminate();
   
       void setNodeOfInterest(const std::string &name);
   
       void pushRequest(RequestPtr &&request);
   
       ResponsePtr tryPopResponse();
   
       void checkForTimeouts();
   
       void setIgnoreDefaultParameters(bool ignoreDefaultParameters);
   
     private:
       void threadFunc();
       void handleRequest(const RequestPtr &request);
   
       Queue<RequestPtr> requestQueue;
       Queue<ResponsePtr> responseQueue;
   
       std::atomic_bool terminateThread = false;
   
       bool ignoreDefaultParameters;
       std::string nodeName;                 
       std::thread thread;                   
       std::thread rosThread;                
       std::promise<bool> terminationHelper; 
   
       std::mutex unfinishedROSRequestsMutex;
       std::vector<std::shared_ptr<FutureTimeoutContainer>> unfinishedROSRequests;
   
       std::shared_ptr<rclcpp::Node> node;
       rclcpp::executors::SingleThreadedExecutor executor;
   
       // clients for calling the different services
       rclcpp::Client<rcl_interfaces::srv::ListParameters>::SharedPtr listParametersClient;
       rclcpp::Client<rcl_interfaces::srv::GetParameters>::SharedPtr getParametersClient;
       rclcpp::Client<rcl_interfaces::srv::SetParameters>::SharedPtr setParametersClient;
   
       // callbacks for the results of the futures
       void nodeParametersReceived(const rclcpp::Client<rcl_interfaces::srv::ListParameters>::SharedFuture &future,
                                   const std::shared_ptr<FutureTimeoutContainer> &timeoutContainer);
       void parameterValuesReceived(const rclcpp::Client<rcl_interfaces::srv::GetParameters>::SharedFuture &future,
                                    const std::vector<std::string> &parameterNames,
                                    const std::shared_ptr<FutureTimeoutContainer> &timeoutContainer);
       void parameterModificationResponseReceived(const rclcpp::Client<rcl_interfaces::srv::SetParameters>::SharedFuture &future,
                                                  const std::string &parameterName,
                                                  const std::shared_ptr<FutureTimeoutContainer> &timeoutContainer);
   };
   
   #endif // RIG_RECONFIGURE_SERVICE_WRAPPER_HPP