Route.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <ad/physics/Distance.hpp>
#include <ad/physics/Duration.hpp>
#include <vector>
#include "ad/map/point/ParaPointList.hpp"
#include "ad/map/route/Routing.hpp"
 
namespace ad {
namespace map {
namespace route {
namespace planning {
 
class Route
{
public:
  struct RawRoute
  {
    point::ParaPointList paraPointList;
    physics::Distance routeDistance{0.};
    physics::Duration routeDuration{0.};
  };
 
  typedef std::vector<point::ParaPointList> BasicRoute;
 
  enum class Type
  {
    INVALID,                   
    SHORTEST,                  
    SHORTEST_IGNORE_DIRECTION, 
  };
 
  Route(const RoutingParaPoint &start,
        const RoutingParaPoint &dest,
        physics::Distance const &maxDistance,
        physics::Duration const &maxDuration,
        Type const &routingType);
 
  Route(Route const &) = delete;
  Route(Route const &&) = delete;
  Route &operator=(Route const &) = delete;
  Route &operator=(Route &&) = delete;
 
  virtual ~Route() = default;
 
  const point::ParaPoint &getStart() const
  {
    return mStart.point;
  }
 
  const RoutingParaPoint &getRoutingStart() const
  {
    return mStart;
  }
 
  const point::ParaPoint &getDest() const
  {
    return mDest.point;
  }
 
  const RoutingParaPoint &getRoutingDest() const
  {
    return mDest;
  }
 
  Type getType() const
  {
    return mType;
  }
 
  bool laneDirectionIsIgnored() const;
 
  virtual bool calculate() = 0;
 
  bool isValid() const
  {
    return mValid;
  }
 
  const RawRoute &getRawRoute(size_t const routeIndex = 0u) const;
 
  const std::vector<RawRoute> &getRawRoutes() const
  {
    return mRawRoutes;
  }
 
  BasicRoute getBasicRoute(size_t const routeIndex = 0u) const;
 
  std::vector<BasicRoute> getBasicRoutes() const;
 
protected:
  RoutingParaPoint mStart;
  RoutingParaPoint mDest;
  physics::Distance const mMaxDistance;
  physics::Duration const mMaxDuration;
  Type mType;
  bool mValid;
  std::vector<RawRoute> mRawRoutes;
};
 
inline std::ostream &operator<<(std::ostream &os, Route::RawRoute const &value)
{
  os << "Route::RawRoute("
     << " routeDistance:" << value.routeDistance << " routeDuration:" << value.routeDuration
     << " paraPoints:" << value.paraPointList << ")";
  return os;
}
 
} // namespace planning
} // namespace route
} // namespace map
} // namespace ad