SUMOVehicleClass
getVehicleClassID(const std::string& name) {
if (SumoVehicleClassStrings.hasString(name)) {
return SumoVehicleClassStrings.get(name);
}
throw InvalidArgument("Unknown vehicle class '" + name + "'.");
}
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);
}
SUMOVehicleShape
getVehicleShapeID(const std::string& name) {
if (SumoVehicleShapeStrings.hasString(name)) {
return SumoVehicleShapeStrings.get(name);
} else {
throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
}
}
int
NWWriter_OpenDrive::getID(const std::string& origID, StringBijection<int>& map, int& lastID) {
if (map.hasString(origID)) {
return map.get(origID);
}
map.insert(origID, lastID++);
return lastID - 1;
}
int
getVehicleClassCompoundID(const std::string& name) {
int ret = SVC_IGNORING;
const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
if (name.find(*it) != std::string::npos) {
ret = ret | (int) SumoVehicleClassStrings.get(*it);
}
}
return ret;
}
std::vector<std::string>
getVehicleClassNamesList(SVCPermissions permissions) {
/// @todo cache values?
const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
std::vector<std::string> result;
for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
const int svc = (int)SumoVehicleClassStrings.get(*it);
if ((svc & permissions) == svc && svc != SVC_IGNORING) {
result.push_back(*it);
}
}
return result;
}
const std::vector<std::string>&
getVehicleClassNamesList(SVCPermissions permissions) {
// first check if it's cached
if (vehicleClassNamesListCached.count(permissions) == 0) {
const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
std::vector<std::string> result;
for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
const int svc = (int)SumoVehicleClassStrings.get(*it);
if ((svc & permissions) == svc && svc != SVC_IGNORING) {
result.push_back(*it);
}
}
// add it into vehicleClassNamesListCached
vehicleClassNamesListCached[permissions] = result;
}
return vehicleClassNamesListCached.at(permissions);
}
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;
}
bool
canParseVehicleClasses(const std::string& classes) {
if (classes == "all") {
return true;
}
StringTokenizer sta(classes, " ");
while (sta.hasNext()) {
if (!SumoVehicleClassStrings.hasString(sta.next())) {
return false;
}
}
return true;
}
bool
canParseVehicleClasses(const std::string& classes) {
if (classes == "all") {
return true;
}
// check if was previously cached
if (parseVehicleClassesCached.count(classes) != 0) {
return true;
}
StringTokenizer sta(classes, " ");
while (sta.hasNext()) {
if (!SumoVehicleClassStrings.hasString(sta.next())) {
return false;
}
}
return true;
}
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;
}
void
writePermissions(OutputDevice& into, SVCPermissions permissions) {
if (permissions == SVCAll) {
return;
} else if (permissions == 0) {
into.writeAttr(SUMO_ATTR_DISALLOW, "all");
return;
} else {
int num_allowed = 0;
for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
if ((mask & permissions) == mask) {
++num_allowed;
}
}
if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
} else {
into.writeAttr(SUMO_ATTR_DISALLOW, getVehicleClassNames(~permissions));
}
}
}
std::string
getVehicleShapeName(SUMOVehicleShape id) {
return SumoVehicleShapeStrings.getString(id);
}
bool
canParseVehicleShape(const std::string& shape) {
return SumoVehicleShapeStrings.hasString(shape);
}
