way::way(const tags_t &a, const tags_t &t, const std::vector<id_t> &wn)
: element(a, t), way_nodes(wn) {
tags_t::const_iterator itr = a.find("tiles");
if ((itr != a.end()) && (!itr->second.empty())) {
tiles_cache = CompressedBitset(itr->second);
}
}
void xml_formatter::write_tags(const tags_t &tags) {
for (tags_t::const_iterator itr = tags.begin(); itr != tags.end(); ++itr) {
writer->start("tag");
writer->attribute("k", itr->first);
writer->attribute("v", itr->second);
writer->end();
}
}
void json_formatter::write_tags(const tags_t &tags) {
writer->object_key("tags");
writer->start_object();
for (tags_t::const_iterator itr = tags.begin(); itr != tags.end(); ++itr) {
writer->object_key(itr->first);
writer->entry_string(itr->second);
}
writer->end_object();
}
int hydra::scoreValue(const tags_t &tags)
{
for (tags_t::const_iterator ii=tags.begin(); ii != tags.end(); ++ii) {
assert(!ii->isEmpty());
if ((*ii)[0] == SCORE_CHAR)
return ii->size();
}
return 0;
}
void sopostloader::add_column(const column_spec &col, const char *value) {
soloader::add_column(col, value);
plidx_cur++;
if (!value)
return;
if (plidx_cur == plidx_id) {
pl_curid = atoi(value);
}
else if (plidx_cur == plidx_posttypeid) {
pl_curposttype = atoi(value);
}
else if (config.tags && (plidx_cur == plidx_tags) && (pl_curposttype == 1)) {
std::string tname(value);
size_t s, e;
s = 0;
while (s < tname.length()) {
e = tname.find('>', s);
if ((tname[s] != '<') || (e == tname.npos)) {
std::cerr << "invalid tags: " << tname << std::endl;
break;
}
std::string tag(tname.substr(s+1, e-s-1));
tags.push_back(std::make_pair(pl_curid, tag));
s = e + 1;
}
}
}
void
OWLDiff::update_metadata(const tags_t &attrs) {
tags_t::const_iterator uid_itr = attrs.find("uid");
tags_t::const_iterator user_itr = attrs.find("user");
tags_t::const_iterator changeset_itr = attrs.find("changeset");
if ((uid_itr != attrs.end()) &&
(user_itr != attrs.end()) &&
(changeset_itr != attrs.end())) {
id_t id = lexical_cast<id_t>(uid_itr->second);
const string &name = user_itr->second;
id_t cs_id = lexical_cast<id_t>(changeset_itr->second);
map<id_t, string>::iterator itr = users_seen.find(id);
if (itr != users_seen.end()) {
if (itr->second != name) {
itr->second = name;
}
} else {
users_seen.insert(std::make_pair(id, name));
}
map<id_t, id_t>::iterator jtr = changesets_seen.find(cs_id);
if (jtr == changesets_seen.end()) {
changesets_seen.insert(std::make_pair(cs_id, id));
} else {
// this should be forbidden by the OSM data model... but it's always worth
// checking these things.
if (jtr->second != id) {
throw runtime_error("Changeset ID refers to two different user IDs!");
}
}
}
}
void json_formatter::write_tags(const tags_t &tags) {
if (tags.empty())
return;
writer->object_key("tags");
writer->start_object();
for (const auto& tag : tags) {
writer->object_key(tag.first);
writer->entry_string(tag.second);
}
writer->end_object();
}
void sopostloader::write_tags(const table_spec &spec) {
std::cout << "writing " << spec.name << std::endl;
std::vector<column_spec> columns = spec.columns();
builder.open_table(spec);
int counter(0);
for (tags_t::iterator it = tags.begin(); it != tags.end(); ++it) {
if (++counter % 100000 == 0)
std::cout << " (" << counter << " datasets)" << std::endl;
builder.open_row();
dbvalue id(it->first);
builder.add_column(columns[0], id.get());
builder.add_column(columns[1], it->second.c_str());
builder.row_complete();
}
std::cout << " (" << counter << " datasets)" << std::endl;
builder.table_complete();
if (config.indexes) {
std::cout << " (indexing " << columns[0].name << "...)" << std::endl;
builder.add_index(columns[0].name);
std::cout << " (indexing " << columns[1].name << "...)" << std::endl;
builder.add_index(columns[1].name);
}
}
extern "C" void executeModule( tags_t& tags, function<void()> stop_module_func )
{
Q_ASSERT_X(false, __FUNC__, "you should not use this function");
#if 0
qDebug () << "QtApp started";
QApplication app( tags.argc(), tags.argv() );
list<QString> modules_paths = parse_conf( tags.projectFolder() );
list<shared_ptr<QLibrary>> libs;
StopFuncs stop_funcs;
for (auto p : modules_paths) {
QString nam = QString::fromStdString (a::fs::lib_path()) + QDir::separator() + "qt"+ QDir::separator() + a::fs::lib_name(p);
libs.push_back( shared_ptr<QLibrary>( new QLibrary(nam) ) );
if (!libs.back()->load() ) {
qWarning() << "qtapp: cant load library: "<<nam; continue;
}
stop_funcs.push_back( pair<QString, function<void()>>(nam, function<void()>() ) );
vis_func_type f = reinterpret_cast<vis_func_type>(libs.back()->resolve("executeModule"));
if (!f) {
qWarning() << "qtapp: cant resolve func executeModule for lib: "<<p; libs.back()->unload(); continue;
}
f(tags, &stop_funcs.back().second, app);
}
stop_module_func = bind (stop, std::ref(app), std::ref(stop_funcs));
app.exec();
#endif
}
bool operator==(const tags_t &a, const tags_t &b) {
if (a.size() != b.size()) {
return false;
}
for (tags_t::const_iterator atr = a.begin(); atr != a.end(); ++atr) {
tags_t::const_iterator btr = b.find(atr->first);
if (btr == b.end()) {
return false;
} else if (atr->second != btr->second) {
return false;
}
}
return true;
}
