▼Nmaliput | Code in this file is inspired by: https://github.com/RobotLocomotion/drake/blob/master/common/text_logging.h |
►Napi | |
►Nrules | |
►CBulb | Models a bulb within a bulb group |
CBoundingBox | Defines the bounding box of the bulb |
CBulbGroup | Models a group of bulbs within a traffic light |
►CDiscreteValueRule | Describes a discrete value rule |
CDiscreteValue | Defines a discrete value for a DiscreteValueRule |
CDiscreteValueRuleStateProvider | Abstract interface for the state provider of DiscreteValueRules |
CPhase | A group of RightOfWayRule instances and their states |
CPhaseProvider | Abstract interface for providing the dynamic states (Phase::Id) of a collection of PhaseRings |
►CPhaseRing | A set of mutually exclusive phases, e.g., that comprise the signaling cycle for an intersection |
CNextPhase | Holds a "next phase" specification |
CPhaseRingBook | Abstract interface for providing the mapping from RightOfWayRule::Id to PhaseRing |
►CRangeValueRule | Describes a numeric range based rule |
CRange | Defines a range for a RangeValueRule |
CRangeValueRuleStateProvider | Abstract interface for the state provider of RangeValueRules |
►CRoadRulebook | Abstract interface for querying "rules of the road" |
CQueryResults | Results of a FindRules() query |
►CRule | Describes a generic rule type |
CState | Defines a base state for a Rule |
►CRuleRegistry | A registry for Rule types |
CQueryResult | Holds a rule type information for a query |
►CStateProviderResult | The state returned by a state provider |
CNext | Information about the next state |
CTrafficLight | Models a traffic light |
CTrafficLightBook | Abstract interface for providing the mapping from TrafficLight::Id to TrafficLight |
CUniqueBulbGroupId | Uniquely identifies a bulb group in the Inertial space |
CUniqueBulbId | Uniquely identifies a bulb in the Inertial space |
►Ntest | |
CMockBranchPoint | |
CMockIdIndex | |
CMockJunction | |
CMockLane | |
CMockLaneEndSet | |
CMockRoadGeometry | |
CMockSegment | |
CPhaseBuildFlags | Holds Phase build configurations |
CRightOfWayBuildFlags | Holds RightOfWayRule build configurations |
CRoadGeometryBuildFlags | Holds RoadGeometry build configuration |
CRoadGeometryContiguityBuildFlags | Holds RoadGeometry contiguity build configuration |
CRoadGeometryIdIndexBuildFlags | |
CRoadNetworkContiguityBuildFlags | Holds RoadNetwork contiguity build configuration |
CRoadRulebookBuildFlags | Holds RoadRulebook build configurations |
CRoadRulebookContiguityBuildFlags | Holds RoadRulebook contiguity build configuration |
CRoadRulebookRelatedRulesBuildFlags | Holds RoadRulebook build configurations when RelatedRules consitency are under test |
CTrafficLightBookBuildFlags | Holds TrafficLightBook build configurations |
CTrafficLightBuildFlags | Holds TrafficLight build configurations |
CBasicIdIndex | Basic general-purpose concrete implementation of the RoadGeometry::IdIndex interface |
CBranchPoint | A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another |
CHBounds | Bounds in the elevation dimension (h component) of a Lane -frame, consisting of a pair of minimum and maximum h value |
CInertialPosition | A position in 3-dimensional geographical Cartesian space, i.e., in the Inertial -frame, consisting of three components x, y, and z |
CIntersection | An abstract convenience class that aggregates information pertaining to an intersection |
CIntersectionBook | An abstract interface for providing the mapping from Intersection::Id to Intersection |
CIsoLaneVelocity | Isometric velocity vector in a Lane -frame |
CJunction | A Junction is a closed set of Segments which have physically coplanar road surfaces, in the sense that RoadPositions with the same h value (height above surface) in the domains of two Segments map to the same InertialPosition |
CLane | A Lane represents a lane of travel in a road network |
►CLaneEnd | A specific endpoint of a specific Lane |
CStrictOrder | An arbitrary strict complete ordering, useful for, e.g., std::map |
CLaneEndSet | A set of LaneEnds |
CLanePosition | A 3-dimensional position in a Lane -frame, consisting of three components: |
CLanePositionResult | Included in the return result of Lane::ToLanePosition() |
CLaneSRange | Directed longitudinal range of a specific Lane, identified by a LaneId |
CLaneSRoute | A route, possibly spanning multiple (end-to-end) lanes |
CRBounds | Bounds in the lateral dimension (r component) of a Lane -frame, consisting of a pair of minimum and maximum r value |
►CRoadGeometry | Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3-space |
CIdIndex | Abstract interface for a collection of methods which allow accessing objects in a RoadGeometry's object graph (Lanes, Segments, Junctions, BranchPoints) by their unique id's |
CRoadNetwork | A container that aggregates everything pertaining to Maliput |
CRoadNetworkValidatorOptions | Provides configuration options for the RoadNetworkValidator |
CRoadPosition | A position in the road network, consisting of a pointer to a specific Lane and a Lane -frame position in that Lane |
CRoadPositionResult | Included in the return result of RoadGeometry::FindRoadPositions() and RoadGeometry::ToRoadPosition() |
CRotation | A 3-dimensional rotation |
CSegment | A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface |
CSRange | Directed, inclusive longitudinal (s value) range from s0 to s1 |
CTypeSpecificIdentifier | TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T |
CUniqueId | Represents an unique identifier |
►Ncommon | |
►Ninternal | |
CFNV1aHasher | The FNV1a hash algorithm, used for hash_append generic hashing |
Cassertion_error | This is what MALIPUT_THROW_UNLESS throws |
CComparisonResult | ComparisonResult is a struct that holds the result of a comparison between two objects of type T |
CComparisonResultCollector | ComparisonResultCollector is a class that collects the results of a series of comparisons between objects of type T |
CDelegatingHasher | An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature |
CFilesystem | |
CLogger | A logger class implementation |
Cnever_destroyed | Wraps an underlying type T such that its storage is a direct member field of this object (i.e., without any indirection into the heap), but unlike most member fields T's destructor is never invoked |
CPasskey | Simple generic implementation of the "Passkey Idiom" |
CPath | |
CRangeValidator | Functor to validate if a number is within [min, max] and considering assuming a tolerance |
CSerialize | Convenient functor for getting a string from a object that has serialization operator defined |
CSink | Sink that uses std::cout to dump the log messages |
CSinkBase | Interface of a sink to dump all log messages |
Cuhash | A hashing functor, somewhat like std::hash |
►Ndrake | |
►Nassert | |
CConditionTraits | |
►Ninternal | |
Cassertion_error | |
CFNV1aHasher | The FNV1a hash algorithm, used for hash_append generic hashing |
CIntPackHasher | |
CIntPackHasher< N, Ns... > | |
CIntPackHasher<> | |
CParameterPackHasher | |
CParameterPackHasher< A, B... > | |
CParameterPackHasher<> | |
CReportUseOfTypeHash | |
CReportUseOfTypeHash< T, 0 > | |
Ctype_erased_ptr | |
CTypeHash | |
CTypeHasher | |
CTypeHasher< T, true > | |
CTypeHasher< T< Args... >, false > | |
CTypeHasher< T< U, N, Ns... >, false > | |
CTypeHasherHasNonTypeTemplateParameter | |
CTypeHasherHasNonTypeTemplateParameter< T, typehasher_void_t< typename T::NonTypeTemplateParameter > > | |
CValueHasher | |
CValueTraitsImpl | |
CValueTraitsImpl< T, false > | |
CValueTraitsImpl< T, true > | |
►Nlogging | |
CWarn | When constructed, logs a message (at "warn" severity); the destructor is guaranteed to be trivial |
►Nsystems | |
►Ninternal | |
CAbstractValueCloner | |
CContextBaseFixedInputAttorney | |
CContextMessageInterface | |
CFrameworkFactory | |
CModelValues | Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) |
COutputPortPrerequisite | |
CSystemBaseContextBaseAttorney | |
CSystemMessageInterface | |
CSystemParentServiceInterface | |
CValueToAbstractValue | Implements Drake policy for taking a concrete value object and storing it in a Drake abstract object (for example, an abstract-valued port) as a type-erased AbstractValue |
CValueToVectorValue | Implements Drake policy for taking a concrete vector type and storing it in a Drake numerical vector object as an AbstractValue of concrete type Value<BasicVector<T>> |
►Nscalar_conversion | |
CFromDoubleTraits | A concrete traits class providing sugar to support for converting only from the double scalar type |
CTraits | A templated traits class for whether an S<U> can be converted into an S<T> ; the default value is true for all values of S , T , and U |
CValueConverter | Converts a scalar U u to its corresponding scalar T t |
CValueConverter< T, T > | |
CAbstractValues | AbstractValues is a container for non-numerical state and parameters |
►CAntiderivativeFunction | A thin wrapper of the ScalarInitialValueProblem class that, in concert with Drake's ODE initial value problem solvers ("integrators"), provide the ability to perform quadrature on an arbitrary scalar integrable function |
CIntegrableFunctionContext | The set of values that, along with the function being integrated, partially specify the definite integral i.e |
CBasicVector | BasicVector is a semantics-free wrapper around an Eigen vector that satisfies VectorBase |
CCache | (Advanced) Stores all the CacheEntryValue objects owned by a particular Context, organized to allow fast access using a CacheIndex as an index |
CCacheEntry | A CacheEntry belongs to a System and represents the properties of one of that System's cached computations |
CCacheEntryValue | (Advanced) This is the representation in the Context for the value of one of a System's CacheEntry objects |
CCompositeEventCollection | This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection |
CContext | Context is an abstract class template that represents all the typed values that are used in a System's computations: time, numeric-valued input ports, numerical state, and numerical parameters |
CContextBase | Provides non-templatized Context functionality shared by the templatized derived classes |
CContinuousState | ContinuousState is a view of, and optionally a container for, all the continuous state variables xc of a Drake System |
CDenseOutput | An interface for dense output of ODE solutions, to efficiently approximate them at arbitrarily many points when solving them numerically (see IntegratorBase class documentation) |
CDependencyGraph | Represents the portion of the complete dependency graph that is a subgraph centered on the owning subcontext, plus some edges leading to other subcontexts |
CDependencyTracker | Manages value interdependencies for a particular value or set of values in a Context |
CDiagram | |
CDiagramCompositeEventCollection | CompositeEventCollection for a Diagram |
CDiagramEventCollection | A concrete class that holds all simultaneous homogeneous events for a Diagram |
CDiscreteUpdateEvent | This class represents a discrete update event |
CDiscreteValues | DiscreteValues is a container for numerical but non-continuous state and parameters |
CEvent | Abstract base class that represents an event |
CEventCollection | There are three concrete event types for any System: publish, discrete state update, and unrestricted state update, listed in order of increasing ability to change the state (i.e., zero to all) |
CEventData | Base class for storing trigger-specific data to be passed to event handlers |
CEventStatus | Holds the return status from execution of an event handler function, or the effective status after a series of handler executions due to dispatching of simultaneous events |
CExternalSystemConstraint | An "external" constraint on a System |
CFixedInputPortValue | A FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports |
►CHermitianDenseOutput | A StepwiseDenseOutput class implementation using Hermitian interpolators, and therefore a continuous extension of the solution 𝐱(t) (see [Engquist, 2105]) |
CIntegrationStep | An integration step representation class, holding just enough for Hermitian interpolation: three (3) related sets containing step times {t₀, ..., tᵢ₋₁, tᵢ} where tᵢ ∈ ℝ, step states {𝐱₀, ..., 𝐱ᵢ₋₁, 𝐱ᵢ} where 𝐱ᵢ ∈ ℝⁿ, and state derivatives {d𝐱/dt₀, ..., d𝐱/dtᵢ₋₁, d𝐱/dtᵢ} where d𝐱/dtᵢ ∈ ℝⁿ |
►CInitialValueProblem | A general initial value problem (or IVP) representation class, that allows evaluating the 𝐱(t; 𝐤) solution function to the given ODE d𝐱/dt = f(t, 𝐱; 𝐤), where f : t ⨯ 𝐱 → ℝⁿ, t ∈ ℝ, 𝐱 ∈ ℝⁿ, 𝐤 ∈ ℝᵐ, provided an initial condition 𝐱(t₀; 𝐤) = 𝐱₀ |
COdeContext | A collection of values i.e |
CInputPort | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
CInputPortBase | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
CIntegratorBase | An abstract class for an integrator for ODEs and DAEs as represented by a Drake System |
CLeafCompositeEventCollection | A CompositeEventCollection for a LeafSystem |
CLeafContext | LeafContext contains all prerequisite data necessary to uniquely determine the results of computations performed by the associated LeafSystem |
CLeafEventCollection | A concrete class that holds all simultaneous homogeneous events for a LeafSystem |
CLeafOutputPort | (Advanced.) Implements an output port whose value is managed by a cache entry in the same LeafSystem as the port |
CLeafSystem | A superclass template that extends System with some convenience utilities that are not applicable to Diagrams |
COutputPort | An OutputPort belongs to a System and represents the properties of one of that System's output ports |
COutputPortBase | OutputPortBase handles the scalar type-independent aspects of an OutputPort |
CParameters | Parameters is a container for variables that parameterize a System so that it can represent a family of related models |
CPeriodicEventData | A token describing an event that recurs on a fixed period |
CPeriodicEventDataComparator | Structure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method |
CPortBase | A PortBase is base class for System ports; users will typically use the InputPort<T> or OutputPort<T> types, not this base class |
CPublishEvent | This class represents a publish event |
CRungeKutta3Integrator | A third-order Runge Kutta integrator with a third order error estimate |
CScalarDenseOutput | A DenseOutput class interface extension to deal with scalar ODE solutions |
►CScalarInitialValueProblem | A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e |
CScalarOdeContext | A collection of values i.e |
CScalarViewDenseOutput | A ScalarDenseOutput class implementation that wraps a DenseOutput class instance and behaves as a view to one of its elements |
CState | State is a container for all the data comprising the complete state of a particular System at a particular moment |
CStepwiseDenseOutput | A DenseOutput class interface extension, geared towards step-wise construction procedures |
CSubvector | Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase |
CSystem | Base class for all System functionality that is dependent on the templatized scalar type T for input, state, parameters, and outputs |
►CSystemBase | Provides non-templatized functionality shared by the templatized System classes |
CContextSizes | Return type for get_context_sizes() |
CSystemConstraint | A SystemConstraint is a generic base-class for constraints on Systems |
CSystemConstraintBounds | The bounds of a SystemConstraint |
CSystemOutput | Conveniently stores a snapshot of the values of every output port of a System |
CSystemScalarConverter | Helper class to convert a System into a System<T>, intended for internal use by the System framework, not directly by users |
CSystemTypeTag | A tag object that denotes a System subclass S in function signatures |
CSystemVisitor | Provides a "Visitor Pattern" for System and Diagram |
CUnrestrictedUpdateEvent | This class represents an unrestricted update event |
CUseDefaultName | (Advanced.) Tag type that indicates a system or port should use a default name, instead of a user-provided name |
CValueProducer | ValueProducer computes an AbstractValue output based on a ContextBase input |
CVectorBase | VectorBase is an abstract base class that real-valued signals between Systems and real-valued System state vectors must implement |
CWitnessFunction | Class that stores a function that is able to help determine the time and state at which a step of the initial value problem integration of a System should end, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling) |
CWitnessTriggeredEventData | Class for storing data from a witness function triggering to be passed to event handlers |
►Ntrajectories | |
CPiecewisePolynomial | A scalar multi-variate piecewise polynomial |
CPiecewiseTrajectory | Abstract class that implements the basic logic of maintaining consequent segments of time (delimited by breaks ) to implement a trajectory that is represented by simpler logic in each segment or "piece" |
CTrajectory | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
►CAbstractValue | A fully type-erased container class |
CWrap | |
CArcLengthIntegrator | Wraps maliput::drake::systems::AntiderivativeFunction<double> by using a pImpl |
Ccopyable_unique_ptr | A smart pointer with deep copy semantics |
CDelegatingHasher | An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature |
Cdummy_value | Provides a "dummy" value for a ScalarType – a value that is unlikely to be mistaken for a purposefully-computed value, useful for initializing a value before the true result is available |
Cdummy_value< int > | |
CEigenPtr | This wrapper class provides a way to write non-template functions taking raw pointers to Eigen objects as parameters while limiting the number of copies, similar to Eigen::Ref |
CEigenSizeMinPreferDynamic | EigenSizeMinPreferDynamic<a, b>::value gives the min between compile-time sizes a and b |
CEigenSizeMinPreferFixed | EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic |
CIdentifier | A simple identifier class |
CIntegratorConfiguration | Holds the configuration of the integrators |
CInverseArcLengthIntegrator | Wraps maliput::drake::systems::ScalarInitialValueProblem<double> by using a pImpl |
Cis_eigen_nonvector_of | |
Cis_eigen_scalar_same | |
Cis_eigen_type | |
Cis_eigen_vector | |
Cis_eigen_vector_of | |
CMultiplyEigenSizes | MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes |
Cnever_destroyed | Wraps an underlying type T such that its storage is a direct member field of this object (i.e., without any indirection into the heap), but unlike most member fields T's destructor is never invoked |
CNiceTypeName | Obtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types |
►CPolynomial | A scalar multi-variate polynomial, modeled after the msspoly in spotless |
CMonomial | An additive atom of a Polynomial: The product of any number of Terms and a coefficient |
CProduct | |
CTerm | An individual variable raised to an integer power; e.g. x**2 |
CRandomGenerator | Defines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds) |
Creset_on_copy | Type wrapper that performs value-initialization on copy construction or assignment |
Cscalar_predicate | A traits struct that describes the return type of predicates over a scalar type (named T ) |
CTypeSafeIndex | A type-safe non-negative index class |
Cuhash | A hashing functor, somewhat like std::hash |
CValue | A container class for an arbitrary type T (with some restrictions) |
►Ngeometry_base | |
►Ntest | |
CMockBranchPoint | Mock api::BranchPoint implementation; see mock_geometry.h |
CMockJunction | Mock api::Junction implementation; see mock_geometry.h |
CMockLane | Mock api::Lane implementation; see mock_geometry.h |
CMockRoadGeometry | Mock api::RoadGeometry implementation; see mock_geometry.h |
CMockSegment | Mock api::Segment implementation; see mock_geometry.h |
CBranchPoint | Geometry_base's implementation of api::BranchPoint |
CBruteForceStrategy | Implements StrategyBase using a brute force algorithm for resolving the maliput::api::RoadGeometry::ToRoadPosition() and maliput::api::RoadGeometry::FindRoadPositions() methods |
CJunction | Geometry_base's implementation of api::Junction |
CKDTreeStrategy | Implements StrategyBase by reorganizing the maliput::api::Lane space into a kd-tree for achieving significantly more performant queries than BruteForceStrategy |
CLane | Geometry_base's implementation of api::Lane |
CLaneEndSet | Geometry_base's implementation of api::LaneEndSet |
CRoadGeometry | Geometry_base provides basic implementations for a subset of the interfaces of maliput's geometry API (api::RoadGeometry, etc) that can be shared by most "leaf" backends |
CSegment | Geometry_base's implementation of api::Segment |
CStrategyBase | Provides a base interface for defining strategies that will affect the behavior of the queries RoadGeomoetry::ToRoadPosition and RoadGeomoetry::FindRoadPositions |
►Nmath | Namespace to group basic mathematical and geometric support to maliput |
►Ndetails | |
CKDTreeBase | KDTree provides a space-partitioning data structure for organizing points in a k-dimensional space |
CNode | Represents a node in a kd-tree data structure |
CNodeCmp | Functor for comparing points according to the given dimension being evaluated at that point |
CSquaredDistance | Calculates the squared distance between two points |
CAxisAlignedBox | Implements BoundingRegion abstract class for axis-aligned-box-shaped bounding regions |
CBoundingBox | Implements BoundingRegion abstract class for non-axis-aligned-box-shaped bounding regions |
CBoundingRegion | Abstract API for bounding description |
CKDTree | N-Dimension KDTree |
CKDTree3D | 3-Dimensional KDTree |
CMatrix | A squared N-dimensional matrix |
CQuaternion | A Quaternion representation |
CRollPitchYaw | This class represents the orientation between two arbitrary frames A and D associated with a Space-fixed (extrinsic) X-Y-Z rotation by "roll-pitch-yaw" angles [r, p, y] , which is equivalent to a Body-fixed (intrinsic) Z-Y-X rotation by "yaw-pitch-roll" angles [y, p, r] |
CVector | A N-dimensional vector |
CVector2 | A 2-dimensional vector |
CVector3 | A 3-dimensional vector |
CVector4 | A 4-dimensional vector |
CVectorBase | Base class for an N-dimensional vector |
►Nplugin | |
CMaliputPlugin | MaliputPlugin loads a dynamic library |
CMaliputPluginManager | Manages the lifecycle of MaliputPlugins |
CRoadNetworkLoader | Interface class for creating a RoadNetwork loader functor |
►Nrouting | |
CPhase | Manages a phase in a Route, towards its end |
CPhasePositionResult | The result of a position query on a Phase |
CRoute | Describes the sequence of paths that go from one api::RoadPosition to another |
CRoutePositionResult | The result of a position query on a Route |
CRouter | Computes Routes within an api::RoadNetwork |
CRoutingConstraints | Holds the constraints that can be applied to the Router when computing a Route |
►Nutility | |
►Nmesh | |
CDirectedEdgeIndex | Index for a directed edge in a GeoMesh |
CFaceEdgeIndex | Index for a face edge in a GeoMesh |
CFaceVertexIndex | Index of a face vertex in a GeoMesh |
CGeoFace | An Inertial -frame face: a sequence of vertices with corresponding normals |
CGeoMesh | An Inertial -frame mesh: a collection of GeoFaces |
►CGeoNormal | An Inertial -frame normal vector |
CEquiv | An equivalence operation suitable for std::unordered_map |
►CGeoVertex | An Inertial -frame vertex |
CEquiv | An equivalence operation suitable for std::unordered_map |
►CIndexFace | A face — a sequence of vertices with normals — in which the vertices and normals are represented by integer indices into some other container/dictionary |
CVertex | |
CSrhFace | A Lane -frame face: a sequence of vertices expressed in the (s,r,h) coordinates of an api::Lane (which is not referenced here) |
CUniqueIndexer | A container for a set of unique objects which keeps track of the original insertion order |
CGenerateStringOptions | Parameters that specify what details about an api::RoadGeometry to print |
CMaterial | Material information for built meshes |
CObjFeatures | Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults |
CRoadGeometryMesh | |
CThreadPool | Creates a pool of threads and a pool of tasks to be executed by the threads simultaneously |
CDiscreteValueRuleConstants | Constants to identify attributes of api::rules::DiscreteValueRule Types |
CIntersection | A concrete implementation of the api::Intersection abstract interface |
CIntersectionBook | A concrete implementation of the api::IntersectionBook abstract interface |
CManualDiscreteValueRuleStateProvider | An implementation of a manual api::rules::DiscreteValueRuleStateProvider |
CManualPhaseProvider | A concrete implementation of the api::rules::PhaseProvider abstract interface that allows the current phase to be manually set |
CManualPhaseRingBook | A simple concrete implementation of the api::rules::PhaseRingBook abstract interface that enables manual addition and removal of api::rules::PhaseRing instances |
CManualRangeValueRuleStateProvider | An implementation of a manual api::rules::RangeValueRuleStateProvider |
CManualRulebook | ManualRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface |
CPhasedDiscreteRuleStateProvider | Provides the state of Right-Of-Way api::rules::DiscreteValueRule instances based on the current api::rules::Phase |
CRangeValueRuleConstants | Constants to identify attributes of api::rules::RangeValueRule Types |
CRelatedRulesKeys | Defines keys used in api::rules::Rule::RelatedRules |
CRelatedUniqueIdsKeys | Defines keys used in api::rules::Rule::RelatedUniqueIds |
CRuleConstants | Constants to identify attributes used in both api::rules::DiscreteValueRules and api::rules::RangeValueRules Types |
CRuleTypeFilter | Functor to filter by api::rules::Rule::TypeId |
CSimplePhaseRingBook | A simple concrete implementation of the api::rules::PhaseRingBook abstract interface |
CSimpleRulebook | SimpleRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface |
CTrafficLightBook | A concrete implementation of the api::rules::TrafficLightBook abstract interface |
▼Nstd | STL namespace |
Chash< maliput::api::rules::UniqueBulbGroupId > | Specialization of std::hash for maliput::api::rules::UniqueBulbGroupId |
Chash< maliput::api::rules::UniqueBulbId > | Specialization of std::hash for maliput::api::rules::UniqueBulbId |
Chash< maliput::api::TypeSpecificIdentifier< T > > | Specialization of std::hash for maliput::api::TypeSpecificIdentifier<T> |
Chash< maliput::api::UniqueId > | Specialization of std::hash for maliput::api::UniqueId |
Chash< maliput::drake::Identifier< Tag > > | Enables use of the identifier to serve as a key in STL containers |
Chash< maliput::drake::TypeSafeIndex< Tag > > | Enables use of the type-safe index to serve as a key in STL containers |
Cless< maliput::api::rules::UniqueBulbGroupId > | Specialization of std::less for maliput::api::rules::UniqueBulbGroupId providing a strict ordering over maliput::api::rules::UniqueBulbGroupId suitable for use with ordered containers |
Cless< maliput::api::rules::UniqueBulbId > | Specialization of std::less for maliput::api::rules::UniqueBulbId providing a strict ordering over maliput::api::rules::UniqueBulbId suitable for use with ordered containers |
Cless< maliput::api::TypeSpecificIdentifier< T > > | Specialization of std::less for maliput::api::TypeSpecificIdentifier<T> providing a strict ordering over maliput::api::TypeSpecificIdentifier<T> suitable for use with ordered containers |
Cless< maliput::api::UniqueId > | Specialization of std::less for maliput::api::UniqueId providing a strict ordering over UniqueId suitable for use with ordered containers |
▼NYAML | |
Cconvert< maliput::api::SRange > | Struct used for encoding and decoding api::SRange with a YAML::Node |