scenario_simulator_v2 C++ API
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
openscenario_interpreter Namespace Reference

Namespaces

 background
 
 cmath
 
 concepts
 
 console
 
 detail
 
 foreground
 
 functional
 
 iterator
 
 posix
 
 reader
 
 record
 
 regex
 
 string
 
 syntax
 
 type_traits
 
 utility
 

Classes

struct  Expression
 
struct  Name
 
struct  Prefixed
 
struct  is
 
struct  is< Object >
 
struct  is_also
 
struct  is_also< Object >
 
struct  Unspecified
 
class  Interpreter
 
class  Pointer
 
class  EnvironmentFrame
 
class  Scope
 
class  SimulatorCore
 
struct  lambda_visitor
 
struct  equal_to
 
struct  equal_to< T, typename std::enable_if< std::is_floating_point< T >::value >::type >
 
struct  equal_to< std::valarray< T >, typename std::enable_if< std::is_floating_point< T >::value >::type >
 
class  CircularIterator
 
struct  FunctionCallExpression
 
struct  AbsoluteTargetLane
 
struct  AbsoluteTargetSpeed
 
struct  AccelerationCondition
 
struct  AcquirePositionAction
 
struct  Act
 
struct  Action
 
struct  Actors
 
struct  AddEntityAction
 
struct  AssignControllerAction
 
struct  AssignRouteAction
 
struct  Axle
 
struct  FrontAxle
 
struct  RearAxle
 
struct  AdditionalAxle
 
struct  Axles
 
struct  Boolean
 
struct  BoundingBox
 
struct  ByEntityCondition
 
struct  ByObjectType
 
struct  ByType
 
struct  ByValueCondition
 
struct  Catalog
 
struct  CatalogDefinition
 
class  CatalogLocation
 
struct  CatalogLocations
 
struct  CatalogReference
 
struct  Center
 
struct  CollisionCondition
 
struct  Command
 
struct  Condition
 
struct  ConditionEdge
 
struct  ConditionGroup
 
struct  Controller
 
struct  ControllerAction
 
struct  CoordinateSystem
 
struct  SpecialAction
 
class  SpecialAction< EXIT_FAILURE >
 
struct  CustomCommand
 
struct  CustomCommandAction
 
struct  DeleteEntityAction
 
struct  Deterministic
 
struct  DeterministicMultiParameterDistribution
 
struct  DeterministicMultiParameterDistributionType
 
struct  DeterministicParameterDistribution
 
struct  DeterministicSingleParameterDistribution
 
struct  DeterministicSingleParameterDistributionType
 
struct  Dimensions
 
struct  DirectionalDimension
 
struct  Directory
 
struct  DistanceCondition
 
struct  DistributionDefinition
 
struct  DistributionRange
 
struct  DistributionSet
 
struct  DistributionSetElement
 
struct  DomeImage
 
struct  Double
 
struct  DynamicConstraints
 
struct  DynamicsDimension
 
struct  DynamicsShape
 
struct  Entities
 
struct  Entity
 
struct  EntityAction
 
struct  EntityCondition
 
struct  EntityObject
 
struct  EntityRef
 
struct  EntitySelection
 
struct  Environment
 
struct  EnvironmentAction
 
struct  Event
 
struct  ExternalObjectReference
 
struct  File
 
struct  FileHeader
 
struct  Fog
 
struct  FollowTrajectoryAction
 
struct  FollowingMode
 
struct  FractionalCloudCover
 
struct  GlobalAction
 
struct  Histogram
 
struct  HistogramBin
 
struct  InfrastructureAction
 
struct  Init
 
struct  InitActions
 
struct  Integer
 
struct  LaneChangeAction
 
struct  LaneChangeTarget
 
struct  LanePosition
 
struct  LateralAction
 
struct  License
 
struct  LongitudinalAction
 
struct  Maneuver
 
struct  ManeuverGroup
 
struct  MiscObject
 
struct  MiscObjectCategory
 
struct  ModifyRule
 
struct  None
 
struct  NormalDistribution
 
struct  ObjectController
 
struct  ObjectType
 
struct  OpenScenario
 
struct  OpenScenarioCategory
 
struct  Orientation
 
struct  OverrideControllerValueAction
 
struct  ParameterAction
 
struct  ParameterAddValueRule
 
struct  ParameterAssignment
 
struct  ParameterAssignments
 
struct  ParameterCondition
 
struct  ParameterDeclaration
 
struct  ParameterDeclarations
 
struct  ParameterModifyAction
 
struct  ParameterMultiplyByValueRule
 
struct  ParameterSetAction
 
struct  ParameterType
 
struct  ParameterValueDistribution
 
struct  ParameterValueDistributionDefinition
 
struct  ParameterValueSet
 
struct  Pedestrian
 
struct  PedestrianCategory
 
struct  Performance
 
struct  Phase
 
struct  PoissonDistribution
 
struct  Polyline
 
struct  Position
 
struct  Precipitation
 
struct  PrecipitationType
 
struct  Priority
 
struct  Private
 
struct  PrivateAction
 
struct  ProbabilityDistributionSet
 
struct  ProbabilityDistributionSetElement
 
struct  Properties
 
struct  Property
 
struct  Range
 
struct  ReachPositionCondition
 
struct  ReferenceContext
 
struct  RelativeClearanceCondition
 
struct  RelativeDistanceCondition
 
struct  RelativeDistanceType
 
struct  RelativeLaneRange
 
struct  RelativeObjectPosition
 
struct  RelativeSpeedCondition
 
struct  RelativeTargetLane
 
struct  RelativeTargetSpeed
 
struct  RelativeWorldPosition
 
struct  RoadCondition
 
struct  RoadNetwork
 
struct  Route
 
struct  RouteStrategy
 
struct  RoutingAction
 
struct  RoutingAlgorithm
 
struct  RuleResultDeduction
 
struct  RuleResultDeduction< std::valarray< T >, U >
 
struct  Rule
 
struct  ScenarioDefinition
 
struct  ScenarioObject
 
struct  SelectedEntities
 
struct  Shape
 
struct  SimulationTimeCondition
 
struct  SpeedAction
 
struct  SpeedActionTarget
 
struct  SpeedCondition
 
struct  SpeedProfileAction
 
struct  SpeedProfileEntry
 
struct  SpeedTargetValueType
 
struct  StandStillCondition
 
struct  Stochastic
 
struct  StochasticDistribution
 
struct  StochasticDistributionType
 
struct  Story
 
struct  Storyboard
 
class  StoryboardElement
 
struct  StoryboardElementState
 
struct  StoryboardElementStateCondition
 
struct  StoryboardElementType
 
struct  Sun
 
struct  TeleportAction
 
struct  TimeHeadwayCondition
 
struct  TimeOfDay
 
struct  TimeReference
 
struct  TimeToCollisionCondition
 
struct  TimeToCollisionConditionTarget
 
struct  Timing
 
struct  TrafficSignalAction
 
struct  TrafficSignalCondition
 
struct  TrafficSignalController
 
struct  TrafficSignalControllerAction
 
struct  TrafficSignalControllerCondition
 
struct  TrafficSignalState
 
struct  TrafficSignalStateAction
 
class  TrafficSignals
 
struct  Trajectory
 
struct  TrajectoryFollowingMode
 
struct  TrajectoryRef
 
struct  TransitionDynamics
 
struct  Trigger
 
struct  TriggeringEntities
 
struct  TriggeringEntitiesRule
 
struct  UniformDistribution
 
struct  UnsignedInteger
 
struct  UnsignedShort
 
struct  UserDefinedAction
 
struct  UserDefinedDistribution
 
class  UserDefinedValueCondition
 
struct  ValueConstraint
 
struct  ValueConstraintGroup
 
struct  ValueSetDistribution
 
struct  Vehicle
 
struct  VehicleCategory
 
struct  Vertex
 
struct  Waypoint
 
struct  Weather
 
struct  Wetness
 
struct  Wind
 
struct  WorldPosition
 
struct  HasMemberFunctionAccomplished
 
struct  HasMemberFunctionAccomplished< T, void_t< decltype(std::declval< T >().accomplished())> >
 
struct  HasMemberFunctionDescription
 
struct  HasMemberFunctionDescription< T, void_t< decltype(std::declval< T >().description())> >
 
struct  HasMemberFunctionEvaluate
 
struct  HasMemberFunctionEvaluate< T, void_t< decltype(std::declval< T >().evaluate())> >
 
struct  HasStreamOutputOperator
 
struct  HasStreamOutputOperator< T, void_t< decltype(std::declval< std::ostream & >()<< std::declval< const T & >())> >
 
struct  IfHasMemberFunctionAccomplished
 
struct  IfHasMemberFunctionAccomplished< T, typename std::enable_if< HasMemberFunctionAccomplished< T >::value >::type >
 
struct  IfHasMemberFunctionDescription
 
struct  IfHasMemberFunctionDescription< T, typename std::enable_if< HasMemberFunctionDescription< T >::value >::type >
 
struct  IfHasMemberFunctionEvaluate
 
struct  IfHasMemberFunctionEvaluate< T, typename std::enable_if< HasMemberFunctionEvaluate< T >::value >::type >
 
struct  IfHasStreamOutputOperator
 
struct  IfHasStreamOutputOperator< T, typename std::enable_if< HasStreamOutputOperator< T >::value >::type >
 
struct  IfNotNothrowDefaultConstructible
 
struct  IfNotNothrowDefaultConstructible< T, typename std::enable_if< std::is_nothrow_default_constructible< T >::value >::type >
 
struct  Iterable
 
struct  Iterable< T, void_t< decltype(std::begin(std::declval< T >()), std::end(std::declval< T >()))> >
 
struct  MustBeDefaultConstructible
 
struct  MustBeDefaultConstructible< T, typename std::enable_if< std::is_default_constructible< T >::value >::type >
 
class  ExecutionTimer
 
struct  AttributeHighlighter
 
struct  overloaded
 
struct  overloaded< T >
 
struct  overloaded< T, U, Ts... >
 
struct  Value
 
struct  Grammar
 
struct  ApplyFaultInjectionAction
 
struct  ApplyPseudoTrafficSignalDetectorConfidenceSetAction
 
struct  ApplyRequestToCorporateCommandAction
 
struct  ApplyV2ITrafficSignalStateAction
 
struct  ApplyWalkStraightAction
 
struct  DebugError
 
struct  DebugSegmentationFault
 
struct  DummyLongRunningAction
 
struct  ExitSuccess
 
struct  ExitFailure
 
struct  PrintParameter
 
struct  TestCommand
 
struct  ForkExecCommand
 
struct  MagicSubscription
 

Typedefs

using Object = Pointer< Expression >
 
using ComplexType = Object
 
using Group = Object
 
using Elements = std::list< Object >
 
using Cardinality = typename std::iterator_traits< typename pugi::xml_node::iterator >::difference_type
 
using NativeWorldPosition = geometry_msgs::msg::Pose
 
using NativeRelativeWorldPosition = NativeWorldPosition
 
using NativeLanePosition = traffic_simulator::CanonicalizedLaneletPose
 
using NativeRelativeLanePosition = traffic_simulator::LaneletPose
 
template<typename T >
using isConditionGroup = typename std::is_same< typename std::decay< T >::type, ConditionGroup >
 
using String = std::string
 
using UnsignedInt = UnsignedInteger
 
template<typename... >
using void_t = void
 
template<typename... Ts>
using Variant = boost::variant< Ts... >
 

Enumerations

enum class  Compatibility { legacy , standard }
 

Functions

template<typename T >
auto hypot (T x, T y, T z)
 
auto operator>> (std::istream &, Compatibility &) -> std::istream &
 
template<typename... Ts>
auto & escape_sequence (std::basic_ostream< Ts... > &os, const std::string &code)
 
template<typename F >
auto curry2 (F &&f) -> decltype(auto)
 
template<typename F , typename T >
constexpr decltype(auto) fold_left (F &&, T &&x)
 
template<typename F , typename T , typename U , typename... Ts>
constexpr decltype(auto) fold_left (F &&f, T &&x, U &&y, Ts &&... xs)
 
template<typename F , typename T >
constexpr decltype(auto) fold_right (F &&, T &&x)
 
template<typename F , typename T , typename... Ts>
constexpr decltype(auto) fold_right (F &&f, T &&x, Ts &&... xs)
 
template<typename... Ts>
constexpr auto fold (Ts &&... xs) -> decltype(auto)
 
template<typename T >
auto size (const T &range)
 
template<typename T , typename... Ts>
constexpr auto make (Ts &&... xs) -> decltype(auto)
 
template<typename T >
constexpr auto make (T &&x) -> decltype(auto)
 
auto operator<< (std::ostream &, const Unspecified &) -> std::ostream &
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const Pointer< T > &pointer)
 
int execvp (const std::vector< std::string > &)
 
pid_t fork_exec (const std::vector< std::string > &)
 
pid_t fork_exec (const std::string &)
 
pid_t fork_exec (const std::string &, const std::string &)
 
template<typename Scope >
auto substitute (std::string attribute, Scope &scope)
 
template<typename T , typename Node , typename Scope >
auto readAttribute (const std::string &name, const Node &node, const Scope &scope) -> T
 
template<typename T , typename Node , typename Scope >
auto readAttribute (const std::string &name, const Node &node, const Scope &scope, T &&value)
 
template<typename T , typename Node , typename Scope >
auto readAttribute (const std::string &name, const Node &node, const Scope &scope, std::nullopt_t)
 
template<typename T , typename Node , typename Scope >
readContent (const Node &node, const Scope &)
 
template<Cardinality MinOccurs, Cardinality MaxOccurs, typename F >
auto traverse (const pugi::xml_node &parent, const std::string &name, F &&f) -> void
 
template<typename T , typename Scope >
auto readElement (const std::string &name, const pugi::xml_node &parent, Scope &scope)
 
template<typename T , typename U , typename Scope >
auto readElement (const std::string &name, const pugi::xml_node &parent, Scope &scope, U &&value)
 
template<typename T , Cardinality MinOccurs, Cardinality MaxOccurs = unbounded, typename... Ts>
auto readElements (const std::string &name, const pugi::xml_node &node, Ts &&... xs)
 
template<typename GroupT , Cardinality MinOccurs, Cardinality MaxOccurs = unbounded, typename... Ts>
auto readGroups (const pugi::xml_node &node, Ts &&... xs)
 
template<typename... Ts>
auto choice (const pugi::xml_node &node, Ts &&... xs) -> decltype(auto)
 
std::string evaluate (const std::string &, const Scope &)
 
auto split (const std::string &target)
 
 DEFINE_LAZY_VISITOR (Action, CASE(GlobalAction), CASE(UserDefinedAction), CASE(PrivateAction),)
 
auto operator>> (std::istream &, Boolean &) -> std::istream &
 
auto operator<< (std::ostream &, const Boolean &) -> std::ostream &
 
auto asBoolean (bool) -> const Object &
 
auto operator>> (std::istream &, Command &) -> std::istream &
 
auto operator<< (std::ostream &, const Command &) -> std::ostream &
 
auto operator<< (boost::json::object &, const Condition &) -> boost::json::object &
 
auto operator>> (std::istream &is, ConditionEdge &) -> std::istream &
 
auto operator<< (std::ostream &os, const ConditionEdge &) -> std::ostream &
 
auto operator<< (boost::json::object &, const ConditionGroup &) -> boost::json::object &
 
auto operator>> (std::istream &, CoordinateSystem &) -> std::istream &
 
auto operator<< (std::ostream &, const CoordinateSystem &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (DeterministicParameterDistribution, CASE(DeterministicMultiParameterDistribution), CASE(DeterministicSingleParameterDistribution),)
 
 DEFINE_LAZY_VISITOR (DeterministicSingleParameterDistributionType, CASE(DistributionSet), CASE(DistributionRange), CASE(UserDefinedDistribution),)
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::euclidianDistance, RoutingAlgorithm::undefined, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::euclidianDistance, RoutingAlgorithm::undefined, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::shortest, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::shortest, true > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::shortest, false > (const EntityRef &, const Position &) -> double
 
template<>
auto DistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::shortest, true > (const EntityRef &, const Position &) -> double
 
 DEFINE_LAZY_VISITOR (DistributionDefinition, CASE(Deterministic), CASE(Stochastic),)
 
auto operator>> (std::istream &, Double &) -> std::istream &
 
auto operator<< (std::ostream &, const Double &) -> std::ostream &
 
auto operator>> (std::istream &, DynamicsDimension &) -> std::istream &
 
auto operator<< (std::ostream &, const DynamicsDimension &) -> std::ostream &
 
auto operator>> (std::istream &, DynamicsShape &) -> std::istream &
 
auto operator<< (std::ostream &, const DynamicsShape &) -> std::ostream &
 
auto operator== (const Entity &, const Entity &) -> bool
 
auto operator<< (std::ostream &, const Entity &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (EntityAction, CASE(AddEntityAction), CASE(DeleteEntityAction),)
 
 DEFINE_LAZY_VISITOR (const EntityObject, CASE(Vehicle), CASE(Pedestrian), CASE(MiscObject),)
 
auto operator>> (std::istream &, FollowingMode &) -> std::istream &
 
auto operator<< (std::ostream &, const FollowingMode &) -> std::ostream &
 
auto operator>> (std::istream &, FractionalCloudCover &) -> std::istream &
 
auto operator<< (std::ostream &, const FractionalCloudCover &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (GlobalAction, CASE(EnvironmentAction), CASE(EntityAction), CASE(ParameterAction), CASE(InfrastructureAction),)
 
 DEFINE_LAZY_VISITOR (InfrastructureAction, CASE(TrafficSignalAction), CASE(TrafficSignalStateAction), CASE(TrafficSignalControllerAction),)
 
auto operator<< (boost::json::object &, const Init &) -> boost::json::object &
 
auto operator>> (std::istream &, Integer &) -> std::istream &
 
auto operator<< (std::ostream &, const Integer &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (LateralAction, CASE(LaneChangeAction),)
 
 DEFINE_LAZY_VISITOR (LongitudinalAction, CASE(SpeedAction), CASE(SpeedProfileAction))
 
auto operator>> (std::istream &, MiscObjectCategory &) -> std::istream &
 
auto operator<< (std::ostream &, const MiscObjectCategory &) -> std::ostream &
 
auto operator>> (std::istream &, ObjectType &) -> std::istream &
 
auto operator<< (std::ostream &, const ObjectType &) -> std::ostream &
 
auto operator<< (boost::json::object &, const OpenScenario &) -> boost::json::object &
 
 DEFINE_LAZY_VISITOR (ParameterAction, CASE(ParameterSetAction), CASE(ParameterModifyAction),)
 
auto operator>> (std::istream &, ParameterType &) -> std::istream &
 
auto operator<< (std::ostream &, const ParameterType &) -> std::ostream &
 
auto operator>> (std::istream &, PedestrianCategory &) -> std::istream &
 
auto operator<< (std::ostream &, const PedestrianCategory &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (Position, CASE(WorldPosition), CASE(RelativeWorldPosition), CASE(RelativeObjectPosition), CASE(LanePosition),)
 
auto operator>> (std::istream &, PrecipitationType &) -> std::istream &
 
auto operator<< (std::ostream &, const PrecipitationType &) -> std::ostream &
 
auto operator>> (std::istream &, Priority &) -> std::istream &
 
auto operator<< (std::ostream &, const Priority &) -> std::ostream &
 
auto operator<< (boost::json::object &, const Private &) -> boost::json::object &
 
 DEFINE_LAZY_VISITOR (PrivateAction, CASE(LongitudinalAction), CASE(LateralAction), CASE(ControllerAction), CASE(TeleportAction), CASE(RoutingAction),)
 
auto operator>> (std::istream &, ReferenceContext &) -> std::istream &
 
auto operator<< (std::ostream &, const ReferenceContext &) -> std::ostream &
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::euclidianDistance, RoutingAlgorithm::undefined, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::euclidianDistance, RoutingAlgorithm::undefined, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::entity, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::undefined, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::undefined, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::shortest, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::lateral, RoutingAlgorithm::shortest, true > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::shortest, false > (const EntityRef &, const EntityRef &) -> double
 
template<>
auto RelativeDistanceCondition::distance< CoordinateSystem::lane, RelativeDistanceType::longitudinal, RoutingAlgorithm::shortest, true > (const EntityRef &, const EntityRef &) -> double
 
auto operator>> (std::istream &, RelativeDistanceType &) -> std::istream &
 
auto operator<< (std::ostream &, const RelativeDistanceType &) -> std::ostream &
 
auto operator>> (std::istream &, RouteStrategy &) -> std::istream &
 
auto operator<< (std::ostream &, const RouteStrategy &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (RoutingAction, CASE(AssignRouteAction), CASE(FollowTrajectoryAction), CASE(AcquirePositionAction),)
 
auto operator>> (std::istream &, RoutingAlgorithm &) -> std::istream &
 
auto operator<< (std::ostream &, const RoutingAlgorithm &) -> std::ostream &
 
auto operator>> (std::istream &, Rule &) -> std::istream &
 
auto operator<< (std::ostream &, const Rule &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (SpeedActionTarget, CASE(RelativeTargetSpeed), CASE(AbsoluteTargetSpeed),)
 
auto operator>> (std::istream &, SpeedTargetValueType &) -> std::istream &
 
auto operator<< (std::ostream &, const SpeedTargetValueType &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (StochasticDistributionType, CASE(ProbabilityDistributionSet), CASE(NormalDistribution), CASE(UniformDistribution), CASE(PoissonDistribution), CASE(Histogram), CASE(UserDefinedDistribution),)
 
auto operator>> (std::istream &, StoryboardElementState &) -> std::istream &
 
auto operator<< (std::ostream &, const StoryboardElementState &) -> std::ostream &
 
auto operator>> (std::istream &, StoryboardElementType &) -> std::istream &
 
auto operator<< (std::ostream &, const StoryboardElementType &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (TrafficSignalAction, CASE(TrafficSignalStateAction), CASE(TrafficSignalControllerAction),)
 
auto operator<< (boost::json::object &, const Trigger &) -> boost::json::object &
 
auto operator>> (std::istream &, TriggeringEntitiesRule &) -> std::istream &
 
auto operator<< (std::ostream &, const TriggeringEntitiesRule &) -> std::ostream &
 
std::istream & operator>> (std::istream &, UnsignedInteger &)
 
std::ostream & operator<< (std::ostream &, const UnsignedInteger &)
 
auto operator>> (std::istream &, UnsignedShort &) -> std::istream &
 
auto operator<< (std::ostream &, const UnsignedShort &) -> std::ostream &
 
 DEFINE_LAZY_VISITOR (UserDefinedAction, CASE(CustomCommandAction),)
 
auto operator>> (std::istream &, VehicleCategory &) -> std::istream &
 
auto operator<< (std::ostream &, const VehicleCategory &) -> std::ostream &
 
auto operator>> (std::istream &, Wetness &) -> std::istream &
 
auto operator<< (std::ostream &, const Wetness &) -> std::ostream &
 
template<class Node , class NodeToChildren , class Hash = std::hash<Node>>
bool circular_check (const Node &init, NodeToChildren &&node_to_children)
 
auto demangle (const char *name) -> std::string
 
auto demangle (const std::type_info &) -> std::string
 
template<typename... Ts>
auto makeTypename (Ts &&... xs)
 
template<typename... Ts>
decltype(auto) operator<< (std::basic_ostream< Ts... > &os, const AttributeHighlighter &highlight)
 
template<typename T , typename = typename std::enable_if<HasStreamOutputOperator<T>::value>::type>
auto highlight (const std::string &name, const T &value)
 
template<typename... Ts>
constexpr auto overload (Ts &&... xs) -> typename utility::overloaded< typename std::decay< Ts >::type... >
 
template<typename T >
auto print_to (std::ostream &os, const T &value) -> std::enable_if_t< concepts::HasStreamOutputOperator< T >::value, std::ostream & >
 
template<typename Visitor , typename... Ts>
auto visit (Visitor &&visitor, const boost::variant< Ts... > &arg0)
 
template<typename Visitor , typename... Ts>
auto visit (Visitor &&visitor, boost::variant< Ts... > &&arg0)
 
template<typename Visitor , typename... Ts, typename... Variants>
auto visit (Visitor &&visitor, const boost::variant< Ts... > &var0, Variants &&... vars)
 
template<typename Visitor , typename... Ts, typename... Variants>
auto visit (Visitor &&visitor, boost::variant< Ts... > &&var0, Variants &&... vars)
 
def generate_launch_description ()
 
template<>
auto Value::cast< Value::Numeric > () const -> Value
 
auto operator<< (boost::json::object &json, const Act &datum) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const Action &datum) -> boost::json::object &
 
 catch (const std::out_of_range &)
 
auto convertScenario (const boost::filesystem::path &yaml_path, const boost::filesystem::path &output_dir)
 
template<typename... Ts>
auto choice_by_attribute (const pugi::xml_node &node, const std::string &attribute, Ts &&... xs)
 
auto makeCustomCommand (const std::string &type, const std::string &content) -> std::shared_ptr< CustomCommand >
 
auto operator<< (boost::json::object &json, const Event &datum) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const InitActions &init_actions) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const Maneuver &maneuver) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const ManeuverGroup &maneuver_group) -> boost::json::object &
 
auto checkName (const std::string &name) -> decltype(auto)
 
template<typename T >
auto generateVector (const std::list< T > &list) -> std::vector< T >
 
auto operator<< (std::ostream &os, const ScenarioDefinition &datum) -> std::ostream &
 
auto operator<< (boost::json::object &json, const ScenarioDefinition &datum) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const Story &story) -> boost::json::object &
 
auto operator<< (boost::json::object &json, const Storyboard &datum) -> boost::json::object &
 

Variables

auto reset = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[0m" ); }
 
auto bold = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[1m" ); }
 
auto faint = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[2m" ); }
 
auto italic = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[3m" ); }
 
auto underline = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[4m" ); }
 
auto slow_blink = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[5m" ); }
 
auto rapid_blink = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[6m" ); }
 
auto reverse = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[7m" ); }
 
auto conceal = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[8m" ); }
 
auto black = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[30m" ); }
 
auto red = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[31m" ); }
 
auto green = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[32m" ); }
 
auto yellow = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[33m" ); }
 
auto blue = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[34m" ); }
 
auto magenta = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[35m" ); }
 
auto cyan = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[36m" ); }
 
auto white = [](std::ostream & os) -> decltype(auto) { return escape_sequence(os, "[37m" ); }
 
auto is_console
 
const Object unspecified {make<Unspecified>()}
 
constexpr auto unbounded = std::numeric_limits<Cardinality>::max()
 
const Object true_v = make<Boolean>(true)
 
const Object false_v = make<Boolean>(false)
 
const Object start_transition = make<StoryboardElementState>(StoryboardElementState::startTransition)
 
const Object end_transition = make<StoryboardElementState>(StoryboardElementState:: endTransition)
 
const Object stop_transition = make<StoryboardElementState>(StoryboardElementState:: stopTransition)
 
const Object skip_transition = make<StoryboardElementState>(StoryboardElementState:: skipTransition)
 
const Object complete_state = make<StoryboardElementState>(StoryboardElementState:: completeState)
 
const Object running_state = make<StoryboardElementState>(StoryboardElementState:: runningState)
 
const Object standby_state = make<StoryboardElementState>(StoryboardElementState:: standbyState)
 
auto print_keys_to
 

Detailed Description

Generate launch description for scenario runner.

Typedef Documentation

◆ ComplexType

◆ Elements

using openscenario_interpreter::Elements = typedef std::list<Object>

◆ Group

◆ NativeLanePosition

◆ NativeRelativeLanePosition

◆ NativeRelativeWorldPosition

◆ NativeWorldPosition

using openscenario_interpreter::NativeWorldPosition = typedef geometry_msgs::msg::Pose

◆ Object

◆ Variant

template<typename... Ts>
using openscenario_interpreter::Variant = typedef boost::variant<Ts...>

Enumeration Type Documentation

◆ Compatibility

Enumerator
legacy 
standard 

Function Documentation

◆ curry2()

template<typename F >
auto openscenario_interpreter::curry2 ( F &&  f) -> decltype(auto)

◆ generate_launch_description()

def openscenario_interpreter.generate_launch_description ( )
Generate launch description for scenario runner.

◆ make() [1/2]

template<typename T >
constexpr auto openscenario_interpreter::make ( T &&  x) -> decltype(auto)
constexpr

◆ make() [2/2]

template<typename T , typename... Ts>
constexpr auto openscenario_interpreter::make ( Ts &&...  xs) -> decltype(auto)
constexpr

◆ operator<<() [1/49]

std::ostream & openscenario_interpreter::operator<< ( std::ostream &  os,
const Unspecified  
) -> std::ostream &

◆ operator<<() [2/49]

template<typename T >
std::ostream& openscenario_interpreter::operator<< ( std::ostream &  os,
const Pointer< T > &  pointer 
)

◆ operator>>() [1/30]

auto openscenario_interpreter::operator>> ( std::istream &  input,
Compatibility compatiblity 
) -> std::istream &

◆ visit() [1/4]

template<typename Visitor , typename... Ts>
auto openscenario_interpreter::visit ( Visitor &&  visitor,
boost::variant< Ts... > &&  arg0 
)

◆ visit() [2/4]

template<typename Visitor , typename... Ts, typename... Variants>
auto openscenario_interpreter::visit ( Visitor &&  visitor,
boost::variant< Ts... > &&  var0,
Variants &&...  vars 
)

◆ visit() [3/4]

template<typename Visitor , typename... Ts>
auto openscenario_interpreter::visit ( Visitor &&  visitor,
const boost::variant< Ts... > &  arg0 
)

◆ visit() [4/4]

template<typename Visitor , typename... Ts, typename... Variants>
auto openscenario_interpreter::visit ( Visitor &&  visitor,
const boost::variant< Ts... > &  var0,
Variants &&...  vars 
)

Variable Documentation

◆ unspecified

const Object openscenario_interpreter::unspecified {make<Unspecified>()}