Lane.hpp

Go to the documentation of this file.

/*
 * ----------------- BEGIN LICENSE BLOCK ---------------------------------
 *
 * Copyright (C) 2018-2020 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 * ----------------- END LICENSE BLOCK -----------------------------------
 */
 
#pragma once
 
#include <iostream>
#include <limits>
#include <memory>
#include <sstream>
#include "ad/map/landmark/LandmarkIdList.hpp"
#include "ad/map/lane/ComplianceVersion.hpp"
#include "ad/map/lane/ContactLaneList.hpp"
#include "ad/map/lane/LaneDirection.hpp"
#include "ad/map/lane/LaneId.hpp"
#include "ad/map/lane/LaneType.hpp"
#include "ad/map/point/BoundingSphere.hpp"
#include "ad/map/point/Geometry.hpp"
#include "ad/map/restriction/Restrictions.hpp"
#include "ad/map/restriction/SpeedLimitList.hpp"
#include "ad/physics/Distance.hpp"
#include "ad/physics/MetricRange.hpp"
namespace ad {
namespace map {
namespace lane {
 
struct Lane
{
  typedef std::shared_ptr<Lane> Ptr;
 
  typedef std::shared_ptr<Lane const> ConstPtr;
 
  Lane() = default;
 
  ~Lane() = default;
 
  Lane(const Lane &other) = default;
 
  Lane(Lane &&other) = default;
 
  Lane &operator=(const Lane &other) = default;
 
  Lane &operator=(Lane &&other) = default;
 
  bool operator==(const Lane &other) const
  {
    return (id == other.id) && (type == other.type) && (direction == other.direction)
      && (restrictions == other.restrictions) && (length == other.length) && (lengthRange == other.lengthRange)
      && (width == other.width) && (widthRange == other.widthRange) && (speedLimits == other.speedLimits)
      && (edgeLeft == other.edgeLeft) && (edgeRight == other.edgeRight) && (contactLanes == other.contactLanes)
      && (complianceVersion == other.complianceVersion) && (boundingSphere == other.boundingSphere)
      && (visibleLandmarks == other.visibleLandmarks);
  }
 
  bool operator!=(const Lane &other) const
  {
    return !operator==(other);
  }
 
  ::ad::map::lane::LaneId id;
 
  ::ad::map::lane::LaneType type;
 
  ::ad::map::lane::LaneDirection direction{::ad::map::lane::LaneDirection::INVALID};
 
  ::ad::map::restriction::Restrictions restrictions;
 
  ::ad::physics::Distance length;
  ::ad::physics::MetricRange lengthRange;
 
  ::ad::physics::Distance width;
  ::ad::physics::MetricRange widthRange;
 
  ::ad::map::restriction::SpeedLimitList speedLimits;
 
  ::ad::map::point::Geometry edgeLeft;
 
  ::ad::map::point::Geometry edgeRight;
 
  ::ad::map::lane::ContactLaneList contactLanes;
  ::ad::map::lane::ComplianceVersion complianceVersion;
  ::ad::map::point::BoundingSphere boundingSphere;
 
  ::ad::map::landmark::LandmarkIdList visibleLandmarks;
};
 
} // namespace lane
} // namespace map
} // namespace ad
 
#ifndef GEN_GUARD_AD_MAP_LANE_LANE
#define GEN_GUARD_AD_MAP_LANE_LANE
 
namespace ad {
namespace map {
namespace lane {
 
inline std::ostream &operator<<(std::ostream &os, Lane const &_value)
{
  os << "Lane(";
  os << "id:";
  os << _value.id;
  os << ",";
  os << "type:";
  os << _value.type;
  os << ",";
  os << "direction:";
  os << _value.direction;
  os << ",";
  os << "restrictions:";
  os << _value.restrictions;
  os << ",";
  os << "length:";
  os << _value.length;
  os << ",";
  os << "lengthRange:";
  os << _value.lengthRange;
  os << ",";
  os << "width:";
  os << _value.width;
  os << ",";
  os << "widthRange:";
  os << _value.widthRange;
  os << ",";
  os << "speedLimits:";
  os << _value.speedLimits;
  os << ",";
  os << "edgeLeft:";
  os << _value.edgeLeft;
  os << ",";
  os << "edgeRight:";
  os << _value.edgeRight;
  os << ",";
  os << "contactLanes:";
  os << _value.contactLanes;
  os << ",";
  os << "complianceVersion:";
  os << _value.complianceVersion;
  os << ",";
  os << "boundingSphere:";
  os << _value.boundingSphere;
  os << ",";
  os << "visibleLandmarks:";
  os << _value.visibleLandmarks;
  os << ")";
  return os;
}
 
} // namespace lane
} // namespace map
} // namespace ad
 
namespace std {
inline std::string to_string(::ad::map::lane::Lane const &value)
{
  stringstream sstream;
  sstream << value;
  return sstream.str();
}
} // namespace std
#endif // GEN_GUARD_AD_MAP_LANE_LANE