C++ const_iterator::value方法代码示例

bool LinearCriterion::isSatisfied(const ConstElementPtr& e) const
{
  bool result = false;

  if (e->getElementType() == ElementType::Node)
  {
    return false;
  }

  const Tags& t = e->getTags();

  if (e->getElementType() == ElementType::Relation)
  {
    ConstRelationPtr r = boost::dynamic_pointer_cast<const Relation>(e);
    result |= r->getType() == MetadataTags::RelationMultilineString();
    result |= r->getType() == MetadataTags::RelationRoute();
    result |= r->getType() == MetadataTags::RelationBoundary();
  }

  for (Tags::const_iterator it = t.constBegin(); it != t.constEnd(); ++it)
  {
    const SchemaVertex& tv = OsmSchema::getInstance().getTagVertex(it.key() + "=" + it.value());
    uint16_t g = tv.geometries;
    if (g & (OsmGeometries::LineString | OsmGeometries::ClosedWay) && !(g & OsmGeometries::Area))
    {
      result = true;
      break;
    }
  }

  return result;
}

void OgrWriter::writeElement(ElementPtr &element, bool debug)
{
  //Unfortunately, this check also has to happen in addition to checking hasMoreElements.  See
  //explanation in ServicesDbReader::readNextElement.
  if (element.get())
  {
    Tags sourceTags = element->getTags();
    Tags destTags;
    for (Tags::const_iterator it = element->getTags().begin();
         it != element->getTags().end(); ++it)
    {
      if (sourceTags[it.key()] != "")
      {
        destTags.appendValue(it.key(), it.value());
      }
    }
    // Now that all the empties are gone, update our element
    element->setTags(destTags);

    if ( debug == true )
    {
      LOG_DEBUG(element->toString());
    }

    PartialOsmMapWriter::writePartial(element);
  }
}

void PbfWriter::_writeRelation(const shared_ptr<const hoot::Relation>& r)
{
    _elementsWritten++;

    if (_pg == 0)
    {
        _pg = _d->primitiveBlock.add_primitivegroup();
    }

    pb::Relation* pbr = _pg->add_relations();

    pbr->set_id(r->getId() + _relationIdDelta);

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Ways_and_Relations
    // For ways and relations, which contain the ID's of other nodes, I exploit the tendency of
    // consecutive nodes in a way or relation to have nearby node ID's by using delta compression,
    // resulting in small integers. (I.E., instead of encoding x_1, x_2, x_3, I encode
    // x_1, x_2-x_1, x_3-x_2, ...).
    long lastId = 0;
    const vector<RelationData::Entry>& entries = r->getMembers();
    for (size_t i = 0; i < entries.size(); i++)
    {
        long id = entries[i].getElementId().getId() + _nodeIdDelta;
        pbr->add_memids(id - lastId);
        lastId = id + _nodeIdDelta;
        pbr->add_types((hoot::pb::Relation_MemberType)
                       _toRelationMemberType(entries[i].getElementId().getType()));
        pbr->add_roles_sid(_convertString(entries[i].role));
    }

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Ways_and_Relations
    // Tags are encoded as two parallel arrays, one array of string-id's of the keys, and the other
    // of string-id's of the values.
    const Tags& tags = r->getTags();
    for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); ++it)
    {
        const QString& key = it.key();
        const QString& value = it.value();
        if (!value.isEmpty())
        {
            pbr->add_keys(_convertString(key));
            pbr->add_vals(_convertString(value));
        }
    }
    int kid = _convertString("error:circular");
    int vid = _convertString(QString::number(r->getCircularError()));
    pbr->add_keys(kid);
    pbr->add_vals(vid);

    if (r->getStatus() != Status::Invalid)
    {
        kid = _convertString("hoot:status");
        vid = _convertString(QString::number(r->getStatus().getEnum()));
        pbr->add_keys(kid);
        pbr->add_vals(vid);
    }

    _dirty = true;
}

void PbfWriter::_writeNode(const shared_ptr<const hoot::Node>& n)
{
    _elementsWritten++;
    if (_pg == 0)
    {
        _pg = _d->primitiveBlock.add_primitivegroup();
    }

    ::google::protobuf::RepeatedPtrField< ::hoot::pb::Node >* nodes =
        _pg->mutable_nodes();

    _dirty = true;

    pb::Node* newNode = nodes->Add();

    newNode->set_id(n->getId() + _nodeIdDelta);
    newNode->set_lon(_convertLon(n->getX()));
    newNode->set_lat(_convertLat(n->getY()));

    const Tags& tags = n->getTags();
    for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); ++it)
    {
        const QString& key = it.key();
        const QString& value = it.value();
        int kid = _convertString(key);
        int vid = _convertString(value);
        if (!value.isEmpty())
        {
            newNode->add_keys(kid);
            newNode->add_vals(vid);
        }
    }

    // if there are tags on the node then record the CE. CE isn't used as part of a way
    // at this point. Instead the way records the CE for the entire way. No need to waste disk.
    if (n->getTags().getNonDebugCount() > 0)
    {
        int kid = _convertString("error:circular");
        int vid = _convertString(QString::number(n->getCircularError()));
        newNode->add_keys(kid);
        newNode->add_vals(vid);

        if (n->getStatus() != Status::Invalid)
        {
            kid = _convertString("hoot:status");
            vid = _convertString(QString::number(n->getStatus().getEnum()));
            newNode->add_keys(kid);
            newNode->add_vals(vid);
        }
    }

}

bool PoiPolygonMatch::_calculateTypeMatch(ConstElementPtr e1, ConstElementPtr e2) const
{
  bool result = false;

  const Tags& t1 = e1->getTags();
  const Tags& t2 = e2->getTags();
  for (Tags::const_iterator it = t1.begin(); it != t1.end(); it++)
  {
    // if it is a use or POI category
    if ((OsmSchema::getInstance().getCategories(it.key(), it.value()) &
         (OsmSchemaCategory::building() | OsmSchemaCategory::use() | OsmSchemaCategory::poi()))
          != OsmSchemaCategory::Empty)
    {
      result = t2.get(it.key()) == it.value();
      if (result)
      {
        return result;
      }
    }
  }

  return result;
}

void OgrWriter::writeElement(ElementInputStream& inputStream, bool debug)
{
  // Make sure incoming element is in WGS84
  assert( inputStream.getProjection()->IsSame(&_wgs84) == true );
  ElementPtr nextElement = inputStream.readNextElement();

  // TERRY TESTING COULD BE CATASTROPHIC
  Tags sourceTags = nextElement->getTags();
  Tags destTags;
  for (Tags::const_iterator it = nextElement->getTags().begin();
       it != nextElement->getTags().end(); ++it)
  {
    if (sourceTags[it.key()] != "")
    {
      destTags.appendValue(it.key(), it.value());
    }
  }
  // Now that all the empties are gone, update our element
  nextElement->setTags(destTags);

  if ( debug == true )
  {
    LOG_DEBUG(nextElement->toString());
  }

  PartialOsmMapWriter::writePartial(nextElement);
  /*
  if ( nextElement->getElementType().getEnum() == ElementType::Node )
  {
    //LOG_DEBUG("\n" << nextElement->toString());

    const long nodeID = nextElement->getId();
    if ( (nodeID >= -265198) && (nodeID <= -265167) )
    {
      LOG_DEBUG("\n" << nextElement->toString());
      PartialOsmMapWriter::writePartial(nextElement);
    }
  }
  else if ((nextElement->getElementType().getEnum() == ElementType::Way) &&
           (nextElement->getId() == -23189) )
  {
    LOG_DEBUG("Writing Little Mill Creek -23189");
    LOG_DEBUG("\n" << nextElement->toString());
    PartialOsmMapWriter::writePartial(nextElement);
  }
  */
}

QString ServicesDb::_escapeTags(const Tags& tags) const
{
  QStringList l;
  static QChar f1('\\'), f2('"'), f3('\'');
  static QChar to('_');

  for (Tags::const_iterator it = tags.begin(); it != tags.end(); ++it)
  {
    // this doesn't appear to be working, but I think it is implementing the spec as described here:
    // http://www.postgresql.org/docs/9.0/static/hstore.html
    // The spec described above does seem to work on the psql command line. Curious.
    QString k = QString(it.key()).replace(f1, "\\\\").replace(f2, "\\\"");
    QString v = QString(it.value()).replace(f1, "\\\\").replace(f2, "\\\"");

    l << QString("\"%1\"=>\"%2\"").arg(k).arg(v);
  }
  return l.join(",");
}

void SplitNameVisitor::visit(const shared_ptr<Element>& e)
{
    Tags& t = e->getTags();

    QStringList extraNames;

    Tags copy = t;
    for (Tags::const_iterator it = copy.begin(); it != copy.end(); ++it)
    {
        const QString& k = it.key();
        const QString& v = it.value();
        if (v.size() > _maxSize &&
                OsmSchema::getInstance().getCategories(it.key()).intersects(OsmSchemaCategory::name()))
        {
            QStringList l = _splitNames(v, extraNames);
            t.setList(k, l);
        }
    }

    _addExtraNames(t, extraNames);
}

void TagComparator::compareTextTags(const Tags& t1, const Tags& t2, double& score, double& weight)
{
  OsmSchema& schema = OsmSchema::getInstance();

  score = 1.0;
  weight = 0.0;

  for (Tags::const_iterator it = t1.begin(); it != t1.end(); it++)
  {
    const SchemaVertex& tv = schema.getTagVertex(it.key());
    if (schema.isAncestor(it.key(), "abstract_name") == false &&
        tv.valueType == Text && t2.contains(it.key()))
    {
      score *= LevenshteinDistance::score(it.value(), t2[it.key()]);
      weight += tv.influence;
    }
  }

  // if the weight is zero don't confuse things with a low score.
  if (weight == 0.0)
  {
    score = 1;
  }
}

bool RoundaboutCriterion::isSatisfied(const ConstElementPtr& e) const
{
  // If it's not a highway, it's not a roundabout
  if (!HighwayCriterion().isSatisfied(e))
  {
    return false;
  }

  // Now check some details...
  bool result = false;
  Tags::const_iterator tagIt = e->getTags().find("junction");

  if (tagIt != e->getTags().end() && tagIt.value().toLower() == "roundabout")
  {
    result = true;
  }

  if (result)
  {
    LOG_TRACE("isRoundabout; key: " << tagIt.key());
  }

  return result;
}

void OsmWriter::_writeRelations(shared_ptr<const OsmMap> map, QXmlStreamWriter& writer)
{
  RelationMap::const_iterator it = map->getRelationMap().begin();
  while (it != map->getRelationMap().end())
  {
    const shared_ptr<Relation>& r = it->second;
    writer.writeStartElement("relation");
    writer.writeAttribute("visible", "true");
    writer.writeAttribute("id", QString::number(r->getId()));

    _writeMetadata(writer, r.get());

    const vector<RelationData::Entry>& members = r->getMembers();
    for (size_t j = 0; j < members.size(); j++)
    {
      const RelationData::Entry& e = members[j];
      writer.writeStartElement("member");
      writer.writeAttribute("type", _typeName(e.getElementId().getType()));
      writer.writeAttribute("ref", QString::number(e.getElementId().getId()));
      writer.writeAttribute("role", _e(e.role));
      writer.writeEndElement();
    }

    const Tags& tags = r->getTags();
    for (Tags::const_iterator tit = tags.constBegin(); tit != tags.constEnd(); ++tit)
    {
      if (tit.key().isEmpty() == false && tit.value().isEmpty() == false)
      {
        writer.writeStartElement("tag");
        writer.writeAttribute("k", _e(tit.key()));
        writer.writeAttribute("v", _e(tit.value()));
        writer.writeEndElement();
      }
    }

    if (r->getType() != "")
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "type");
      writer.writeAttribute("v", _e(r->getType()));
      writer.writeEndElement();
    }

    if (r->getCircularError() >= 0)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "error:circular");
      writer.writeAttribute("v", QString("%1").arg(r->getCircularError()));
      writer.writeEndElement();
    }

    if (_includeDebug || _includeIds)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:id");
      writer.writeAttribute("v", QString("%1").arg(r->getId()));
      writer.writeEndElement();
    }

    if (_includeDebug)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:status");
      writer.writeAttribute("v", QString("%1").arg(r->getStatus().getEnum()));
      writer.writeEndElement();
    }

    writer.writeEndElement();

    ++it;
  }
}

void PbfWriter::_writeWay(const shared_ptr<const hoot::Way>& w)
{
    _elementsWritten++;

    if (_pg == 0)
    {
        _pg = _d->primitiveBlock.add_primitivegroup();
    }

    pb::Way* pbw = _pg->add_ways();

    pbw->set_id(w->getId() + _wayIdDelta);

    // if the cached envelope is valid
    const Envelope& env = w->getApproximateEnvelope(_map);
    if (env.isNull() == false)
    {
        // write the way's approximate bounding box. This is a custom Hoot extension to the format.
        pbw->mutable_bbox()->set_left(_convertLon(env.getMinX()));
        pbw->mutable_bbox()->set_right(_convertLon(env.getMaxX()));
        pbw->mutable_bbox()->set_top(_convertLat(env.getMaxY()));
        pbw->mutable_bbox()->set_bottom(_convertLat(env.getMinY()));
    }

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Ways_and_Relations
    // For ways and relations, which contain the ID's of other nodes, I exploit the tendency of
    // consecutive nodes in a way or relation to have nearby node ID's by using delta compression,
    // resulting in small integers. (I.E., instead of encoding x_1, x_2, x_3, I encode
    // x_1, x_2-x_1, x_3-x_2, ...).
    long lastId = 0;
    const std::vector<long>& ids = w->getNodeIds();
    for (size_t i = 0; i < ids.size(); i++)
    {
        pbw->add_refs(ids[i] + _nodeIdDelta - lastId);
        lastId = ids[i] + _nodeIdDelta;
    }

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Ways_and_Relations
    // Tags are encoded as two parallel arrays, one array of string-id's of the keys, and the other
    // of string-id's of the values.
    const Tags& tags = w->getTags();
    for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); ++it)
    {
        const QString& key = it.key();
        const QString& value = it.value();
        if (!value.isEmpty())
        {
            pbw->add_keys(_convertString(key));
            pbw->add_vals(_convertString(value));
        }
    }
    int kid = _convertString("error:circular");
    int vid = _convertString(QString::number(w->getCircularError()));
    pbw->add_keys(kid);
    pbw->add_vals(vid);

    if (w->getStatus() != Status::Invalid)
    {
        kid = _convertString("hoot:status");
        vid = _convertString(QString::number(w->getStatus().getEnum()));
        pbw->add_keys(kid);
        pbw->add_vals(vid);
    }

    _dirty = true;

}

QString AttributeCount::Count(QString input)
{
  QString finalText;
  int maxAttributes = ConfigOptions().getAttributeCountValues();

  OgrReader reader;
  reader.setTranslationFile(QString(getenv("HOOT_HOME")) + "/translations/quick.js");

  QStringList layers;
  if (input.contains(";"))
  {
    QStringList list = input.split(";");
    input = list.at(0);
    layers.append(list.at(1));
  }
  else
  {
    layers = reader.getFilteredLayerNames(input);
  }

  if (layers.size() == 0)
  {
    LOG_WARN("Could not find any valid layers to read from in " + input + ".");
  }

  for (int i = 0; i < layers.size(); i++)
  {
    AttributeCountHash result;

    LOG_DEBUG("Reading: " + input + " " + layers[i]);

    shared_ptr<ElementIterator> iterator(reader.createIterator(input, layers[i]));

    while(iterator->hasNext())
    {
      shared_ptr<Element> e = iterator->next();

      //        // Interesting problem: If there are no elements in the file, e == 0
      //        // Need to look at the ElementIterator.cpp file to fix this.
      //        if (e == 0)
      //        {
      //          LOG_WARN("No features in: " + input + " " + layer);
      //          break;
      //        }

      Tags t = e->getTags();
      for (Tags::const_iterator it = e->getTags().begin(); it != e->getTags().end(); ++it)
      {
        if (it.value() == "") // Drop empty values
        {
          continue;
        }

        // Drop Hoot metadata tags
        if (it.key() == "source:ingest:datetime")
        {
          continue;
        }

        // The default is 30 values
        if (result.value(it.key()).size() < maxAttributes )
        {
          result[it.key()][it.value()]++;
        }
      }
    } // End Layer

    QString tmpText = _printJSON(layers[i], result);

    // Skip empty layers
    if (tmpText == "")
    {
      continue;
    }

    finalText += tmpText;

    if (i != (layers.size() - 1))
    {
      finalText += ",\n";
    }

  } // End layer list

  return finalText;
} // End AttributeCount

void PbfWriter::_writeNodeDense(const shared_ptr<const hoot::Node>& n)
{
    _elementsWritten++;
    if (_dn == 0)
    {
        _dn = _d->primitiveBlock.add_primitivegroup()->mutable_dense();
    }

    _dirty = true;

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Nodes
    // I store the group 'columnwise', as an array of ID's, array of latitudes, and array of
    // longitudes. Each column is delta-encoded. This reduces header overheads and allows
    // delta-coding to work very effectively.
    long lon = _convertLon(n->getX());
    long lat = _convertLat(n->getY());
    _dn->add_id(n->getId() + _nodeIdDelta - _lastId);
    _dn->add_lon(lon - _lastLon);
    _dn->add_lat(lat - _lastLat);
    _lastId = n->getId() + _nodeIdDelta;
    _lastLon = lon;
    _lastLat = lat;

    // From http://wiki.openstreetmap.org/wiki/PBF_Format#Nodes
    // Keys and values for all nodes are encoded as a single array of stringid's. Each node's tags
    // are encoded in alternating <keyid> <valid>. We use a single stringid of 0 to delimit when the
    // tags of a node ends and the tags of the next node begin. The storage pattern is:
    // ((<keyid> <valid>)* '0' )*
    const Tags& tags = n->getTags();
    for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); ++it)
    {
        const QString& key = it.key();
        const QString& value = it.value();
        int kid = _convertString(key);
        int vid = _convertString(value);
        if (!value.isEmpty())
        {
            _dn->add_keys_vals(kid);
            _dn->add_keys_vals(vid);
        }
    }

    // if there are tags on the node then record the CE. CE isn't used as part of a way
    // at this point. Instead the way records the CE for the entire way. No need to waste disk.
    if (n->getTags().getNonDebugCount() > 0)
    {
        int kid = _convertString("error:circular");
        int vid = _convertString(QString::number(n->getCircularError()));
        _dn->add_keys_vals(kid);
        _dn->add_keys_vals(vid);

        if (n->getStatus() != Status::Invalid)
        {
            kid = _convertString("hoot:status");
            vid = _convertString(QString::number(n->getStatus().getEnum()));
            _dn->add_keys_vals(kid);
            _dn->add_keys_vals(vid);
        }
    }

    _dn->add_keys_vals(0);
}

QList<ElementPhoneNumber> PhoneNumberParser::parsePhoneNumbers(const Element& element) const
{
  //phone=* is the standard OSM tag, but have seen many others over time...keeping the allowed tags
  //fairly loose for now
  QList<ElementPhoneNumber> parsedPhoneNums;
  for (Tags::const_iterator it = element.getTags().constBegin();
       it != element.getTags().constEnd(); ++it)
  {
    const QString tagKey = it.key();
    LOG_VART(tagKey);
    if (_additionalTagKeys.contains(tagKey, Qt::CaseInsensitive) ||
        tagKey.contains("phone", Qt::CaseInsensitive))
    {
      const QString tagValue = it.value().toUtf8().trimmed().simplified();
      LOG_VART(tagValue);

      if (_regionCode.isEmpty())
      {
        // If we're not using a region code to see if the number is valid, then just check for at
        // least one digit (vanity numbers can have letters).
        // consider getting rid of this, as its too weak of a check
        if (StringUtils::hasDigit(tagValue))
        {
          _addPhoneNumber(element.getTags().getName(), tagKey, tagValue, parsedPhoneNums);
        }
      }
      else
      {
        if (!_searchInText)
        {
          // IsPossibleNumber is a fairly quick check (IsValidNumber is more strict and a little
          // more expensive)
          if (PhoneNumberUtil::GetInstance()->IsPossibleNumberForString(
                tagValue.toStdString(), _regionCode.toStdString()))
          {
            _addPhoneNumber(element.getTags().getName(), tagKey, tagValue, parsedPhoneNums);
          }
        }
        else
        {
          // This lets us search through text that may have other things in it besides phone
          // numbers.
          PhoneNumberMatcher numberFinder(
            *PhoneNumberUtil::GetInstance(),
            tagValue.toStdString(),
            _regionCode.toStdString(),
            PhoneNumberMatcher::Leniency::POSSIBLE,
            //not sure what a good number is for max tries yet or what that number actually even
            //means
            1);
          int parserFinds = 0;
          while (numberFinder.HasNext())
          {
            PhoneNumberMatch match;
            numberFinder.Next(&match);
            const QString parsedNum = QString::fromStdString(match.raw_string());
            _addPhoneNumber(element.getTags().getName(), tagKey, parsedNum, parsedPhoneNums);
            parserFinds++;
          }
          LOG_TRACE("Number finder found " << parserFinds << " numbers.");
        }
      }

      if (parsedPhoneNums.size() == 0)
      {
        LOG_TRACE("Not a phone number: " << tagKey << "=" << tagValue);
      }
    }
  }
  return parsedPhoneNums;
}