C++ OSMObject::type方法代码示例

void ExportFormatJSON::add_attributes(const osmium::OSMObject& object) {
    if (!options().type.empty()) {
        m_writer.String(options().type);
        if (object.type() == osmium::item_type::area) {
            if (static_cast<const osmium::Area&>(object).from_way()) {
                m_writer.String("way");
            } else {
                m_writer.String("relation");
            }
        } else {
            m_writer.String(osmium::item_type_to_name(object.type()));
        }
    }

    if (!options().id.empty()) {
        m_writer.String(options().id);
        m_writer.Int64(object.type() == osmium::item_type::area ? osmium::area_id_to_object_id(object.id()) : object.id());
    }

    if (!options().version.empty()) {
        m_writer.String(options().version);
        m_writer.Int64(object.version());
    }

    if (!options().changeset.empty()) {
        m_writer.String(options().changeset);
        m_writer.Int64(object.changeset());
    }

    if (!options().uid.empty()) {
        m_writer.String(options().uid);
        m_writer.Int64(object.uid());
    }

    if (!options().user.empty()) {
        m_writer.String(options().user);
        m_writer.String(object.user());
    }

    if (!options().timestamp.empty()) {
        m_writer.String(options().timestamp);
        m_writer.Int64(object.timestamp().seconds_since_epoch());
    }

    if (!options().way_nodes.empty() && object.type() == osmium::item_type::way) {
        m_writer.String(options().way_nodes);
        m_writer.StartArray();
        for (const auto& nr : static_cast<const osmium::Way&>(object).nodes()) {
            m_writer.Int64(nr.ref());
        }
        m_writer.EndArray();
    }
}

            /**
             * Initialize area attributes from the attributes of the given object.
             */
            void initialize_from_object(const osmium::OSMObject& source) {
                osmium::Area& area = object();
                area.set_id(osmium::object_id_to_area_id(source.id(), source.type()));
                area.set_version(source.version());
                area.set_changeset(source.changeset());
                area.set_timestamp(source.timestamp());
                area.set_visible(source.visible());
                area.set_uid(source.uid());

                add_user(source.user());
            }

                /**
                 * Find this object in the member vectors and add it to all
                 * relations that need it.
                 *
                 * @returns true if the member was added to at least one
                 *          relation and false otherwise
                 */
                bool find_and_add_object(const osmium::OSMObject& object) {
                    auto& mmv = m_collector.member_meta(object.type());
                    auto range = std::equal_range(mmv.begin(), mmv.end(), MemberMeta(object.id()));

                    if (osmium::relations::count_not_removed(range.first, range.second) == 0) {
                        // nothing found
                        return false;
                    }

                    {
                        m_collector.members_buffer().add_item(object);
                        const size_t member_offset = m_collector.members_buffer().commit();

                        for (auto it = range.first; it != range.second; ++it) {
                            it->set_buffer_offset(member_offset);
                        }
                    }

                    for (auto it = range.first; it != range.second; ++it) {
                        MemberMeta& member_meta = *it;
                        if (member_meta.removed()) {
                            break;
                        }
                        assert(member_meta.member_id() == object.id());
                        assert(member_meta.relation_pos() < m_collector.m_relations.size());
                        RelationMeta& relation_meta = m_collector.m_relations[member_meta.relation_pos()];
//                        std::cerr << "  => " << member_meta.member_pos() << " < " << m_collector.get_relation(relation_meta).members().size() << " (id=" << m_collector.get_relation(relation_meta).id() << ")\n";
                        assert(member_meta.member_pos() < m_collector.get_relation(relation_meta).members().size());
//                        std::cerr << "  add way " << member_meta.member_id() << " to rel " << m_collector.get_relation(relation_meta).id() << " at pos " << member_meta.member_pos() << "\n";
                        relation_meta.got_one_member();
                        if (relation_meta.has_all_members()) {
                            const size_t relation_offset = member_meta.relation_pos();
                            m_collector.complete_relation(relation_meta);
                            m_collector.m_relations[relation_offset] = RelationMeta();
                            m_collector.possibly_purge_removed_members();
                        }
                    }

                    // Remove MemberMetas that were marked as removed.
                    mmv.erase(std::remove_if(mmv.begin(), mmv.end(), [](MemberMeta& mm) {
                        return mm.removed();
                    }), mmv.end());

                    return true;
                }

 bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept {
     return const_tie(lhs.type(), lhs.id() < 0, lhs.positive_id(), rhs.version(), rhs.timestamp()) <
            const_tie(rhs.type(), rhs.id() < 0, rhs.positive_id(), lhs.version(), lhs.timestamp());
 }

 osmium::item_type type() const noexcept {
     return m_curr->type();
 }

bool lua_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
                                     int *roads, export_list const &,
                                     taglist_t &out_tags, bool)
{
    switch (o.type()) {
    case osmium::item_type::node:
        lua_getglobal(L, m_node_func.c_str());
        break;
    case osmium::item_type::way:
        lua_getglobal(L, m_way_func.c_str());
        break;
    case osmium::item_type::relation:
        lua_getglobal(L, m_rel_func.c_str());
        break;
    default:
        throw std::runtime_error("Unknown OSM type");
    }

    lua_newtable(L); /* key value table */

    lua_Integer sz = 0;
    for (auto const &t : o.tags()) {
        lua_pushstring(L, t.key());
        lua_pushstring(L, t.value());
        lua_rawset(L, -3);
        ++sz;
    }
    if (m_extra_attributes && o.version() > 0) {
        taglist_t tags;
        tags.add_attributes(o);
        for (auto const &t : tags) {
            lua_pushstring(L, t.key.c_str());
            lua_pushstring(L, t.value.c_str());
            lua_rawset(L, -3);
        }
        sz += tags.size();
    }

    lua_pushinteger(L, sz);

    if (lua_pcall(L, 2, (o.type() == osmium::item_type::way) ? 4 : 2, 0)) {
        fprintf(stderr,
                "Failed to execute lua function for basic tag processing: %s\n",
                lua_tostring(L, -1));
        /* lua function failed */
        return 1;
    }

    if (o.type() == osmium::item_type::way) {
        if (roads) {
            *roads = (int)lua_tointeger(L, -1);
        }
        lua_pop(L, 1);
        if (polygon) {
            *polygon = (int)lua_tointeger(L, -1);
        }
        lua_pop(L, 1);
    }

    lua_pushnil(L);
    while (lua_next(L, -2) != 0) {
        const char *key = lua_tostring(L, -2);
        const char *value = lua_tostring(L, -1);
        out_tags.emplace_back(key, value);
        lua_pop(L, 1);
    }

    bool filter = lua_tointeger(L, -2);

    lua_pop(L, 2);

    return filter;
}

bool gazetteer_style_t::copy_out_maintag(pmaintag_t const &tag,
                                         osmium::OSMObject const &o,
                                         std::string const &geom,
                                         db_copy_mgr_t &buffer)
{
    std::vector<osmium::Tag const *> domain_name;
    if (std::get<2>(tag) & SF_MAIN_NAMED_KEY) {
        domain_name = domain_names(std::get<0>(tag), o.tags());
        if (domain_name.empty())
            return false;
    }

    if (std::get<2>(tag) & SF_MAIN_NAMED) {
        if (domain_name.empty() && !m_is_named) {
            return false;
        }
    }

    buffer.new_line(place_table);
    // osm_id
    buffer.add_column(o.id());
    // osm_type
    char const osm_type[2] = { (char)toupper(osmium::item_type_to_char(o.type())), '\0'};
    buffer.add_column(osm_type);
    // class
    buffer.add_column(std::get<0>(tag));
    // type
    buffer.add_column(std::get<1>(tag));
    // names
    if (!domain_name.empty()) {
        auto prefix_len = strlen(std::get<0>(tag)) + 1; // class name and ':'
        buffer.new_hash();
        for (auto *t : domain_name) {
            buffer.add_hash_elem(t->key() + prefix_len, t->value());
        }
        buffer.finish_hash();
    } else {
        bool first = true;
        // operator will be ignored on anything but these classes
        if (m_operator && (std::get<2>(tag) & SF_MAIN_OPERATOR)) {
            buffer.new_hash();
            buffer.add_hash_elem("operator", m_operator);
            first = false;
        }
        for (auto const &entry : m_names) {
            if (first) {
                buffer.new_hash();
                first = false;
            }

            buffer.add_hash_elem(entry.first, entry.second);
        }

        if (first) {
            buffer.add_null_column();
        } else {
            buffer.finish_hash();
        }
    }
    // admin_level
    buffer.add_column(m_admin_level);
    // address
    if (m_address.empty()) {
        buffer.add_null_column();
    } else {
        buffer.new_hash();
        for (auto const &a : m_address) {
            if (strcmp(a.first, "tiger:county") == 0) {
                std::string term;
                auto *end = strchr(a.second, ',');
                if (end) {
                    auto len = (std::string::size_type)(end - a.second);
                    term = std::string(a.second, len);
                } else {
                    term = a.second;
                }
                term += " county";
                buffer.add_hash_elem(a.first, term);
            } else {
                buffer.add_hash_elem(a.first, a.second);
            }
        }
        buffer.finish_hash();
    }
    // extra tags
    if (m_extra.empty()) {
        buffer.add_null_column();
    } else {
        buffer.new_hash();
        for (auto const &entry : m_extra) {
            buffer.add_hash_elem(entry.first, entry.second);
        }
        buffer.finish_hash();
    }
    // add the geometry - encoding it to hex along the way
    buffer.add_hex_geom(geom);

    buffer.finish_line();

    return true;
//.........这里部分代码省略.........