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();
}
}
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);
}
}
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();
}
}
void
GNECalibrator::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_EDGE:
changeEdgeParents(this, value);
break;
case SUMO_ATTR_LANE:
changeLaneParents(this, value);
break;
case SUMO_ATTR_POSITION:
myPositionOverLane = parse<double>(value);
break;
case SUMO_ATTR_FREQUENCY:
myFrequency = parse<double>(value);
break;
case SUMO_ATTR_NAME:
myAdditionalName = value;
break;
case SUMO_ATTR_OUTPUT:
myOutput = value;
break;
case SUMO_ATTR_ROUTEPROBE:
myRouteProbe = 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();
}
}
void
GNERouteProbReroute::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_ROUTE:
myNewRouteId = value;
break;
case SUMO_ATTR_PROB:
myProbability = parse<double>(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(true);
}
}
void
GNEDetectorExit::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_LANE:
myLane = changeLane(myLane, value);
break;
case SUMO_ATTR_POSITION:
myPositionOverLane = parse<double>(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_PARENT:
changeFirstAdditionalParent(value);
break;
case GNE_ATTR_SELECTED:
if(parse<bool>(value)) {
selectAttributeCarrier();
} else {
unselectAttributeCarrier();
}
break;
case GNE_ATTR_GENERIC:
setGenericParametersStr(value);
break;
default:
throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
}
// After setting attribute always update Geometry
updateGeometry();
}
void
GNECalibratorFlow::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeAdditionalID(value);
break;
case SUMO_ATTR_TYPE:
myVehicleType = myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, value);
break;
case SUMO_ATTR_ROUTE:
myRoute = myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_ROUTE, value);
break;
case SUMO_ATTR_VEHSPERHOUR:
myVehsPerHour = value;
break;
case SUMO_ATTR_SPEED:
mySpeed = value;
break;
case SUMO_ATTR_COLOR:
myColor = parse<RGBColor>(value);
break;
case SUMO_ATTR_BEGIN:
myBegin = parse<double>(value);
break;
case SUMO_ATTR_END:
myEnd = parse<double>(value);
break;
case SUMO_ATTR_DEPARTLANE:
myDepartLane = value;
break;
case SUMO_ATTR_DEPARTPOS:
myDepartPos = value;
break;
case SUMO_ATTR_DEPARTSPEED:
myDepartSpeed = value;
break;
case SUMO_ATTR_ARRIVALLANE:
myArrivalLane = value;
break;
case SUMO_ATTR_ARRIVALPOS:
myArrivalPos = value;
break;
case SUMO_ATTR_ARRIVALSPEED:
myArrivalSpeed = value;
break;
case SUMO_ATTR_LINE:
myLine = value;
break;
case SUMO_ATTR_PERSON_NUMBER:
myPersonNumber = parse<int>(value);
break;
case SUMO_ATTR_CONTAINER_NUMBER:
myContainerNumber = parse<int>(value);
break;
case SUMO_ATTR_REROUTE:
myReroute = parse<bool>(value);
break;
case SUMO_ATTR_DEPARTPOS_LAT:
myDepartPosLat = value;
break;
case SUMO_ATTR_ARRIVALPOS_LAT:
myArrivalPosLat = 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(true);
}
}
void
GNEStop::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
changeDemandElementID(value);
break;
case SUMO_ATTR_DURATION:
duration = string2time(value);
break;
case SUMO_ATTR_UNTIL:
until = string2time(value);
break;
case SUMO_ATTR_INDEX:
if (value == "fit") {
index = STOP_INDEX_FIT;
} else if (value == "end") {
index = STOP_INDEX_END;
} else {
index = parse<int>(value);
}
break;
case SUMO_ATTR_TRIGGERED:
if (value.empty()) {
parametersSet &= ~STOP_TRIGGER_SET;
} else {
triggered = parse<bool>(value);
parametersSet |= STOP_TRIGGER_SET;
}
break;
case SUMO_ATTR_CONTAINER_TRIGGERED:
if (value.empty()) {
parametersSet &= ~STOP_CONTAINER_TRIGGER_SET;
} else {
containerTriggered = parse<bool>(value);
parametersSet |= STOP_CONTAINER_TRIGGER_SET;
}
break;
case SUMO_ATTR_EXPECTED:
if (value.empty()) {
parametersSet &= ~STOP_EXPECTED_SET;
} else {
awaitedPersons = parse<std::set<std::string> >(value);
parametersSet |= STOP_EXPECTED_SET;
}
break;
case SUMO_ATTR_EXPECTED_CONTAINERS:
if (value.empty()) {
parametersSet &= ~STOP_EXPECTED_CONTAINERS_SET;
} else {
awaitedContainers = parse<std::set<std::string> >(value);
parametersSet |= STOP_EXPECTED_CONTAINERS_SET;
}
break;
case SUMO_ATTR_PARKING:
if (value.empty()) {
parametersSet &= ~STOP_PARKING_SET;
} else {
parking = parse<bool>(value);
parametersSet |= STOP_PARKING_SET;
}
break;
case SUMO_ATTR_ACTTYPE:
// CHECK
break;
case SUMO_ATTR_TRIP_ID:
if (value.empty()) {
parametersSet &= ~STOP_TRIP_ID_SET;
} else {
tripId = value;
parametersSet |= STOP_TRIP_ID_SET;
}
break;
// specific of Stops over stoppingPlaces
case SUMO_ATTR_BUS_STOP:
case SUMO_ATTR_CONTAINER_STOP:
case SUMO_ATTR_CHARGING_STATION:
case SUMO_ATTR_PARKING_AREA:
changeAdditionalParent(this, value, 0);
break;
// specific of Stops over lanes
case SUMO_ATTR_LANE:
changeLaneParents(this, value);
break;
case SUMO_ATTR_STARTPOS:
if (value.empty()) {
parametersSet &= ~STOP_START_SET;
} else {
startPos = parse<double>(value);
parametersSet |= STOP_START_SET;
}
break;
case SUMO_ATTR_ENDPOS:
if (value.empty()) {
parametersSet &= ~STOP_END_SET;
} else {
endPos = parse<double>(value);
parametersSet |= STOP_END_SET;
}
break;
case SUMO_ATTR_FRIENDLY_POS:
myFriendlyPosition = 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(true);
}
}
void
GNEPOI::setAttribute(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID: {
std::string oldID = myID;
myID = value;
myNet->changeShapeID(this, oldID);
setMicrosimID(value);
break;
}
case SUMO_ATTR_COLOR:
setShapeColor(parse<RGBColor>(value));
break;
case SUMO_ATTR_LANE:
myLane = value;
changeLaneParents(this, value);
break;
case SUMO_ATTR_POSITION: {
if (getLaneParents().size() > 0) {
myPosOverLane = parse<double>(value);
} else {
// first remove object from grid due position is used for boundary
myNet->removeGLObjectFromGrid(this);
// set position
set(parse<Position>(value));
// set GEO Position
myGEOPosition = *this;
GeoConvHelper::getFinal().cartesian2geo(myGEOPosition);
// add object into grid again
myNet->addGLObjectIntoGrid(this);
}
break;
}
case SUMO_ATTR_POSITION_LAT:
// first remove object from grid due position is used for boundary
myNet->removeGLObjectFromGrid(this);
myPosLat = parse<double>(value);
// add object into grid again
myNet->addGLObjectIntoGrid(this);
break;
case SUMO_ATTR_GEOPOSITION: {
// first remove object from grid due position is used for boundary
myNet->removeGLObjectFromGrid(this);
myGEOPosition = parse<Position>(value);
// set cartesian Position
set(myGEOPosition);
GeoConvHelper::getFinal().x2cartesian_const(*this);
// add object into grid again
myNet->addGLObjectIntoGrid(this);
break;
}
case SUMO_ATTR_GEO:
myGeo = parse<bool>(value);
break;
case SUMO_ATTR_TYPE:
setShapeType(value);
break;
case SUMO_ATTR_LAYER:
if (value == "default") {
setShapeLayer(Shape::DEFAULT_LAYER_POI);
} else {
setShapeLayer(parse<double>(value));
}
break;
case SUMO_ATTR_IMGFILE:
// first remove object from grid due img file affect to boundary
myNet->removeGLObjectFromGrid(this);
setShapeImgFile(value);
// all textures must be refresh
GUITexturesHelper::clearTextures();
// add object into grid again
myNet->addGLObjectIntoGrid(this);
break;
case SUMO_ATTR_RELATIVEPATH:
setShapeRelativePath(parse<bool>(value));
break;
case SUMO_ATTR_WIDTH:
// first remove object from grid due position is used for boundary
myNet->removeGLObjectFromGrid(this);
setWidth(parse<double>(value));
// add object into grid again
myNet->addGLObjectIntoGrid(this);
break;
case SUMO_ATTR_HEIGHT:
// first remove object from grid due position is used for boundary
myNet->removeGLObjectFromGrid(this);
setHeight(parse<double>(value));
// add object into grid again
myNet->addGLObjectIntoGrid(this);
break;
case SUMO_ATTR_ANGLE:
setShapeNaviDegree(parse<double>(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() + " attribute '" + toString(key) + "' not allowed");
}
// check if updated attribute requieres update geometry
if (myTagProperty.hasAttribute(key) && myTagProperty.getAttributeProperties(key).requiereUpdateGeometry()) {
updateGeometry();
}
}
void
GNECrossing::setAttribute(SumoXMLAttr key, const std::string& value) {
auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges);
switch (key) {
case SUMO_ATTR_ID:
throw InvalidArgument("Modifying attribute '" + toString(key) + "' of " + getTagStr() + " isn't allowed");
case SUMO_ATTR_EDGES: {
// obtain GNEEdges
std::vector<GNEEdge*> edges = parse<std::vector<GNEEdge*> >(myNet, value);
// remove NBEdges of crossing
crossing->edges.clear();
// set NBEdge of every GNEEdge into Crossing Edges
for (auto i : edges) {
crossing->edges.push_back(i->getNBEdge());
}
// sort new edges
std::sort(crossing->edges.begin(), crossing->edges.end());
// change myCrossingEdges by the new edges
myCrossingEdges = crossing->edges;
// update geometry of parent junction
myParentJunction->updateGeometry(true);
break;
}
case SUMO_ATTR_WIDTH:
// Change width an refresh element
crossing->customWidth = parse<double>(value);
break;
case SUMO_ATTR_PRIORITY:
crossing->priority = parse<bool>(value);
break;
case SUMO_ATTR_TLLINKINDEX:
crossing->customTLIndex = parse<int>(value);
// make new value visible immediately
crossing->tlLinkIndex = crossing->customTLIndex;
break;
case SUMO_ATTR_TLLINKINDEX2:
crossing->customTLIndex2 = parse<int>(value);
// make new value visible immediately
crossing->tlLinkIndex2 = crossing->customTLIndex2;
break;
case SUMO_ATTR_CUSTOMSHAPE: {
// first remove object from grid
myNet->removeGLObjectFromGrid(this);
// set custom shape
crossing->customShape = parse<PositionVector>(value);
// insert object in grid again
myNet->removeGLObjectFromGrid(this);
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) + "'");
}
// Crossing are a special case and we need ot update geometry of junction instead of crossing
if ((key != SUMO_ATTR_ID) && (key != GNE_ATTR_GENERIC) && (key != GNE_ATTR_SELECTED)) {
myParentJunction->updateGeometry(true);
}
}
