C++ ConstOsmMapPtr::visitRo方法代码示例

bool MapScoringStatusAndRefTagValidator::allTagsAreValid(const ConstOsmMapPtr& map)
{
  //if first map has any element with a hoot::status = Unknown1 tag and a tag with key = REF2,
  //then fail
  FilteredVisitor unknown1Visitor(
    new ChainCriterion(
      new StatusCriterion(Status::Unknown1),
      new HasTagCriterion("REF2")),
    new CountVisitor());
  FilteredVisitor& filteredRefVisitor = const_cast<FilteredVisitor&>(unknown1Visitor);
  SingleStatistic* singleStat = dynamic_cast<SingleStatistic*>(&unknown1Visitor.getChildVisitor());
  assert(singleStat != 0);
  map->visitRo(filteredRefVisitor);
  const long numFirstInputBadTags = singleStat->getStat();

  //if second map has any element with a hoot::status = Unknown2 tag and a tag with key = REF1,
  //then fail
  FilteredVisitor unknown2Visitor(
    new ChainCriterion(
      new StatusCriterion(Status::Unknown2),
      new HasTagCriterion("REF1")),
    new CountVisitor());
  filteredRefVisitor = const_cast<FilteredVisitor&>(unknown2Visitor);
  singleStat = dynamic_cast<SingleStatistic*>(&unknown2Visitor.getChildVisitor());
  assert(singleStat != 0);
  map->visitRo(filteredRefVisitor);
  const long numSecondInputBadTags = singleStat->getStat();

  return (numFirstInputBadTags + numSecondInputBadTags) == 0;
}

void AttributeCoOccurence::addToMatrix(const ConstOsmMapPtr& in)

{
  RefToEidVisitor ref2("REF2");

  in->visitRo(ref2);

  CoOccurenceVisitor coOccurenceResult(ref2.getRefToEid(), _resultMatrix);

  in->visitRo(coOccurenceResult);
}

void PlacesPoiMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match *> &matches,
  ConstMatchThresholdPtr threshold)
{
  LOG_DEBUG(SystemInfo::getMemoryUsageString());
  {
    WorstCircularErrorVisitor wav;
    map->visitRo(wav);
    LOG_DEBUG("Worst circular error: " << wav.getWorstCircularError());
    PlacesPoiMatchVisitor v(map, matches, wav.getWorstCircularError(), _bounds, threshold);
    map->visitRo(v);
    LOG_DEBUG(SystemInfo::getMemoryUsageString());
  }
  LOG_DEBUG(SystemInfo::getMemoryUsageString());
}

void ScriptMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match *> &matches,
                                       ConstMatchThresholdPtr threshold)
{
  if (!_script)
  {
    throw IllegalArgumentException("The script must be set on the ScriptMatchCreator.");
  }

  ScriptMatchVisitor v(map, matches, threshold, _script, _filter);
  v.setScriptPath(_scriptPath);
  v.calculateSearchRadius();
  _cachedCustomSearchRadii[_scriptPath] = v.getCustomSearchRadius();
  LOG_VART(_scriptPath);
  LOG_VART(_cachedCustomSearchRadii[_scriptPath]);
  QFileInfo scriptFileInfo(_scriptPath);

  LOG_DEBUG(
    "Creating matches with: " << className() << ";" << scriptFileInfo.fileName() << "...");
  LOG_VARD(*threshold);
  map->visitRo(v);
  LOG_INFO(
    "Found " << v.getNumMatchCandidatesFound() << " " <<
    CreatorDescription::baseFeatureTypeToString(
      _getScriptDescription(_scriptPath).baseFeatureType) << " match candidates.");
}

void BuildingMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match*>& matches,
  ConstMatchThresholdPtr threshold)
{
  LOG_VAR(*threshold);
  BuildingMatchVisitor v(map, matches, _getRf(), threshold, Status::Unknown1);
  map->visitRo(v);
}

void ScriptMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match *> &matches,
                                       ConstMatchThresholdPtr threshold)
{
  if (!_script)
  {
    throw IllegalArgumentException("The script must be set on the ScriptMatchCreator.");
  }
  ScriptMatchVisitor v(map, matches, threshold, _script);
  v.customScriptInit();
  map->visitRo(v);
}

  ScriptMatchVisitor(const ConstOsmMapPtr& map, vector<const Match*>& result,
    ConstMatchThresholdPtr mt, shared_ptr<PluginContext> script) :
    _map(map),
    _result(result),
    _mt(mt),
    _script(script),
    _searchRadius(-1.0)
  {
    _neighborCountMax = -1;
    _neighborCountSum = 0;
    _elementsEvaluated = 0;
    _maxGroupSize = 0;

    HandleScope handleScope;
    Context::Scope context_scope(_script->getContext());
    Handle<Object> plugin = getPlugin();
    _candidateDistanceSigma = getNumber(plugin, "candidateDistanceSigma", 0.0, 1.0);

    //this is meant to have been set externally in a js rules file
    _searchRadius = getNumber(plugin, "searchRadius", -1.0, 15.0);

    Handle<v8::Value> value = plugin->Get(toV8("getSearchRadius"));
    if (value->IsUndefined())
    {
      // pass
    }
    else if (value->IsFunction() == false)
    {
      throw HootException("getSearchRadius is not a function.");
    }
    else
    {
      _getSearchRadius = Persistent<Function>::New(Handle<Function>::Cast(value));
    }

    SmWorstCircularErrorVisitor v(*this);
    map->visitRo(v);
    _worstCircularError = v.getWorstCircularError();
  }

QStringList ShapefileWriter::getColumns(ConstOsmMapPtr map, ElementType type) const
{
  if (_columns.size() != 0)
  {
    return _columns;
  }
  else
  {
    QStringList result;
    ColumnVisitor v(type);
    map->visitRo(v);
    QMultiMap<int, QString> backwardKeys = v.getBackwardKeys();

    QMapIterator<int, QString> i(backwardKeys);
    i.toBack();
    while (i.hasPrevious() && result.size() < 20)
    {
      i.previous();
      result << i.value();
    }

    return result;
  }
}

void PoiPolygonMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match*>& matches,
  ConstMatchThresholdPtr threshold)
{
  PoiPolygonMatchVisitor v(map, matches, threshold);
  map->visitRo(v);
}

void HighwayMatchCreator::createMatches(const ConstOsmMapPtr& map, vector<const Match *> &matches,
  ConstMatchThresholdPtr threshold)
{
  HighwayMatchVisitor v(map, matches, _classifier, _sublineMatcher, Status::Unknown1, threshold);
  map->visitRo(v);
}