Program Listing for File Writer.hpp

↰ Return to documentation for file (/tmp/ws/src/rmf_traffic/rmf_traffic/include/rmf_traffic/schedule/Writer.hpp)

/*
 * 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__SCHEDULE__WRITER_HPP
#define RMF_TRAFFIC__SCHEDULE__WRITER_HPP

#include <rmf_traffic/schedule/Itinerary.hpp>
#include <rmf_traffic/schedule/ParticipantDescription.hpp>

namespace rmf_traffic {
namespace schedule {

//==============================================================================
class Writer
{
public:

  using ParticipantId = rmf_traffic::schedule::ParticipantId;
  using ParticipantDescription = rmf_traffic::schedule::ParticipantDescription;
  using Itinerary = rmf_traffic::schedule::Itinerary;
  using ItineraryVersion = rmf_traffic::schedule::ItineraryVersion;
  using ProgressVersion = rmf_traffic::schedule::ProgressVersion;
  using PlanId = rmf_traffic::PlanId;
  using Duration = rmf_traffic::Duration;
  using RouteId = rmf_traffic::RouteId;
  using CheckpointId = rmf_traffic::CheckpointId;
  using StorageId = uint64_t;

  virtual void set(
    ParticipantId participant,
    PlanId plan,
    const Itinerary& itinerary,
    StorageId storage_base,
    ItineraryVersion version) = 0;

  virtual void extend(
    ParticipantId participant,
    const Itinerary& routes,
    ItineraryVersion version) = 0;

  virtual void delay(
    ParticipantId participant,
    Duration delay,
    ItineraryVersion version) = 0;

  virtual void reached(
    ParticipantId participant,
    PlanId plan,
    const std::vector<CheckpointId>& reached_checkpoints,
    ProgressVersion version) = 0;

  virtual void clear(
    ParticipantId participant,
    ItineraryVersion version) = 0;

  class Registration
  {
  public:

    Registration(
      ParticipantId id,
      ItineraryVersion version,
      PlanId plan_id,
      StorageId storage_base);

    ParticipantId id() const;

    ItineraryVersion last_itinerary_version() const;

    PlanId last_plan_id() const;

    StorageId next_storage_base() const;

    class Implementation;
  private:
    rmf_utils::impl_ptr<Implementation> _pimpl;
  };

  virtual Registration register_participant(
    ParticipantDescription participant_info) = 0;

  virtual void unregister_participant(
    ParticipantId participant) = 0;

  virtual void update_description(
    ParticipantId participant,
    ParticipantDescription desc) = 0;

  // virtual destructor
  virtual ~Writer() = default;

};

} // namespace schedule
} // namespace rmf_traffic

#endif // RMF_TRAFFIC__SCHEDULE__WRITER_HPP