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) + "'");
}
}
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) + "'");
}
}
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) + "'");
}
}
long
GNEFrame::GenericParametersEditor::onCmdEditGenericParameter(FXObject*, FXSelector, void*) {
// edit generic parameters using dialog
if(GNEGenericParameterDialog(myFrameParent->getViewNet(), myGenericParameters).execute()) {
// set values edited in Parameter dialog in Edited AC
if(myAC) {
myAC->setAttribute(GNE_ATTR_GENERIC, getGenericParametersStr(), myFrameParent->getViewNet()->getUndoList());
} else if (myACs.size() > 0) {
myFrameParent->getViewNet()->getUndoList()->p_begin("Change multiple generic attributes");
for (auto i : myACs) {
i->setAttribute(GNE_ATTR_GENERIC, getGenericParametersStr(), myFrameParent->getViewNet()->getUndoList());
}
myFrameParent->getViewNet()->getUndoList()->p_end();
}
// Refresh parameter editor
refreshGenericParametersEditor();
}
return 1;
}
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) + "'");
}
}
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");
}
}
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) + "'");
}
}
std::string
GNEClosingReroute::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_EDGE:
return myClosedEdge->getID();
case SUMO_ATTR_ALLOW:
return getVehicleClassNames(myPermissions);
case SUMO_ATTR_DISALLOW:
return getVehicleClassNames(invertPermissions(myPermissions));
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
GNEFrame::GenericParametersEditor::refreshGenericParametersEditor() {
// update text field depending of AC
if(myAC) {
myTextFieldGenericParameter->setText(getGenericParametersStr().c_str());
myTextFieldGenericParameter->setTextColor(FXRGB(0, 0, 0));
} else if(myACs.size()) {
// check if generic parameters of all inspected ACs are different
std::string genericParameter = myACs.front()->getAttribute(GNE_ATTR_GENERIC);
for (auto i : myACs) {
if(genericParameter != i->getAttribute(GNE_ATTR_GENERIC)) {
genericParameter = "different generic attributes";
}
}
myTextFieldGenericParameter->setText(genericParameter.c_str());
myTextFieldGenericParameter->setTextColor(FXRGB(0, 0, 0));
}
}
std::string
GNEDetectorE2::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getAdditionalID();
case SUMO_ATTR_LANE:
case SUMO_ATTR_LANES:
return parseIDs(getLaneParents());
case SUMO_ATTR_POSITION:
return toString(myPositionOverLane);
case SUMO_ATTR_ENDPOS:
return toString(myEndPositionOverLane);
case SUMO_ATTR_FREQUENCY:
return toString(myFreq);
case SUMO_ATTR_LENGTH:
return toString(myLength);
case SUMO_ATTR_NAME:
return myAdditionalName;
case SUMO_ATTR_FILE:
return myFilename;
case SUMO_ATTR_VTYPES:
return myVehicleTypes;
case SUMO_ATTR_HALTING_TIME_THRESHOLD:
return toString(myTimeThreshold);
case SUMO_ATTR_HALTING_SPEED_THRESHOLD:
return toString(mySpeedThreshold);
case SUMO_ATTR_JAM_DIST_THRESHOLD:
return toString(myJamThreshold);
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) + "'");
}
}
long
GNEFrame::GenericParametersEditor::onCmdSetGenericParameter(FXObject*, FXSelector, void*) {
// separate value in a vector of string using | as separator
std::vector<std::string> parsedValues;
StringTokenizer st(myTextFieldGenericParameter->getText().text(), "|", true);
while (st.hasNext()) {
parsedValues.push_back(st.next());
}
// first check if parsed generic parameters are valid
for(auto i : parsedValues) {
if(!GNEAttributeCarrier::isGenericParametersValid(i)) {
WRITE_WARNING("Invalid format of Generic Parameter (" + i + ")");
myTextFieldGenericParameter->setTextColor(FXRGB(255, 0, 0));
return 1;
}
}
// now check if there is duplicated parameters
std::sort(parsedValues.begin(), parsedValues.end());
for (auto i = parsedValues.begin(); i != parsedValues.end(); i++) {
if(((i+1) != parsedValues.end())) {
std::vector<std::string> firstKey, secondKey;
StringTokenizer stKey1(*i, "=", true);
StringTokenizer stKey2(*(i+1), "=", true);
//parse both keys
while (stKey1.hasNext()) {
firstKey.push_back(stKey1.next());
}
while (stKey2.hasNext()) {
secondKey.push_back(stKey2.next());
}
// compare both keys and stop if are equal
if((firstKey.size() != 2) || (secondKey.size() != 2) || (firstKey.front() == secondKey.front())) {
WRITE_WARNING("Generic Parameters wit the same key aren't allowed (" + (*i) + "," + *(i+1) + ")");
myTextFieldGenericParameter->setTextColor(FXRGB(255, 0, 0));
return 1;
}
}
}
// parsed generic parameters ok, then set text field black and continue
myTextFieldGenericParameter->setTextColor(FXRGB(0, 0, 0));
myTextFieldGenericParameter->killFocus();
// clear current existent generic parameters and set parsed generic parameters
myGenericParameters->clear();
for(auto i : parsedValues) {
std::vector<std::string> parsedParameters;
StringTokenizer stParam(i, "=", true);
while (stParam.hasNext()) {
parsedParameters.push_back(stParam.next());
}
// Check that parsed parameters are exactly two and contains valid chracters
if(parsedParameters.size() == 2 && SUMOXMLDefinitions::isValidNetID(parsedParameters.front()) && SUMOXMLDefinitions::isValidAttribute(parsedParameters.back())) {
myGenericParameters->push_back(std::make_pair(parsedParameters.front(), parsedParameters.back()));
}
}
// if we're editing generic attributes of an AttributeCarrier, set it
if(myAC) {
myAC->setAttribute(GNE_ATTR_GENERIC, getGenericParametersStr(), myFrameParent->getViewNet()->getUndoList());
} else if (myACs.size() > 0) {
myFrameParent->getViewNet()->getUndoList()->p_begin("Change multiple generic attributes");
for (auto i : myACs) {
i->setAttribute(GNE_ATTR_GENERIC, getGenericParametersStr(), myFrameParent->getViewNet()->getUndoList());
}
myFrameParent->getViewNet()->getUndoList()->p_end();
}
return 1;
}
std::string
GNEStop::getAttribute(SumoXMLAttr key) const {
switch (key) {
case SUMO_ATTR_ID:
return getDemandElementID();
case SUMO_ATTR_DURATION:
return time2string(duration);
case SUMO_ATTR_UNTIL:
return time2string(until);
case SUMO_ATTR_INDEX:
if (index == STOP_INDEX_END) {
return "end";
} else if (index == STOP_INDEX_FIT) {
return "fit";
} else {
return toString(index);
}
case SUMO_ATTR_TRIGGERED:
if (parametersSet & STOP_TRIGGER_SET) {
return toString(triggered);
} else {
return "";
}
case SUMO_ATTR_CONTAINER_TRIGGERED:
if (parametersSet & STOP_CONTAINER_TRIGGER_SET) {
return toString(containerTriggered);
} else {
return "";
}
case SUMO_ATTR_EXPECTED:
if (parametersSet & STOP_EXPECTED_SET) {
return toString(awaitedPersons);
} else {
return "";
}
case SUMO_ATTR_EXPECTED_CONTAINERS:
if (parametersSet & STOP_EXPECTED_CONTAINERS_SET) {
return toString(awaitedContainers);
} else {
return "";
}
case SUMO_ATTR_PARKING:
if (parametersSet & STOP_PARKING_SET) {
return toString(parking);
} else {
return "";
}
case SUMO_ATTR_ACTTYPE:
return ""; // CHECK
case SUMO_ATTR_TRIP_ID:
if (parametersSet & STOP_TRIP_ID_SET) {
return tripId;
} else {
return "";
}
// 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:
return getAdditionalParents().front()->getID();
// specific of stops over lanes
case SUMO_ATTR_LANE:
return getLaneParents().front()->getID();
case SUMO_ATTR_STARTPOS:
if (parametersSet & STOP_START_SET) {
return toString(startPos);
} else {
return "";
}
case SUMO_ATTR_ENDPOS:
if (parametersSet & STOP_END_SET) {
return toString(endPos);
} else {
return "";
}
case SUMO_ATTR_FRIENDLY_POS:
return toString(myFriendlyPosition);
//
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) + "'");
}
}