convert remaining outputs to libosmium

Author: lonvia

contrib/libosmium/osmium/geom/wkb.hpp

@@ -199,6 +199,31 @@ namespace osmium {
                     }
                 }
 
+                /* MultiLineString */
+
+                void multilinestring_start() {
+                    m_data.clear();
+                    m_multipolygon_size_offset = header(m_data, wkbMultiLineString, true);
+                }
+
+                void add_part(std::string const &part) {
+                    m_data.append(part);
+                }
+
+                linestring_type multilinestring_finish(size_t num_lines) {
+                    set_size(m_multipolygon_size_offset, num_lines);
+                    std::string data;
+
+                    using std::swap;
+                    swap(data, m_data);
+
+                    if (m_out_type == out_type::hex) {
+                        return convert_to_hex(data);
+                    } else {
+                        return data;
+                    }
+                }
+
                 /* Polygon */
                 polygon_type polygon_finish() {
                     set_size(m_polygon_size_offset, m_rings);

expire-tiles.cpp

@@ -508,6 +508,7 @@ int expire_tiles::from_db(table_t* table, osmid_t osm_id) {
     //dirty the stuff
     const char* wkb = nullptr;
     while((wkb = wkbs.get_next()))
+        // XXX need to convert from hex to binary
         from_wkb(wkb, osm_id);
 
     //return how many rows were affected

geometry-processor.cpp

@@ -14,16 +14,16 @@
 std::shared_ptr<geometry_processor> geometry_processor::create(const std::string &type,
                                                                  const options_t *options) {
     std::shared_ptr<geometry_processor> ptr;
-    int srid = options->projection->target_srs();
 
     if (type == "point") {
-        ptr = std::make_shared<processor_point>(srid);
+        ptr = std::make_shared<processor_point>(options->projection);
     }
     else if (type == "line") {
-        ptr = std::make_shared<processor_line>(srid);
+        ptr = std::make_shared<processor_line>(options->projection);
     }
     else if (type == "polygon") {
-        ptr = std::make_shared<processor_polygon>(srid, options->enable_multi);
+        ptr = std::make_shared<processor_polygon>(options->projection,
+                                                  options->enable_multi);
     }
     else {
         throw std::runtime_error((boost::format("Unable to construct geometry processor "
@@ -38,8 +38,7 @@ geometry_processor::geometry_processor(int srid, const std::string &type, unsign
     : m_srid(srid), m_type(type), m_interests(interests) {
 }
 
-geometry_processor::~geometry_processor() {
-}
+geometry_processor::~geometry_processor() = default;
 
 int geometry_processor::srid() const {
     return m_srid;
@@ -57,40 +56,29 @@ bool geometry_processor::interests(unsigned int interested) const {
     return (interested & m_interests) == interested;
 }
 
-geometry_builder::pg_geom_t geometry_processor::process_node(double, double) {
-    return geometry_builder::pg_geom_t();
-}
-
-geometry_builder::pg_geom_t geometry_processor::process_way(const nodelist_t &) {
-    return geometry_builder::pg_geom_t();
-}
-
-geometry_builder::pg_geoms_t geometry_processor::process_relation(const multinodelist_t &) {
-    return geometry_builder::pg_geoms_t();
+geometry_processor::wkb_t
+geometry_processor::process_node(osmium::Location const &)
+{
+    return wkb_t();
 }
 
-way_helper::way_helper()
+geometry_processor::wkb_t geometry_processor::process_way(osmium::Way const &)
 {
+    return wkb_t();
 }
-way_helper::~way_helper()
+
+geometry_processor::wkbs_t
+geometry_processor::process_relation(osmium::Relation const &,
+                                     osmium::memory::Buffer const &)
 {
+    return wkbs_t();
 }
-size_t way_helper::set(osmium::WayNodeList const &node_ids,
-                       middle_query_t const *mid, reprojection const *proj)
-{
-    node_cache.clear();
-    mid->nodes_get_list(node_cache, node_ids, proj);
 
-    // equivalent to returning node_count for complete ways, different for partial
-    // extracts
-    return node_cache.size();
-}
 
 relation_helper::relation_helper()
 : data(1024, osmium::memory::Buffer::auto_grow::yes)
 {}
 
-relation_helper::~relation_helper() = default;
 
 size_t relation_helper::set(osmium::RelationMemberList const &member_list, middle_t const *mid)
 {
@@ -100,13 +88,10 @@ size_t relation_helper::set(osmium::RelationMemberList const &member_list, middl
     roles.clear();
 
     //grab the way members' ids
-    size_t num_input = member_list.size();
-    input_way_ids.reserve(num_input);
-    roles.reserve(num_input);
-    for (auto const &member : member_list) {
-        if (member.type() == osmium::item_type::way) {
-            input_way_ids.push_back(member.ref());
-            roles.push_back(member.role());
+    for (auto const &m : member_list) {
+        /* Need to handle more than just ways... */
+        if (m.type() == osmium::item_type::way) {
+            input_way_ids.push_back(m.ref());
         }
     }
 
@@ -118,21 +103,14 @@ size_t relation_helper::set(osmium::RelationMemberList const &member_list, middl
     auto num_ways = mid->ways_get_list(input_way_ids, data);
 
     //grab the roles of each way
-    if (num_ways < input_way_ids.size()) {
-        size_t memberpos = 0;
-        size_t waypos = 0;
-        for (auto const &w : data.select<osmium::Way>()) {
-            while (memberpos < input_way_ids.size()) {
-                if (input_way_ids[memberpos] == w.id()) {
-                    roles[waypos] = roles[memberpos];
-                    ++memberpos;
-                    break;
-                }
-                ++memberpos;
+    for (auto const &w : data.select<osmium::Way>()) {
+        for (auto const &member : member_list) {
+            if (member.ref() == w.id() &&
+                member.type() == osmium::item_type::way) {
+                roles.emplace_back(member.role());
+                break;
             }
-            ++waypos;
         }
-        roles.resize(num_ways);
     }
 
     //mark the ends of each so whoever uses them will know where they end..
@@ -147,21 +125,15 @@ multitaglist_t relation_helper::get_filtered_tags(tagtransform *transform, expor
 
     size_t i = 0;
     for (auto const &w : data.select<osmium::Way>()) {
-        transform->filter_tags(w, nullptr, nullptr, el, filtered[i++]);
+        transform->filter_tags(w, nullptr, nullptr, el, filtered[++i]);
     }
 
     return filtered;
 }
 
-multinodelist_t relation_helper::get_nodes(middle_t const *mid,
-                                           reprojection const *proj) const
+void relation_helper::add_way_locations(middle_t const *mid)
 {
-    multinodelist_t nodes(roles.size());
-
-    size_t i = 0;
-    for (auto const &w : data.select<osmium::Way>()) {
-        mid->nodes_get_list(nodes[i++], w.nodes(), proj);
+    for (auto &w : data.select<osmium::Way>()) {
+        mid->nodes_get_list(&(w.nodes()));
     }
-
-    return nodes;
 }

geometry-processor.hpp

@@ -8,7 +8,7 @@
 
 #include <osmium/memory/buffer.hpp>
 
-#include "geometry-builder.hpp"
+#include "osmium-builder.hpp"
 #include "osmtypes.hpp"
 #include "tagtransform.hpp"
 
@@ -18,6 +18,8 @@ struct options_t;
 class reprojection;
 
 struct geometry_processor {
+    using wkb_t = geom::osmium_builder_t::wkb_t;
+    using wkbs_t = geom::osmium_builder_t::wkbs_t;
     // factory method for creating various types of geometry processors either by name or by geometry column type
     static std::shared_ptr<geometry_processor> create(const std::string &type,
                                                         const options_t *options);
@@ -45,17 +47,18 @@ struct geometry_processor {
 
     // process a node, optionally returning a WKB string describing
     // geometry to be inserted into the table.
-    virtual geometry_builder::pg_geom_t process_node(double lat, double lon);
+    virtual wkb_t process_node(osmium::Location const &loc);
 
     // process a way
     // position data and optionally returning WKB-encoded geometry
     // for insertion into the table.
-    virtual geometry_builder::pg_geom_t process_way(const nodelist_t &nodes);
+    virtual wkb_t process_way(osmium::Way const &way);
 
     // process a way, taking a middle query object to get way and
     // node position data. optionally returns an array of WKB-encoded geometry
     // for insertion into the table.
-    virtual geometry_builder::pg_geoms_t process_relation(const multinodelist_t &nodes);
+    virtual wkbs_t process_relation(osmium::Relation const &rel,
+                                    osmium::memory::Buffer const &ways);
 
     // returns the SRID of the output geometry.
     int srid() const;
@@ -75,29 +78,15 @@ struct geometry_processor {
 };
 
 
-//various bits for continuous processing of ways
-struct way_helper
-{
-    way_helper();
-    ~way_helper();
-    size_t set(osmium::WayNodeList const &node_ids, middle_query_t const *mid,
-               reprojection const *proj);
-
-    nodelist_t node_cache;
-};
-
 //various bits for continuous processing of members of relations
-struct relation_helper
+class relation_helper
 {
+public:
     relation_helper();
-    ~relation_helper();
+
     size_t set(osmium::RelationMemberList const &member_list, middle_t const *mid);
     multitaglist_t get_filtered_tags(tagtransform *transform, export_list const &el) const;
-    multinodelist_t get_nodes(middle_t const *mid,
-                              reprojection const *proj) const;
-
-    osmium::memory::ItemIteratorRange<const osmium::Way> way_iterator() const
-    { return data.select<osmium::Way>(); }
+    void add_way_locations(middle_t const *mid);
 
     rolelist_t roles;
     std::vector<int> superseded;