SVCPermissions
parseVehicleClasses(const std::vector<std::string>& allowedS) {
SVCPermissions result = 0;
for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
const SUMOVehicleClass vc = getVehicleClassID(*i);
const std::string& realName = SumoVehicleClassStrings.getString(vc);
if (realName != *i) {
WRITE_WARNING("The vehicle class '" + (*i) + "' is deprecated, use '" + realName + "' instead.");
}
result |= getVehicleClassID(*i);
}
return result;
}
SVCPermissions
parseVehicleClasses(const std::string& allowedS) {
if (allowedS == "all") {
return SVCAll;
}
// check if allowedS was previously cached
if (parseVehicleClassesCached.count(allowedS) == 0) {
SVCPermissions result = 0;
StringTokenizer sta(allowedS, " ");
while (sta.hasNext()) {
const std::string s = sta.next();
if (!SumoVehicleClassStrings.hasString(s)) {
WRITE_ERROR("Unknown vehicle class '" + s + "' encountered.");
} else {
const SUMOVehicleClass vc = getVehicleClassID(s);
const std::string& realName = SumoVehicleClassStrings.getString(vc);
if (realName != s) {
deprecatedVehicleClassesSeen.insert(s);
}
result |= vc;
}
}
// save parsed vehicle class cached
parseVehicleClassesCached[allowedS] = result;
}
return parseVehicleClassesCached.at(allowedS);
}
SVCPermissions
parseVehicleClasses(const std::vector<std::string>& allowedS) {
SVCPermissions result = 0;
for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
result |= getVehicleClassID(*i);
}
return result;
}
SVCPermissions
parseVehicleClasses(const std::string& allowedS) {
SVCPermissions result = 0;
StringTokenizer sta(allowedS, " ");
while (sta.hasNext()) {
result |= getVehicleClassID(sta.next());
}
return result;
}
void
RONetHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
switch (element) {
case SUMO_TAG_EDGE:
// in the first step, we do need the name to allocate the edge
// in the second, we need it to know to which edge we have to add
// the following edges to
parseEdge(attrs);
break;
case SUMO_TAG_LANE:
if (myProcess) {
parseLane(attrs);
}
break;
case SUMO_TAG_JUNCTION:
parseJunction(attrs);
break;
case SUMO_TAG_CONNECTION:
parseConnection(attrs);
break;
case SUMO_TAG_BUS_STOP:
parseBusStop(attrs);
break;
case SUMO_TAG_CONTAINER_STOP:
parseContainerStop(attrs);
break;
case SUMO_TAG_TAZ:
parseDistrict(attrs);
break;
case SUMO_TAG_TAZSOURCE:
parseDistrictEdge(attrs, true);
break;
case SUMO_TAG_TAZSINK:
parseDistrictEdge(attrs, false);
break;
case SUMO_TAG_TYPE: {
bool ok = true;
myCurrentTypeID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
break;
}
case SUMO_TAG_RESTRICTION: {
bool ok = true;
const SUMOVehicleClass svc = getVehicleClassID(attrs.get<std::string>(SUMO_ATTR_VCLASS, myCurrentTypeID.c_str(), ok));
const SUMOReal speed = attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentTypeID.c_str(), ok);
if (ok) {
myNet.addRestriction(myCurrentTypeID, svc, speed);
}
break;
}
default:
break;
}
}
SVCPermissions
parseVehicleClasses(const std::string& allowedS) {
if (allowedS == "all") {
return SVCAll;
}
SVCPermissions result = 0;
StringTokenizer sta(allowedS, " ");
while (sta.hasNext()) {
const std::string s = sta.next();
const SUMOVehicleClass vc = getVehicleClassID(s);
const std::string& realName = SumoVehicleClassStrings.getString(vc);
if (realName != s) {
deprecatedVehicleClassesSeen.insert(s);
}
result |= vc;
}
return result;
}
SUMOVehicleClass
SUMOVehicleParserHelper::parseVehicleClass(const SUMOSAXAttributes& attrs,
const std::string& id) {
SUMOVehicleClass vclass = SVC_IGNORING;
try {
bool ok = true;
std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
if (vclassS == "") {
return vclass;
}
const SUMOVehicleClass result = getVehicleClassID(vclassS);
const std::string& realName = SumoVehicleClassStrings.getString(result);
if (realName != vclassS) {
WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
}
return result;
} catch (...) {
WRITE_ERROR("The class for " + attrs.getObjectType() + " '" + id + "' is not known.");
}
return vclass;
}
void
Person::setVehicleClass(const std::string& personID, const std::string& clazz) {
getPerson(personID)->getSingularType().setVClass(getVehicleClassID(clazz));
}
void
NBEdgeCont::applyOptions(OptionsCont& oc) {
myAmLeftHanded = oc.getBool("lefthand");
// set edges dismiss/accept options
myEdgesMinSpeed = oc.isSet("keep-edges.min-speed") ? oc.getFloat("keep-edges.min-speed") : -1;
myRemoveEdgesAfterJoining = oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload");
if (oc.isSet("keep-edges.explicit")) {
const std::vector<std::string> edges = oc.getStringVector("keep-edges.explicit");
myEdges2Keep.insert(edges.begin(), edges.end());
}
if (oc.isSet("remove-edges.explicit")) {
const std::vector<std::string> edges = oc.getStringVector("remove-edges.explicit");
myEdges2Remove.insert(edges.begin(), edges.end());
}
if (oc.exists("keep-edges.by-vclass") && oc.isSet("keep-edges.by-vclass")) {
const std::vector<std::string> classes = oc.getStringVector("keep-edges.by-vclass");
for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) {
myVehicleClasses2Keep |= getVehicleClassID(*i);
}
}
if (oc.exists("remove-edges.by-vclass") && oc.isSet("remove-edges.by-vclass")) {
const std::vector<std::string> classes = oc.getStringVector("remove-edges.by-vclass");
for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) {
myVehicleClasses2Remove |= getVehicleClassID(*i);
}
}
if (oc.exists("keep-edges.by-type") && oc.isSet("keep-edges.by-type")) {
const std::vector<std::string> types = oc.getStringVector("keep-edges.by-type");
myTypes2Keep.insert(types.begin(), types.end());
}
if (oc.exists("remove-edges.by-type") && oc.isSet("remove-edges.by-type")) {
const std::vector<std::string> types = oc.getStringVector("remove-edges.by-type");
myTypes2Remove.insert(types.begin(), types.end());
}
if (oc.isSet("keep-edges.in-boundary") || oc.isSet("keep-edges.in-geo-boundary")) {
std::vector<std::string> polyS = oc.getStringVector(oc.isSet("keep-edges.in-boundary") ?
"keep-edges.in-boundary" : "keep-edges.in-geo-boundary");
// !!! throw something if length<4 || length%2!=0?
std::vector<SUMOReal> poly;
for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) {
poly.push_back(TplConvert::_2SUMOReal((*i).c_str())); // !!! may throw something anyhow...
}
if (poly.size() < 4) {
throw ProcessError("Invalid boundary: need at least 2 coordinates");
} else if (poly.size() % 2 != 0) {
throw ProcessError("Invalid boundary: malformed coordinate");
} else if (poly.size() == 4) {
// prunning boundary (box)
myPrunningBoundary.push_back(Position(poly[0], poly[1]));
myPrunningBoundary.push_back(Position(poly[2], poly[1]));
myPrunningBoundary.push_back(Position(poly[2], poly[3]));
myPrunningBoundary.push_back(Position(poly[0], poly[3]));
} else {
for (std::vector<SUMOReal>::iterator j = poly.begin(); j != poly.end();) {
SUMOReal x = *j++;
SUMOReal y = *j++;
myPrunningBoundary.push_back(Position(x, y));
}
}
if (oc.isSet("keep-edges.in-geo-boundary")) {
NBNetBuilder::transformCoordinates(myPrunningBoundary, false);
}
}
}
void
VehicleType::setVehicleClass(const std::string& typeID, const std::string& clazz) {
getVType(typeID)->setVClass(getVehicleClassID(clazz));
}
