void
GNEDetectorE2::commitGeometryMoving(GNEUndoList* undoList) {
// commit geometry moving depending of number of lanes
if (getLaneParents().size() == 1) {
// commit new position allowing undo/redo
undoList->p_begin("position of " + getTagStr());
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition));
undoList->p_end();
} else {
undoList->p_begin("position of " + getTagStr());
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition));
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_ENDPOS, toString(myEndPositionOverLane), true, myMove.secondOriginalPosition));
undoList->p_end();
}
}
void
GNEClosingReroute::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_EDGE:
myClosedEdge = myViewNet->getNet()->retrieveEdge(value);
break;
case SUMO_ATTR_ALLOW:
myPermissions = parseVehicleClasses(value);
break;
case SUMO_ATTR_DISALLOW:
myPermissions = invertPermissions(parseVehicleClasses(value));
break;
case GNE_ATTR_GENERIC:
setGenericParametersStr(value);
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
// check if updated attribute requieres update geometry
if (myTagProperty.hasAttribute(key) && myTagProperty.getAttributeProperties(key).requiereUpdateGeometry()) {
updateGeometry();
}
}
std::string
GNECrossing::getAttribute(SumoXMLAttr key) const {
auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges, (key != SUMO_ATTR_ID));
switch (key) {
case SUMO_ATTR_ID:
// get attribute requieres a special case
if (crossing) {
return crossing->id;
} else {
return "Temporal Unreferenced";
}
case SUMO_ATTR_WIDTH:
return toString(crossing->customWidth);
case SUMO_ATTR_PRIORITY:
return crossing->priority ? "true" : "false";
case SUMO_ATTR_EDGES:
return toString(crossing->edges);
case SUMO_ATTR_TLLINKINDEX:
return toString(crossing->customTLIndex);
case SUMO_ATTR_TLLINKINDEX2:
return toString(crossing->customTLIndex2);
case SUMO_ATTR_CUSTOMSHAPE:
return toString(crossing->customShape);
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
std::string
GNEAccess::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_LANE:
return getLaneParents().front()->getID();
case SUMO_ATTR_POSITION:
return toString(myPositionOverLane);
case SUMO_ATTR_LENGTH:
return toString(myLength);
case SUMO_ATTR_FRIENDLY_POS:
return toString(myFriendlyPosition);
case GNE_ATTR_BLOCK_MOVEMENT:
return toString(myBlockMovement);
case GNE_ATTR_PARENT:
return getAdditionalParents().at(0)->getID();
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
std::string
GNEDetectorE1::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_LANE:
return getLaneParents().front()->getID();
case SUMO_ATTR_POSITION:
return toString(myPositionOverLane);
case SUMO_ATTR_FREQUENCY:
return toString(myFreq);
case SUMO_ATTR_NAME:
return myAdditionalName;
case SUMO_ATTR_FILE:
return myFilename;
case SUMO_ATTR_VTYPES:
return myVehicleTypes;
case SUMO_ATTR_FRIENDLY_POS:
return toString(myFriendlyPosition);
case GNE_ATTR_BLOCK_MOVEMENT:
return toString(myBlockMovement);
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEDetectorE2::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
if (value == getAttribute(key)) {
return; //avoid needless changes, later logic relies on the fact that attributes have changed
}
switch (key) {
case SUMO_ATTR_ID:
case SUMO_ATTR_LANE:
case SUMO_ATTR_LANES:
case SUMO_ATTR_POSITION:
case SUMO_ATTR_ENDPOS:
case SUMO_ATTR_FREQUENCY:
case SUMO_ATTR_LENGTH:
case SUMO_ATTR_NAME:
case SUMO_ATTR_FILE:
case SUMO_ATTR_VTYPES:
case SUMO_ATTR_HALTING_TIME_THRESHOLD:
case SUMO_ATTR_HALTING_SPEED_THRESHOLD:
case SUMO_ATTR_JAM_DIST_THRESHOLD:
case SUMO_ATTR_FRIENDLY_POS:
case GNE_ATTR_BLOCK_MOVEMENT:
case GNE_ATTR_SELECTED:
case GNE_ATTR_GENERIC:
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEPOI::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
if (value == getAttribute(key)) {
return; //avoid needless changes, later logic relies on the fact that attributes have changed
}
switch (key) {
case SUMO_ATTR_ID:
case SUMO_ATTR_COLOR:
case SUMO_ATTR_LANE:
case SUMO_ATTR_POSITION:
case SUMO_ATTR_POSITION_LAT:
case SUMO_ATTR_GEOPOSITION:
case SUMO_ATTR_GEO:
case SUMO_ATTR_TYPE:
case SUMO_ATTR_LAYER:
case SUMO_ATTR_IMGFILE:
case SUMO_ATTR_RELATIVEPATH:
case SUMO_ATTR_WIDTH:
case SUMO_ATTR_HEIGHT:
case SUMO_ATTR_ANGLE:
case GNE_ATTR_BLOCK_MOVEMENT:
case GNE_ATTR_SELECTED:
case GNE_ATTR_GENERIC:
undoList->p_add(new GNEChange_Attribute(this, myNet, key, value));
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
std::string
GNECalibrator::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_EDGE:
return getEdgeParents().front()->getID();
case SUMO_ATTR_LANE:
return getLaneParents().front()->getID();
case SUMO_ATTR_POSITION:
return toString(myPositionOverLane);
case SUMO_ATTR_FREQUENCY:
return toString(myFrequency);
case SUMO_ATTR_NAME:
return myAdditionalName;
case SUMO_ATTR_OUTPUT:
return myOutput;
case SUMO_ATTR_ROUTEPROBE:
return myRouteProbe;
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNECalibratorFlow::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
if (value == getAttribute(key)) {
return; //avoid needless changes, later logic relies on the fact that attributes have changed
}
switch (key) {
case SUMO_ATTR_ID:
case SUMO_ATTR_TYPE:
case SUMO_ATTR_ROUTE:
case SUMO_ATTR_COLOR:
case SUMO_ATTR_VEHSPERHOUR:
case SUMO_ATTR_SPEED:
case SUMO_ATTR_BEGIN:
case SUMO_ATTR_END:
case SUMO_ATTR_DEPARTLANE:
case SUMO_ATTR_DEPARTPOS:
case SUMO_ATTR_DEPARTSPEED:
case SUMO_ATTR_ARRIVALLANE:
case SUMO_ATTR_ARRIVALPOS:
case SUMO_ATTR_ARRIVALSPEED:
case SUMO_ATTR_LINE:
case SUMO_ATTR_PERSON_NUMBER:
case SUMO_ATTR_CONTAINER_NUMBER:
case SUMO_ATTR_REROUTE:
case SUMO_ATTR_DEPARTPOS_LAT:
case SUMO_ATTR_ARRIVALPOS_LAT:
case GNE_ATTR_GENERIC:
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEDetectorE1::commitGeometryMoving(GNEUndoList* undoList) {
// commit new position allowing undo/redo
undoList->p_begin("position of " + getTagStr());
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_POSITION, toString(myPositionOverLane), true, myMove.firstOriginalLanePosition));
undoList->p_end();
}
static STDataItem stringToItem(const STString &str)
{
STString itemTag = getFirstTagName(str);
if (itemTag.empty() ) {
return STDataItem("");
}
STString interTagStr = getTagStr(str, itemTag, false);
if (interTagStr.empty() ) {
return STDataItem("");
}
STDataItem item(itemTag);
if (isValueStr(interTagStr)) {
STString valueTag = getFirstTagName(interTagStr);
STString valueStr = getTagStr(interTagStr, valueTag);
if ("bool" == valueTag) {
item = stringToBool(valueStr);
}
else if ("int" == valueTag) {
item = stringToInt(valueStr);
}
else if ("string" == valueTag) {
item = valueStr;
}
}
else {
STString childStr = interTagStr;
int childPos = -1;
STString childTag = getFirstTagName(childStr, childPos);
while (!childTag.empty()) {
STString realChildStr = getTagStr(childStr, childTag, true);
STDataItem child = stringToItem(getTagStr(childStr, childTag, true));
if ( child.isValid() ) {
item.addChild(child);
}
childStr = childStr.substr(childPos+realChildStr.size()
, childStr.size()-childPos-realChildStr.size());
childTag = getFirstTagName(childStr, childPos);
}
}
return item;
}
bool
GNEDetectorE2::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidDetectorID(value);
case SUMO_ATTR_LANE:
if (value.empty()) {
return false;
} else {
return canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false);
}
case SUMO_ATTR_LANES:
if (value.empty()) {
return false;
} else if (canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false)) {
// check if lanes are consecutives
return lanesConsecutives(parse<std::vector<GNELane*> >(myViewNet->getNet(), value));
} else {
return false;
}
case SUMO_ATTR_POSITION:
return canParse<double>(value);
case SUMO_ATTR_ENDPOS:
return canParse<double>(value);
case SUMO_ATTR_FREQUENCY:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_LENGTH:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_NAME:
return SUMOXMLDefinitions::isValidAttribute(value);
case SUMO_ATTR_FILE:
return SUMOXMLDefinitions::isValidFilename(value);
case SUMO_ATTR_VTYPES:
if (value.empty()) {
return true;
} else {
return SUMOXMLDefinitions::isValidListOfTypeID(value);
}
case SUMO_ATTR_HALTING_TIME_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_HALTING_SPEED_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_JAM_DIST_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEPOI::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return SUMOXMLDefinitions::isValidNetID(value) && (myNet->retrievePOI(value, false) == nullptr);
case SUMO_ATTR_COLOR:
return canParse<RGBColor>(value);
case SUMO_ATTR_LANE:
return (myNet->retrieveLane(value, false) != nullptr);
case SUMO_ATTR_POSITION:
if (getLaneParents().size() > 0) {
return canParse<double>(value);
} else {
return canParse<Position>(value);
}
case SUMO_ATTR_POSITION_LAT:
return canParse<double>(value);
case SUMO_ATTR_GEOPOSITION: {
return canParse<Position>(value);
}
case SUMO_ATTR_GEO:
return canParse<bool>(value);
case SUMO_ATTR_TYPE:
return true;
case SUMO_ATTR_LAYER:
if (value == "default") {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_IMGFILE:
if (value == "") {
return true;
} else {
// check that image can be loaded
return GUITexturesHelper::getTextureID(value) != -1;
}
case SUMO_ATTR_RELATIVEPATH:
return canParse<bool>(value);
case SUMO_ATTR_WIDTH:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_HEIGHT:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_ANGLE:
return canParse<double>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEPOI::commitGeometryMoving(const Position& oldPos, GNEUndoList* undoList) {
if (!myBlockMovement) {
// restore original Position before moving (to avoid problems in GL Tree)
Position myNewPosition(*this);
set(oldPos);
// commit new position allowing undo/redo
if (getLaneParents().size() > 0) {
// restore old position before commit new position
double originalPosOverLane = getLaneParents().at(0)->getGeometry().shape.nearest_offset_to_point2D(oldPos, false);
undoList->p_begin("position of " + getTagStr());
undoList->p_add(new GNEChange_Attribute(this, myNet, SUMO_ATTR_POSITION, toString(myPosOverLane), true, toString(originalPosOverLane)));
undoList->p_end();
} else {
undoList->p_begin("position of " + getTagStr());
undoList->p_add(new GNEChange_Attribute(this, myNet, SUMO_ATTR_POSITION, toString(myNewPosition), true, toString(oldPos)));
undoList->p_end();
}
}
}
void
GNEConnection::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
switch (key) {
case SUMO_ATTR_FROM:
case SUMO_ATTR_TO:
case SUMO_ATTR_FROM_LANE:
case SUMO_ATTR_TO_LANE:
case SUMO_ATTR_PASS:
case SUMO_ATTR_KEEP_CLEAR:
case SUMO_ATTR_CONTPOS:
case SUMO_ATTR_UNCONTROLLED:
case SUMO_ATTR_VISIBILITY_DISTANCE:
case SUMO_ATTR_SPEED:
case SUMO_ATTR_CUSTOMSHAPE:
case GNE_ATTR_SELECTED:
case GNE_ATTR_GENERIC:
// no special handling
undoList->p_add(new GNEChange_Attribute(this, myNet, key, value));
break;
case SUMO_ATTR_TLLINKINDEX:
if (value != getAttribute(key)) {
// trigger GNEChange_TLS
undoList->p_begin("change tls linkIndex for connection");
// make a copy
std::set<NBTrafficLightDefinition*> defs = getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS();
for (NBTrafficLightDefinition* tlDef : defs) {
NBLoadedSUMOTLDef* sumoDef = dynamic_cast<NBLoadedSUMOTLDef*>(tlDef);
NBTrafficLightLogic* tllogic = sumoDef ? sumoDef->getLogic() : tlDef->compute(OptionsCont::getOptions());
if (tllogic != nullptr) {
NBLoadedSUMOTLDef* newDef = new NBLoadedSUMOTLDef(tlDef, tllogic);
newDef->addConnection(getEdgeFrom()->getNBEdge(), getEdgeTo()->getNBEdge(),
getLaneFrom()->getIndex(), getLaneTo()->getIndex(), parse<int>(value), false);
std::vector<NBNode*> nodes = tlDef->getNodes();
for (NBNode* node : nodes) {
GNEJunction* junction = getNet()->retrieveJunction(node->getID());
undoList->add(new GNEChange_TLS(junction, tlDef, false), true);
undoList->add(new GNEChange_TLS(junction, newDef, true), true);
}
} else {
WRITE_ERROR("Could not set attribute '" + toString(key) + "' (tls is broken)");
}
}
undoList->p_end();
}
break;
case SUMO_ATTR_DIR:
throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified");
case SUMO_ATTR_STATE:
throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified");
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEDemandElement::changeDemandElementID(const std::string& newID) {
if (myViewNet->getNet()->retrieveDemandElement(myTagProperty.getTag(), newID, false) != nullptr) {
throw InvalidArgument("An DemandElement with tag " + getTagStr() + " and ID = " + newID + " already exists");
} else {
// Save old ID
std::string oldID = getMicrosimID();
// set New ID
setMicrosimID(newID);
// update demand element ID in the container of net
myViewNet->getNet()->updateDemandElementID(oldID, this);
}
}
std::string
GNECalibratorFlow::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_TYPE:
return myVehicleType->getID();
case SUMO_ATTR_ROUTE:
return myRoute->getID();
case SUMO_ATTR_VEHSPERHOUR:
return toString(myVehsPerHour);
case SUMO_ATTR_SPEED:
return toString(mySpeed);
case SUMO_ATTR_COLOR:
return toString(myColor);
case SUMO_ATTR_BEGIN:
return toString(myBegin);
case SUMO_ATTR_END:
return toString(myEnd);
case SUMO_ATTR_DEPARTLANE:
return myDepartLane;
case SUMO_ATTR_DEPARTPOS:
return myDepartPos;
case SUMO_ATTR_DEPARTSPEED:
return myDepartSpeed;
case SUMO_ATTR_ARRIVALLANE:
return myArrivalLane;
case SUMO_ATTR_ARRIVALPOS:
return myArrivalPos;
case SUMO_ATTR_ARRIVALSPEED:
return myArrivalSpeed;
case SUMO_ATTR_LINE:
return myLine;
case SUMO_ATTR_PERSON_NUMBER:
return toString(myPersonNumber);
case SUMO_ATTR_CONTAINER_NUMBER:
return toString(myContainerNumber);
case SUMO_ATTR_REROUTE:
return toString(myReroute);
case SUMO_ATTR_DEPARTPOS_LAT:
return myDepartPosLat;
case SUMO_ATTR_ARRIVALPOS_LAT:
return myArrivalPosLat;
case GNE_ATTR_PARENT:
return getAdditionalParents().at(0)->getID();
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEConnection::setAttribute(SumoXMLAttr key, const std::string& value) {
NBEdge::Connection& nbCon = getNBEdgeConnection();
switch (key) {
case SUMO_ATTR_PASS:
nbCon.mayDefinitelyPass = parse<bool>(value);
break;
case SUMO_ATTR_KEEP_CLEAR:
nbCon.keepClear = parse<bool>(value);
break;
case SUMO_ATTR_UNCONTROLLED:
nbCon.uncontrolled = parse<bool>(value);
break;
case SUMO_ATTR_CONTPOS:
nbCon.contPos = parse<double>(value);
break;
case SUMO_ATTR_VISIBILITY_DISTANCE:
nbCon.visibility = parse<double>(value);
break;
case SUMO_ATTR_SPEED:
nbCon.speed = parse<double>(value);
break;
case SUMO_ATTR_STATE:
throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified");
case SUMO_ATTR_DIR:
throw InvalidArgument("Attribute of '" + toString(key) + "' cannot be modified");
case SUMO_ATTR_CUSTOMSHAPE: {
nbCon.customShape = parse<PositionVector>(value);
break;
}
case GNE_ATTR_SELECTED:
if (parse<bool>(value)) {
selectAttributeCarrier();
} else {
unselectAttributeCarrier();
}
break;
case GNE_ATTR_GENERIC:
setGenericParametersStr(value);
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
// Update Geometry after setting a new attribute (but avoided for certain attributes)
if ((key != SUMO_ATTR_ID) && (key != GNE_ATTR_GENERIC) && (key != GNE_ATTR_SELECTED)) {
const bool init = (myShape.size() == 0);
markConnectionGeometryDeprecated();
updateGeometry(!init);
}
}
bool
GNECrossing::isValid(SumoXMLAttr key, const std::string& value) {
auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges);
switch (key) {
case SUMO_ATTR_ID:
return false;
case SUMO_ATTR_EDGES:
if (canParse<std::vector<GNEEdge*> >(myNet, value, false)) {
// parse edges and save their IDs in a set
std::vector<GNEEdge*> parsedEdges = parse<std::vector<GNEEdge*> >(myNet, value);
EdgeVector nbEdges;
for (auto i : parsedEdges) {
nbEdges.push_back(i->getNBEdge());
}
std::sort(nbEdges.begin(), nbEdges.end());
//
EdgeVector originalEdges = crossing->edges;
std::sort(originalEdges.begin(), originalEdges.end());
// return true if we're setting the same edges
if (toString(nbEdges) == toString(originalEdges)) {
return true;
} else {
return !myParentJunction->getNBNode()->checkCrossingDuplicated(nbEdges);
}
} else {
return false;
}
case SUMO_ATTR_WIDTH:
return canParse<double>(value) && ((parse<double>(value) > 0) || (parse<double>(value) == -1)); // kann NICHT 0 sein, oder -1 (bedeutet default)
case SUMO_ATTR_PRIORITY:
return canParse<bool>(value);
case SUMO_ATTR_TLLINKINDEX:
case SUMO_ATTR_TLLINKINDEX2:
return (crossing->tlID != "" && canParse<int>(value)
// -1 means that tlLinkIndex2 takes on the same value as tlLinkIndex when setting idnices
&& ((parse<double>(value) >= 0) || ((parse<double>(value) == -1) && (key == SUMO_ATTR_TLLINKINDEX2)))
&& myParentJunction->getNBNode()->getControllingTLS().size() > 0
&& (*myParentJunction->getNBNode()->getControllingTLS().begin())->getMaxValidIndex() >= parse<int>(value));
case SUMO_ATTR_CUSTOMSHAPE: {
// empty shapes are allowed
return canParse<PositionVector>(value);
}
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEStop::commitGeometryMoving(GNEUndoList* undoList) {
// only commit geometry moving if at leats start or end positions is defined
if ((getLaneParents().size() > 0) && ((parametersSet & STOP_START_SET) || (parametersSet & STOP_END_SET))) {
undoList->p_begin("position of " + getTagStr());
if (parametersSet & STOP_START_SET) {
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_STARTPOS, toString(startPos), true, myMove.firstOriginalLanePosition));
}
if (parametersSet & STOP_END_SET) {
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), SUMO_ATTR_ENDPOS, toString(endPos), true, myMove.secondOriginalPosition));
}
undoList->p_end();
}
}
GUIGLObjectPopupMenu*
GNEDemandElement::getPopUpMenu(GUIMainWindow& app, GUISUMOAbstractView& parent) {
GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
// build header
buildPopupHeader(ret, app);
// build menu command for center button and copy cursor position to clipboard
buildCenterPopupEntry(ret);
buildPositionCopyEntry(ret, false);
// buld menu commands for names
new FXMenuCommand(ret, ("Copy " + getTagStr() + " name to clipboard").c_str(), nullptr, ret, MID_COPY_NAME);
new FXMenuCommand(ret, ("Copy " + getTagStr() + " typed name to clipboard").c_str(), nullptr, ret, MID_COPY_TYPED_NAME);
new FXMenuSeparator(ret);
// build selection and show parameters menu
myViewNet->buildSelectionACPopupEntry(ret, this);
buildShowParamsPopupEntry(ret);
// show option to open demand element dialog
if (myTagProperty.hasDialog()) {
new FXMenuCommand(ret, ("Open " + getTagStr() + " Dialog").c_str(), getIcon(), &parent, MID_OPEN_ADDITIONAL_DIALOG);
new FXMenuSeparator(ret);
}
new FXMenuCommand(ret, ("Cursor position in view: " + toString(getPositionInView().x()) + "," + toString(getPositionInView().y())).c_str(), nullptr, nullptr, 0);
return ret;
}
std::string
GNEPOI::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return myID;
case SUMO_ATTR_COLOR:
return toString(getShapeColor());
case SUMO_ATTR_LANE:
return myLane;
case SUMO_ATTR_POSITION:
if (getLaneParents().size() > 0) {
return toString(myPosOverLane);
} else {
return toString(*this);
}
case SUMO_ATTR_POSITION_LAT:
return toString(myPosLat);
case SUMO_ATTR_GEOPOSITION:
return toString(myGEOPosition, gPrecisionGeo);
case SUMO_ATTR_GEO:
return toString(myGeo);
case SUMO_ATTR_TYPE:
return getShapeType();
case SUMO_ATTR_LAYER:
if (getShapeLayer() == Shape::DEFAULT_LAYER_POI) {
return "default";
} else {
return toString(getShapeLayer());
}
case SUMO_ATTR_IMGFILE:
return getShapeImgFile();
case SUMO_ATTR_RELATIVEPATH:
return toString(getShapeRelativePath());
case SUMO_ATTR_WIDTH:
return toString(getWidth());
case SUMO_ATTR_HEIGHT:
return toString(getHeight());
case SUMO_ATTR_ANGLE:
return toString(getShapeNaviDegree());
case GNE_ATTR_BLOCK_MOVEMENT:
return toString(myBlockMovement);
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " attribute '" + toString(key) + "' not allowed");
}
}
bool
GNERouteProbReroute::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_ROUTE:
return SUMOXMLDefinitions::isValidVehicleID(value);
case SUMO_ATTR_PROB:
return canParse<double>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNEDetectorE1::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_LANE:
changeLaneParents(this, value);
break;
case SUMO_ATTR_POSITION:
myPositionOverLane = parse<double>(value);
break;
case SUMO_ATTR_FREQUENCY:
myFreq = parse<double>(value);
break;
case SUMO_ATTR_FILE:
myFilename = value;
break;
case SUMO_ATTR_NAME:
myAdditionalName = value;
break;
case SUMO_ATTR_VTYPES:
myVehicleTypes = value;
break;
case SUMO_ATTR_FRIENDLY_POS:
myFriendlyPosition = parse<bool>(value);
break;
case GNE_ATTR_BLOCK_MOVEMENT:
myBlockMovement = parse<bool>(value);
break;
case GNE_ATTR_SELECTED:
if (parse<bool>(value)) {
selectAttributeCarrier();
} else {
unselectAttributeCarrier();
}
break;
case GNE_ATTR_GENERIC:
setGenericParametersStr(value);
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
// check if updated attribute requieres update geometry
if (myTagProperty.hasAttribute(key) && myTagProperty.getAttributeProperties(key).requiereUpdateGeometry()) {
updateGeometry();
}
}
bool
GNEClosingLaneReroute::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_LANE:
return (myViewNet->getNet()->retrieveLane(value, false) != nullptr);
case SUMO_ATTR_ALLOW:
case SUMO_ATTR_DISALLOW:
return canParseVehicleClasses(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
void
GNERouteProbReroute::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
if (value == getAttribute(key)) {
return; //avoid needless changes, later logic relies on the fact that attributes have changed
}
switch (key) {
case SUMO_ATTR_ID:
case SUMO_ATTR_ROUTE:
case SUMO_ATTR_PROB:
case GNE_ATTR_GENERIC:
undoList->p_add(new GNEChange_Attribute(this, myViewNet->getNet(), key, value));
break;
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEConnection::isValid(SumoXMLAttr key, const std::string& value) {
// Currently ignored before implementation to avoid warnings
switch (key) {
case SUMO_ATTR_FROM:
case SUMO_ATTR_TO:
case SUMO_ATTR_FROM_LANE:
case SUMO_ATTR_TO_LANE:
return false;
case SUMO_ATTR_PASS:
return canParse<bool>(value);
case SUMO_ATTR_KEEP_CLEAR:
return canParse<bool>(value);
case SUMO_ATTR_CONTPOS:
return canParse<double>(value);
case SUMO_ATTR_UNCONTROLLED:
return canParse<bool>(value);
case SUMO_ATTR_VISIBILITY_DISTANCE:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_TLLINKINDEX:
if (getNBEdgeConnection().uncontrolled == false
&& getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().size() > 0
&& canParse<int>(value)
&& parse<int>(value) >= 0) {
NBTrafficLightDefinition* def = *getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().begin();
return def->getMaxValidIndex() >= parse<int>(value);
} else {
return false;
}
case SUMO_ATTR_SPEED:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_CUSTOMSHAPE: {
// empty custom shapes are allowed
return canParse<PositionVector>(value);
}
case SUMO_ATTR_STATE:
return false;
case SUMO_ATTR_DIR:
return false;
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
std::string
GNEConnection::getAttribute(SumoXMLAttr key) const {
if (key == SUMO_ATTR_ID) {
// used by GNEReferenceCounter
// @note: may be called for connections without a valid nbCon reference
return getMicrosimID();
}
NBEdge::Connection& nbCon = getNBEdgeConnection();
switch (key) {
case SUMO_ATTR_FROM:
return getEdgeFrom()->getID();
case SUMO_ATTR_TO:
return nbCon.toEdge->getID();
case SUMO_ATTR_FROM_LANE:
return toString(nbCon.toLane);
case SUMO_ATTR_TO_LANE:
return toString(nbCon.toLane);
case SUMO_ATTR_PASS:
return toString(nbCon.mayDefinitelyPass);
case SUMO_ATTR_KEEP_CLEAR:
return toString(nbCon.keepClear);
case SUMO_ATTR_CONTPOS:
return toString(nbCon.contPos);
case SUMO_ATTR_UNCONTROLLED:
return toString(nbCon.uncontrolled);
case SUMO_ATTR_VISIBILITY_DISTANCE:
return toString(nbCon.visibility);
case SUMO_ATTR_TLLINKINDEX:
return toString(nbCon.tlLinkIndex);
case SUMO_ATTR_SPEED:
return toString(nbCon.speed);
case SUMO_ATTR_DIR:
return toString(getEdgeFrom()->getNBEdge()->getToNode()->getDirection(
getEdgeFrom()->getNBEdge(), nbCon.toEdge, OptionsCont::getOptions().getBool("lefthand")));
case SUMO_ATTR_STATE:
return toString(getEdgeFrom()->getNBEdge()->getToNode()->getLinkState(
getEdgeFrom()->getNBEdge(), nbCon.toEdge, nbCon.fromLane, nbCon.toLane, nbCon.mayDefinitelyPass, nbCon.tlID));
case SUMO_ATTR_CUSTOMSHAPE:
return toString(nbCon.customShape);
case GNE_ATTR_SELECTED:
return toString(isAttributeCarrierSelected());
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
std::string
GNERouteProbReroute::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_ROUTE:
return myNewRouteId;
case SUMO_ATTR_PROB:
return toString(myProbability);
case GNE_ATTR_PARENT:
return getAdditionalParents().at(0)->getID();
case GNE_ATTR_GENERIC:
return getGenericParametersStr();
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNECalibrator::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_EDGE:
if (myViewNet->getNet()->retrieveEdge(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_LANE:
if (myViewNet->getNet()->retrieveLane(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_POSITION:
if (canParse<double>(value)) {
// obtain position and check if is valid
double newPosition = parse<double>(value);
PositionVector shape = (getLaneParents().size() > 0) ? getLaneParents().front()->getGeometry().shape : getEdgeParents().front()->getLanes().at(0)->getGeometry().shape;
if ((newPosition < 0) || (newPosition > shape.length())) {
return false;
} else {
return true;
}
} else {
return false;
}
case SUMO_ATTR_FREQUENCY:
return (canParse<double>(value) && parse<double>(value) >= 0);
case SUMO_ATTR_NAME:
return SUMOXMLDefinitions::isValidAttribute(value);
case SUMO_ATTR_OUTPUT:
return SUMOXMLDefinitions::isValidFilename(value);
case SUMO_ATTR_ROUTEPROBE:
return SUMOXMLDefinitions::isValidNetID(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
