.. _program_listing_file__tmp_ws_src_rmf_traffic_rmf_traffic_include_rmf_traffic_agv_SimpleNegotiator.hpp:

Program Listing for File SimpleNegotiator.hpp
=============================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_rmf_traffic_rmf_traffic_include_rmf_traffic_agv_SimpleNegotiator.hpp>` (``/tmp/ws/src/rmf_traffic/rmf_traffic/include/rmf_traffic/agv/SimpleNegotiator.hpp``)

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

.. code-block:: cpp

   /*
    * Copyright (C) 2020 Open Source Robotics Foundation
    *
    * 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 RMF_TRAFFIC__AGV__NEGOTIATOR_HPP
   #define RMF_TRAFFIC__AGV__NEGOTIATOR_HPP
   
   #include <rmf_traffic/agv/Planner.hpp>
   #include <rmf_traffic/schedule/Participant.hpp>
   #include <rmf_traffic/schedule/Negotiator.hpp>
   
   namespace rmf_traffic {
   namespace agv {
   
   //==============================================================================
   class SimpleNegotiator : public schedule::Negotiator
   {
   public:
   
     class Options
     {
     public:
   
       static constexpr double DefaultMaxCostLeeway = 1.5;
       static constexpr double DefaultMinCostThreshold = 30.0;
   
       using ApprovalCallback =
         std::function<Responder::UpdateVersion(rmf_traffic::agv::Plan)>;
   
       Options(
         ApprovalCallback approval_cb = nullptr,
         std::shared_ptr<const bool> interrupt_flag = nullptr,
         std::optional<double> maximum_cost_leeway = DefaultMaxCostLeeway,
         std::optional<std::size_t> maximum_alts = std::nullopt,
         Duration min_hold_time = Planner::Options::DefaultMinHoldingTime);
   
       // TODO(MXG): The approval_callback option needs to be unit tested
       Options& approval_callback(ApprovalCallback cb);
   
       Options& interrupt_flag(std::shared_ptr<const bool> flag);
   
       const std::shared_ptr<const bool>& interrupt_flag() const;
   
       Options& maximum_cost_leeway(std::optional<double> leeway);
   
       std::optional<double> maximum_cost_leeway() const;
   
       Options& minimum_cost_threshold(std::optional<double> cost);
   
       std::optional<double> minimum_cost_threshold() const;
   
       Options& maximum_cost_threshold(std::optional<double> cost);
   
       std::optional<double> maximum_cost_threshold() const;
   
       Options& maximum_alternatives(rmf_utils::optional<std::size_t> num);
   
       std::optional<std::size_t> maximum_alternatives() const;
   
       Options& minimum_holding_time(Duration holding_time);
   
       Duration minimum_holding_time() const;
   
       class Implementation;
     private:
       rmf_utils::impl_ptr<Implementation> _pimpl;
     };
   
     SimpleNegotiator(
       schedule::Participant::AssignIDPtr assign_id,
       Planner::Start start,
       Planner::Goal goal,
       Planner::Configuration planner_configuration,
       Options options = Options());
   
     SimpleNegotiator(
       schedule::Participant::AssignIDPtr assign_id,
       std::vector<Planner::Start> starts,
       Planner::Goal goal,
       Planner::Configuration planner_configuration,
       Options options = Options());
   
     SimpleNegotiator(
       schedule::Participant::AssignIDPtr assign_id,
       std::vector<Planner::Start> starts,
       Planner::Goal goal,
       std::shared_ptr<const Planner> planner,
       Options options = Options());
   
     // TODO(MXG): Offer a constructor that accepts a Planner instance to benefit
     // from the cached heuristics.
   
     // Documentation inherited
     void respond(
       const schedule::Negotiation::Table::ViewerPtr& table_viewer,
       const ResponderPtr& responder) final;
   
     class Implementation;
     class Debug;
   private:
     rmf_utils::impl_ptr<Implementation> _pimpl;
   };
   
   } // namespace agv
   } // namespace rmf_traffic
   
   #endif // RMF_TRAFFIC__AGV__NEGOTIATOR_HPP