| ▼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 | |
| ►Ngraph | |
| CEdge | An edge wraps a pointer to an api::Segment and the identities of the connecting nodes |
| CGraph | Basic type to hold the graph structure |
| CNode | A node wraps a bundle of api::BranchPoints and Edges |
| 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 |
| CDistanceRouter | Basic implementation of a Router which only looks at the traveled distance to provide solutions |
| 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 |
