自学教程：C++ HootException函数代码示例

void OgrWriter::_addFeatureToLayer(OGRLayer* layer, shared_ptr<Feature> f, const Geometry* g,                                   OGRFeature* poFeature){  std::string wkt = g->toString();  char* t = (char*)wkt.data();  OGRGeometry* geom;  int errCode = OGRGeometryFactory::createFromWkt(&t, layer->GetSpatialRef(), &geom) ;  if (errCode != OGRERR_NONE)  {    throw HootException(      QString("Error parsing WKT (%1).  OGR Error Code: (%2)").arg(QString::fromStdString(wkt)).arg(QString::number(errCode)));  }  errCode = poFeature->SetGeometryDirectly(geom);  if (errCode != OGRERR_NONE)  {    throw HootException(      QString("Error setting geometry - OGR Error Code: (%1)  Geometry: (%2)").arg(QString::number(errCode)).arg(QString::fromStdString(g->toString())));  }  errCode = layer->CreateFeature(poFeature);  if (errCode != OGRERR_NONE)  {    throw HootException(      QString("Error creating feature - OGR Error Code: (%1) /nFeature causing error: (%2)").arg(QString::number(errCode)).arg(f->toString()));  }}

  bool isMatchCandidate(ConstElementPtr e)  {    Context::Scope context_scope(_script->getContext());    HandleScope handleScope;    Persistent<Object> plugin = getPlugin();    Handle<String> isMatchCandidateStr = String::New("isMatchCandidate");    if (plugin->Has(isMatchCandidateStr) == false)    {      throw HootException("Error finding 'isMatchCandidate' function.");    }    Handle<v8::Value> value = plugin->Get(isMatchCandidateStr);    if (value->IsFunction() == false)    {      throw HootException("isMatchCandidate is not a function.");    }    Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);    Handle<Value> jsArgs[2];    int argc = 0;    jsArgs[argc++] = OsmMapJs::create(_map);    jsArgs[argc++] = ElementJs::New(e);    Handle<Value> f = func->Call(plugin, argc, jsArgs);    return f->BooleanValue();  }

  /*   * This is meant to run one time when the match creator is initialized.   */  void customScriptInit()  {    Context::Scope context_scope(_script->getContext());    HandleScope handleScope;    Persistent<Object> plugin = getPlugin();    Handle<String> initStr = String::New("init");    if (plugin->Has(initStr) == false)    {      throw HootException("Error finding 'init' function.");    }    Handle<v8::Value> value = plugin->Get(initStr);    if (value->IsFunction() == false)    {      throw HootException("init is not a function.");    }    Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);    Handle<Value> jsArgs[1];    int argc = 0;    HandleScope scope;    assert(_map.get());    OsmMapPtr copiedMap(new OsmMap(_map));    jsArgs[argc++] = OsmMapJs::create(copiedMap);    func->Call(plugin, argc, jsArgs);    //this is meant to have been set externally in a js rules file    _searchRadius = getNumber(plugin, "searchRadius", -1.0, 15.0);  }

void ServicesDb::closeChangeSet(long mapId, long changeSetId, Envelope env, int numChanges){  if (!changesetExists(mapId, changeSetId))  {    throw HootException("No changeset exists with ID: " + changeSetId);  }  _checkLastMapId(mapId);  if (_closeChangeSet == 0)  {    _closeChangeSet.reset(new QSqlQuery(_db));    _closeChangeSet->prepare(      QString("UPDATE %1 SET min_lat=:min_lat, max_lat=:max_lat, min_lon=:min_lon, "        "max_lon=:max_lon, closed_at=NOW(), num_changes=:num_changes WHERE id=:id")         .arg(_getChangesetsTableName(mapId)));  }  _closeChangeSet->bindValue(":min_lat", env.getMinY());  _closeChangeSet->bindValue(":max_lat", env.getMaxY());  _closeChangeSet->bindValue(":min_lon", env.getMinX());  _closeChangeSet->bindValue(":max_lon", env.getMaxX());  _closeChangeSet->bindValue(":num_changes", numChanges);  _closeChangeSet->bindValue(":id", (qlonglong)changeSetId);  if (_closeChangeSet->exec() == false)  {    LOG_ERROR("query bound values: ");    LOG_ERROR(_closeChangeSet->boundValues());    LOG_ERROR("/n");    throw HootException("Error executing close changeset: " + _closeChangeSet->lastError().text() +                        " (SQL: " + _closeChangeSet->executedQuery() + ")" + " with envelope: " +                        QString::fromStdString(env.toString()));  }}

WordCountReader::WordCountReader(QString path){  if (QSqlDatabase::contains(path) == false)  {    _db = QSqlDatabase::addDatabase("QSQLITE", path);    _db.setDatabaseName(path);    if (_db.open() == false)    {      throw HootException("Error opening DB. " + path);    }  }  else  {    _db = QSqlDatabase::database(path);  }  if (_db.isOpen() == false)  {    throw HootException("Error DB is not open. " + path);  }  _select = QSqlQuery(_db);  if (_select.prepare("SELECT count FROM words WHERE word=:word") == false)  {    throw HootException(QString("Error preparing query: %1").arg(_select.lastError().text()));  }}

QSqlQuery ServicesDb::_exec(QString sql, QVariant v1, QVariant v2, QVariant v3) const{  QSqlQuery q(_db);  LOG_VARD(sql);  if (q.prepare(sql) == false)  {    throw HootException(QString("Error preparing query: %1 (%2)").arg(q.lastError().text()).                        arg(sql));  }  if (v1.isValid())  {    q.bindValue(0, v1);  }  if (v2.isValid())  {    q.bindValue(1, v2);  }  if (v3.isValid())  {    q.bindValue(2, v3);  }  if (q.exec() == false)  {    throw HootException(QString("Error executing query: %1 (%2)").arg(q.lastError().text()).                        arg(sql));  }  return q;}

QString ServicesDb::getDbVersion(){  if (_selectDbVersion == 0)  {    _selectDbVersion.reset(new QSqlQuery(_db));    _selectDbVersion->prepare("SELECT id || ':' || author AS version_id FROM databasechangelog "                             "ORDER BY dateexecuted DESC LIMIT 1");  }  if (_selectDbVersion->exec() == false)  {    throw HootException(_selectDbVersion->lastError().text());  }  QString result;  if (_selectDbVersion->next())  {    result = _selectDbVersion->value(0).toString();  }  else  {    throw HootException("Unable to retrieve the DB version.");  }  return result;}

Envelope BaseCommand::parseEnvelope(QString envStr) const{  QStringList envArr = envStr.split(",");  if (envArr.size() != 4)  {    throw HootException("Invalid bounds format, requires 4 values: " + envStr);  }  bool ok, allOk = true;  double left = envArr[0].toDouble(&ok);  allOk &= ok;  double bottom = envArr[1].toDouble(&ok);  allOk &= ok;  double right = envArr[2].toDouble(&ok);  allOk &= ok;  double top = envArr[3].toDouble(&ok);  allOk &= ok;  if (allOk == false)  {    throw HootException("Invalid bounds format: " + envStr);  }  return Envelope(left, right, bottom, top);}

void ConflateMapper::_addNode(const shared_ptr<Node>& n){  long key = -1;  // if the node falls in one of the envelopes  for (size_t i = 0; i < _envelopes.size(); i++)  {    // set a positive key    if (_envelopes[i].contains(n->getX(), n->getY()))    {      if (key != -1)      {        throw HootException("This should never happen. Envelopes must not overlap.");      }      key = i;    }  }  // if the node is not in one of the envelopes.  if (key == -1)  {    // calculate a negative key based on node ID    key = -1 - (abs(n->getId()) % _reduceTaskCount);  }  if (key < -_reduceTaskCount || key >= (int)_envelopes.size())  {    LOG_INFO("envelope size: " << _envelopes.size());    throw HootException(QString("Key is out of range. nid: %1 key: %2").arg(n->getId()).arg(key));  }  if (Debug::isTroubledNode(n->getId()))  {    LOG_WARN("Writing a troubled node: " << n->toString());    LOG_WARN("  key: " << key)  }

shared_ptr<OGRDataSource> OgrUtilities::createDataSource(QString url){  const char* driverName = NULL;  int i = 0;  while (extensions[i][0] != NULL)  {    if (url.endsWith(extensions[i][0]))    {      driverName = extensions[i][1];    }    i++;  }  i = 0;  while (beginName[i][0] != NULL)  {    if (url.startsWith(beginName[i][0]))    {      driverName = beginName[i][1];    }    i++;  }  if (driverName == NULL)  {    throw HootException("No driver found for: " + url);  }  OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driverName);  if (driver == 0)  {    throw HootException("Error getting driver by name: " + QString(driverName));  }  // if the user specifies a shapefile then crop off the .shp and create a directory.  if (url.toLower().endsWith(".shp"))  {    url = url.mid(0, url.length() - 4);  }  shared_ptr<OGRDataSource> result(driver->CreateDataSource(url.toAscii()));  if (result == NULL)  {    throw HootException("Unable to create data source: " + url +                        " (" + QString(CPLGetLastErrorMsg()) + ")");  }  result->SetDriver(driver);  if (QString(driverName) == "FileGDB")  {    long v = GDAL_VERSION_MAJOR * 1000000 + GDAL_VERSION_MINOR * 1000 + GDAL_VERSION_REV;    long lowest = 1 * 1000000 + 10 * 1000 + 1;    if (v < lowest)    {      LOG_WARN("Writing to FileGDB with GDAL v" << GDAL_RELEASE_NAME << ". FileGDB with a GDAL "               "v1.9.0 is known to create files that can't be read by ArcMap 10.2. "               "GDAL v1.10.1 is known to work.");    }  }  return result;}

long SequenceIdReserver::_reserveIds(){  if (_query == 0)  {    _query.reset(new QSqlQuery(_db));    _query->setForwardOnly(true);    ////    // This query contains a race condition. It is possible that one process could call SETVAL    // between the call to CURRVAL and SETVAL. This can result in a smaller value than expected    // and duplicate IDs. See #3607 for details.    //    LOG_WARN("This query contains a race condition and may not do what you want.");    _query->prepare(      QString("SELECT NEXTVAL('%1'), "              "SETVAL('%1', CURRVAL('%1') + :count)").arg(_sequenceName));  }  _query->bindValue(0, (qlonglong)_bulkSize - 1);  if (_query->exec() == false)  {    throw HootException("Error reserving IDs. count: " +      QString::number(_bulkSize) + " Error: " + _query->lastError().text());  }  long result = -1;  if (_query->next())  {    bool ok;    result = _query->value(1).toLongLong(&ok);    if (!ok)    {      throw HootException("Did not retrieve starting reserved ID.");    }  }  else  {    LOG_VARW(_nextId);    LOG_VARW(result);    LOG_VARW(_bulkSize);    throw HootException("Error retrieving sequence value. count: " +      QString::number(_bulkSize) + " Error: " + _query->lastError().text());  }  if (result < _nextId)  {    LOG_VARW(_nextId);    LOG_VARW(result);    LOG_VARW(_bulkSize);    QString err = QString("Error allocating new sequence value. Expected to retrieve a value "                          ">= %1, but got %2.").arg(_nextId).arg(result);    LOG_WARN(err);    throw HootException(err);  }  _query->finish();  return result;}

void ServicesDbReader::open(QString urlStr){  if (!isSupported(urlStr))  {    throw HootException("An unsupported URL was passed in.");  }  QUrl url(urlStr);  QString osmElemId = url.queryItemValue("osm-element-id");  QString osmElemType = url.queryItemValue("osm-element-type");  QStringList pList = url.path().split("/");  bool ok;  bool ok2;  QString mapName;  _database.open(url);  _mapId = pList[pList.size() - 1].toLong(&ok);  if(osmElemId.length() > 0 && osmElemType.length() > 0)  {    _osmElemId = osmElemId.toLong(&ok2);    _osmElemType = ElementType::fromString(osmElemType);  }  if (!ok)  {    if (_email == "")    {      throw HootException("If a map name is specified then the user email must also be specified "                          "via: " + emailKey());    }    mapName = pList[pList.size() - 1];    long userId = _database.getUserId(_email);    set<long> mapIds = _database.selectMapIds(mapName, userId);    if (mapIds.size() != 1)    {      QString str = QString("Expected 1 map with the name '%1' but found %2 maps.").arg(mapName)          .arg(mapIds.size());      throw HootException(str);    }    _mapId = *mapIds.begin();  }  if (!_database.mapExists(_mapId))  {    _database.close();    throw HootException("No map exists with ID: " + QString::number(_mapId));  }  //using a transaction seems to make sense here, b/c we don't want to read a map being modified  //in the middle of its modification caused by a changeset upload, which could cause the map to  //be invalid as a whole  _database.transaction();  _open = true;}

void ServicesDb::insertRelationMembers(long mapId, long relationId, ElementType type,  long elementId, QString role, int sequenceId){  _checkLastMapId(mapId);  if (_insertRelationMembers == 0)  {    _insertRelationMembers.reset(new QSqlQuery(_db));    _insertRelationMembers->prepare(      "INSERT INTO " + _getRelationMembersTableName(mapId) +        " (relation_id, member_type, member_id, member_role, sequence_id) "      "VALUES (:relation_id, :member_type, :member_id, :member_role, :sequence_id)");  }  _insertRelationMembers->bindValue(":relation_id", (qlonglong)relationId);  _insertRelationMembers->bindValue(":member_type", type.toString().toLower());  _insertRelationMembers->bindValue(":member_id", (qlonglong)elementId);  _insertRelationMembers->bindValue(":member_role", role);  _insertRelationMembers->bindValue(":sequence_id", sequenceId);  if (!_insertRelationMembers->exec())  {    throw HootException("Error inserting relation memeber: " +      _insertRelationMembers->lastError().text());  }}

bool TileBoundsCalculator::_isDone(vector<PixelBox> &boxes){  bool smallEnough = true;  bool minSize = false;  for (size_t i = 0; i < boxes.size(); i++)  {    PixelBox& b = boxes[i];    if (b.getWidth() == 1 || b.getHeight() == 1)    {      minSize = true;    }    if (_sumPixels(b) > _maxNodesPerBox)    {      smallEnough = false;    }  }  if (minSize == true && smallEnough == false)  {    throw HootException("Could not find a solution. Try reducing the pixel size or increasing the "      "max nodes per pixel value.");  }  else  {    return smallEnough;  }}

OsmMapPtr AlphaShapeGenerator::generateMap(OsmMapPtr inputMap){  boost::shared_ptr<Geometry> cutterShape = generateGeometry(inputMap);  if (cutterShape->getArea() == 0.0)  {    //would rather this be thrown than a warning logged, as the warning may go unoticed by web    //clients who are expecting the alpha shape to be generated    throw HootException("Alpha Shape area is zero. Try increasing the buffer size and/or alpha.");  }  OsmMapPtr result;  result.reset(new OsmMap(inputMap->getProjection()));  // add the resulting alpha shape for debugging.  GeometryConverter(result).convertGeometryToElement(cutterShape.get(), Status::Invalid, -1);  const RelationMap& rm = result->getRelations();  for (RelationMap::const_iterator it = rm.begin(); it != rm.end(); ++it)  {    Relation* r = result->getRelation(it->first).get();    r->setTag("area", "yes");  }  return result;}

double LogisticRegression::evaluate(map<QString, double> sample){  // Taken from Weka's documentation:  //  // The probability for class j with the exception of the last class is  // Pj(Xi) = exp(XiBj)/((sum[j=1..(k-1)]exp(Xi*Bj))+1)  // since we only have two classes:  // this code shamelessly modified from Weka  double prob = 0.0;  double v = 0.0;  // Log-posterior before normalizing  for (Coeff::iterator it = _coeff.begin(); it != _coeff.end(); ++it)  {    double par = it->second;    map<QString, double>::const_iterator sit = sample.find(it->first);    if (sit == sample.end())    {      throw HootException("Error finding sample key: " + it->first);    }    double data = sample.find(it->first)->second;    v += par * data;  }  v += _intercept;  // Do so to avoid scaling problems  prob = 1 / (1 + exp(-v));  return prob;}

bool OsmApiDbChangesetWriter::conflictExistsInTarget(const QString boundsStr, const QString timeStr){  LOG_INFO("Checking for OSM API DB conflicts for changesets within " << boundsStr << " and " <<           "created after " << timeStr << "...");  const Envelope bounds = GeometryUtils::envelopeFromConfigString(boundsStr);  LOG_VARD(bounds.toString());  const QDateTime time = QDateTime::fromString(timeStr, OsmApiDb::TIME_FORMAT);  LOG_VARD(time);  if (!time.isValid())  {    throw HootException(      "Invalid timestamp: " + time.toString() + ".  Should be of the form " + OsmApiDb::TIME_FORMAT);  }  shared_ptr<QSqlQuery> changesetItr = _db.getChangesetsCreatedAfterTime(timeStr);  while (changesetItr->next())  {    shared_ptr<Envelope> changesetBounds(      new Envelope(changesetItr->value(0).toDouble(),                   changesetItr->value(1).toDouble(),                   changesetItr->value(2).toDouble(),                   changesetItr->value(3).toDouble()));    LOG_VARD(changesetBounds->toString());    if (changesetBounds->intersects(bounds))    {      return true;    }  }  return false;}

WayLocation::WayLocation(ConstOsmMapPtr map, ConstWayPtr way, int segmentIndex,  double segmentFraction) :  _map(map){  _way = way;  _segmentIndex = segmentIndex;  _segmentFraction = segmentFraction;  if (_segmentFraction == 1.0)  {    _segmentIndex++;    _segmentFraction = 0.0;  }  if (_segmentFraction < 0.0 || _segmentFraction >= 1.0)  {    throw HootException("Segment Fraction is out of range.");  }  if (_segmentIndex < 0)  {    _segmentIndex = 0;    _segmentFraction = 0.0;  }  if (_segmentIndex >= (int)_way->getNodeCount() - 1)  {    _segmentIndex = _way->getNodeCount() - 1;    _segmentFraction = 0.0;  }}

long Hoot::_toBytes(const QString& str) const{  QString s = str;  long multiplier = 1;  if (s.endsWith("KB"))  {    multiplier = 1000;    s = s.remove(s.size() - 2, 2);  }  else if (s.endsWith("MB"))  {    multiplier = 1000 * 1000;    s = s.remove(s.size() - 2, 2);  }  else if (s.endsWith("GB"))  {    multiplier = 1000 * 1000 * 1000;    s = s.remove(s.size() - 2, 2);  }  bool ok;  long result = s.toLong(&ok) * multiplier;  if (!ok)  {    throw HootException("Unable to parse max memory usage: " + s);  }  return result;}

void WaySublineCollection::addSubline(const WaySubline& subline){  if (_sublines.size() == 0)  {    _sublines.push_back(subline);  }  else  {    for (size_t i = 0; i < _sublines.size(); i++)    {      if (subline.overlaps(_sublines[i]))      {        throw HootException("A subline string may not contain overlapping sublines.");        //use this for debugging only        /*if (logWarnCount < Log::getWarnMessageLimit())        {          LOG_WARN("A subline string may not contain overlapping sublines.");        }        else if (logWarnCount == Log::getWarnMessageLimit())        {          LOG_WARN(className() << ": " << Log::LOG_WARN_LIMIT_REACHED_MESSAGE);        }        logWarnCount++;*/      }    }    _sublines.push_back(subline);  }}

void MergerFactory::createMergers(const OsmMapPtr& map, const MatchSet& matches,  vector<Merger*>& result) const{  for (size_t i = 0; i < _creators.size(); i++)  {    OsmMapConsumer* omc = dynamic_cast<OsmMapConsumer*>(_creators[i]);    if (omc)    {      omc->setOsmMap(map.get());    }    if (_creators[i]->createMergers(matches, result))    {      return;    }    // we don't want the creators to hold onto a map pointer that will go out of scope    if (omc)    {      omc->setOsmMap((OsmMap*)0);    }  }  LOG_WARN("Error finding Mergers for these matches: " << matches);  LOG_WARN("Creators: " << _creators);  throw HootException("Error creating a merger for the provided set of matches.");}

unsigned long ElementCacheLRU::typeCount(const ElementType::Type typeToCount) const{  unsigned long retVal = 0;  switch ( typeToCount )  {  case ElementType::Node:    retVal = _nodes.size();    break;  case ElementType::Way:    retVal = _ways.size();    break;  case ElementType::Relation:    retVal = _relations.size();    break;  default:    throw HootException("Invalid type passed");    break;  }  return retVal;}

void OsmApiDbReader::open(QString urlStr){  if (!isSupported(urlStr))  {    throw HootException("An unsupported URL was passed in.");  }  _elementResultIterator.reset();  _selectElementType = ElementType::Node;  QUrl url(urlStr);  QString osmElemId = url.queryItemValue("osm-element-id");  QString osmElemType = url.queryItemValue("osm-element-type");  LOG_DEBUG("url path = "+url.path());  bool ok;  _database.open(url);  if(osmElemId.length() > 0 && osmElemType.length() > 0)  {    _osmElemId = osmElemId.toLong(&ok);    _osmElemType = ElementType::fromString(osmElemType);  }  //using a transaction seems to make sense here, b/c we don't want to read a map being modified  //in the middle of its modification caused by a changeset upload, which could cause the map to  //be invalid as a whole  _database.transaction();  _open = true;}

  void runUncompressTest()  {    const std::string cmd(      "gzip -c test-files/ToyTestA.osm > test-output/ToyTestA_compressed.osm.gz");    LOG_DEBUG("Running compress command: " << cmd);    int retVal;    if ((retVal = std::system(cmd.c_str())) != 0)    {      QString error = QString("Error %1 returned from compress command: %2").arg(retVal).        arg(QString::fromStdString(cmd));      throw HootException(error);    }    OsmXmlReader uut;    OsmMapPtr map(new OsmMap());    uut.setUseDataSourceIds(true);    // Excercise the code    uut.read("test-output/ToyTestA_compressed.osm.gz", map);    // Check a few things    CPPUNIT_ASSERT_EQUAL(36,(int)map->getNodes().size());    CPPUNIT_ASSERT_EQUAL(4, (int)map->getWays().size());    QFile f("test-output/ToyTestA_compressed.osm.gz");    CPPUNIT_ASSERT(f.exists());    CPPUNIT_ASSERT(f.remove());  }

shared_ptr<QSqlQuery> OsmApiDb::selectElements(const ElementType& elementType){  LOG_DEBUG("IN selectElement");  _selectElementsForMap.reset(new QSqlQuery(_db));  _selectElementsForMap->setForwardOnly(true);  // setup base sql query string  QString sql =  "SELECT " + _elementTypeToElementTableName(elementType);  // sort them in descending order, set limit and offset  sql += " ORDER BY id DESC";  // let's see what that sql query string looks like  LOG_DEBUG(QString("The sql query= "+sql));  _selectElementsForMap->prepare(sql);  // execute the query on the DB and get the results back  if (_selectElementsForMap->exec() == false)  {    QString err = _selectElementsForMap->lastError().text();    LOG_WARN(sql);    throw HootException("Error selecting elements of type: " + elementType.toString() +      " Error: " + err);  }  LOG_DEBUG("LEAVING OsmApiDb::selectElements...");  return _selectElementsForMap;}

shared_ptr<OsmMapWriter> OsmMapWriterFactory::createWriter(QString url){  QString writerOverride = ConfigOptions().getOsmMapWriterFactoryWriter();  shared_ptr<OsmMapWriter> writer;  if (writerOverride != "")  {    writer.reset(Factory::getInstance().constructObject<OsmMapWriter>(writerOverride));  }  vector<std::string> names =    Factory::getInstance().getObjectNamesByBase(OsmMapWriter::className());  for (size_t i = 0; i < names.size() && !writer; ++i)  {    writer.reset(Factory::getInstance().constructObject<OsmMapWriter>(names[i]));    if (writer->isSupported(url))    {      LOG_DEBUG("Using writer: " << names[i]);    }    else    {      writer.reset();    }  }  if (!writer)  {    throw HootException("A valid writer could not be found for the URL: " + url);  }  return writer;}