►CAbstractLookupTable< E, V > | |
CFullLookupTable< E, V > | |
CLandmarkLookupTable< E, V > | Computes the shortest path through a network using the A* algorithm |
►CAbstractPoly | |
►CBoundary | A class that stores a 2D geometrical boundary |
►CSUMORTree | A RT-tree for efficient storing of SUMO's GL-objects |
CLayeredRTree | A RT-tree for efficient storing of SUMO's GL-objects in layers |
CPositionVector | A list of positions |
CAGActivities | |
►CAGActivity | |
CAGFreeTime | |
CAGWorkAndSchool | |
CAGActivityGen | Central object handling City, Activities and Trips |
CAGActivityTripWriter | |
CAGBus | |
CAGBusLine | |
CAGCar | |
CAGCity | |
CAGDataAndStatistics | |
CAGFrame | Sets and checks options for ActivityGen |
CAGHousehold | |
►CAGPerson | Base class of every person in the city (adults and children) |
CAGAdult | An adult person who can have a job |
CAGChild | |
CAGPosition | A location in the 2D plane freely positioned on a street |
CAGSchool | |
CAGTime | |
CAGTrip | |
CAGWorkPosition | |
CAStarRouter< E, V >::EdgeInfoComparator | |
CBinaryInputDevice | Encapsulates binary reading operations on a file |
CBresenham | |
►CBresenham::BresenhamCallBack | |
CNBEdge::ToEdgeConnectionsAdder | A class that being a bresenham-callback assigns the incoming lanes to the edges |
CNBNode::ApproachingDivider | Computes lane-2-lane connections |
Cby_second_sorter | |
CCC_VehicleVariables::FAKE_CONTROLLER_DATA | Represent the set of fake data which is sent to the controller in order to automatically make the car move to a precise position before joining the platoon. we expect to get from the upper application the data that the CACC needs, i.e.: |
CChargingStation | Definition of charging stations |
CCHBuilder< E, V > | |
CCHBuilder< E, V >::CHConnection | Forward/backward connection with associated FORWARD cost |
CCHBuilder< E, V >::CHInfo | |
CCHBuilder< E, V >::CHInfoComparator | |
CCHBuilder< E, V >::Connection | Forward/backward connection with associated forward/backward cost |
CCHBuilder< E, V >::Hierarchy | |
CCHBuilder< E, V >::Shortcut | |
CCHRouter< E, V >::Unidirectional | |
CCHRouter< E, V >::Unidirectional::EdgeInfoByTTComparator | |
CCircularBuffer< T > | |
►CCommand | Base (microsim) event class |
CCommand_SaveTLSProgram | Writes the switch times of a tls into a file when the tls switches |
CCommand_SaveTLSState | Writes the state of the tls to a file (in each second) |
CCommand_SaveTLSSwitches | Writes information about the green durations of a tls |
CCommand_SaveTLSSwitchStates | Writes the switch times of a tls into a file when the tls switches |
►CMSCalibrator | Calibrates the flow on a segment to a specified one |
CGUICalibrator | Changes the speed allowed on a set of lanes (gui version) |
CMETriggeredCalibrator | Calibrates the flow on a segment to a specified one |
CMSCalibrator::CalibratorCommand | |
CMSCModel_NonInteracting::MoveToNextEdge | |
CMSDevice_BTreceiver::BTreceiverUpdate | A global update performer |
►CMSLaneSpeedTrigger | Changes the speed allowed on a set of lanes |
CGUILaneSpeedTrigger | Changes the speed allowed on a set of lanes (gui version) |
CMSPerson::MSPersonStage_Access::ProceedCmd | |
CMSPModel_NonInteracting::MoveToNextEdge | |
CMSPModel_Remote::Event | |
CMSPModel_Striping::MovePedestrians | |
CMSTLLogicControl::SwitchInitCommand | This event-class is used to initialise a WAUT switch at a certain time |
CMSTrafficLightLogic::SwitchCommand | Class realising the switch between the traffic light phases |
CMSVTypeProbe | Writes positions of vehicles that have a certain (named) type |
CParametrisedWrappingCommand< T, S > | A wrapper for a Command function with parameter |
CStaticCommand< T > | A wrapper for a Command function |
CWrappingCommand< T > | A wrapper for a Command function |
CWrappingCommand< MSDevice_Routing > | |
CWrappingCommand< MSDevice_ToC > | |
CWrappingCommand< MSTransportableDevice_Routing > | |
CComparatorIdLess | Function-object for stable sorting of objects acting like Named without being derived (SUMOVehicle) |
CComparatorNumericalIdLess | Function-object for stable sorting of objects with numerical ids |
CCState | |
CDijkstraRouter< E, V >::EdgeInfoByEffortComparator | |
CDistributionCont | |
CDriverStateDefaults | Default values for the MSDriverState parameters |
CDynamicShapeUpdater | Ensures that dynamic shapes tracking traffic objects are removed when the objects are removed |
CEdge | C++ TraCI client API implementation |
CEdgeInfoByEffortComparator | |
CEdgeInfoByEffortComparator | |
CEdgeInfoByRankComparator | |
►CEffortCalculator | Effort calculator interface |
CFareModul | |
CEngineParameters | |
CEngineParameters::GearShiftingRules | |
CEngineParameters::PolynomialEngineModelRpmToHp | |
CFareState | |
CFileHelpers | Functions for an easier usage of files and paths |
CFlowDef | Definition of the traffic during a certain time containing the flows and speeds |
CFONSparams | |
CFONSquad | |
CFONStextIter | |
►CFXButton | |
CMFXCheckableButton | |
►CFXComboBox | |
CMFXIconComboBox | |
►CFXCommand | |
►CGNEChange | Function-object for an editing operation (abstract base) |
CGNEChange_Additional | |
CGNEChange_Attribute | Function-object for an editing operation (abstract base) |
CGNEChange_Children | |
CGNEChange_Connection | |
CGNEChange_Crossing | |
CGNEChange_DemandElement | |
CGNEChange_Edge | |
CGNEChange_EnableAttribute | Function-object for an editing operation (abstract base) |
CGNEChange_Junction | |
CGNEChange_Lane | |
CGNEChange_Shape | |
CGNEChange_TLS | |
CGNENet::GNEChange_ReplaceEdgeInTLS | Class for GNEChange_ReplaceEdgeInTLS |
►CFXCommandGroup | |
CGNEUndoList::CommandGroup | Class CommandGroup |
CFXConditionalLock | A scoped lock which only triggers on condition |
►CFXDelegator | |
CGNEInternalLane | This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routeted to an internal dataTarget and to the editor (hence inheritance from FXDelegator) |
CGNELane | This lane is powered by an underlying GNEEdge and basically knows how to draw itself |
►CFXDialogBox | |
CGNEAbout | The application's "About" - dialog |
CGNEAllowDisallow | Dialog for edit rerouters |
CGNEFixAdditionalElements | Dialog for edit rerouters |
CGNEFixDemandElements | Dialog for edit rerouters |
CGNEParametersDialog | Dialog for edit parameters |
CGUIDialog_AboutSUMO | The application's "About" - dialog |
CGUIDialog_AppSettings | The dialog to change the application (gui) settings |
CGUIDialog_EditViewport | A dialog to change the viewport |
CGUIDialog_Options | |
CGUIDialog_ViewSettings | The dialog to change the view (gui) settings |
►CGUIManipulator | |
CGUICalibrator::GUIManip_Calibrator | |
CGUILaneSpeedTrigger::GUIManip_LaneSpeedTrigger | |
CGUITriggeredRerouter::GUIManip_TriggeredRerouter | |
►CFXFrame | |
CFXEX::FXSevenSegment | |
►CFXGLCanvas | |
CGUIParameterTracker::GUIParameterTrackerPanel | |
►CGUISUMOAbstractView | |
CGNEViewNet | |
CGUIViewTraffic | |
CGUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerPanel | The canvas for the visualisation of phases |
►CFXGroupBox | |
CGNEAdditionalFrame::SelectorChildEdges | |
CGNEAdditionalFrame::SelectorChildLanes | |
CGNEAdditionalFrame::SelectorParentLanes | |
CGNEConnectorFrame::ConnectionLegend | |
CGNEConnectorFrame::ConnectionModifications | |
CGNEConnectorFrame::ConnectionOperations | |
CGNEConnectorFrame::ConnectionSelection | |
CGNEConnectorFrame::CurrentLane | |
CGNECrossingFrame::CreateCrossing | |
CGNECrossingFrame::CrossingParameters | |
CGNECrossingFrame::CurrentJunction | |
CGNECrossingFrame::EdgesSelector | |
CGNEDeleteFrame::DeleteOptions | |
CGNEFixAdditionalElements::AdditionalList | Groupbox for list |
CGNEFixAdditionalElements::ConsecutiveLaneOptions | Groupbox for group all radio buttons related to additionals with consecutive lanes |
CGNEFixAdditionalElements::PositionOptions | Groupbox for group all radio buttons related to additionals with single lanes |
CGNEFixDemandElements::DemandList | Groupbox for list |
CGNEFixDemandElements::FixRouteOptions | Groupbox for all radio buttons related with fix route options |
CGNEFixDemandElements::FixStopOptions | Groupbox for all radio buttons related with fix stop options |
CGNEFixDemandElements::FixVehicleOptions | Groupbox for all radio buttons related with fix vehicle options |
CGNEFrameAttributesModuls::AttributesCreator | |
CGNEFrameAttributesModuls::AttributesCreatorFlow | |
CGNEFrameAttributesModuls::AttributesEditor | |
CGNEFrameAttributesModuls::AttributesEditorExtended | |
CGNEFrameAttributesModuls::AttributesEditorFlow | |
CGNEFrameAttributesModuls::DrawingShape | |
CGNEFrameAttributesModuls::NeteditAttributes | |
CGNEFrameAttributesModuls::ParametersEditor | |
CGNEFrameModuls::AttributeCarrierHierarchy | |
CGNEFrameModuls::DemandElementSelector | |
CGNEFrameModuls::DrawingShape | |
CGNEFrameModuls::EdgePathCreator | |
CGNEFrameModuls::OverlappedInspection | |
CGNEFrameModuls::SelectorParent | |
CGNEFrameModuls::TagSelector | |
CGNEInspectorFrame::GEOAttributesEditor | |
CGNEInspectorFrame::NeteditAttributesEditor | FOX-declaration |
CGNEInspectorFrame::TemplateEditor | |
CGNEParametersDialog::ParametersOptions | |
CGNEParametersDialog::ParametersValues | FOX-declaration |
CGNEPersonFrame::HelpCreation | |
CGNEPersonPlanFrame::HelpCreation | |
CGNEPersonPlanFrame::PersonPlanCreator | |
CGNEPersonTypeFrame::PersonTypeEditor | |
CGNEPersonTypeFrame::PersonTypeSelector | |
CGNEPolygonFrame::GEOPOICreator | |
CGNEProhibitionFrame::Modifications | |
CGNEProhibitionFrame::ProhibitionLegend | |
CGNEProhibitionFrame::RelativeToConnection | |
CGNERouteFrame::ConsecutiveEdges | |
CGNERouteFrame::NonConsecutiveEdges | |
CGNERouteFrame::RouteModeSelector | |
CGNESelectorFrame::ElementSet | |
CGNESelectorFrame::LockGLObjectTypes | |
CGNESelectorFrame::MatchAttribute | |
CGNESelectorFrame::ModificationMode | |
CGNESelectorFrame::SelectionOperation | |
CGNESelectorFrame::VisualScaling | |
CGNEStopFrame::HelpCreation | |
CGNETAZFrame::TAZChildDefaultParameters | |
CGNETAZFrame::TAZCommonStatistics | |
CGNETAZFrame::TAZCurrent | |
CGNETAZFrame::TAZEdgesGraphic | |
CGNETAZFrame::TAZParameters | |
CGNETAZFrame::TAZSaveChanges | |
CGNETAZFrame::TAZSelectionStatistics | |
CGNETLSEditorFrame::TLSAttributes | |
CGNETLSEditorFrame::TLSDefinition | |
CGNETLSEditorFrame::TLSFile | |
CGNETLSEditorFrame::TLSJunction | FOX-declaration |
CGNETLSEditorFrame::TLSModifications | |
CGNETLSEditorFrame::TLSPhases | |
CGNEVehicleFrame::HelpCreation | |
CGNEVehicleTypeDialog::CarFollowingModelParameters | Class for CarFollowingModel |
CGNEVehicleTypeFrame::VehicleTypeEditor | |
CGNEVehicleTypeFrame::VehicleTypeSelector | |
►CFXHorizontalFrame | |
CFXEX::FXLCDLabel | |
CGNEFrameAttributesModuls::AttributesCreatorRow | |
CGNEFrameAttributesModuls::AttributesEditorRow | |
CGNEVehicleTypeDialog::CarFollowingModelParameters::CarFollowingModelRow | Class used for represent rows with Car Following Model parameters |
CGNEVehicleTypeDialog::VTypeAtributes::VClassRow | FOX-declaration |
CGNEVehicleTypeDialog::VTypeAtributes::VShapeRow | Class for VShapeRow |
CGNEVehicleTypeDialog::VTypeAtributes::VTypeAttributeRow | Class used for represent rows with Vehicle Type parameters |
CGUIDialog_Options::InputBool | |
CGUIDialog_Options::InputFloat | |
CGUIDialog_Options::InputInt | |
CGUIDialog_Options::InputString | |
►CFXLabel | |
CFXLinkLabel | |
►CFXListItem | |
CMFXListItem | |
►CFXMainWindow | |
CGUIDialog_Breakpoints | Editor for simulation breakpoints |
CGUIDialog_GLChosenEditor | Editor for the list of chosen objects |
►CGUIDialog_GLObjChooser | |
CGNEDialogACChooser | |
►CGUIMainWindow | |
CGNEApplicationWindow | The main window of the Netedit |
CGUIApplicationWindow | The main window of the SUMO-gui |
CGUIParameterTableWindow | A window containing a gl-object's parameter |
CGUIParameterTracker | A window which displays the time line of one (or more) value(s) |
CGUITLLogicPhasesTrackerWindow | This window displays a phase diagram for a chosen tl-logic |
►CFXMDIChild | |
►CGUIGlChildWindow | |
CGNEViewParent | A single child window which contains a view of the simulation area |
CGUISUMOViewParent | A single child window which contains a view of the simulation area |
►CFXMenuCommand | |
CMFXMenuHeader | |
►CFXMenuPane | |
►CGUIGLObjectPopupMenu | The popup menu of a globject |
CGNEPerson::GNEPersonPopupMenu | Class used in GUIGLObjectPopupMenu for person transformations |
CGNEPerson::GNESelectedPersonsPopupMenu | Class used in GUIGLObjectPopupMenu for single person transformations |
CGNERoute::GNERoutePopupMenu | Class used in GUIGLObjectPopupMenu for routes |
CGNEVehicle::GNESelectedVehiclesPopupMenu | Class used in GUIGLObjectPopupMenu for single vehicle transformations |
CGNEVehicle::GNESingleVehiclePopupMenu | Class used in GUIGLObjectPopupMenu for single vehicle transformations |
CGUIBaseVehicle::GUIBaseVehiclePopupMenu | |
CGUICalibrator::GUICalibratorPopupMenu | |
CGUIContainer::GUIContainerPopupMenu | |
CGUILaneSpeedTrigger::GUILaneSpeedTriggerPopupMenu | |
CGUIPerson::GUIPersonPopupMenu | |
CGUITrafficLightLogicWrapper::GUITrafficLightLogicWrapperPopupMenu | |
CGUITriggeredRerouter::GUITriggeredRerouterPopupMenu | |
CGUIParam_PopupMenuInterface | A popup-menu for dynamic patameter table entries |
►CFXObject | |
►CFXEX::FXBaseObject | |
CFXEX::FXThreadEvent | |
CFXThreadMessageRetriever | |
►CFXSingleEventThread | |
CGNELoadThread | |
CGUILoadThread | |
CGUIRunThread | |
CGNESelectorFrame::LockGLObjectTypes::ObjectTypeEntry | Class for object types entries |
CFXSynchQue< T, Container > | |
CFXSynchQue< GUIEvent * > | |
CFXSynchQue< MSLane *, std::vector< MSLane * > > | |
CFXSynchQue< MSVehicle *, std::vector< MSVehicle * > > | |
CFXSynchQue< MSVehicleTransfer::VehicleInformation, std::vector< MSVehicleTransfer::VehicleInformation > > | |
►CFXTable | |
CMFXAddEditTypedTable | |
CMFXEditableTable | |
►CFXText | |
CGUIMessageWindow | A logging window for the gui |
►CFXThread | |
CFXSingleEventThread | |
CFXWorkerThread | A thread repeatingly calculating incoming tasks |
►CFXTopWindow | |
►CGNEAdditionalDialog | Dialog to edit sequences, parameters, etc.. of Additionals |
CGNECalibratorDialog | Dialog for edit calibrators |
CGNECalibratorFlowDialog | Dialog for edit rerouter intervals |
CGNERerouterDialog | Dialog for edit rerouters |
CGNERerouterIntervalDialog | Dialog for edit rerouter intervals |
CGNEVariableSpeedSignDialog | |
►CGNEDemandElementDialog | Dialog to edit sequences, parameters, etc.. of DemandElements |
CGNERouteDialog | Dialog for edit Calibrator Routes |
CGNEVehicleTypeDialog | Dialog for edit rerouter intervals |
►CFXUndoList | |
CGNEUndoList | |
►CFXVerticalFrame | |
►CGNEFrame | |
CGNEAdditionalFrame | |
CGNEConnectorFrame | |
CGNECreateEdgeFrame | |
CGNECrossingFrame | |
CGNEDeleteFrame | |
CGNEInspectorFrame | |
CGNEPersonFrame | |
CGNEPersonPlanFrame | |
CGNEPersonTypeFrame | |
CGNEPolygonFrame | |
CGNEProhibitionFrame | |
CGNERouteFrame | |
CGNESelectorFrame | |
CGNEStopFrame | |
CGNETAZFrame | |
CGNETLSEditorFrame | |
CGNEVehicleFrame | |
CGNEVehicleTypeFrame | |
CGNEVehicleTypeDialog::VTypeAtributes | Class for VClasses |
CFXWorkerThread::Pool | A pool of worker threads which distributes the tasks and collects the results |
CFXWorkerThread::Task | Abstract superclass of a task to be run with an index to keep track of pending tasks |
►CGenericEngineModel | |
CFirstOrderLagModel | |
CRealisticEngineModel | |
CGeoConvHelper | Static methods for processing the coordinates conversion for the current net |
CGeomConvHelper | |
CGeomHelper | Some static methods performing geometrical operations |
CGLHelper | Some methods which help to draw certain geometrical objects in openGL |
CGLObjectValuePassConnector< T > | Class passing values from a GUIGlObject to another object |
CGLObjectValuePassConnector< std::pair< SUMOTime, MSPhaseDefinition > > | |
CGNEAdditional::AdditionalMove | Struct for pack all variables related with additional move |
CGNEAdditional::BlockIcon | Struct for pack all variables and functions related with Block Icon |
CGNEAdditionalHandler::HierarchyInsertedAdditionals | Stack used to save the last inserted element |
CGNEApplicationWindow::EditMenuCommands | Struct for edit menu commands |
CGNEApplicationWindow::EditMenuCommands::DemandMenuCommands | Struct for Demand menu commands |
CGNEApplicationWindow::EditMenuCommands::NetworkMenuCommands | Struct for network menu commands |
CGNEApplicationWindow::FileMenuCommands | Struct for File menu commands |
CGNEApplicationWindow::LocateMenuCommands | Struct for locate menu commands |
CGNEApplicationWindow::MenuBarFile | Struct for menu bar file |
CGNEApplicationWindow::ProcessingMenuCommands | Struct for processing menu commands |
CGNEApplicationWindow::SupermodeCommands | Struct for supermode commands |
CGNEApplicationWindow::ToolbarsGrip | FOX-declaration |
CGNEApplicationWindow::WindowsMenuCommands | Struct for windows menu commands |
CGNEAttributeCarrier::AttributeProperties | Struct with the attribute Properties |
CGNEAttributeCarrier::TagProperties | Struct with the attribute Properties |
CGNEDeleteFrame::SubordinatedElements | Struct for saving subordinated elements (Junction->Edge->Lane->(Additional | DemandElement) |
CGNEDemandElement::DemandElementMove | Struct for pack all variables related with Demand Element moving |
CGNEDemandElement::RouteCalculator | Class used to calculate routes in nets |
CGNEdetector | |
CGNEFrameAttributesModuls | |
CGNEFrameModuls | |
CGNEGeometry | |
CGNEGeometry::Geometry | Struct for pack all variables related with geometry of stop |
CGNEGeometry::Lane2laneConnection | Lane2lane struct |
CGNEGeometry::ParentConnections | Struct for pack all variables and functions relative to connections between hierarchical element and their children |
CGNEGeometry::SegmentGeometry | Struct for pack all variables related with geometry of elemements divided in segments |
CGNEGeometry::SegmentGeometry::Segment | Struct used for represent segments of element geometry |
CGNEGeometry::SegmentGeometry::SegmentToUpdate | Struct used for represent segments that must be updated |
►CGNEHierarchicalChildElements | An special type of Attribute carrier that owns hierarchical elements |
►CGNEAdditional | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEAccess | |
CGNECalibrator | |
CGNECalibratorFlow | |
CGNEClosingLaneReroute | |
CGNEClosingReroute | |
CGNEDestProbReroute | |
►CGNEDetector | |
CGNEDetectorE1 | |
CGNEDetectorE1Instant | |
CGNEDetectorE2 | |
CGNEDetectorEntryExit | |
CGNEDetectorE3 | |
CGNEParkingAreaReroute | |
CGNEParkingSpace | Vehicle space used by GNEParkingAreas |
CGNERerouter | |
CGNERerouterInterval | |
CGNERouteProbe | Representation of a RouteProbe in netedit |
CGNERouteProbReroute | |
►CGNEStoppingPlace | |
CGNEBusStop | A lane area vehicles can halt at (netedit-version) |
CGNEChargingStation | |
CGNEContainerStop | A lane area vehicles can halt at (netedit-version) |
CGNEParkingArea | A lane area vehicles can park at (netedit-version) |
CGNETAZ | |
CGNETAZSourceSink | |
CGNEVaporizer | Representation of a vaporizer in netedit |
CGNEVariableSpeedSign | |
CGNEVariableSpeedSignStep | |
►CGNEDemandElement | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEPerson | |
CGNEPersonTrip | |
CGNERide | |
CGNERoute | |
CGNEStop | |
CGNEVehicle | |
CGNEVehicleType | |
CGNEWalk | |
►CGNENetElement | |
CGNEConnection | |
CGNECrossing | This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routeted to an internal dataTarget and to the editor (hence inheritance from FXDelegator) |
CGNEEdge | A road/street connecting two junctions (netedit-version) |
CGNEJunction | |
CGNELane | This lane is powered by an underlying GNEEdge and basically knows how to draw itself |
►CGNEShape | |
CGNEPOI | |
CGNEPoly | |
CGNEHierarchicalChildElements::ChildConnections | Struct for pack all variables and functions relative to connections between hierarchical element and their children |
CGNEHierarchicalChildElements::ChildConnections::ConnectionGeometry | Connection geometry |
►CGNEHierarchicalParentElements | An special type of Attribute carrier that owns hierarchical elements |
CGNEAdditional | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEDemandElement | An Element which don't belongs to GNENet but has influency in the simulation |
CGNENetElement | |
CGNEShape | |
CGNENet::AttributeCarriers | Struct used for saving all attribute carriers of net, in different formats |
CGNEParametersDialog::ParametersValues::ParameterRow | Class for parameters Row |
CGNEPerson::personPlanSegment | |
►CGNEReferenceCounter | |
►CGNEAttributeCarrier | |
CGNEAdditional | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEDemandElement | An Element which don't belongs to GNENet but has influency in the simulation |
CGNENetElement | |
CGNEShape | |
CGNERouteHandler::PersonPlansValues | Struct used for load person plans (Rides, Walks, etc.) |
CGNERouteHandler::RouteParameter | Struct for saving route parameters |
CGNETAZFrame::TAZCurrent::TAZEdge | Struct for edges and the source/sink colors |
CGNEViewNetHelper | |
CGNEViewNetHelper::CommonCheckableButtons | Struct used to group all variables related with common chekable Buttons |
CGNEViewNetHelper::CommonViewOptions | Struct used to group all variables related to view options in all supermodes |
CGNEViewNetHelper::DemandCheckableButtons | Struct used to group all variables related with Demand checkable Buttons |
CGNEViewNetHelper::DemandViewOptions | Struct used to group all variables related to view options in supermode Demand |
CGNEViewNetHelper::EditModes | Struct used to group all variables related with Supermodes |
CGNEViewNetHelper::EditShapes | Struct used to group all variables related with edit shapes of NetElements |
CGNEViewNetHelper::KeyPressed | Class used to group all variables related with key pressed after certain events |
CGNEViewNetHelper::MoveMultipleElementValues | Struct used to group all variables related with movement of groups of elements |
CGNEViewNetHelper::MoveSingleElementValues | Struct used to group all variables related with movement of single elements |
CGNEViewNetHelper::NetworkCheckableButtons | Struct used to group all variables related with Network chekable Buttons |
CGNEViewNetHelper::NetworkViewOptions | Struct used to group all variables related to view options in supermode Network |
CGNEViewNetHelper::ObjectsUnderCursor | Class used to group all variables related with objects under cursor after a click over view |
CGNEViewNetHelper::SelectingArea | Struct used to group all variables related with selecting using a square or polygon |
CGNEViewNetHelper::TestingMode | Struct used to group all variables related with testing |
CGNEViewNetHelper::VehicleOptions | Struct used to group all variables related with movement of groups of elements |
CGNEViewNetHelper::VehicleTypeOptions | Struct used to group all variables related with movement of groups of elements |
CGNEViewParent::ACChoosers | Struct for ACChoosers dialog |
CGNEViewParent::Frames | Struct for Frames |
►CGUI_RTREE_QUAL | |
CSUMORTree | A RT-tree for efficient storing of SUMO's GL-objects |
CGUIBasePersonHelper | A list of functions used for drawing persons in GUI |
CGUIBaseVehicleHelper | A MSVehicle extended by some values for usage within the gui |
CGUICompleteSchemeStorage | Storage for available visualization settings |
CGUICursorSubSys | |
CGUIDialog_ViewSettings::NamePanel | |
CGUIDialog_ViewSettings::SizePanel | |
CGUIE3Collector::MyWrapper::SingleCrossingDefinition | Representation of a single crossing point |
►CGUIEvent | |
CGNEEvent_NetworkLoaded | |
CGUIEvent_Message | |
CGUIEvent_SimulationEnded | Event sent when the the simulation is over |
CGUIEvent_SimulationLoaded | |
CGUIEvent_SimulationStep | |
CGUIGlobals | |
►CGUIGlObject | |
CGNEAdditional | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEDemandElement | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEInternalLane | This object is responsible for drawing a shape and for supplying a a popup menu. Messages are routeted to an internal dataTarget and to the editor (hence inheritance from FXDelegator) |
CGNENet | A NBNetBuilder extended by visualisation and editing capabilities |
CGNENetElement | |
►CGUIBaseVehicle | A MSVehicle extended by some values for usage within the gui |
CGUIMEVehicle | A MSVehicle extended by some values for usage within the gui |
CGUIVehicle | A MSVehicle extended by some values for usage within the gui |
CGUIContainer | |
CGUIEdge | A road/street connecting two junctions (gui-version) |
►CGUIGlObject_AbstractAdd | |
CGUIBusStop | A lane area vehicles can halt at (gui-version) |
CGUICalibrator | Changes the speed allowed on a set of lanes (gui version) |
CGUIChargingStation | A lane area vehicles can halt at (gui-version) |
CGUIContainerStop | A lane area vehicles can halt at (gui-version) |
►CGUIDetectorWrapper | |
CGUIE2Collector::MyWrapper | |
CGUIE3Collector::MyWrapper | |
CGUIInductLoop::MyWrapper | A MSInductLoop-visualiser |
CGUIInstantInductLoop::MyWrapper | A MSInductLoop-visualiser |
CGUIMEInductLoop::MyWrapper | |
CGUILaneSpeedTrigger | Changes the speed allowed on a set of lanes (gui version) |
CGUIParkingArea | A lane area vehicles can halt at (gui-version) |
►CGUIPointOfInterest | |
CGNEPOI | |
►CGUIPolygon | |
CGNEPoly | |
CGUITriggeredRerouter | Reroutes vehicles passing an edge One rerouter can be active on multiple edges. To reduce drawing load we instantiate GUIGlObjects for every edge XXX multiple rerouters active on the same edge are problematic |
CGUIJunctionWrapper | |
CGUILane | Representation of a lane in the micro simulation (gui-version) |
CGUINet | A MSNet extended by some values for usage within the gui |
CGUIPerson | |
CGUITrafficLightLogicWrapper | |
CGUITriggeredRerouter::GUITriggeredRerouterEdge | |
CGUIGlObjectStorage | A storage for of displayed objects via their numerical id |
CGUIIconSubSys | |
►CGUIParameterTableItemInterface | Interface to a single line in a parameter window |
CGUIParameterTableItem< T > | Instance of a single line in a parameter window |
►CGUIPerspectiveChanger | |
CGUIDanielPerspectiveChanger | |
CGUIPropertyScheme< T > | |
CGUIPropertySchemeStorage< T > | Base class for coloring. Allows changing the used colors and sets the used color in dependence to a value |
CGUIPropertySchemeStorage< GUIColorScheme > | |
CGUIPropertySchemeStorage< GUIScaleScheme > | |
CGUISelectedStorage | Storage for "selected" objects |
CGUISelectedStorage::SingleTypeSelections | A container for ids of selected objects of a certain type |
►CGUISelectedStorage::UpdateTarget | |
CGUIDialog_GLChosenEditor | Editor for the list of chosen objects |
CGUIShortcutsSubSys | |
CGUISUMOAbstractView::Decal | A decal (an image) that can be shown |
CGUITexturesHelper | Global storage for textures; manages and draws them |
CGUITextureSubSys | |
CGUIUserIO | Some OS-dependant functions to ease cliboard manipulation |
CGUIVideoEncoder | A simple video encoder from RGBA pics to anything ffmpeg can handle |
CGUIVisualizationColorSettings | Struct for color settings |
CGUIVisualizationDetailSettings | Struct for detail settings |
CGUIVisualizationSettings | Stores the information about how to visualize structures |
CGUIVisualizationSizeSettings | Struct for size settings |
CGUIVisualizationTextSettings | |
CGUIVisualizationWidthSettings | Struct for width settings |
CHelpersHarmonoise | Helper methods for Harmonoise-based noise emission computation |
CIDSupplier | |
CInductionLoop | C++ TraCI client API implementation |
CInstancePool< T > | A pool of resuable instances |
CIntermodalNetwork< E, L, N, V > | Intermodal network storing edges, connections and the mappings to the "real" edges |
CIntermodalRouter | |
CIntermodalRouter::TripItem | |
CIntermodalRouter< E, L, N, V > | |
CIntermodalTrip< E, N, V > | "vehicle" type that is given to the internal router (SUMOAbstractRouter) |
Cinvalid_return< X > | |
Cinvalid_return< bool > | |
Cinvalid_return< Boundary > | |
Cinvalid_return< double > | |
Cinvalid_return< int > | |
Cinvalid_return< long long int > | |
Cinvalid_return< PositionVector > | |
Cinvalid_return< RGBColor > | |
Cinvalid_return< std::string > | |
Cinvalid_return< std::vector< int > > | |
Cinvalid_return< std::vector< std::string > > | |
CJunction | C++ TraCI client API implementation |
CLane | C++ TraCI client API implementation |
CLaneArea | C++ TraCI client API implementation |
CLaneStoringVisitor | |
Clibsumo::Edge | |
Clibsumo::Helper | C++ TraCI client API implementation |
Clibsumo::Helper::LaneUtility | |
Clibsumo::InductionLoop | |
Clibsumo::Junction | |
Clibsumo::Lane | |
Clibsumo::LaneArea | |
Clibsumo::MultiEntryExit | |
Clibsumo::Person | |
Clibsumo::POI | |
Clibsumo::Polygon | |
Clibsumo::Route | |
Clibsumo::Simulation | |
Clibsumo::Subscription | Representation of a subscription |
Clibsumo::TraCIBestLanesData | |
Clibsumo::TraCIConnection | |
Clibsumo::TraCILink | |
Clibsumo::TraCILogic | |
Clibsumo::TraCINextStopData | |
Clibsumo::TraCINextTLSData | |
Clibsumo::TraCIPhase | |
►Clibsumo::TraCIResult | |
Clibsumo::TraCIColor | A color |
Clibsumo::TraCIDouble | |
Clibsumo::TraCIInt | |
Clibsumo::TraCIPosition | A 3D-position |
Clibsumo::TraCIRoadPosition | An edgeId, position and laneIndex |
Clibsumo::TraCIString | |
Clibsumo::TraCIStringList | |
Clibsumo::TraCIStage | |
Clibsumo::TraCIVehicleData | Mirrors MSInductLoop::VehicleData |
Clibsumo::TrafficLight | |
►Clibsumo::VariableWrapper | |
Clibsumo::Helper::SubscriptionWrapper | |
CTraCIServer | TraCI server used to control sumo by a remote TraCI client |
Clibsumo::Vehicle | |
Clibsumo::VehicleType | |
►CLineHandler | Interface definition for a class which retrieves lines from a LineHandler |
CNIImporter_DlrNavteq::ConnectedLanesHandler | Imports prohibitions regarding connectivity |
CNIImporter_DlrNavteq::EdgesHandler | Importer of edges stored in unsplit elmar format |
CNIImporter_DlrNavteq::NamesHandler | Importer of street names in DLRNavteq's (aka elmar) format |
CNIImporter_DlrNavteq::NodesHandler | Importer of nodes stored in unsplit elmar format |
CNIImporter_DlrNavteq::ProhibitionHandler | Imports prohibitions regarding connectivity |
CNIImporter_DlrNavteq::TimeRestrictionsHandler | Importer of street names in DLRNavteq's (aka elmar) format |
CNIImporter_DlrNavteq::TrafficlightsHandler | Importer of traffic lights stored in DLRNavteq's (aka elmar) format |
CLineReader | Retrieves a file linewise and reports the lines to a handler |
CMELoop | The main mesocopic simulation loop |
CMFXAddEditTypedTable::EditedTableItem | |
CMFXAddEditTypedTable::NumberCellParams | |
CMFXEditedTableItem | |
CMFXImageHelper | |
►CMFXInterThreadEventClient | |
CGNEApplicationWindow | The main window of the Netedit |
CGUIApplicationWindow | The main window of the SUMO-gui |
CMFXUtils | Some helper functions for FOX |
►CMSAbstractLaneChangeModel | Interface for lane-change models |
CMSLCM_DK2008 | A lane change model developed by D. Krajzewicz between 2004 and 2010 |
CMSLCM_LC2013 | A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013 |
CMSLCM_SL2015 | A lane change model developed by J. Erdmann |
CMSAbstractLaneChangeModel::MSLCMessager | A class responsible for exchanging messages between cars involved in lane-change interaction |
CMSAbstractLaneChangeModel::StateAndDist | |
CMSActuatedTrafficLightLogic::InductLoopInfo | |
CMSAmitranTrajectories | Realises dumping the complete network state |
CMSBatteryExport | Realises dumping Battery Data |
CMSCalibrator::AspiredState | |
►CMSCFModel | The car-following model abstraction |
CMSCFModel_ACC | The ACC car-following model |
CMSCFModel_CACC | The CACC car-following model |
CMSCFModel_CC | A set of automatic Cruise Controllers, including classic Cruise Control (CC), Adaptive Cruise Control (ACC) and Cooperative Adaptive Cruise Control (CACC). Take as references the chapters 5, 6 and 7 of the Rajamani's book "Vehicle dynamics and control" (2011). This model is meant to be used for simulation of platooning systems in mixed scenarios, so with automatic and driver controlled vehicles. The platooning manager is a distributed application implemented for veins (so for omnet++) supported by a 802.11p based communication protocol, which will determine the actions to be performed (such as switching on the automatic controller, or the lane to move to) and communicate them to this car following models via TraCI |
CMSCFModel_Daniel1 | The original Krauss (1998) car-following model and parameter |
CMSCFModel_IDM | The Intelligent Driver Model (IDM) car-following model |
CMSCFModel_Kerner | Car-following model by B. Kerner |
►CMSCFModel_KraussOrig1 | The original Krauss (1998) car-following model and parameter |
►CMSCFModel_Krauss | Krauss car-following model, with acceleration decrease and faster start |
CMSCFModel_KraussPS | Krauss car-following model, changing accel and speed by slope |
CMSCFModel_KraussX | Krauss car-following model, changing accel and speed by slope |
CMSCFModel_PWag2009 | Scalable model based on Krauss by Peter Wagner |
CMSCFModel_Rail | |
CMSCFModel_SmartSK | The original Krauss (1998) car-following model and parameter |
CMSCFModel_W99 | The W99 Model car-following model |
CMSCFModel_Wiedemann | The Wiedemann Model car-following model |
►CMSCFModel::VehicleVariables | |
CCC_VehicleVariables | |
CMSCFModel_ACC::ACCVehicleVariables | |
CMSCFModel_CACC::CACCVehicleVariables | |
CMSCFModel_IDM::VehicleVariables | |
CMSCFModel_Kerner::VehicleVariables | |
CMSCFModel_PWag2009::VehicleVariables | |
CMSCFModel_SmartSK::SSKVehicleVariables | |
CMSCFModel_Wiedemann::VehicleVariables | |
CMSCFModel_Rail::TrainParams | |
CMSChargingStation::charge | Struct to save information for the cahrgingStation output |
CMSCModel_NonInteracting | The container following model for tranship |
CMSCrossSection | A simple description of a position on a lane (crossing of a lane) |
CMSDetectorControl | Detectors container; responsible for string and output generation |
CMSDevice_BTreceiver::MeetingPoint | Holds the information about exact positions/speeds/time of the begin/end of a meeting |
CMSDevice_BTreceiver::SeenDevice | Class representing a single seen device |
CMSDevice_BTsender::VehicleState | A single movement state of the vehicle |
CMSDevice_SSM::Encounter | An encounter is an episode involving two vehicles, which are closer to each other than some specified distance |
CMSDevice_SSM::Encounter::compare | Compares encounters regarding to their start time |
CMSDevice_SSM::Encounter::ConflictPointInfo | ConflictPointInfo stores some information on a specific conflict point (used to store information on ssm-extremal values) |
CMSDevice_SSM::Encounter::Trajectory | A trajectory encloses a series of positions x and speeds v for one vehicle (the times are stored only once in the enclosing encounter) |
CMSDevice_SSM::EncounterApproachInfo | Structure to collect some info on the encounter needed during ssm calculation by various functions |
CMSDevice_SSM::FoeInfo | |
CMSDevice_SSM::UpstreamScanStartInfo | Auxiliary structure used to handle upstream scanning start points Upstream scan has to be started after downstream scan is completed, see #5644 |
CMSDevice_ToC::OpenGapParams | |
CMSDevice_Vehroutes::RouteReplaceInfo | Information about a replaced route |
CMSDriverState | ** |
CMSE2Collector::JamInfo | Internal representation of a jam |
CMSE2Collector::MoveNotificationInfo | Values collected in notifyMove and needed in detectorUpdate() to calculate the accumulated quantities for the detector. These are temporarily stored in myMoveNotifications for each step |
CMSE2Collector::VehicleInfo | A VehicleInfo stores values that are tracked for the individual vehicles on the detector, e.g., accumulated timeloss. These infos are stored in myVehicles. If a vehicle leaves the detector (may it be temporarily), the entry in myVehicles is discarded, i.e. all information on the vehicle is reset |
CMSE3Collector::E3Values | Internal storage for values from a vehicle |
CMSEdge::by_id_sorter | Sorts edges by their ids |
CMSEdge::transportable_by_position_sorter | Sorts transportables by their positions |
CMSEdgeControl | Stores edges and lanes, performs moving of vehicle |
CMSEdgeControl::LaneUsage | A structure holding some basic information about a simulated lane |
CMSEdgeWeightsStorage | A storage for edge travel times and efforts |
CMSEmissionExport | Realises dumping Emission Data |
►CMSEventControl | Stores time-dependant events and executes them at the proper time |
CGUIEventControl | Stores time-dependant events and executes them at the proper time (guisim) |
CMSEventControl::EventSortCrit | Sort-criterion for events |
CMSFCDExport | Realises dumping FCD Data |
CMSFrame | Sets and checks options for microsim; inits global outputs and settings |
CMSFullExport | Dumping a hugh List of Parameters available in the Simulation |
►CMsgHandler | |
CMsgHandlerSynchronized | |
CMSGlobals | |
CMSInductLoop::VehicleData | Struct to store the data of the counted vehicle internally |
CMSInsertionControl | Inserts vehicles into the network when their departure time is reached |
CMSInsertionControl::Flow | Definition of vehicle flow with the current index for vehicle numbering |
►CMSJunctionLogic | |
CMSBitSetLogic< N > | |
CMSLane::AnyVehicleIterator | AnyVehicleIterator is a structure, which manages the iteration through all vehicles on the lane, that may be of importance for the car-following dynamics along that lane. The relevant types of vehicles are: 1) vehicles with their front on the lane (myVehicles), 2) vehicles intersecting the lane but with front on another lane (myPartialVehicles) |
CMSLane::by_connections_to_sorter | Sorts edges by their angle relative to the given edge (straight comes first) |
CMSLane::edge_finder | |
CMSLane::incoming_lane_priority_sorter | Sorts lanes (IncomingLaneInfos) by their priority or, if this doesn't apply, wrt. the angle difference magnitude relative to the target lane's angle (straight comes first) |
CMSLane::IncomingLaneInfo | |
CMSLane::outgoing_lane_priority_sorter | Sorts lanes (their origin link) by the priority of their noninternal target edges or, if this doesn't yield an unambiguous result, wrt. the angle difference magnitude relative to the target lane's angle (straight comes first) |
CMSLane::vehicle_natural_position_sorter | |
CMSLane::vehicle_position_sorter | Sorts vehicles by their position (descending) |
►CMSLaneChanger | Performs lane changing of vehicles |
CMSLaneChangerSublane | Performs lane changing of vehicles |
CMSLaneChanger::ChangeElem | |
►CMSLeaderInfo | |
►CMSLeaderDistanceInfo | Saves leader/follower vehicles and their distances relative to an ego vehicle |
CMSCriticalFollowerDistanceInfo | |
CMSLink | |
CMSLink::ApproachingVehicleInformation | A structure holding the information about vehicles approaching a link |
CMSLink::LinkLeader | |
CMSLinkCont | |
CMSLinkContHelper | |
CMSLinks | A connnection between lanes |
CMSMeanData::MeanDataValueTracker::TrackerEntry | |
►CMSMoveReminder | Something on a lane to be noticed about vehicle movement |
CMSCalibrator::VehicleRemover | |
►CMSE2Collector | An areal detector corresponding to a sequence of consecutive lanes |
CGUIE2Collector | The gui-version of the MSE2Collector |
CMSE3Collector::MSE3EntryReminder | A place on the road net (at a certain lane and position on it) where the E3 area begins |
CMSE3Collector::MSE3LeaveReminder | A place on the road net (at a certain lane and position on it) where the E3 area ends |
►CMSInductLoop | An unextended detector measuring at a fixed position on a fixed lane |
CGUIInductLoop | The gui-version of the MSInductLoop |
►CMSInstantInductLoop | An instantaneous induction loop |
CGUIInstantInductLoop | The gui-version of the MSInstantInductLoop |
►CMSMeanData::MeanDataValues | Data structure for mean (aggregated) edge/lane values |
CMSMeanData::MeanDataValueTracker | Data structure for mean (aggregated) edge/lane values for tracked vehicles |
CMSMeanData_Amitran::MSLaneMeanDataValues | Data structure for mean (aggregated) edge/lane values |
CMSMeanData_Emissions::MSLaneMeanDataValues | Data structure for mean (aggregated) edge/lane values |
CMSMeanData_Harmonoise::MSLaneMeanDataValues | Data structure for mean (aggregated) edge/lane values |
CMSMeanData_Net::MSLaneMeanDataValues | Data structure for mean (aggregated) edge/lane values |
CMSRouteProbe | Writes routes of vehicles passing a certain edge |
►CMSTriggeredRerouter | Reroutes vehicles passing an edge |
CGUITriggeredRerouter | Reroutes vehicles passing an edge One rerouter can be active on multiple edges. To reduce drawing load we instantiate GUIGlObjects for every edge XXX multiple rerouters active on the same edge are problematic |
►CMSVehicleDevice | Abstract in-vehicle device |
CMSDevice_Battery | Battery device for electric vehicles |
CMSDevice_Bluelight | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSDevice_BTreceiver | A BT receiver |
CMSDevice_BTsender | A BT sender |
CMSDevice_DriverState | The ToC Device controls transition of control between automated and manual driving |
CMSDevice_Emissions | A device which collects vehicular emissions |
CMSDevice_Example | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSDevice_FCD | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSDevice_Routing | A device that performs vehicle rerouting based on current edge speeds |
CMSDevice_SSM | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSDevice_ToC | The ToC Device controls transition of control between automated and manual driving |
CMSDevice_Transportable | |
CMSDevice_Tripinfo | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSDevice_Vehroutes | A device which collects info on the vehicle trip (mainly on departure and arrival) |
►CMSNet | The simulated network and simulation perfomer |
CGUINet | A MSNet extended by some values for usage within the gui |
►CMSNet::VehicleStateListener | Interface for objects listening to vehicle state changes |
Clibsumo::Helper::VehicleStateListener | |
CMSDevice_Vehroutes::StateListener | A class that is notified about reroutings |
CMSDynamicShapeUpdater | |
CMSVehicle::Influencer::GapControlVehStateListener | A static instance of this class in GapControlState deactivates gap control for vehicles whose reference vehicle is removed from the road network |
CTraCIServer | TraCI server used to control sumo by a remote TraCI client |
CMSParkingArea::LotSpaceDefinition | Representation of a single lot space |
CMSPerson::Influencer | Changes the wished person speed and position |
CMSPerson::MSPersonStage_Walking::arrival_finder | |
CMSPhaseDefinition | The definition of a single phase of a tls logic |
►CMSPModel | The pedestrian following model |
CMSPModel_NonInteracting | The pedestrian following model |
CMSPModel_Remote | |
CMSPModel_Striping | The pedestrian following model |
CMSPModel_Striping::by_xpos_sorter | Sorts the persons by position on the lane. If dir is forward, higher x positions come first |
CMSPModel_Striping::lane_by_numid_sorter | |
CMSPModel_Striping::NextLaneInfo | |
CMSPModel_Striping::Obstacle | Information regarding surround Pedestrians (and potentially other things) |
CMSPModel_Striping::walkingarea_path_sorter | |
CMSPModel_Striping::WalkingAreaPath | |
►CMSPushButton | |
CMSPedestrianPushButton | |
CMSQueueExport | Export the queueing length in front of a junction (very experimental!) |
CMSRailSignal::DriveWay | |
CMSRailSignal::LinkInfo | |
CMSRoutingEngine | A device that performs vehicle rerouting based on current edge speeds |
CMSSimpleDriverState | Provides an interface to an error whose fluctuation is controlled via the driver's 'awareness', which can be controlled externally, |
CMSSOTLPolicy5DListStimulus | This class determines the stimulus of a MSSOTLPolicy when used in combination with a high level policy.
The stimulus function is calculated as follows:
stimulus = cox * exp(-pow(pheroIn - offsetIn, 2)/divisor -pow(pheroOut - offsetOut, 2)/divisor) |
CMSSOTLPolicyStimulus | This class determines the stimulus of a MSSOTLPolicy when used in combination with a high level policy.
The stimulus function is calculated as follows:
stimulus = cox * exp(-pow(pheroIn - offsetIn, 2)/divisor -pow(pheroOut - offsetOut, 2)/divisor) |
►CMSSOTLSensors | |
CMSSOTLE2Sensors | |
CMSStopOut | Realises dumping the complete network state |
CMSStopOut::StopInfo | |
CMSTLLogicControl | A class that stores and controls tls and switching of their programs |
►CMSTLLogicControl::OnSwitchAction | Base class for things to execute if a tls switches to a new phase |
►CCommand_SaveTLCoupledDet | Writes e2 state on each tls switch |
CCommand_SaveTLCoupledLaneDet | Writes e2 state of a link for the time the link has yellow/red |
CMSTLLogicControl::TLSLogicVariants | Storage for all programs of a single tls |
CMSTLLogicControl::WAUT | A WAUT definition |
CMSTLLogicControl::WAUTJunction | Storage for a junction assigned to a WAUT |
CMSTLLogicControl::WAUTSwitch | Storage for a WAUTs switch point |
►CMSTLLogicControl::WAUTSwitchProcedure | This is the abstract base class for switching from one tls program to another |
CMSTLLogicControl::WAUTSwitchProcedure_GSP | This class switches using the GSP algorithm |
CMSTLLogicControl::WAUTSwitchProcedure_JustSwitch | This class simply switches to the next program |
CMSTLLogicControl::WAUTSwitchProcedure_Stretch | This class switches using the Stretch algorithm |
CMSTLLogicControl::WAUTSwitchProcedure_Stretch::StretchBereichDef | A definition of a stretch - Bereich |
CMSTLLogicControl::WAUTSwitchProcess | An initialised switch process |
►CMSTransportable::Stage | |
CMSContainer::MSContainerStage_Tranship | |
CMSPerson::MSPersonStage_Access | |
CMSPerson::MSPersonStage_Walking | |
►CMSTransportable::Stage_Driving | |
CMSContainer::MSContainerStage_Driving | |
CMSPerson::MSPersonStage_Driving | |
CMSTransportable::Stage_Trip | |
CMSTransportable::Stage_Waiting | |
►CMSTransportableControl | |
CGUITransportableControl | GUI-version of the transportable control for building gui persons and containers |
CMSTriggeredRerouter::RerouteInterval | |
CMSVehicle::DriveProcessItem | Drive process items represent bounds on the safe velocity corresponding to the upcoming links |
CMSVehicle::Influencer | Changes the wished vehicle speed / lanes |
CMSVehicle::Influencer::GapControlState | Container for state and parameters of the gap control |
CMSVehicle::LaneQ | A structure representing the best lanes for continuing the current route starting at 'lane' |
CMSVehicle::Manoeuvre | Container for manouevering time associated with stopping |
CMSVehicle::State | Container that holds the vehicles driving state (position+speed) |
CMSVehicle::Stop | Definition of vehicle stop (position and duration) |
CMSVehicle::WaitingTimeCollector | Stores the waiting intervals over the previous seconds (memory is to be specified in ms.) |
CMSVehicleContainer | |
CMSVehicleContainer::DepartFinder | Searches for the VehicleDepartureVector with the wished depart |
CMSVehicleContainer::VehicleDepartureVectorSortCrit | Sort-criterion for vehicle departure lists |
►CMSVehicleControl | The class responsible for building and deletion of vehicles |
CGUIVehicleControl | The class responsible for building and deletion of vehicles (gui-version) |
►CMEVehicleControl | The class responsible for building and deletion of vehicles (gui-version) |
CGUIMEVehicleControl | The class responsible for building and deletion of vehicles (gui-version) |
CMSVehicleTransfer | |
CMSVehicleTransfer::VehicleInformation | Holds the information needed to move the vehicle over the network |
CMSVehicleType | The car-following model and parameter |
CMSVTKExport | Produce a VTK output to use with Tools like ParaView |
CMSXMLRawOut | Realises dumping the complete network state |
CMultiEntryExit | C++ TraCI client API implementation |
►CNamed | Base class for objects which have an id |
►CDistribution | |
CDistribution_Parameterized | |
CDistribution_Points | |
►CIntermodalEdge< E, L, N, V > | Base edge type that is given to the internal router (SUMOAbstractRouter) |
CAccessEdge< E, L, N, V > | Access edge connecting different modes that is given to the internal router (SUMOAbstractRouter) |
CCarEdge< E, L, N, V > | Car edge type that is given to the internal router (SUMOAbstractRouter) |
CPedestrianEdge< E, L, N, V > | Pedestrian edge type that is given to the internal router (SUMOAbstractRouter) |
CPublicTransportEdge< E, L, N, V > | Public transport edge type connecting the stop edges |
CStopEdge< E, L, N, V > | Stop edge type representing bus and train stops |
CMESegment | A single mesoscopic segment (cell) |
►CMSDetectorFileOutput | Base of value-generating classes (detectors) |
►CMEInductLoop | An induction loop for mesoscopic simulation |
CGUIMEInductLoop | |
CMSCalibrator | Calibrates the flow on a segment to a specified one |
CMSE2Collector | An areal detector corresponding to a sequence of consecutive lanes |
►CMSE3Collector | A detector of vehicles passing an area between entry/exit points |
CGUIE3Collector | The gui-version of the MSE3Collector |
CMSInductLoop | An unextended detector measuring at a fixed position on a fixed lane |
CMSInstantInductLoop | An instantaneous induction loop |
►CMSMeanData | Data collector for edges/lanes |
CMSMeanData_Amitran | Network state mean data collector for edges/lanes |
CMSMeanData_Emissions | Emission data collector for edges/lanes |
CMSMeanData_Harmonoise | Noise data collector for edges/lanes |
CMSMeanData_Net | Network state mean data collector for edges/lanes |
CMSRouteProbe | Writes routes of vehicles passing a certain edge |
►CMSDevice | Abstract in-vehicle / in-person device |
►CMSTransportableDevice | Abstract in-person device |
CMSTransportableDevice_FCD | A device which collects info on the vehicle trip (mainly on departure and arrival) |
CMSTransportableDevice_Routing | A device that performs person rerouting based on current edge speeds |
CMSVehicleDevice | Abstract in-vehicle device |
►CMSDevice_BTsender::VehicleInformation | Stores the information of a vehicle |
CMSDevice_BTreceiver::VehicleInformation | Stores the information of a vehicle |
►CMSEdge | A road/street connecting two junctions |
CGUIEdge | A road/street connecting two junctions (gui-version) |
►CMSJunction | The base class for an intersection |
►CMSLogicJunction | |
CMSInternalJunction | |
CMSRightOfWayJunction | A junction with right-of-way - rules |
CMSNoLogicJunction | |
►CMSLane | Representation of a lane in the micro simulation |
CGUILane | Representation of a lane in the micro simulation (gui-version) |
CMSRoute | |
►CMSStoppingPlace | A lane area vehicles can halt at |
CGUIBusStop | A lane area vehicles can halt at (gui-version) |
CGUIContainerStop | A lane area vehicles can halt at (gui-version) |
►CMSChargingStation | |
CGUIChargingStation | A lane area vehicles can halt at (gui-version) |
►CMSParkingArea | A lane area vehicles can halt at |
CGUIParkingArea | A lane area vehicles can halt at (gui-version) |
►CMSTrafficLightLogic | The parent class for traffic light logics |
CMSOffTrafficLightLogic | A traffic lights logic which represents a tls in an off-mode |
►CMSPhasedTrafficLightLogic | A fixed traffic light logic |
►CMSSOTLTrafficLightLogic | A self-organizing traffic light logic |
►CMSSOTLHiLevelTrafficLightLogic | A self-organizing high-level traffic light logic |
CMSDeterministicHiLevelTrafficLightLogic | |
CMSSwarmTrafficLightLogic | |
CMSSOTLPhaseTrafficLightLogic | |
CMSSOTLPolicyBasedTrafficLightLogic | A self-organizing traffic light logic based on a particular policy |
CMSSOTLWaveTrafficLightLogic | |
CMSRailSignal | A signal for rails |
►CMSSimpleTrafficLightLogic | A fixed traffic light logic |
CMSActuatedTrafficLightLogic | An actuated (adaptive) traffic light logic |
CMSDelayBasedTrafficLightLogic | An actuated traffic light logic based on time delay of approaching vehicles |
CMSRailCrossing | A signal for rails |
►CMSTrigger | An abstract device that changes the state of the micro simulation |
CMSCalibrator | Calibrates the flow on a segment to a specified one |
CMSLaneSpeedTrigger | Changes the speed allowed on a set of lanes |
CMSTriggeredRerouter | Reroutes vehicles passing an edge |
CMSVTypeProbe | Writes positions of vehicles that have a certain (named) type |
CNBDistrict | A class representing a single district |
CNBEdge | The representation of a single edge during network building |
CNBLoadedTLDef::SignalGroup | A single signal group, may control several connections |
CNBNode | Represents a single node (junction) during network building |
CNBParking | The representation of a single pt stop |
►CNBTrafficLightDefinition | The base class for traffic light logic definitions |
CNBLoadedSUMOTLDef | A loaded (complete) traffic light logic |
CNBLoadedTLDef | A loaded (complete) traffic light logic |
CNBOwnTLDef | A traffic light logics which must be computed (only nodes/edges are given) |
CNBTrafficLightLogic | A SUMO-compliant built logic for a traffic light |
CNGEdge | A netgen-representation of an edge |
CNGNode | A netgen-representation of a node |
CODDistrict | A district (origin/destination) |
CRODFDetector | Class representing a detector within the DFROUTER |
►CROEdge | A basic edge for routing applications |
CAGStreet | A model of the street in the city |
CRODFEdge | |
CROJTREdge | An edge the jtr-router may route through |
CROMAEdge | A basic edge for routing applications |
CROLane | A single lane the router may use |
CRONode | Base class for nodes used by the router |
CRORoute | A complete router's route |
CRORouteDef | Base class for a vehicle's route definition |
►CShape | A 2D- or 3D-Shape |
►CPointOfInterest | A point-of-interest |
CGUIPointOfInterest | |
►CSUMOPolygon | |
CGUIPolygon | |
CNamed::StoringVisitor | Allows to store the object; used as context while traveling the rtree in TraCI |
►CNAMED_RTREE_QUAL | |
CNamedRTree | A RT-tree for efficient storing of SUMO's Named objects |
CNamedColumnsParser | A parser to retrieve information from a table with known columns |
CNamedObjectCont< T > | A map of named object pointers |
CNamedObjectCont< MSDetectorFileOutput * > | |
►CNamedObjectCont< MSJunction * > | |
CMSJunctionControl | Container for junctions; performs operations on all stored junctions |
►CNamedObjectCont< ODDistrict * > | |
CODDistrictCont | A container for districts |
CNamedObjectCont< PointOfInterest * > | |
CNamedObjectCont< ROEdge * > | |
CNamedObjectCont< RONode * > | |
CNamedObjectCont< RORouteDef * > | |
CNamedObjectCont< SUMOPolygon * > | |
CNamedObjectCont< SUMOVehicleParameter * > | |
CNamedObjectCont< SUMOVTypeParameter * > | |
CNBCapacity2Lanes | A helper class which computes the lane number from given capacity |
CNBConnection | |
CNBContHelper | |
CNBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter | |
CNBContHelper::edge_by_priority_sorter | |
CNBContHelper::edge_opposite_direction_sorter | Class to sort edges by their angle in relation to the given edge |
CNBContHelper::edge_similar_direction_sorter | |
CNBContHelper::edge_with_destination_finder | |
CNBContHelper::node_with_incoming_finder | |
CNBContHelper::node_with_outgoing_finder | |
CNBContHelper::opposite_finder | |
CNBContHelper::relative_incoming_edge_sorter | |
CNBContHelper::relative_outgoing_edge_sorter | |
CNBContHelper::same_connection_edge_sorter | |
CNBDistrictCont | A container for districts |
CNBEdge::connections_conflict_finder | |
CNBEdge::connections_finder | |
CNBEdge::connections_fromlane_finder | |
CNBEdge::connections_relative_edgelane_sorter | Class to sort edges by their angle |
CNBEdge::connections_toedge_finder | |
CNBEdge::connections_toedgelane_finder | |
CNBEdge::MainDirections | Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drives on this street may take on the junction the edge ends in The back direction is not regarded |
CNBEdgeCont | Storage for edges, including some functionality operating on multiple edges |
CNBEdgeCont::PostProcessConnection | A structure representing a connection between two lanes |
CNBEdgeCont::Split | A structure which describes changes of lane number or speed along the road |
CNBEdgeCont::split_sorter | Sorts splits by their position (increasing) |
CNBEdgePriorityComputer | |
CNBFrame | Sets and checks options for netbuild |
CNBHeightMapper | Set z-values for all network positions based on data from a height map |
CNBHeightMapper::QueryResult | Class for cirumventing the const-restriction of RTree::Search-context |
CNBHeightMapper::Triangle | |
CNBHelpers | |
CNBLinkPossibilityMatrix | |
CNBLoadedSUMOTLDef::connection_equal | Class for identifying connections |
CNBLoadedTLDef::SignalGroup::phase_by_time_sorter | Sorts phases by their begin time |
CNBLoadedTLDef::SignalGroup::PhaseDef | Definition of a single, loaded phase |
CNBNetBuilder | Instance responsible for building networks |
CNBNetBuilder::by_id_sorter | Sorts nodes by their ids |
CNBNode::edge_by_direction_sorter | Sorts outgoing before incoming edges |
CNBNode::nodes_by_id_sorter | Used for sorting the cells by the begin time they describe |
CNBNode::WalkingArea | A definition of a pedestrian walking area |
CNBNode::WalkingAreaCustomShape | |
CNBNodeCont | Container for nodes during the netbuilding process |
CNBNodesEdgesSorter | |
CNBNodesEdgesSorter::crossing_by_junction_angle_sorter | Sorts crossings by minimum clockwise clockwise edge angle. Use the ordering found in myAllEdges of the given node |
CNBNodesEdgesSorter::edge_by_junction_angle_sorter | Sorts incoming and outgoing edges clockwise around the given node |
CNBNodeShapeComputer | This class computes shapes of junctions |
CNBNodeTypeComputer | |
CNBOwnTLDef::edge_by_incoming_priority_sorter | Sorts edges by their priority within the node they end at |
CNBPTLine | |
CNBPTLineCont | |
CNBPTPlatform | |
CNBPTStop | The representation of a single pt stop |
CNBPTStopCont | |
CNBRailwayTopologyAnalyzer | |
CNBRailwayTopologyAnalyzer::Track | Routing edge |
CNBRampsComputer | |
CNBRequest | |
►CNBRouterEdge | Superclass for NBEdge and NBEdge::Connection to initialize Router |
CNBEdge | The representation of a single edge during network building |
CNBEdge::Connection | A structure which describes a connection between edges or lanes |
CNBShapeHandler | The XML-Handler for shapes loading network loading |
CNBSign | A class representing a single street sign |
CNBTrafficLightDefinition::StreamPair | Data structure for caching needsCont information |
CNBTrafficLightLogic::PhaseDefinition | The definition of a single phase of the logic |
CNBTrafficLightLogicCont | A container for traffic light definitions and built programs |
CNBTurningDirectionsComputer | |
CNBTurningDirectionsComputer::Combination | Stores the information about the angle between an incoming ("from") and an outgoing ("to") edge |
CNBTurningDirectionsComputer::combination_by_angle_sorter | Sorts "Combination"s by decreasing angle |
CNBTypeCont | A storage for available types of edges |
CNBTypeCont::TypeDefinition | |
CNBVehicle | A vehicle as used by router |
CNGFrame | Sets and checks options for netgen |
CNGNet | The class storing the generated network |
CNGRandomNetBuilder | A class that builds random network using an algorithm by Markus Hartinger |
CNIFrame | Sets and checks options for netimport |
CNIImporter_ArcView | Importer for networks stored in ArcView-shape format |
CNIImporter_DlrNavteq | Importer for networks stored in Elmar's format |
CNIImporter_ITSUMO | Importer for networks stored in ITSUMO format |
CNIImporter_ITSUMO::Handler::Lane | |
CNIImporter_ITSUMO::Handler::LaneSet | |
CNIImporter_ITSUMO::Handler::Section | |
CNIImporter_MATSim | Importer for networks stored in MATSim format |
CNIImporter_OpenDrive::Connection | A connection between two roads |
CNIImporter_OpenDrive::OpenDriveEdge | Representation of an openDrive "link" |
CNIImporter_OpenDrive::OpenDriveGeometry | Representation of an OpenDrive geometry part |
CNIImporter_OpenDrive::OpenDriveLane | Representation of a lane |
CNIImporter_OpenDrive::OpenDriveLaneSection | Representation of a lane section |
CNIImporter_OpenDrive::OpenDriveLink | Representation of an OpenDrive link |
CNIImporter_OpenDrive::OpenDriveObject | |
CNIImporter_OpenDrive::OpenDriveSignal | Representation of a signal |
CNIImporter_OpenDrive::Poly3 | |
CNIImporter_OpenDrive::same_position_finder | |
CNIImporter_OpenDrive::sections_by_s_sorter | A class for sorting lane sections by their s-value |
CNIImporter_OpenStreetMap | Importer for networks stored in OpenStreetMap format |
CNIImporter_OpenStreetMap::CompareEdges | Functor which compares two Edges |
CNIImporter_OpenStreetMap::CompareNodes | Functor which compares two NIOSMNodes according to their coordinates |
CNIImporter_OpenStreetMap::NIOSMNode | An internal representation of an OSM-node |
CNIImporter_OpenStreetMap::RelationHandler::NIIPTPlatform | |
CNIImporter_RobocupRescue | Importer for networks stored in robocup rescue league format |
CNIImporter_SUMO::Crossing | Describes a pedestrian crossing |
CNIImporter_SUMO::JunctionAttrs | Describes the values found in a junction |
CNIImporter_SUMO::Prohibition | Describes the values found in a prohibition |
CNIImporter_SUMO::WalkingAreaParsedCustomShape | Describes custom shape for a walking area during parsing |
CNIImporter_Vissim | Importer for networks stored in Vissim format |
►CNIImporter_Vissim::VissimSingleTypeParser | |
CNIVissimSingleTypeParser__XKurvedefinition | |
CNIVissimSingleTypeParser__XVerteilungsdefinition | |
CNIVissimSingleTypeParser_Auswertungsdefinition | |
CNIVissimSingleTypeParser_Detektordefinition | |
CNIVissimSingleTypeParser_DynUml | |
CNIVissimSingleTypeParser_Einheitendefinition | |
CNIVissimSingleTypeParser_Emission | |
CNIVissimSingleTypeParser_Fahrtverlaufdateien | |
CNIVissimSingleTypeParser_Fahrverhaltendefinition | |
CNIVissimSingleTypeParser_Fahrzeugklassendefinition | |
CNIVissimSingleTypeParser_Fahrzeugtypdefinition | |
CNIVissimSingleTypeParser_Fensterdefinition | |
CNIVissimSingleTypeParser_Gefahrwarnungsdefinition | |
CNIVissimSingleTypeParser_Gelbverhaltendefinition | |
CNIVissimSingleTypeParser_Geschwindigkeitsverteilungsdefinition | |
CNIVissimSingleTypeParser_Haltestellendefinition | |
CNIVissimSingleTypeParser_Kantensperrung | |
CNIVissimSingleTypeParser_Kennungszeile | |
CNIVissimSingleTypeParser_Knotendefinition | |
CNIVissimSingleTypeParser_Laengenverteilungsdefinition | |
CNIVissimSingleTypeParser_Langsamfahrbereichdefinition | |
CNIVissimSingleTypeParser_Lichtsignalanlagendefinition | |
CNIVissimSingleTypeParser_Liniendefinition | |
CNIVissimSingleTypeParser_Linksverkehr | |
CNIVissimSingleTypeParser_LSAKopplungsdefinition | |
CNIVissimSingleTypeParser_Messungsdefinition | |
CNIVissimSingleTypeParser_Netzobjektdefinition | |
CNIVissimSingleTypeParser_Parkplatzdefinition | |
CNIVissimSingleTypeParser_Querschnittsmessungsdefinition | |
CNIVissimSingleTypeParser_Querverkehrsstoerungsdefinition | |
CNIVissimSingleTypeParser_Rautedefinition | |
CNIVissimSingleTypeParser_Reisezeitmessungsdefinition | |
CNIVissimSingleTypeParser_Richtungsentscheidungsdefinition | |
CNIVissimSingleTypeParser_Richtungspfeildefinition | |
CNIVissimSingleTypeParser_Routenentscheidungsdefinition | |
CNIVissimSingleTypeParser_Signalgeberdefinition | |
CNIVissimSingleTypeParser_Signalgruppendefinition | |
CNIVissimSingleTypeParser_Simdauer | |
CNIVissimSingleTypeParser_SimRate | |
CNIVissimSingleTypeParser_Startuhrzeit | |
CNIVissimSingleTypeParser_Startzufallszahl | |
CNIVissimSingleTypeParser_Stauparameterdefinition | |
CNIVissimSingleTypeParser_Stauzaehlerdefinition | |
CNIVissimSingleTypeParser_Stopschilddefinition | |
CNIVissimSingleTypeParser_Streckendefinition | |
CNIVissimSingleTypeParser_Streckentypdefinition | |
CNIVissimSingleTypeParser_TEAPACDefinition | |
CNIVissimSingleTypeParser_Verbindungsdefinition | |
CNIVissimSingleTypeParser_Verkehrszusammensetzungsdefinition | |
CNIVissimSingleTypeParser_Verlustzeitmessungsdefinition | |
CNIVissimSingleTypeParser_VWunschentscheidungsdefinition | |
CNIVissimSingleTypeParser_Zeitenverteilungsdefinition | |
CNIVissimSingleTypeParser_Zeitschrittfaktor | |
CNIVissimSingleTypeParser_Zuflussdefinition | |
CNIVissimSingleTypeParser_Zusammensetzungsdefinition | |
CNIImporter_VISUM | A VISUM network importer |
CNIImporter_VISUM::TypeParser | A complete call description for parsing a single db |
CNILoader | Perfoms network import |
CNINavTeqHelper | Some parser methods shared around several formats containing NavTeq-Nets |
CNITypeLoader | Loads a specificy type of xml file |
►CNIVissimAbstractEdge | |
CNIVissimConnection | |
CNIVissimEdge | A temporary storage for edges imported from Vissim |
►CNIVissimBoundedClusterObject | |
CNIVissimConnection | |
CNIVissimDisturbance | |
CNIVissimClosedLaneDef | |
CNIVissimClosures | |
CNIVissimConflictArea | A temporary storage for conflict areas imported from Vissim |
CNIVissimConnectionCluster | |
CNIVissimConnectionCluster::NodeSubCluster | |
CNIVissimConnectionCluster::same_direction_sorter | |
CNIVissimDistrictConnection | |
CNIVissimEdge::connection_cluster_position_sorter | |
CNIVissimEdge::connection_position_sorter | |
CNIVissimEdgePosMap | |
CNIVissimExtendedEdgePoint | |
CNIVissimNodeCluster | |
►CNIVissimNodeDef | |
►CNIVissimNodeDef_Edges | |
CNIVissimNodeDef_Poly | |
CNIVissimNodeDef_Edges::id_matches | |
CNIVissimNodeDef_Edges::lying_within_match | |
CNIVissimNodeParticipatingEdge | |
CNIVissimSingleTypeXMLHandler_ConflictArea | A class which extracts VISSIM-ConflictAreas from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_Fahrzeugklassendefinition | A class which extracts VISSIM-Fahrzeugklassen from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_Geschwindigkeitsverteilungsdefinition | A class which extracts VISSIM-Geschwindigkeitsverteilung from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_Parkplatzdefinition | A class which extracts VISSIM-Parkplätze from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_Streckendefinition | A class which extracts VISSIM-Strecken from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_VWunschentscheidungsdefinition | A class which extracts VISSIM-VWunschentscheidungen from a parsed VISSIM-file |
CNIVissimSingleTypeXMLHandler_Zuflussdefinition | A class which extracts VISSIM-Zuflüsse from a parsed VISSIM-file |
CNIVissimSource | |
CNIVissimTL | |
CNIVissimTL::NIVissimTLSignal | |
CNIVissimTL::NIVissimTLSignalGroup | |
CNIVissimTrafficDescription | |
CNIVissimVehicleClass | |
CNIVissimVehicleType | |
CNIVissimVehTypeClass | |
CNIVisumTL | Intermediate class for storing visum traffic lights during their import |
►CNIVisumTL::TimePeriod | A time period with a start and an end time |
CNIVisumTL::Phase | A phase |
CNIVisumTL::SignalGroup | A signal group can be defined either by a time period or by phases |
CNIXMLEdgesHandler::split_by_pos_finder | Finds a split at the given position |
CNLBuilder | The main interface for loading a microsim |
►CNLDetectorBuilder | Builds detectors for microsim |
CGUIDetectorBuilder | Builds detectors for guisim |
CNLDetectorBuilder::E3DetectorDefinition | Holds the incoming definitions of an e3 detector unless the detector is build |
CNLDiscreteEventBuilder | |
►CNLEdgeControlBuilder | Interface for building edges |
CGUIEdgeControlBuilder | Derivation of NLEdgeControlBuilder which builds gui-edges |
CNLJunctionControlBuilder | Builder of microsim-junctions and tls |
►CNLTriggerBuilder | Builds trigger objects for microsim |
CGUITriggerBuilder | Builds trigger objects for guisim |
CNodesHandler | A class which parses an ITSUMO file |
CNWFrame | Sets and checks options for netwrite; saves the network |
CNWWriter_Amitran | Exporter writing networks using the Amitran format |
CNWWriter_DlrNavteq | Exporter writing networks using XML (native input) format |
CNWWriter_MATSim | Exporter writing networks using the MATSim format |
CNWWriter_OpenDrive | Exporter writing networks using the openDRIVE format |
CNWWriter_SUMO | Exporter writing networks using the SUMO format |
CNWWriter_XML | Exporter writing networks using XML (native input) format |
CObject | A road object (e.g. parkingSpace) |
CODCell | A single O/D-matrix cell |
CODMatrix | An O/D (origin/destination) matrix |
CODMatrix::cell_by_begin_comparator | Used for sorting the cells by the begin time they describe |
CODMatrix::descending_departure_comperator | Used for sorting vehicles by their departure (latest first) |
CODMatrix::ODVehicle | An internal representation of a single vehicle |
COpenDriveElevation | Coefficients of an elevation profile (3rd degree polynomial) |
►COption | A class representing a single program option |
►COption_Bool | |
COption_BoolExtended | |
COption_Float | |
COption_Integer | An integer-option |
COption_IntVector | |
COption_String | |
►COption_StringVector | |
COption_FileName | |
COptionsCont | A storage for options typed value containers) |
COptionsIO | |
COptionsParser | Parses command line arguments |
COUProcess | An Ornstein-Uhlenbeck stochastic process |
►COutputDevice | Static storage of an output device and its base (abstract) implementation |
CGUIMessageWindow::MsgOutputDevice | Class MsgOutputDevice |
CMsgRetrievingFunction< T > | Encapsulates an object's method for using it as a message retriever |
COutputDevice_CERR | An output device that encapsulates cerr |
COutputDevice_COUT | An output device that encapsulates cout |
COutputDevice_File | An output device that encapsulates an ofstream |
COutputDevice_Network | An output device for TCP/IP network connections |
COutputDevice_String | An output device that encapsulates an ofstream |
►COutputFormatter | Abstract base class for output formatters |
CBinaryFormatter | Output formatter for plain XML output |
CPlainXMLFormatter | Output formatter for plain XML output |
►CParameterised | An upper class for objects with additional parameters |
CGNEAdditional | An Element which don't belongs to GNENet but has influency in the simulation |
CGNEPersonTrip | |
CGNERide | |
CGNERoute | |
CGNEWalk | |
CMSEdge | A road/street connecting two junctions |
CMSJunction | The base class for an intersection |
CMSLane | Representation of a lane in the micro simulation |
CMSRoute | |
►CMSSOTLPolicy | Class for a low-level policy |
CMSSOTLCongestionPolicy | Class for low-level congestion policy |
CMSSOTLMarchingPolicy | Class for low-level marching policy |
CMSSOTLPhasePolicy | Class for low-level phase policy |
CMSSOTLPlatoonPolicy | Class for low-level platoon policy |
CMSSOTLRequestPolicy | Class for low-level request policy |
►CMSSOTLPolicyDesirability | This class determines the desirability algorithm of a MSSOTLPolicy when used in combination with a high level policy |
CMSSOTLPolicy5DFamilyStimulus | |
►CMSSOTLPolicy5DStimulus | |
CMSSOTLPolicy3DStimulus | |
CMSStoppingPlace | A lane area vehicles can halt at |
CMSTrafficLightLogic | The parent class for traffic light logics |
CNBEdge | The representation of a single edge during network building |
CNBEdge::Connection | A structure which describes a connection between edges or lanes |
CNBEdge::Lane | An (internal) definition of a single lane of an edge |
CNBNode | Represents a single node (junction) during network building |
CNBNode::Crossing | A definition of a pedestrian crossing |
CNBTrafficLightDefinition | The base class for traffic light logic definitions |
CNBTrafficLightLogic | A SUMO-compliant built logic for a traffic light |
CNIImporter_OpenStreetMap::Edge | An internal definition of a loaded edge |
CNIImporter_SUMO::Connection | A connection description |
CNIImporter_SUMO::EdgeAttrs | Describes the values found in an edge's definition and this edge's lanes |
CNIImporter_SUMO::LaneAttrs | Describes the values found in a lane's definition |
CPointOfInterest | A point-of-interest |
CROEdge | A basic edge for routing applications |
CSUMOPolygon | |
►CSUMOVehicleParameter | Structure representing possible vehicle parameter |
CGNEPerson | |
CGNEVehicle | |
►CSUMOVehicleParameter::Stop | Definition of vehicle stop (position and duration) |
CGNEStop | |
►CSUMOVTypeParameter | Structure representing possible vehicle parameter |
CGNEVehicleType | |
CParBuffer | |
CPCLoaderArcView | A reader of pois and polygons from shape files |
CPCLoaderDlrNavteq | A reader of pois and polygons stored in DLR-Navteq (Elmar)-format |
CPCLoaderOSM::PCOSMEdge | An internal definition of a loaded edge |
CPCLoaderOSM::PCOSMNode | An internal representation of an OSM-node |
CPCLoaderOSM::PCOSMRelation | An internal definition of a loaded relation |
CPCLoaderVisum | A reader of pois and polygons stored in VISUM-format |
CPCPolyContainer::LanePos | |
CPCTypeMap | A storage for type mappings |
CPCTypeMap::TypeDef | A single definition of values that shall be used for a given type |
CPedestrianRouter | |
CPedestrianRouter< E, L, N, V > | |
►CPedestrianState | Abstract base class for managing callbacks to retrieve various state information from the model |
CDummyState | |
CMSPModel_NonInteracting::PState | Abstract base class for managing callbacks to retrieve various state information from the model |
CMSPModel_Remote::PState | Container for pedestrian state and individual position update function |
►CMSPModel_Striping::PState | Container for pedestrian state and individual position update function |
CMSPModel_Striping::PStateVehicle | |
CPerson | C++ TraCI client API implementation |
CPHEMCEP | Data Handler for a single CEP emission data set |
CPHEMCEPHandler | Data Handler for all CEP emission and vehicle Data |
CPHEMlightdll::CEP | |
CPHEMlightdll::CEPHandler | |
CPHEMlightdll::Constants | |
CPHEMlightdll.EmissionData | |
CPHEMlightdll::Helpers | |
CPHEMlightdll.PHEMLight | |
CPHEMlightdll.Start | |
CPHEMlightdll.VehicleResult | |
CPlexe::CCDataHeader | Struct used as header for generic data passing to this model through traci |
CPlexe::VEHICLE_DATA | |
CPOI | C++ TraCI client API implementation |
CPollutantsInterface | Helper methods for PHEMlight-based emission computation |
CPollutantsInterface::Emissions | Storage for collected values of all emission types |
►CPollutantsInterface::Helper | Abstract superclass for the model helpers |
CHelpersEnergy | Helper methods for energy-based electricity consumption computation based on the battery device |
CHelpersHBEFA | Helper methods for HBEFA-based emission computation |
CHelpersHBEFA3 | Helper methods for HBEFA3-based emission computation |
CHelpersPHEMlight | Helper methods for PHEMlight-based emission computation |
CPolygon | A 2D- or 3D-polygon |
CPolygonDynamics | |
►CPosition | A point in 2D or 3D with translation and scaling methods |
CPointOfInterest | A point-of-interest |
CPositionVector::as_poly_cw_sorter | Clase for CW Sorter |
CPositionVector::increasing_x_y_sorter | Clase for increasing Sorter |
CPrices | |
CPublicTransportEdge< E, L, N, V >::Schedule | |
►CPushButtonLogic | |
CMSSOTLMarchingPolicy | Class for low-level marching policy |
CMSSOTLPhasePolicy | Class for low-level phase policy |
CMSSOTLPlatoonPolicy | Class for low-level platoon policy |
CRandHelper | Utility functions for using a global, resetable random number generator |
CRandomDistributor< T > | Represents a generic random distribution |
CRandomDistributor< const MSRoute * > | |
►CRandomDistributor< double > | |
CDistribution_Points | |
CRandomDistributor< int > | |
CRandomDistributor< MSEdge * > | |
CRandomDistributor< MSVehicleType * > | |
CRandomDistributor< ParkingAreaVisible > | |
CRandomDistributor< std::string > | |
CRandomDistributor< SUMOVTypeParameter * > | |
CRGBColor | |
►CROAbstractEdgeBuilder | Interface for building instances of router-edges |
CAGStreet::Builder | |
CRODFEdgeBuilder | Interface for building instances of dfrouter-edges |
CRODUAEdgeBuilder | Interface for building instances of duarouter-edges |
CROJTREdgeBuilder | Interface for building instances of jtrrouter-edges |
CROMAEdgeBuilder | Interface for building instances of duarouter-edges |
CRODFDetectorCon | A container for RODFDetectors |
CRODFDetectorFlows | A container for flows |
CRODFDetFlowLoader | A loader for detector flows |
CRODFFrame | Sets and checks options for df-routing |
CRODFNet::DFRouteDescByTimeComperator | |
CRODFNet::idComp | Comparator for maps using edges as key, used only in myDetectorsOnEdges to make tests comparable |
CRODFNet::IterationEdge | |
CRODFRouteCont | A container for DFROUTER-routes |
CRODFRouteCont::by_distance_sorter | A class for sorting route descriptions by their length |
CRODFRouteCont::route_finder | A class for finding a same route (one that passes the same edges) |
CRODFRouteDesc | A route within the DFROUTER |
CRODUAFrame | Sets and checks options for dua-routing |
CROFrame | Sets and checks options for routing |
CROJTRFrame | Sets and checks options for jtr-routing |
CROLoader | The data loader |
CROMAAssignments | Assignment methods |
CROMAFrame | Sets and checks options for dua-routing |
►CRONet | The router's network representation |
CRODFNet | A DFROUTER-network |
►CROPerson::PlanItem | Every person has a plan comprising of multiple planItems |
CROPerson::PersonTrip | A planItem can be a Trip which contains multiple tripItems |
CROPerson::Stop | A planItem can be a Stop |
►CROPerson::TripItem | A TripItem is part of a trip, e.g., go from here to here by car |
CROPerson::Ride | A ride is part of a trip, e.g., go from here to here by car or bus |
CROPerson::Walk | A walk is part of a trip, e.g., go from here to here by foot |
►CRORoutable | A routable thing such as a vehicle or person |
CROPerson | A person as used by router |
CROVehicle | A vehicle as used by router |
CRORouteDef::ComparatorProbability | |
CRoute | C++ TraCI client API implementation |
►CRouteCostCalculator< R, E, V > | Abstract base class providing static factory method |
CGawronCalculator< R, E, V > | Cost calculation with Gawron's method |
CLogitCalculator< R, E, V > | Cost calculation with c-logit or logit method |
CRouterProvider< E, L, N, V > | |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES > | |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::Branch | |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::Iterator | Iterator is not remove safe |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::Iterator::StackElement | |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::ListNode | A link list of nodes for reinsertion after a delete operation |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::Node | Node for each branch level |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::PartitionVars | Variables for finding a split partition |
CRTree< DATATYPE, DATATYPENP, ELEMTYPE, NUMDIMS, CONTEXT, ELEMTYPEREAL, TMAXNODES, TMINNODES >::Rect | Minimal bounding rectangle (n-dimensional) |
►CSAXWeightsHandler::EdgeFloatTimeLineRetriever | Interface for a class which obtains read weights for named edges |
CGUINet::EdgeFloatTimeLineRetriever_GUI | |
CNLBuilder::EdgeFloatTimeLineRetriever_EdgeEffort | |
CNLBuilder::EdgeFloatTimeLineRetriever_EdgeTravelTime | Obtains edge efforts from a weights handler and stores them within the edges |
CROLoader::EdgeFloatTimeLineRetriever_EdgeTravelTime | Obtains edge travel times from a weights handler and stores them within the edges |
CROLoader::EdgeFloatTimeLineRetriever_EdgeWeight | Obtains edge weights from a weights handler and stores them within the edges |
CSAXWeightsHandler::ToRetrieveDefinition | Complete definition about what shall be retrieved and where to store it |
►CShapeContainer | Storage for geometrical objects |
CGNENet | A NBNetBuilder extended by visualisation and editing capabilities |
CGUIShapeContainer | Storage for geometrical objects extended by mutexes |
CPCPolyContainer | A storage for loaded polygons and pois |
►CSigmoidLogic | |
CMSSOTLPhasePolicy | Class for low-level phase policy |
CMSSOTLPlatoonPolicy | Class for low-level platoon policy |
CSimulation | C++ TraCI client API implementation |
CSPTree< E, C > | |
CSPTree< E, C >::EdgeByTTComparator | |
CSPTree< CHBuilder::CHInfo, CHBuilder::CHConnection > | |
Cstbtt__bitmap | |
Cstbtt__buf | |
Cstbtt_aligned_quad | |
Cstbtt_bakedchar | |
Cstbtt_fontinfo | |
Cstbtt_pack_context | |
Cstbtt_pack_range | |
Cstbtt_packedchar | |
Cstbtt_vertex | |
►Cbinary_function | |
CMSDetectorControl::detectorEquals | Returns true if detectors are equal |
CMSLane::VehPosition | |
►Cexception | |
Cstrict_fstream::Exception | Exception class thrown by failed operations |
Czstr::Exception | Exception class thrown by failed zlib operations |
►Cfstream | |
Cstrict_fstream::fstream | |
►Cifstream | |
Cstrict_fstream::ifstream | |
►Cistream | |
Czstr::ifstream | |
Czstr::istream | |
►Cless | |
CROVehicleByDepartureComperator | A function for sorting vehicles by their departure time |
►Cofstream | |
Cstrict_fstream::ofstream | |
►Costream | |
Czstr::ofstream | |
Czstr::ostream | |
►Cruntime_error | |
Clibsumo::TraCIException | |
►CProcessError | |
CEmptyData | |
►CFormatException | |
CBoolFormatException | |
CNumberFormatException | |
CTimeFormatException | |
CInvalidArgument | |
CIOError | |
COutOfBoundsException | |
CUnknownElement | |
Ctcpip::SocketException | |
►Cstreambuf | |
Czstr::istreambuf | |
Czstr::ostreambuf | |
►Cvector | |
CNBParkingCont | |
CPositionVector | A list of positions |
Cstrict_fstream::detail::static_method_holder | |
►Czstr::detail::strict_fstream_holder< strict_fstream::ifstream > | |
Czstr::ifstream | |
►Czstr::detail::strict_fstream_holder< strict_fstream::ofstream > | |
Czstr::ofstream | |
CStringBijection< T > | |
CStringBijection< T >::Entry | |
CStringBijection< double > | |
CStringBijection< FringeType > | |
CStringBijection< FXuint > | |
CStringBijection< GUIGlObjectType > | |
CStringBijection< int > | |
CStringBijection< LaneChangeAction > | |
CStringBijection< LaneChangeModel > | |
CStringBijection< LaneSpreadFunction > | |
CStringBijection< LateralAlignment > | |
CStringBijection< LinkDirection > | |
CStringBijection< LinkState > | |
CStringBijection< PersonMode > | |
CStringBijection< RightOfWay > | |
CStringBijection< SignType > | |
CStringBijection< std::vector< double > > | |
CStringBijection< SUMOEmissionClass > | |
CStringBijection< SumoXMLEdgeFunc > | |
CStringBijection< SumoXMLNodeType > | |
CStringBijection< SumoXMLTag > | |
CStringBijection< TrafficLightType > | |
CStringBijection< TrainType > | |
CStringBijection< VISUM_KEY > | |
CStringTokenizer | |
CStringUtils | Some static methods for string processing |
►CSUMOAbstractRouter< E, V > | |
CAStarRouter< E, V > | Computes the shortest path through a network using the A* algorithm |
CCHRouter< E, V > | Computes the shortest path through a contracted network |
CCHRouterWrapper< E, V > | Computes the shortest path through a contracted network |
CDijkstraRouter< E, V > | Computes the shortest path through a network using the Dijkstra algorithm |
CSUMOAbstractRouter< E, V >::EdgeInfo | |
CSUMOAbstractRouter< MSEdge, SUMOVehicle > | |
CSUMOAbstractRouter< NBRouterEdge, NBVehicle > | |
►CSUMOAbstractRouter< ROEdge, ROVehicle > | |
CROJTRRouter | Computes routes using junction turning percentages |
CSUMORouteLoader | |
CSUMORouteLoaderControl | |
►CSUMOSAXAttributes | Encapsulated SAX-Attributes |
CSUMOSAXAttributesImpl_Binary | Encapsulated Xerces-SAX-attributes |
CSUMOSAXAttributesImpl_Cached | Encapsulated Xerces-SAX-attributes |
CSUMOSAXAttributesImpl_Xerces | Encapsulated Xerces-SAX-attributes |
CSUMOSAXReader | SAX-reader encapsulation containing binary reader |
►CSUMOTrafficObject | Representation of a vehicle or person |
►CMSTransportable | |
►CMSContainer | |
CGUIContainer | |
►CMSPerson | |
CGUIPerson | |
►CSUMOVehicle | Representation of a vehicle |
►CMSBaseVehicle | The base class for microscopic and mesoscopic vehicles |
►CMEVehicle | A vehicle from the mesoscopic point of view |
CGUIMEVehicle | A MSVehicle extended by some values for usage within the gui |
►CMSVehicle | Representation of a vehicle in the micro simulation |
CGUIVehicle | A MSVehicle extended by some values for usage within the gui |
CSUMOVehicleParserHelper | Helper methods for parsing vehicle attributes |
CSUMOVTypeParameter::VClassDefaultValues | Struct for default values that depend of VClass |
CSUMOXMLDefinitions | Class for maintaining associations between enums and xml-strings |
CSystemFrame | A set of actions common to all applications |
CSysUtils | A few system-specific functions |
Ctcpip::Socket | |
Ctcpip::Storage | |
►CTraCIAPI | C++ TraCI client API implementation |
CTraCITestClient | A test execution class |
►CTraCIAPI::TraCIScopeWrapper | An abstract interface for accessing type-dependent values |
CTraCIAPI::EdgeScope | Scope for interaction with edges |
CTraCIAPI::GUIScope | Scope for interaction with the gui |
CTraCIAPI::InductionLoopScope | Scope for interaction with inductive loops |
CTraCIAPI::JunctionScope | Scope for interaction with junctions |
CTraCIAPI::LaneAreaScope | Scope for interaction with lane area detectors |
CTraCIAPI::LaneScope | Scope for interaction with lanes |
CTraCIAPI::MeMeScope | Scope for interaction with multi entry/-exit detectors |
CTraCIAPI::PersonScope | Scope for interaction with vehicles |
CTraCIAPI::POIScope | Scope for interaction with POIs |
CTraCIAPI::PolygonScope | Scope for interaction with polygons |
CTraCIAPI::RouteScope | Scope for interaction with routes |
CTraCIAPI::SimulationScope | Scope for interaction with the simulation |
CTraCIAPI::TrafficLightScope | Scope for interaction with traffic lights |
CTraCIAPI::VehicleScope | Scope for interaction with vehicles |
CTraCIAPI::VehicleTypeScope | Scope for interaction with vehicle types |
CTraCIPositionVector | A list of positions |
CTraCIServer::SocketInfo | |
CTraCIServerAPI_AreaDetector | APIs for getting/setting multi-entry/multi-exit detector values via TraCI |
CTraCIServerAPI_Edge | APIs for getting/setting edge values via TraCI |
CTraCIServerAPI_GUI | APIs for getting/setting GUI values via TraCI |
CTraCIServerAPI_InductionLoop | APIs for getting/setting induction loop values via TraCI |
CTraCIServerAPI_Junction | APIs for getting/setting junction values via TraCI |
CTraCIServerAPI_Lane | APIs for getting/setting lane values via TraCI |
CTraCIServerAPI_LaneArea | |
CTraCIServerAPI_MultiEntryExit | APIs for getting/setting multi-entry/multi-exit detector values via TraCI |
CTraCIServerAPI_Person | APIs for getting/setting person values via TraCI |
CTraCIServerAPI_POI | APIs for getting/setting POI values via TraCI |
CTraCIServerAPI_Polygon | APIs for getting/setting polygon values via TraCI |
CTraCIServerAPI_Route | APIs for getting/setting route values via TraCI |
CTraCIServerAPI_Simulation | APIs for getting/setting simulation values via TraCI |
CTraCIServerAPI_TrafficLight | APIs for getting/setting traffic light values via TraCI |
CTraCIServerAPI_Vehicle | APIs for getting/setting vehicle values via TraCI |
CTraCIServerAPI_VehicleType | APIs for getting/setting vehicle type values via TraCI |
CTrafficLight | C++ TraCI client API implementation |
Cupdate | |
CValueRetriever< T > | |
►CValueRetriever< double > | |
CTrackerValueDesc | Representation of a timeline of floats with their names and moments |
►CValueRetriever< std::pair< SUMOTime, MSPhaseDefinition > > | |
CGUITLLogicPhasesTrackerWindow | This window displays a phase diagram for a chosen tl-logic |
CValueSource< T > | |
CValueSource< double > | |
►CValueSource< R > | |
CCastingFunctionBinding< T, R, O > | |
CFuncBinding_IntParam< T, R > | |
CFuncBinding_StringParam< T, R > | |
CFunctionBinding< T, R > | |
CValueSource< std::pair< SUMOTime, MSPhaseDefinition > > | |
►CValueSource< std::string > | |
CFunctionBindingString< T > | |
CValueTimeLine< T > | |
CValueTimeLine< double > | |
CVectorHelper< T > | |
CVehicle | C++ TraCI client API implementation |
Cvehicle_reverse_position_sorter | Sorts vehicles by their position (ascending) |
CVehicleType | C++ TraCI client API implementation |
►CBinInputStream | |
CIStreamBinInputStream | Xerces BinInputStream reading from arbitrary std::istream |
►CDefaultHandler | |
►CGenericSAXHandler | A handler which converts occuring elements and attributes into enums |
CNIImporter_ITSUMO::Handler | |
CNIImporter_MATSim::EdgesHandler | A class which extracts MATSIM-edges from a parsed MATSIM-file |
CNIImporter_MATSim::NodesHandler | A class which extracts MATSIM-nodes from a parsed MATSIM-file |
CNIImporter_OpenDrive | Importer for networks stored in openDrive format |
CNIImporter_Vissim::NIVissimXMLHandler_ConflictArea | |
CNIImporter_Vissim::NIVissimXMLHandler_Fahrzeugklassendefinition | |
CNIImporter_Vissim::NIVissimXMLHandler_Geschwindigkeitsverteilungsdefinition | |
CNIImporter_Vissim::NIVissimXMLHandler_Parkplatzdefinition | |
CNIImporter_Vissim::NIVissimXMLHandler_Routenentscheidungsdefinition | A class which extracts VISSIM-Routes from a parsed VISSIM-file |
CNIImporter_Vissim::NIVissimXMLHandler_Streckendefinition | |
CNIImporter_Vissim::NIVissimXMLHandler_VWunschentscheidungsdefinition | |
CNIImporter_Vissim::NIVissimXMLHandler_Zuflussdefinition | |
►CSUMOSAXHandler | SAX-handler base for SUMO-files |
CAGActivityGenHandler | |
CGNEParametersDialog::ParametersOptions::GNEParameterHandler | Load parameters from a filename |
CGUINet::DiscoverAttributes | Class for discovering edge attributes |
CGUISettingsHandler | An XML-handler for visualisation schemes |
CMSLaneSpeedTrigger | Changes the speed allowed on a set of lanes |
CMSTriggeredRerouter | Reroutes vehicles passing an edge |
CNIImporter_OpenStreetMap::EdgesHandler | A class which extracts OSM-edges from a parsed OSM-file |
CNIImporter_OpenStreetMap::NodesHandler | A class which extracts OSM-nodes from a parsed OSM-file |
CNIImporter_OpenStreetMap::RelationHandler | A class which extracts relevant relation information from a parsed OSM-file |
CNIImporter_SUMO | Importer for networks stored in SUMO format |
CNIXMLConnectionsHandler | Importer for edge connections stored in XML |
CNIXMLEdgesHandler | Importer for network edges stored in XML |
CNIXMLNodesHandler | Importer for network nodes stored in XML |
CNIXMLPTHandler | Importer for network edges stored in XML |
CNIXMLTrafficLightsHandler | Importer for edge connections stored in XML |
CNIXMLTypesHandler | Importer for edge type information stored in XML |
CODAmitranHandler | An XML-Handler for districts |
CODDistrictHandler | An XML-Handler for districts |
CPCLoaderOSM | A reader of pois and polygons stored in OSM-format |
CPCLoaderOSM::EdgesHandler | A class which extracts OSM-edges from a parsed OSM-file |
CPCLoaderOSM::NodesHandler | A class which extracts OSM-nodes from a parsed OSM-file |
CPCLoaderOSM::RelationsHandler | A class which extracts relevant way-ids from relations in a parsed OSM-file |
CPCNetProjectionLoader | A reader for a SUMO network's projection description |
CPCTypeDefHandler | A handler for loading polygon type maps |
CRODFDetectorHandler | SAX2-Handler for loading DFROUTER-detector definitions |
CROJTRTurnDefLoader | Loader for the of turning percentages and source/sink definitions |
CROMARouteHandler | Parser and container for routes during their loading |
CRONetHandler | The handler that parses a SUMO-network for its usage in a router |
CSAXWeightsHandler | An XML-handler for network weights |
►CShapeHandler | The XML-Handler for network loading |
CGNEAdditionalHandler | Builds additional objects for GNENet (busStops, chargingStations, detectors, etc..) |
CNIXMLShapeHandler | |
CNLShapeHandler | The XML-Handler for shapes loading network loading |
CPCLoaderXML | A reader for polygons and pois stored in XML-format |
►CSUMORouteHandler | Parser for routes during their loading |
CGNERouteHandler | Builds trigger objects for GNENet (busStops, chargingStations, detectors, etc..) |
►CMSRouteHandler | Parser and container for routes during their loading |
CMSCalibrator | Calibrates the flow on a segment to a specified one |
CMSStateHandler | Parser and output filter for routes and vehicles state saving and loading |
CNLHandler | The XML-Handler for network loading |
CRORouteHandler | Parser and container for routes during their loading |
CTrajectoriesHandler | An XML-Handler for amitran and netstate trajectories |
CVehicleEngineHandler | |
►CEntityResolver | |
CSUMOSAXReader::LocalSchemaResolver | |
►CHandlerBase | |
COptionsLoader | A SAX-Handler for loading options |
►CInputSource | |
CIStreamInputSource | Xerces InputSource reading from arbitrary std::istream |
CXMLSubSys | Utility methods for initialising, closing and using the XML-subsystem |
►Cz_stream | |
Czstr::detail::z_stream_wrapper | |
CZoneCounter | |
Czstr::detail::strict_fstream_holder< FStream_Type > | |