69 myNet(net), myActionBuilder(net),
70 myCurrentIsInternalToSkip(false),
71 myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
72 myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
73 myAmParsingTLLogicOrJunction(false), myCurrentIsBroken(false),
74 myHaveWarnedAboutDeprecatedLanes(false),
75 myLastParameterised(0),
76 myHaveSeenInternalEdge(false),
77 myHaveSeenNeighs(false),
78 myHaveSeenAdditionalSpeedRestrictions(false),
81 myNetIsLoaded(false) {
269 myAmParsingTLLogicOrJunction =
false;
288 WRITE_ERROR(
"Unknown from-node '" + it->second.first +
"' for edge '" + it->first +
"'.");
292 WRITE_ERROR(
"Unknown to-node '" + it->second.second +
"' for edge '" + it->first +
"'.");
347 WRITE_ERROR(
"Edge '" +
id +
"' has an invalid type.");
372 if (!crossingEdges.empty()) {
373 std::vector<std::string> crossingEdgesVector;
376 crossingEdgesVector.push_back(edges.
next());
421 if (shape.size() < 2) {
422 WRITE_ERROR(
"Shape of lane '" +
id +
"' is broken.\n Can not build according edge.");
427 if (permissions !=
SVCAll) {
437 WRITE_ERROR(
"Another lane with the id '" +
id +
"' exists.");
465 if (shape.size() > 2) {
475 WRITE_ERROR(
"An unknown or invalid junction type occured in junction '" +
id +
"'.");
480 std::vector<MSLane*> incomingLanes;
483 std::vector<MSLane*> internalLanes;
493 WRITE_ERROR(e.what() + std::string(
"\n Can not build according junction."));
502 const std::string& def, std::vector<MSLane*>& into,
bool& ok) {
505 std::string laneID = st.
next();
511 WRITE_ERROR(
"An unknown lane ('" + laneID +
"') was tried to be set as incoming to junction '" + junctionID +
"'.");
515 into.push_back(lane);
620 if (request >= 0 && response.length() > 0) {
665 WRITE_ERROR(
"Traffic light '" +
id +
"' has unknown type '" + typeS +
"'.");
708 std::string phaseTypeString;
709 bool transient_notdecisional_bit;
716 transient_notdecisional_bit =
false;
718 if (phaseTypeString.find(
"decisional") != std::string::npos) {
719 transient_notdecisional_bit =
false;
720 }
else if (phaseTypeString.find(
"transient") != std::string::npos) {
721 transient_notdecisional_bit =
true;
723 MsgHandler::getWarningInstance()->
inform(
"SOTL_ATTL_TYPE_DECISIONAL nor SOTL_ATTL_TYPE_TRANSIENT. Assuming phase type as SUMOSOTL_TagAttrDefinitions::SOTL_ATTL_TYPE_TRANSIENT");
724 transient_notdecisional_bit =
false;
726 commit_bit = (phaseTypeString.find(
"commit") != std::string::npos);
728 if (phaseTypeString.find(
"target") != std::string::npos) {
729 std::string delimiter(
" ,;");
737 std::string::size_type firstPos = targetLanesString.find_first_not_of(delimiter, 0);
739 std::string::size_type pos = targetLanesString.find_first_of(delimiter, firstPos);
741 while (std::string::npos != pos || std::string::npos != firstPos) {
743 targetLanesVector.push_back(targetLanesString.substr(firstPos, pos - firstPos));
746 firstPos = targetLanesString.find_first_not_of(delimiter, pos);
749 pos = targetLanesString.find_first_of(delimiter, firstPos);
789 friendlyPos, vTypes);
875 const std::string toLane = attrs.
getOpt<std::string>(
SUMO_ATTR_TO,
id.c_str(), ok,
"");
880 const double length = attrs.
getOpt<
double>(
SUMO_ATTR_LENGTH,
id.c_str(), ok, std::numeric_limits<double>::max());
884 const bool showDetector =
true;
887 WRITE_WARNING(
"Ignoring deprecated argument 'cont' for E2 detector '" +
id +
"'");
893 double endPosition = attrs.
getOpt<
double>(
SUMO_ATTR_ENDPOS,
id.c_str(), ok, std::numeric_limits<double>::max());
899 bool lanesGiven = lanes !=
"";
900 bool laneGiven = lane !=
"";
901 if (!(lanesGiven || laneGiven)) {
903 WRITE_WARNING(
"Trying to specify detector's lane by the given id since the argument 'lane' is missing.")
907 bool lengthGiven = length != std::numeric_limits<double>::max();
908 bool posGiven = position != std::numeric_limits<double>::max();
909 bool endPosGiven = endPosition != std::numeric_limits<double>::max();
910 bool lsaGiven = lsaid !=
"";
911 bool toLaneGiven = toLane !=
"";
914 std::vector<MSLane*> clanes;
917 std::string seps =
" ,\t\n";
921 std::string nextLaneID = st.
next();
923 if (nextLaneID.find_first_of(seps) != nextLaneID.npos) {
927 clanes.push_back(clane);
929 if (clanes.size() == 0) {
930 throw InvalidArgument(
"Malformed argument 'lanes' for E2Detector '" +
id +
"'.\nSpecify 'lanes' as a sequence of lane-IDs seperated by whitespace or comma (',')");
933 WRITE_WARNING(
"Ignoring argument 'lane' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 934 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
937 WRITE_WARNING(
"Ignoring argument 'length' for E2Detector '" +
id +
"' since argument 'lanes' was given.\n" 938 "Usage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]");
943 WRITE_WARNING(
"Missing argument 'pos' for E2Detector '" +
id +
"'. Assuming detector start == lane start of lane '" + clanes[0]->getID() +
"'.");
947 endPosition = clanes[clanes.size() - 1]->getLength();
948 WRITE_WARNING(
"Missing argument 'endPos' for E2Detector '" +
id +
"'. Assuming detector end == lane end of lane '" + clanes[clanes.size() - 1]->getID() +
"'.");
953 std::stringstream ss;
954 ss <<
"Missing argument 'lane' for E2Detector '" <<
id <<
"'." 955 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
962 if (endPosGiven && lengthGiven) {
963 std::stringstream ss;
964 ss <<
"Ignoring argument 'endPos' for E2Detector '" <<
id <<
"' since argument 'pos' was given." 965 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
967 endPosition = std::numeric_limits<double>::max();
969 if (!lengthGiven && !endPosGiven) {
970 std::stringstream ss;
971 ss <<
"Missing arguments 'length'/'endPos' for E2Detector '" <<
id <<
"'. Assuming detector end == lane end of lane '" << lane <<
"'.";
973 endPosition = clane->getLength();
975 }
else if (endPosGiven) {
978 std::stringstream ss;
979 ss <<
"Missing arguments 'length'/'pos' for E2Detector '" <<
id <<
"'. Assuming detector start == lane start of lane '" << lane <<
"'.";
983 std::stringstream ss;
984 if (lengthGiven && fabs(length - clane->getLength()) >
NUMERICAL_EPS) {
985 ss <<
"Incomplete positional specification for E2Detector '" <<
id <<
"'." 986 <<
"\nUsage combinations for positional specification: [lane, pos, length], [lane, endPos, length], or [lanes, pos, endPos]";
989 endPosition = clane->getLength();
991 ss <<
"Missing arguments 'pos'/'endPos' for E2Detector '" <<
id <<
"'. Assuming that the detector covers the whole lane '" << lane <<
"'.";
1013 throw InvalidArgument(
"The detector '" +
id +
"' refers to an unknown lsa '" + lsaid +
"'.");
1015 if (frequency != -1) {
1016 WRITE_WARNING(
"Ignoring argument 'frequency' for E2Detector '" +
id +
"' since argument 'tl' was given.");
1028 std::string filename;
1039 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1040 vTypes, friendlyPos, showDetector,
1045 haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
1046 vTypes, friendlyPos, showDetector,
1060 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1068 frequency, haltingSpeedThreshold, haltingTimeThreshold, vTypes);
1113 const std::string file = attrs.
get<std::string>(
SUMO_ATTR_FILE,
id.c_str(), ok);
1114 const std::string type = attrs.
getOpt<std::string>(
SUMO_ATTR_TYPE,
id.c_str(), ok,
"performance");
1126 excludeEmpty[0] !=
't' && excludeEmpty[0] !=
'T' && excludeEmpty[0] !=
'1' && excludeEmpty[0] !=
'x',
1127 excludeEmpty ==
"defaults", withInternal, trackVehicles,
1128 maxTravelTime, minSamples, haltingSpeedThreshold, vtypes,
1161 WRITE_ERROR(
"Unknown from-edge '" + fromID +
"' in connection.");
1166 WRITE_ERROR(
"Unknown to-edge '" + toID +
"' in connection.");
1169 if (fromLaneIdx < 0 || fromLaneIdx >= (
int)from->getLanes().size() ||
1170 toLaneIdx < 0 || toLaneIdx >= (int)to->
getLanes().size()) {
1171 WRITE_ERROR(
"Invalid lane index in connection from '" + from->getID() +
"' to '" + to->
getID() +
"'.");
1174 MSLane* fromLane = from->getLanes()[fromLaneIdx];
1185 if ((tlLinkIdx < 0 || tlLinkIdx >= (
int)logic->getCurrentPhaseDef().getState().size())
1186 && logic->getLogicType() !=
"railSignal" 1187 && logic->getLogicType() !=
"railCrossing") {
1189 "' in connection controlled by '" + tlID +
"'");
1196 double length = fromLane->
getShape()[-1].distanceTo(toLane->
getShape()[0]);
1204 "') should be set as a via-lane for lane '" + toLane->
getID() +
"'.");
1209 link =
new MSLink(fromLane, toLane, via, dir, state, length, foeVisibilityDistance, keepClear, logic, tlLinkIdx);
1273 WRITE_WARNING(
"no valid geo projection loaded from network. fcd-output.geo will not work");
1295 sink->
initialize(
new std::vector<MSLane*>());
1301 source->
initialize(
new std::vector<MSLane*>());
1304 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1316 if (shape.size() != 0) {
1317 if (!
myNet.
getShapeContainer().
addPolygon(
myCurrentDistrictID,
"taz",
RGBColor::parseColor(
"1.0,.33,.33"), 0, 0,
"", shape,
false,
false)) {
1355 for (std::vector<std::string>::iterator it = edgeIDs.begin(); it != edgeIDs.end(); ++it) {
1358 WRITE_ERROR(
"Unknown edge '" + (*it) +
"' in roundabout");
1398 WRITE_ERROR(
"Lane '" + laneID +
"' to place poi '" + poiID +
"' on is not known.");
1404 if (lanePos < 0 || lanePos > lane->
getLength()) {
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
void parseAndAddLotEntry(const SUMOSAXAttributes &attrs)
Parses his values and adds a lot entry to current parking area.
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
void parseAndBuildCalibrator(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a mesoscopic or microscopic calibrator.
void beginE3Detector(const SUMOSAXAttributes &attrs)
Starts building of an e3 detector using the given specification.
void initTrafficLightLogic(const std::string &id, const std::string &programID, TrafficLightType type, SUMOTime offset)
Begins the reading of a traffic lights logic.
SumoXMLTag
Numbers representing SUMO-XML - element names.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
void addWAUTJunction(const SUMOSAXAttributes &attrs)
Builds detectors for microsim.
virtual void addE2Detector(const SUMOSAXAttributes &attrs)
Builds an e2 detector using the given specification.
static RGBColor parseColor(std::string coldef)
Parses a color information.
alternative tag for e1 detector
bool myCurrentIsInternalToSkip
Information whether the currently parsed edge is internal and not wished, here.
Whether vehicles must keep the junction clear.
void addSuccessor(MSEdge *edge)
Adds an edge to the list of edges which may be reached from this edge and to the incoming of the othe...
a source within a district (connection road)
void addAccess(MSNet &net, const SUMOSAXAttributes &attrs)
Parses the values and adds an access point to the currently parsed stopping place.
Storage for all programs of a single tls.
void buildInstantInductLoop(const std::string &id, const std::string &lane, double pos, const std::string &device, bool friendlyPos, const std::string &vTypes)
Builds an instantenous induction and adds it to the net.
MSLane * getLaneChecking(const std::string &laneID, SumoXMLTag type, const std::string &detid)
Returns the named lane.
root element of a network file
begin/end of the description of a junction
virtual MSEdge * closeEdge()
Closes the building of an edge; The edge is completely described by now and may not be opened again...
void createEdgeLaneMeanData(const std::string &id, SUMOTime frequency, SUMOTime begin, SUMOTime end, const std::string &type, const bool useLanes, const bool withEmpty, const bool printDefaults, const bool withInternal, const bool trackVehicles, const double maxTravelTime, const double minSamples, const double haltSpeed, const std::string &vTypes, const std::string &device)
Creates edge based mean data collector using the given specification.
begin/end of the description of a single lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
virtual void openWAUT(const SUMOSAXAttributes &attrs)
void addIncoming(MSEdge *edge)
A calibrator placed over edge.
void openJunction(const std::string &id, const std::string &key, const SumoXMLNodeType type, const Position pos, const PositionVector &shape, const std::vector< MSLane *> &incomingLanes, const std::vector< MSLane *> &internalLanes)
Begins the processing of the named junction.
a traffic assignment zone
void beginE3Detector(const std::string &id, const std::string &device, SUMOTime splInterval, double haltingSpeedThreshold, SUMOTime haltingTimeThreshold, const std::string &vTypes)
Stores temporary the initial information about an e3 detector to build.
connectio between two lanes
The base class for an intersection.
void addE3Entry(const std::string &lane, double pos, bool friendlyPos)
Builds an entry point of an e3 detector.
const double SUMO_const_laneWidth
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
const std::string & getFileName() const
returns the current file name
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
void addLink(MSLink *link)
Delayed initialization.
virtual void addVTypeProbeDetector(const SUMOSAXAttributes &attrs)
Builds a vtype-detector using the given specification.
void addRoundabout(const SUMOSAXAttributes &attrs)
NLDetectorBuilder & myDetectorBuilder
The detector builder to use.
void parseAndBuildChargingStation(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a charging station.
foe visibility distance of a link
void parseAndBuildRerouter(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a rerouter.
void closeJunctionLogic()
Ends the building of a junction logic (row-logic)
weights: time range begin
link,node: the traffic light id responsible for this link
void addIncomingLane(MSLane *lane, MSLink *viaLink)
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
void buildRouteProbe(const std::string &id, const std::string &edge, SUMOTime frequency, SUMOTime begin, const std::string &device, const std::string &vTypes)
Builds a routeProbe and adds it to the net.
double getLength() const
Returns the lane's length.
const PositionVector & getShape() const
Returns this lane's shape.
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary...
virtual void addE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
NLHandler(const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder)
Constructor.
void initialize(const std::vector< MSLane *> *lanes)
Initialize the edge.
void addLink(MSLink *link, MSLane *lane, int pos)
void beginEdgeParsing(const SUMOSAXAttributes &attrs)
begins the processing of an edge
maximum duration of a phase
const std::string & getID() const
Returns the id.
const std::string & getActiveSubKey() const
Returns the active sub key.
virtual MSEdge * buildEdge(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, const int priority)
Builds an edge instance (MSEdge in this case)
static StringBijection< LinkState > LinkStates
link states
const SVCPermissions SVCAll
all VClasses are allowed
std::string myCurrentDistrictID
The id of the current district.
begin/end of the description of an edge restriction
A parking space for a single vehicle within a parking area.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
void parseAndBeginParkingArea(MSNet &net, const SUMOSAXAttributes &attrs)
Parses his values and builds a parking area.
void buildVTypeProbe(const std::string &id, const std::string &vtype, SUMOTime frequency, const std::string &device)
Builds a vTypeProbe and adds it to the net.
virtual void endE3Detector()
Builds of an e3 detector using collected values.
void endE3Detector()
Builds of an e3 detector using collected values.
bool myAmParsingTLLogicOrJunction
internal information whether a tls-logic is currently read
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
virtual SumoXMLEdgeFunc getEdgeFunc(bool &ok) const =0
Returns the value of the named attribute.
A class that stores a 2D geometrical boundary.
#define WRITE_WARNING(msg)
The simulated network and simulation perfomer.
static OptionsCont & getOptions()
Retrieves the options.
int getNumberOfLoadedPhases() const
return the number of phases loaded so far (for error reporting)
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
void parseLanes(const std::string &junctionID, const std::string &def, std::vector< MSLane *> &into, bool &ok)
void closeJunction(const std::string &basePath)
Closes (ends) the processing of the current junction.
MSTLLogicControl::TLSLogicVariants & getTLLogic(const std::string &id) const
Returns a previously build tls logic.
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
bool myHaveSeenAdditionalSpeedRestrictions
whether additional files contained type-specific speed limits
void addE3Exit(const std::string &lane, double pos, bool friendlyPos)
Builds an exit point of an e3 detector.
void addParam(const SUMOSAXAttributes &attrs)
an edge based mean data detector
void addDistrict(const SUMOSAXAttributes &attrs)
static StringBijection< LinkDirection > LinkDirections
link directions
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, const PositionVector &shape, bool geo, bool fill, bool ignorePruning=false)
Builds a polygon using the given values and adds it to the container.
void addApproachingLane(MSLane *lane, bool warnMultiCon)
A road/street connecting two junctions.
void setLocation(const SUMOSAXAttributes &attrs)
Parses network location description.
void addPhase(SUMOTime duration, const std::string &state, SUMOTime min, SUMOTime max)
Adds a phase to the currently built traffic lights logic.
The definition of a periodic event.
virtual void openJunction(const SUMOSAXAttributes &attrs)
opens a junction for processing
NLEdgeControlBuilder & myEdgeControlBuilder
The edge builder to use.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void addE3Entry(const SUMOSAXAttributes &attrs)
Adds an entry to the currently processed e3 detector.
Encapsulated SAX-Attributes.
An instantenous induction loop.
void addE3Exit(const SUMOSAXAttributes &attrs)
Adds an exit to the currently processed e3 detector.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Builder of microsim-junctions and tls.
ShapeContainer & getShapeContainer()
Returns the shapes container.
A point in 2D or 3D with translation and scaling methods.
virtual void endParkingArea()
End a parking area.
parameter associated to a certain key
virtual void closeTrafficLightLogic(const std::string &basePath)
Ends the building of a traffic lights logic.
void addWAUTSwitch(const SUMOSAXAttributes &attrs)
JunctionGraph myJunctionGraph
void addRequest(const SUMOSAXAttributes &attrs)
adds a request item to the current junction logic
void setPermissionsFound()
Labels the network to contain vehicle class permissions.
T get(const std::string &str) const
Position getLanePos(const std::string &poiID, const std::string &laneID, double lanePos, double lanePosLat)
get position for a given laneID
void addConnection(const SUMOSAXAttributes &attrs)
adds a connection
std::string myCurrentTypeID
The id of the currently processed edge type.
void parseAndBuildLaneSpeedTrigger(MSNet &net, const SUMOSAXAttributes &attrs, const std::string &base)
Parses his values and builds a lane speed trigger.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
void addAction(const SUMOSAXAttributes &attrs, const std::string &basePath)
Builds an action and saves it for further use.
static bool init(OptionsCont &oc)
Initialises the processing and the final instance using the given options.
SUMOTime string2time(const std::string &r)
roundabout defined in junction
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
void parseAndBuildStoppingPlace(MSNet &net, const SUMOSAXAttributes &attrs, const SumoXMLTag element)
Parses the values and builds a stopping places for busses, trains or container vehicles.
MSJunction * retrieve(const std::string id)
try to retrieve junction by id
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
edge: the shape in xml-definition
bool myHaveSeenInternalEdge
whether the loaded network contains internal lanes
LinkDirection parseLinkDir(const std::string &dir)
Parses the given character into an enumeration typed link direction.
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
void addParam(const std::string &key, const std::string &value)
Adds a parameter.
begin/end of the description of a neighboring lane
std::string getCurrentE3ID() const
Returns the id of the currently built e3 detector.
virtual SumoXMLNodeType getNodeType(bool &ok) const =0
Returns the value of the named attribute.
void buildInductLoop(const std::string &id, const std::string &lane, double pos, SUMOTime splInterval, const std::string &device, bool friendlyPos, const std::string &vTypes)
Builds an e1 detector and adds it to the net.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
virtual void addNeigh(const std::string id)
Adds a neighbor to the current lane.
void addOutgoing(MSEdge *edge)
description of a logic request within the junction
MSTLLogicControl & getTLLogicControlToUse() const
Returns the used tls control.
begin/end of the description of an edge
void addWAUTJunction(const std::string &wautid, const std::string &tls, const std::string &proc, bool synchron)
Adds a tls to the list of tls to be switched by the named WAUT.
virtual std::vector< std::string > getStringVector(int attr) const =0
Tries to read given attribute assuming it is a string vector.
std::string myCurrentWAUTID
The id of the currently processed WAUT.
virtual void myEndElement(int element)
Called when a closing tag occurs.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
a lane based mean data detector
trigger: the time of the step
virtual void addInstantE1Detector(const SUMOSAXAttributes &attrs)
Builds an e1 detector using the given specification.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
std::vector< std::string > LaneIdVector
virtual void closeEdge()
Closes the process of building an edge.
virtual void addRouteProbeDetector(const SUMOSAXAttributes &attrs)
Builds a routeProbe-detector using the given specification.
A train stop (alias for bus stop)
void addLane(const SUMOSAXAttributes &attrs)
adds a lane to the previously opened edge
bool myHaveSeenNeighs
whether the loaded network contains explicit neighbor lanes
a sink within a district (connection road)
the edges crossed by a pedestrian crossing
virtual ~NLHandler()
Destructor.
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
NLTriggerBuilder & myTriggerBuilder
The trigger builder to use.
double myNetworkVersion
the loaded network version
void initJunctionLogic(const std::string &id)
Initialises a junction logic.
The link is controlled by a tls which is off and blinks, has to brake.
static std::string checkForRelativity(const std::string &filename, const std::string &basePath)
Returns the path from a configuration so that it is accessable from the current working directory...
bool myNetIsLoaded
whether the location element was already loadee
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
virtual std::string getStringSecure(int id, const std::string &def) const =0
Returns the string-value of the named (by its enum-value) attribute.
void inform(std::string msg, bool addType=true)
adds a new error to the list
virtual MSLane * addLane(const std::string &id, double maxSpeed, double length, const PositionVector &shape, double width, SVCPermissions permissions, int index, bool isRampAccel)
Adds a lane to the current edge.
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
void addPhase(const SUMOSAXAttributes &attrs)
adds a phase to the traffic lights logic currently build
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
void addDistrictEdge(const SUMOSAXAttributes &attrs, bool isSource)
MSNet & myNet
The net to fill (preinitialised)
void beginEdgeParsing(const std::string &id, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority)
Begins building of an MSEdge.
static const GeoConvHelper & getFinal()
the coordinate transformation for writing the location element and for tracking the original coordina...
LinkState parseLinkState(const std::string &state)
Parses the given character into an enumeration typed link state.
The abstract direction of a link.
void setJunctions(MSJunction *from, MSJunction *to)
void buildE2Detector(const std::string &id, MSLane *lane, double pos, double endPos, double length, const std::string &device, SUMOTime frequency, SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold, const std::string &vTypes, bool friendlyPos, bool showDetector, MSTLLogicControl::TLSLogicVariants *tlls=0, MSLane *toLane=0)
Builds a new E2 detector and adds it to the net's detector control. Also performs some consistency ch...
The parent class for traffic light logics.
NLDiscreteEventBuilder myActionBuilder
A builder for object actions.
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
link: the index of the link within the traffic light
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
virtual void addCrossingEdges(const std::vector< std::string > &)
add the crossingEdges in a crossing edge if present
virtual void myEndElement(int element)
Called when a closing tag occurs.
MSTrafficLightLogic * getActive() const
virtual void addEdgeLaneMeanData(const SUMOSAXAttributes &attrs, int objecttype)
Builds edge or lane base mean data collector using the given specification.
Builds trigger objects for microsim.
void initJunctionLogic(const SUMOSAXAttributes &attrs)
begins the reading of a junction row logic
bool myLefthand
whether the loaded network was built for left hand traffic
Parameterised * myLastParameterised
An access point for a train stop.
void closePolygon()
ensures that the last position equals the first
Representation of a lane in the micro simulation.
void buildVaporizer(const SUMOSAXAttributes &attrs)
Builds a vaporization.
a single phase description
alternative tag for e3 detector
const std::string & getActiveKey() const
Returns the active key.
NLJunctionControlBuilder & myJunctionControlBuilder
The junction builder to use.
alternative tag for e2 detector
Parser and container for routes during their loading.
void initTrafficLightLogic(const SUMOSAXAttributes &attrs)
begins the reading of a traffic lights logic
static const Position INVALID
used to indicate that a position is valid
Interface for building edges.
void addLogicItem(int request, const std::string &response, const std::string &foes, bool cont)
Adds a logic item.