maliput
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CAbstractValueA fully type-erased container class
 CAbstractValueCloner
 CAbstractValuesAbstractValues 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 >
 CArcLengthIntegratorWraps maliput::drake::systems::AntiderivativeFunction<double> by using a pImpl
 Cbool_constant
 CBulb::BoundingBoxDefines the bounding box of the bulb
 CBoundingRegion< Coordinate >Abstract API for bounding description
 CBoundingRegion< Vector3 >
 CBranchPointA BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another
 CBulbModels a bulb within a bulb group
 CBulbGroupModels 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
 CCacheEntryA 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
 CComparisonResultCollectorComparisonResultCollector 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
 CConditionTraits< Condition >
 CContextBaseFixedInputAttorney
 CContextMessageInterface
 CSystemBase::ContextSizesReturn 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
 CDelegatingHasherAn adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature
 CDelegatingHasherAn 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)
 CDependencyGraphRepresents the portion of the complete dependency graph that is a subgraph centered on the owning subcontext, plus some edges leading to other subcontexts
 CDependencyTrackerManages value interdependencies for a particular value or set of values in a Context
 CDiagram< T >
 CDirectedEdgeIndexIndex for a directed edge in a GeoMesh
 CDiscreteValueRuleConstantsConstants to identify attributes of api::rules::DiscreteValueRule Types
 CDiscreteValueRuleStateProviderAbstract interface for the state provider of DiscreteValueRules
 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::EquivAn equivalence operation suitable for std::unordered_map
 CGeoNormal::EquivAn equivalence operation suitable for std::unordered_map
 CEvent< T >Abstract base class that represents an 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)
 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 > >
 CEventDataBase class for storing trigger-specific data to be passed to event handlers
 CEventStatusHolds 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
 CexceptionSTL class
 CExternalSystemConstraintAn "external" constraint on a System
 CFaceEdgeIndexIndex for a face edge in a GeoMesh
 CFaceVertexIndexIndex of a face vertex in a GeoMesh
 CFilesystem
 CFixedInputPortValueA FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports
 CFNV1aHasherThe FNV1a hash algorithm, used for hash_append generic hashing
 CFNV1aHasherThe FNV1a hash algorithm, used for hash_append generic hashing
 CFrameworkFactory
 CFromDoubleTraitsA concrete traits class providing sugar to support for converting only from the double scalar type
 CGenerateStringOptionsParameters that specify what details about an api::RoadGeometry to print
 CGeoFaceAn Inertial-frame face: a sequence of vertices with corresponding normals
 CGeoMeshAn Inertial-frame mesh: a collection of GeoFaces
 CGeoNormalAn Inertial-frame normal vector
 CGeoVertexAn Inertial-frame vertex
 CHBoundsBounds 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::IdIndexAbstract 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
 CIndexFaceA face — a sequence of vertices with normals — in which the vertices and normals are represented by integer indices into some other container/dictionary
 CInertialPositionA 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 >::IntegrableFunctionContextThe set of values that, along with the function being integrated, partially specify the definite integral i.e
 CHermitianDenseOutput< T >::IntegrationStepAn 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
 CIntegratorBase< double >
 CIntegratorConfigurationHolds the configuration of the integrators
 CIntersectionAn abstract convenience class that aggregates information pertaining to an intersection
 CIntersectionBookAn abstract interface for providing the mapping from Intersection::Id to Intersection
 CIntPackHasher< Ns >
 CIntPackHasher< N, Ns... >
 CIntPackHasher<>
 CInverseArcLengthIntegratorWraps maliput::drake::systems::ScalarInitialValueProblem<double> by using a pImpl
 Cis_base_of
 CIsoLaneVelocityIsometric velocity vector in a Lane-frame
 CJunctionA 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
 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 > >
 CKDTreeBase< KDTree3D< MaliputPoint, details::SquaredDistance< MaliputPoint, 3 >, details::NodeCmp< 3 > >, MaliputPoint, 3, AxisAlignedBox, details::SquaredDistance< MaliputPoint, 3 >, details::NodeCmp< 3 > >
 CKDTreeBase< KDTree< Coordinate, Dimension, BoundingRegion< Coordinate >, details::SquaredDistance< Coordinate, Dimension >, details::NodeCmp< Dimension > >, Coordinate, Dimension, BoundingRegion< Coordinate >, details::SquaredDistance< Coordinate, Dimension >, details::NodeCmp< Dimension > >
 CLaneA Lane represents a lane of travel in a road network
 CLaneEndA specific endpoint of a specific Lane
 CLaneEndSetA set of LaneEnds
 CLanePositionA 3-dimensional position in a Lane-frame, consisting of three components:
 CLanePositionResultIncluded in the return result of Lane::ToLanePosition()
 CLaneSRangeDirected longitudinal range of a specific Lane, identified by a LaneId
 CLaneSRouteA 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
 CLoggerA logger class implementation
 CMaliputPluginMaliputPlugin loads a dynamic library
 CMaliputPluginManagerManages the lifecycle of MaliputPlugins
 CMaterialMaterial information for built meshes
 CMatrix< N >A squared N-dimensional matrix
 CModelValuesRepresents models for a sequence of AbstractValues (usually a sequence of either input or output ports)
 CPolynomial< T >::MonomialAn 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 >::NextInformation about the next state
 CPhaseRing::NextPhaseHolds a "next phase" specification
 CNiceTypeNameObtains 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
 CObjFeaturesMultitude of parameters for generating an OBJ model of a road surface, with sensible defaults
 CInitialValueProblem< T >::OdeContextA 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
 CPeriodicEventDataComparatorStructure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method
 CPhaseManages a phase in a Route, towards its end
 CPhaseA group of RightOfWayRule instances and their states
 CPhaseBuildFlagsHolds Phase build configurations
 CPhasePositionResultThe result of a position query on a Phase
 CPhaseProviderAbstract interface for providing the dynamic states (Phase::Id) of a collection of PhaseRings
 CPhaseRingA set of mutually exclusive phases, e.g., that comprise the signaling cycle for an intersection
 CPhaseRingBookAbstract interface for providing the mapping from RightOfWayRule::Id to PhaseRing
 CPolynomial< T >A scalar multi-variate polynomial, modeled after the msspoly in spotless
 CPortBaseA PortBase is base class for System ports; users will typically use the InputPort<T> or OutputPort<T> types, not this base class
 CPolynomial< T >::Product< Rhs, Lhs >
 CQuaternionA Quaternion representation
 CRuleRegistry::QueryResultHolds a rule type information for a query
 CRoadRulebook::QueryResultsResults of a FindRules() query
 CRandomGeneratorDefines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds)
 CRangeValidatorFunctor to validate if a number is within [min, max] and considering assuming a tolerance
 CRangeValueRuleConstantsConstants to identify attributes of api::rules::RangeValueRule Types
 CRangeValueRuleStateProviderAbstract interface for the state provider of RangeValueRules
 CRBoundsBounds in the lateral dimension (r component) of a Lane-frame, consisting of a pair of minimum and maximum r value
 CRelatedRulesKeysDefines keys used in api::rules::Rule::RelatedRules
 CRelatedUniqueIdsKeysDefines 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 * >
 CRightOfWayBuildFlagsHolds RightOfWayRule build configurations
 CRoadGeometryAbstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3-space
 CRoadGeometryBuildFlagsHolds RoadGeometry build configuration
 CRoadGeometryContiguityBuildFlagsHolds RoadGeometry contiguity build configuration
 CRoadGeometryIdIndexBuildFlags
 CRoadGeometryMesh
 CRoadNetworkA container that aggregates everything pertaining to Maliput
 CRoadNetworkContiguityBuildFlagsHolds RoadNetwork contiguity build configuration
 CRoadNetworkLoaderInterface class for creating a RoadNetwork loader functor
 CRoadNetworkValidatorOptionsProvides configuration options for the RoadNetworkValidator
 CRoadPositionA position in the road network, consisting of a pointer to a specific Lane and a Lane-frame position in that Lane
 CRoadPositionResultIncluded in the return result of RoadGeometry::FindRoadPositions() and RoadGeometry::ToRoadPosition()
 CRoadRulebookAbstract interface for querying "rules of the road"
 CRoadRulebookBuildFlagsHolds RoadRulebook build configurations
 CRoadRulebookContiguityBuildFlagsHolds RoadRulebook contiguity build configuration
 CRoadRulebookRelatedRulesBuildFlagsHolds RoadRulebook build configurations when RelatedRules consitency are under test
 CRollPitchYawThis 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]
 CRotationA 3-dimensional rotation
 CRouteDescribes the sequence of paths that go from one api::RoadPosition to another
 CRoutePositionResultThe result of a position query on a Route
 CRouterComputes Routes within an api::RoadNetwork
 CRoutingConstraintsHolds the constraints that can be applied to the Router when computing a Route
 CRuleDescribes a generic rule type
 CRuleConstantsConstants to identify attributes used in both api::rules::DiscreteValueRules and api::rules::RangeValueRules Types
 CRuleRegistryA registry for Rule types
 CRuleTypeFilterFunctor 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 >::ScalarOdeContextA collection of values i.e
 CSegmentA Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface
 CSerializeConvenient functor for getting a string from a object that has serialization operator defined
 CSinkBaseInterface of a sink to dump all log messages
 CSquaredDistance< Coordinate, Dimension >Calculates the squared distance between two points
 CSRangeDirected, inclusive longitudinal (s value) range from s0 to s1
 CSrhFaceA 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::StateDefines a base state for a Rule
 CStateProviderResult< T >The state returned by a state provider
 CStrategyBaseProvides a base interface for defining strategies that will affect the behavior of the queries RoadGeomoetry::ToRoadPosition and RoadGeomoetry::FindRoadPositions
 CLaneEnd::StrictOrderAn 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
 CSystem< double >
 CSystemBaseContextBaseAttorney
 CSystemConstraint< T >A SystemConstraint is a generic base-class for constraints on Systems
 CSystemConstraint< double >
 CSystemConstraintBoundsThe bounds of a SystemConstraint
 CSystemMessageInterface
 CSystemOutput< T >Conveniently stores a snapshot of the values of every output port of a System
 CSystemParentServiceInterface
 CSystemScalarConverterHelper 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 >::TermAn individual variable raised to an integer power; e.g. x**2
 CThreadPoolCreates a pool of threads and a pool of tasks to be executed by the threads simultaneously
 CTrafficLightModels a traffic light
 CTrafficLightBookAbstract interface for providing the mapping from TrafficLight::Id to TrafficLight
 CTrafficLightBookBuildFlagsHolds TrafficLightBook build configurations
 CTrafficLightBuildFlagsHolds 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
 CTrajectory< 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
 Cuhash< HashAlgorithm >A hashing functor, somewhat like std::hash
 Cunique_ptr< T >STL class
 CUniqueIdRepresents an unique identifier
 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 >
 CValueProducerValueProducer computes an AbstractValue output based on a ContextBase input
 CValueToAbstractValueImplements 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
 CVectorBase< N, Derived >Base class for an N-dimensional vector
 CVectorBase< 2, Vector2 >
 CVectorBase< 3, Vector3 >
 CVectorBase< 4, Vector4 >
 CVectorBase< double >
 CVectorBase< N, Vector< N > >
 CIndexFace::Vertex
 CWarnWhen 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