CAbstractValue | A fully type-erased container class |
CAbstractValueCloner | |
CAbstractValues | AbstractValues is a container for non-numerical state and parameters |
CAntiderivativeFunction< T > | 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 |
CAntiderivativeFunction< double > | |
CArcLengthIntegrator | Wraps maliput::drake::systems::AntiderivativeFunction<double> by using a pImpl |
►Cbool_constant | |
Cis_eigen_nonvector_of< Derived, Scalar > | |
Cis_eigen_scalar_same< Derived, Scalar > | |
Cis_eigen_vector< Derived > | |
Cis_eigen_vector_of< Derived, Scalar > | |
CBulb::BoundingBox | Defines the bounding box of the bulb |
CBoundingRegion< Coordinate > | Abstract API for bounding description |
►CBoundingRegion< Vector3 > | |
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 |
►CBranchPoint | A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another |
CMockBranchPoint | |
►CBranchPoint | Geometry_base's implementation of api::BranchPoint |
CMockBranchPoint | Mock api::BranchPoint implementation; see mock_geometry.h |
CBulb | Models a bulb within a bulb group |
CBulbGroup | Models a group of bulbs within a traffic light |
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 |
CComparisonResult< T > | 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 |
►CCompositeEventCollection< T > | This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection |
CDiagramCompositeEventCollection< T > | CompositeEventCollection for a Diagram |
CConditionTraits< Condition > | |
CContextBaseFixedInputAttorney | |
►CContextMessageInterface | |
►CContextBase | Provides non-templatized Context functionality shared by the templatized derived classes |
CContext< double > | |
►CContext< T > | 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 |
CLeafContext< T > | LeafContext contains all prerequisite data necessary to uniquely determine the results of computations performed by the associated LeafSystem |
CSystemBase::ContextSizes | Return type for get_context_sizes() |
CContinuousState< T > | ContinuousState is a view of, and optionally a container for, all the continuous state variables xc of a Drake System |
CContinuousState< double > | |
Cconvert< maliput::api::SRange > | Struct used for encoding and decoding api::SRange with a YAML::Node |
CDelegatingHasher | An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature |
CDelegatingHasher | An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature |
►CDenseOutput< T > | An interface for dense output of ODE solutions, to efficiently approximate them at arbitrarily many points when solving them numerically (see IntegratorBase class documentation) |
►CScalarDenseOutput< T > | A DenseOutput class interface extension to deal with scalar ODE solutions |
CScalarViewDenseOutput< T > | A ScalarDenseOutput class implementation that wraps a DenseOutput class instance and behaves as a view to one of its elements |
►CStepwiseDenseOutput< T > | A DenseOutput class interface extension, geared towards step-wise construction procedures |
CHermitianDenseOutput< T > | A StepwiseDenseOutput class implementation using Hermitian interpolators, and therefore a continuous extension of the solution 𝐱(t) (see [Engquist, 2105]) |
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< T > | |
CDirectedEdgeIndex | Index for a directed edge in a GeoMesh |
CDiscreteValueRuleConstants | Constants to identify attributes of api::rules::DiscreteValueRule Types |
►CDiscreteValueRuleStateProvider | Abstract interface for the state provider of DiscreteValueRules |
►CManualDiscreteValueRuleStateProvider | An implementation of a manual api::rules::DiscreteValueRuleStateProvider |
CPhasedDiscreteRuleStateProvider | Provides the state of Right-Of-Way api::rules::DiscreteValueRule instances based on the current api::rules::Phase |
CDiscreteValues< T > | DiscreteValues is a container for numerical but non-continuous state and parameters |
CDiscreteValues< double > | |
Cdummy_value< T > | 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< PlainObjectType > | 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< a, b > | EigenSizeMinPreferDynamic<a, b>::value gives the min between compile-time sizes a and b |
CEigenSizeMinPreferFixed< a, b > | EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic |
CGeoVertex::Equiv | An equivalence operation suitable for std::unordered_map |
CGeoNormal::Equiv | An equivalence operation suitable for std::unordered_map |
►CEvent< T > | Abstract base class that represents an event |
CDiscreteUpdateEvent< T > | This class represents a discrete update event |
CPublishEvent< T > | This class represents a publish event |
CUnrestrictedUpdateEvent< T > | This class represents an unrestricted update event |
►CEventCollection< EventType > | 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) |
CDiagramEventCollection< EventType > | A concrete class that holds all simultaneous homogeneous events for a Diagram |
CEventCollection< maliput::drake::systems::DiscreteUpdateEvent< double > > | |
CEventCollection< maliput::drake::systems::DiscreteUpdateEvent< T > > | |
CEventCollection< maliput::drake::systems::PublishEvent< double > > | |
CEventCollection< maliput::drake::systems::PublishEvent< T > > | |
CEventCollection< maliput::drake::systems::UnrestrictedUpdateEvent< double > > | |
CEventCollection< maliput::drake::systems::UnrestrictedUpdateEvent< T > > | |
►CEventData | Base class for storing trigger-specific data to be passed to event handlers |
CPeriodicEventData | A token describing an event that recurs on a fixed period |
CWitnessTriggeredEventData< T > | Class for storing data from a witness function triggering 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 |
►Cexception | STL class |
►Cruntime_error | STL class |
Cassertion_error | This is what MALIPUT_THROW_UNLESS throws |
Cassertion_error | |
CExternalSystemConstraint | An "external" constraint on a System |
CFaceEdgeIndex | Index for a face edge in a GeoMesh |
CFaceVertexIndex | Index of a face vertex in a GeoMesh |
CFilesystem | |
CFixedInputPortValue | A FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports |
CFNV1aHasher | The FNV1a hash algorithm, used for hash_append generic hashing |
CFNV1aHasher | The FNV1a hash algorithm, used for hash_append generic hashing |
CFrameworkFactory | |
CFromDoubleTraits | A concrete traits class providing sugar to support for converting only from the double scalar type |
CGenerateStringOptions | Parameters that specify what details about an api::RoadGeometry to print |
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 |
CGeoVertex | An Inertial -frame vertex |
CHBounds | Bounds in the elevation dimension (h component) of a Lane -frame, consisting of a pair of minimum and maximum h value |
CIdentifier< Tag > | A simple identifier class |
CIdentifier< class SystemIdTag > | |
►CRoadGeometry::IdIndex | 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 |
CBasicIdIndex | Basic general-purpose concrete implementation of the RoadGeometry::IdIndex interface |
CMockIdIndex | |
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 |
CInertialPosition | A position in 3-dimensional geographical Cartesian space, i.e., in the Inertial -frame, consisting of three components x, y, and z |
CInitialValueProblem< T > | 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₀; 𝐤) = 𝐱₀ |
CInitialValueProblem< double > | |
CAntiderivativeFunction< T >::IntegrableFunctionContext | The set of values that, along with the function being integrated, partially specify the definite integral i.e |
CHermitianDenseOutput< T >::IntegrationStep | 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ᵢ ∈ ℝⁿ |
►CIntegratorBase< T > | An abstract class for an integrator for ODEs and DAEs as represented by a Drake System |
CRungeKutta3Integrator< T > | A third-order Runge Kutta integrator with a third order error estimate |
CIntegratorBase< double > | |
CIntegratorConfiguration | Holds the configuration of the integrators |
►CIntersection | An abstract convenience class that aggregates information pertaining to an intersection |
CIntersection | A concrete implementation of the api::Intersection abstract interface |
►CIntersectionBook | An abstract interface for providing the mapping from Intersection::Id to Intersection |
CIntersectionBook | A concrete implementation of the api::IntersectionBook abstract interface |
CIntPackHasher< Ns > | |
CIntPackHasher< N, Ns... > | |
CIntPackHasher<> | |
CInverseArcLengthIntegrator | Wraps maliput::drake::systems::ScalarInitialValueProblem<double> by using a pImpl |
►Cis_base_of | |
Cis_eigen_type< Derived > | |
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 |
CMockJunction | |
►CJunction | Geometry_base's implementation of api::Junction |
CMockJunction | Mock api::Junction implementation; see mock_geometry.h |
CKDTreeBase< CRTP, Coordinate, Dimension, Region, Distance, NodeCmp > | KDTree provides a space-partitioning data structure for organizing points in a k-dimensional space |
►CKDTreeBase< KDTree3D< Coordinate, details::SquaredDistance< Coordinate, 3 >, details::NodeCmp< 3 > >, Coordinate, 3, AxisAlignedBox, details::SquaredDistance< Coordinate, 3 >, details::NodeCmp< 3 > > | |
CKDTree3D< Coordinate, Distance, NodeCmp > | 3-Dimensional KDTree |
►CKDTreeBase< KDTree3D< MaliputPoint, details::SquaredDistance< MaliputPoint, 3 >, details::NodeCmp< 3 > >, MaliputPoint, 3, AxisAlignedBox, details::SquaredDistance< MaliputPoint, 3 >, details::NodeCmp< 3 > > | |
CKDTree3D< MaliputPoint > | |
►CKDTreeBase< KDTree< Coordinate, Dimension, BoundingRegion< Coordinate >, details::SquaredDistance< Coordinate, Dimension >, details::NodeCmp< Dimension > >, Coordinate, Dimension, BoundingRegion< Coordinate >, details::SquaredDistance< Coordinate, Dimension >, details::NodeCmp< Dimension > > | |
CKDTree< Coordinate, Dimension, Region, Distance, NodeCmp > | N-Dimension KDTree |
►CLane | A Lane represents a lane of travel in a road network |
CMockLane | |
►CLane | Geometry_base's implementation of api::Lane |
CMockLane | Mock api::Lane implementation; see mock_geometry.h |
CLaneEnd | A specific endpoint of a specific Lane |
►CLaneEndSet | A set of LaneEnds |
CMockLaneEndSet | |
CLaneEndSet | Geometry_base's implementation of api::LaneEndSet |
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 |
CLeafCompositeEventCollection< T > | A CompositeEventCollection for a LeafSystem |
CLeafEventCollection< EventType > | A concrete class that holds all simultaneous homogeneous events for a LeafSystem |
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 |
CLogger | A logger class implementation |
CMaliputPlugin | MaliputPlugin loads a dynamic library |
CMaliputPluginManager | Manages the lifecycle of MaliputPlugins |
CMaterial | Material information for built meshes |
CMatrix< N > | A squared N-dimensional matrix |
CModelValues | Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) |
CPolynomial< T >::Monomial | An additive atom of a Polynomial: The product of any number of Terms and a coefficient |
CMultiplyEigenSizes< a, b > | MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes |
Cnever_destroyed< T > | 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 |
Cnever_destroyed< T > | 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 |
CStateProviderResult< T >::Next | Information about the next state |
CPhaseRing::NextPhase | Holds a "next phase" specification |
CNiceTypeName | Obtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types |
CNode< Coordinate, Region > | Represents a node in a kd-tree data structure |
CNodeCmp< Dimension > | Functor for comparing points according to the given dimension being evaluated at that point |
CObjFeatures | Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults |
CInitialValueProblem< T >::OdeContext | A collection of values i.e |
COutputPortPrerequisite | |
CParameterPackHasher< Args > | |
CParameterPackHasher< A, B... > | |
CParameterPackHasher<> | |
CParameters< T > | Parameters is a container for variables that parameterize a System so that it can represent a family of related models |
CParameters< double > | |
CPasskey< T > | Simple generic implementation of the "Passkey Idiom" |
CPath | |
CPeriodicEventDataComparator | Structure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method |
CPhase | Manages a phase in a Route, towards its end |
CPhase | A group of RightOfWayRule instances and their states |
CPhaseBuildFlags | Holds Phase build configurations |
CPhasePositionResult | The result of a position query on a Phase |
►CPhaseProvider | Abstract interface for providing the dynamic states (Phase::Id) of a collection of PhaseRings |
CManualPhaseProvider | A concrete implementation of the api::rules::PhaseProvider abstract interface that allows the current phase to be manually set |
CPhaseRing | A set of mutually exclusive phases, e.g., that comprise the signaling cycle for an intersection |
►CPhaseRingBook | Abstract interface for providing the mapping from RightOfWayRule::Id to PhaseRing |
CManualPhaseRingBook | A simple concrete implementation of the api::rules::PhaseRingBook abstract interface that enables manual addition and removal of api::rules::PhaseRing instances |
CSimplePhaseRingBook | A simple concrete implementation of the api::rules::PhaseRingBook abstract interface |
CPolynomial< T > | A scalar multi-variate polynomial, modeled after the msspoly in spotless |
►CPortBase | A PortBase is base class for System ports; users will typically use the InputPort<T> or OutputPort<T> types, not this base class |
►CInputPortBase | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
CInputPort< T > | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
►COutputPortBase | OutputPortBase handles the scalar type-independent aspects of an OutputPort |
►COutputPort< T > | An OutputPort belongs to a System and represents the properties of one of that System's output ports |
CLeafOutputPort< T > | (Advanced.) Implements an output port whose value is managed by a cache entry in the same LeafSystem as the port |
CPolynomial< T >::Product< Rhs, Lhs > | |
CQuaternion | A Quaternion representation |
CRuleRegistry::QueryResult | Holds a rule type information for a query |
CRoadRulebook::QueryResults | Results of a FindRules() query |
CRandomGenerator | Defines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds) |
CRangeValidator | Functor to validate if a number is within [min, max] and considering assuming a tolerance |
CRangeValueRuleConstants | Constants to identify attributes of api::rules::RangeValueRule Types |
►CRangeValueRuleStateProvider | Abstract interface for the state provider of RangeValueRules |
CManualRangeValueRuleStateProvider | An implementation of a manual api::rules::RangeValueRuleStateProvider |
CRBounds | Bounds in the lateral dimension (r component) of a Lane -frame, consisting of a pair of minimum and maximum r value |
CRelatedRulesKeys | Defines keys used in api::rules::Rule::RelatedRules |
CRelatedUniqueIdsKeys | Defines keys used in api::rules::Rule::RelatedUniqueIds |
CReportUseOfTypeHash< T, hash > | |
CReportUseOfTypeHash< T, 0 > | |
Creset_on_copy< T > | Type wrapper that performs value-initialization on copy construction or assignment |
Creset_on_copy< const maliput::drake::systems::internal::ContextMessageInterface * > | |
Creset_on_copy< maliput::drake::systems::ContextBase * > | |
CRightOfWayBuildFlags | Holds RightOfWayRule build configurations |
►CRoadGeometry | Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3-space |
CMockRoadGeometry | |
►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 |
CMockRoadGeometry | Mock api::RoadGeometry implementation; see mock_geometry.h |
CRoadGeometryBuildFlags | Holds RoadGeometry build configuration |
CRoadGeometryContiguityBuildFlags | Holds RoadGeometry contiguity build configuration |
CRoadGeometryIdIndexBuildFlags | |
CRoadGeometryMesh | |
CRoadNetwork | A container that aggregates everything pertaining to Maliput |
CRoadNetworkContiguityBuildFlags | Holds RoadNetwork contiguity build configuration |
CRoadNetworkLoader | Interface class for creating a RoadNetwork loader functor |
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() |
►CRoadRulebook | Abstract interface for querying "rules of the road" |
CManualRulebook | ManualRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface |
CSimpleRulebook | SimpleRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface |
CRoadRulebookBuildFlags | Holds RoadRulebook build configurations |
CRoadRulebookContiguityBuildFlags | Holds RoadRulebook contiguity build configuration |
CRoadRulebookRelatedRulesBuildFlags | Holds RoadRulebook build configurations when RelatedRules consitency are under test |
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] |
CRotation | A 3-dimensional rotation |
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 |
►CRule | Describes a generic rule type |
CDiscreteValueRule | Describes a discrete value rule |
CRangeValueRule | Describes a numeric range based rule |
CRuleConstants | Constants to identify attributes used in both api::rules::DiscreteValueRules and api::rules::RangeValueRules Types |
CRuleRegistry | A registry for Rule types |
CRuleTypeFilter | Functor to filter by api::rules::Rule::TypeId |
Cscalar_predicate< T > | A traits struct that describes the return type of predicates over a scalar type (named T ) |
CScalarInitialValueProblem< T > | A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e |
CScalarInitialValueProblem< double > | |
CScalarInitialValueProblem< T >::ScalarOdeContext | A collection of values i.e |
►CSegment | A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface |
CMockSegment | |
►CSegment | Geometry_base's implementation of api::Segment |
CMockSegment | Mock api::Segment implementation; see mock_geometry.h |
CSerialize | Convenient functor for getting a string from a object that has serialization operator defined |
►CSinkBase | Interface of a sink to dump all log messages |
CSink | Sink that uses std::cout to dump the log messages |
CSquaredDistance< Coordinate, Dimension > | Calculates the squared distance between two points |
CSRange | Directed, inclusive longitudinal (s value) range from s0 to s1 |
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) |
CState< T > | State is a container for all the data comprising the complete state of a particular System at a particular moment |
►CRule::State | Defines a base state for a Rule |
CDiscreteValueRule::DiscreteValue | Defines a discrete value for a DiscreteValueRule |
CRangeValueRule::Range | Defines a range for a RangeValueRule |
CStateProviderResult< T > | The state returned by a state provider |
►CStrategyBase | Provides a base interface for defining strategies that will affect the behavior of the queries RoadGeomoetry::ToRoadPosition and RoadGeomoetry::FindRoadPositions |
CBruteForceStrategy | Implements StrategyBase using a brute force algorithm for resolving the maliput::api::RoadGeometry::ToRoadPosition() and maliput::api::RoadGeometry::FindRoadPositions() methods |
CKDTreeStrategy | Implements StrategyBase by reorganizing the maliput::api::Lane space into a kd-tree for achieving significantly more performant queries than BruteForceStrategy |
CLaneEnd::StrictOrder | An arbitrary strict complete ordering, useful for, e.g., std::map |
►CSystem< T > | Base class for all System functionality that is dependent on the templatized scalar type T for input, state, parameters, and outputs |
CLeafSystem< T > | A superclass template that extends System with some convenience utilities that are not applicable to Diagrams |
CSystem< double > | |
CSystemBaseContextBaseAttorney | |
CSystemConstraint< T > | A SystemConstraint is a generic base-class for constraints on Systems |
CSystemConstraint< double > | |
CSystemConstraintBounds | The bounds of a SystemConstraint |
►CSystemMessageInterface | |
CSystemBase | Provides non-templatized functionality shared by the templatized System classes |
CSystemOutput< T > | Conveniently stores a snapshot of the values of every output port of a System |
CSystemParentServiceInterface | |
CSystemScalarConverter | Helper class to convert a System into a System<T>, intended for internal use by the System framework, not directly by users |
CSystemTypeTag< S > | A tag object that denotes a System subclass S in function signatures |
CSystemVisitor< T > | Provides a "Visitor Pattern" for System and Diagram |
CPolynomial< T >::Term | An individual variable raised to an integer power; e.g. x**2 |
CThreadPool | Creates a pool of threads and a pool of tasks to be executed by the threads simultaneously |
CTrafficLight | Models a traffic light |
►CTrafficLightBook | Abstract interface for providing the mapping from TrafficLight::Id to TrafficLight |
CTrafficLightBook | A concrete implementation of the api::rules::TrafficLightBook abstract interface |
CTrafficLightBookBuildFlags | Holds TrafficLightBook build configurations |
CTrafficLightBuildFlags | Holds TrafficLight build configurations |
CTraits< S > | 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 |
►CTrajectory< T > | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
►CPiecewiseTrajectory< T > | 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" |
CPiecewisePolynomial< T > | A scalar multi-variate piecewise polynomial |
►CTrajectory< double > | |
►CPiecewiseTrajectory< double > | |
CPiecewisePolynomial< double > | |
Ctype_erased_ptr | |
CTypeHash< T > | |
CTypeHasher< T, bool > | |
CTypeHasher< T, true > | |
CTypeHasher< T< Args... >, false > | |
CTypeHasher< T< U, N, Ns... >, false > | |
CTypeHasherHasNonTypeTemplateParameter< T, U > | |
CTypeHasherHasNonTypeTemplateParameter< T, typehasher_void_t< typename T::NonTypeTemplateParameter > > | |
CTypeSafeIndex< Tag > | A type-safe non-negative index class |
CTypeSafeIndex< class CacheTag > | |
CTypeSafeIndex< class DependencyTag > | |
CTypeSpecificIdentifier< T > | TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T |
CTypeSpecificIdentifier< BulbGroup > | |
CTypeSpecificIdentifier< class BranchPoint > | |
CTypeSpecificIdentifier< class Bulb > | |
CTypeSpecificIdentifier< class Junction > | |
CTypeSpecificIdentifier< class Lane > | |
CTypeSpecificIdentifier< class MaliputPlugin > | |
CTypeSpecificIdentifier< class PhaseRing > | |
CTypeSpecificIdentifier< class RoadGeometry > | |
CTypeSpecificIdentifier< class Rule > | |
CTypeSpecificIdentifier< class Segment > | |
CTypeSpecificIdentifier< class Type > | |
CTypeSpecificIdentifier< Phase > | |
CTypeSpecificIdentifier< TrafficLight > | |
►Cuhash< HashAlgorithm > | A hashing functor, somewhat like std::hash |
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 |
►Cuhash< HashAlgorithm > | A hashing functor, somewhat like std::hash |
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 |
►Cunique_ptr< T > | STL class |
Ccopyable_unique_ptr< maliput::drake::AbstractValue > | |
Ccopyable_unique_ptr< maliput::drake::systems::CacheEntryValue > | |
Ccopyable_unique_ptr< maliput::drake::systems::EventData > | |
Ccopyable_unique_ptr< maliput::drake::systems::FixedInputPortValue > | |
Ccopyable_unique_ptr< maliput::drake::systems::Parameters< double > > | |
Ccopyable_unique_ptr< maliput::drake::systems::Parameters< T > > | |
Ccopyable_unique_ptr< T > | A smart pointer with deep copy semantics |
►CUniqueId | Represents an unique identifier |
CUniqueBulbGroupId | Uniquely identifies a bulb group in the Inertial space |
CUniqueBulbId | Uniquely identifies a bulb in the Inertial space |
CUniqueIndexer< T, Hash, KeyEqual > | A container for a set of unique objects which keeps track of the original insertion order |
CUniqueIndexer< maliput::utility::mesh::GeoNormal, maliput::common::uhash, maliput::utility::mesh::GeoNormal::Equiv > | |
CUniqueIndexer< maliput::utility::mesh::GeoVertex, maliput::common::uhash, maliput::utility::mesh::GeoVertex::Equiv > | |
CUseDefaultName | (Advanced.) Tag type that indicates a system or port should use a default name, instead of a user-provided name |
CValue< T > | A container class for an arbitrary type T (with some restrictions) |
CValueConverter< T, U > | Converts a scalar U u to its corresponding scalar T t |
CValueConverter< T, T > | |
CValueHasher< T, K > | |
CValueProducer | ValueProducer computes an AbstractValue output based on a ContextBase input |
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< T > | 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>> |
CValueTraitsImpl< T, use_copy > | |
CValueTraitsImpl< T, false > | |
CValueTraitsImpl< T, true > | |
►CVectorBase< T > | VectorBase is an abstract base class that real-valued signals between Systems and real-valued System state vectors must implement |
CBasicVector< T > | BasicVector is a semantics-free wrapper around an Eigen vector that satisfies VectorBase |
CSubvector< T > | Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase |
CVectorBase< N, Derived > | Base class for an N-dimensional vector |
►CVectorBase< 2, Vector2 > | |
CVector2 | A 2-dimensional vector |
►CVectorBase< 3, Vector3 > | |
CVector3 | A 3-dimensional vector |
►CVectorBase< 4, Vector4 > | |
CVector4 | A 4-dimensional vector |
►CVectorBase< double > | |
CBasicVector< double > | |
►CVectorBase< N, Vector< N > > | |
CVector< N > | A N-dimensional vector |
CIndexFace::Vertex | |
CWarn | When constructed, logs a message (at "warn" severity); the destructor is guaranteed to be trivial |
CWitnessFunction< T > | 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) |
CAbstractValue::Wrap | |
Cdouble | |