Merge pull request #907 from lonvia/simplify-output-pgsql-members

Some cleanup for output-pgsql members

Author: lonvia

output-multi.cpp

@@ -13,21 +13,20 @@
 
 output_multi_t::output_multi_t(std::string const &name,
                                std::shared_ptr<geometry_processor> processor_,
-                               export_list const &export_list_,
+                               export_list const &export_list,
                                std::shared_ptr<middle_query_t> const &mid,
                                options_t const &options)
 : output_t(mid, options),
-  m_tagtransform(tagtransform_t::make_tagtransform(&m_options)),
-  m_export_list(new export_list(export_list_)), m_processor(processor_),
-  m_proj(m_options.projection),
+  m_tagtransform(tagtransform_t::make_tagtransform(&m_options, export_list)),
+  m_processor(processor_), m_proj(m_options.projection),
   // TODO: we could in fact have something that is interested in nodes and
   // ways..
   m_osm_type(m_processor->interests(geometry_processor::interest_node)
                  ? osmium::item_type::node
                  : osmium::item_type::way),
   m_table(new table_t(
       m_options.database_options.conninfo(), name, m_processor->column_type(),
-      m_export_list->normal_columns(m_osm_type), m_options.hstore_columns,
+      export_list.normal_columns(m_osm_type), m_options.hstore_columns,
       m_processor->srid(), m_options.append, m_options.slim, m_options.droptemp,
       m_options.hstore_mode, m_options.enable_hstore_index,
       m_options.tblsmain_data, m_options.tblsmain_index)),
@@ -36,15 +35,14 @@ output_multi_t::output_multi_t(std::string const &name,
            m_options.projection),
   buffer(1024, osmium::memory::Buffer::auto_grow::yes),
   m_builder(m_options.projection, m_options.enable_multi),
-  m_way_area(m_export_list->has_column(m_osm_type, "way_area"))
+  m_way_area(export_list.has_column(m_osm_type, "way_area"))
 {
 }
 
 output_multi_t::output_multi_t(output_multi_t const *other,
                                std::shared_ptr<middle_query_t> const &mid)
 : output_t(mid, other->m_options),
-  m_tagtransform(tagtransform_t::make_tagtransform(&m_options)),
-  m_export_list(new export_list(*other->m_export_list)),
+  m_tagtransform(other->m_tagtransform->clone()),
   m_processor(other->m_processor), m_proj(other->m_proj),
   m_osm_type(other->m_osm_type), m_table(new table_t(*other->m_table)),
   // NOTE: we need to know which ways were used by relations so each thread
@@ -284,8 +282,7 @@ int output_multi_t::process_node(osmium::Node const &node)
 {
     // check if we are keeping this node
     taglist_t outtags;
-    auto filter = m_tagtransform->filter_tags(node, 0, 0, *m_export_list.get(),
-                                              outtags, true);
+    auto filter = m_tagtransform->filter_tags(node, 0, 0, outtags, true);
     if (!filter) {
         // grab its geom
         auto geom = m_processor->process_node(node.location(), &m_builder);
@@ -312,8 +309,8 @@ int output_multi_t::reprocess_way(osmium::Way *way, bool exists)
 
     //check if we are keeping this way
     taglist_t outtags;
-    unsigned int filter = m_tagtransform->filter_tags(
-        *way, 0, 0, *m_export_list.get(), outtags, true);
+    unsigned int filter =
+        m_tagtransform->filter_tags(*way, 0, 0, outtags, true);
     if (!filter) {
         m_mid->nodes_get_list(&(way->nodes()));
         auto geom = m_processor->process_way(*way, &m_builder);
@@ -327,7 +324,7 @@ int output_multi_t::reprocess_way(osmium::Way *way, bool exists)
 int output_multi_t::process_way(osmium::Way *way) {
     //check if we are keeping this way
     taglist_t outtags;
-    auto filter = m_tagtransform->filter_tags(*way, 0, 0, *m_export_list.get(), outtags, true);
+    auto filter = m_tagtransform->filter_tags(*way, 0, 0, outtags, true);
     if (!filter) {
         //get the geom from the middle
         if (m_mid->nodes_get_list(&(way->nodes())) < 1)
@@ -358,8 +355,7 @@ int output_multi_t::process_relation(osmium::Relation const &rel, bool exists)
 
     //does this relation have anything interesting to us
     taglist_t rel_outtags;
-    auto filter = m_tagtransform->filter_tags(rel, 0, 0, *m_export_list.get(),
-                                              rel_outtags, true);
+    auto filter = m_tagtransform->filter_tags(rel, 0, 0, rel_outtags, true);
     if (!filter) {
         //TODO: move this into geometry processor, figure a way to come back for tag transform
         //grab ways/nodes of the members in the relation, bail if none were used
@@ -377,8 +373,7 @@ int output_multi_t::process_relation(osmium::Relation const &rel, bool exists)
         taglist_t outtags;
         filter = m_tagtransform->filter_rel_member_tags(
             rel_outtags, m_relation_helper.data, m_relation_helper.roles,
-            &make_boundary, &make_polygon, &roads, *m_export_list.get(),
-            outtags, true);
+            &make_boundary, &make_polygon, &roads, outtags, true);
         if (!filter)
         {
             m_relation_helper.add_way_locations(m_mid.get());

output-multi.hpp

@@ -31,7 +31,7 @@ class output_multi_t : public output_t
 public:
     output_multi_t(std::string const &name,
                    std::shared_ptr<geometry_processor> processor_,
-                   export_list const &export_list_,
+                   export_list const &export_list,
                    std::shared_ptr<middle_query_t> const &mid,
                    options_t const &options);
     virtual ~output_multi_t();
@@ -78,7 +78,6 @@ class output_multi_t : public output_t
                        taglist_t &tags);
 
     std::unique_ptr<tagtransform_t> m_tagtransform;
-    std::unique_ptr<export_list> m_export_list;
     std::shared_ptr<geometry_processor> m_processor;
     std::shared_ptr<reprojection> m_proj;
     osmium::item_type const m_osm_type;

output-pgsql.cpp

@@ -163,8 +163,7 @@ int output_pgsql_t::pending_way(osmid_t id, int exists) {
         int polygon;
         int roads;
         auto &way = buffer.get<osmium::Way>(0);
-        if (!m_tagtransform->filter_tags(way, &polygon, &roads,
-                                         *m_export_list.get(), outtags)) {
+        if (!m_tagtransform->filter_tags(way, &polygon, &roads, outtags)) {
             auto nnodes = m_mid->nodes_get_list(&(way.nodes()));
             if (nnodes > 1) {
                 pgsql_out_way(way, &outtags, polygon, roads);
@@ -243,7 +242,7 @@ void output_pgsql_t::stop(osmium::thread::Pool *pool)
 {
     // attempt to stop tables in parallel
     for (auto &t : m_tables) {
-        pool->submit(std::bind(&table_t::stop, t));
+        pool->submit(std::bind(&table_t::stop, t.get()));
     }
 
     if (m_options.expire_tiles_zoom_min > 0) {
@@ -255,8 +254,7 @@ void output_pgsql_t::stop(osmium::thread::Pool *pool)
 int output_pgsql_t::node_add(osmium::Node const &node)
 {
     taglist_t outtags;
-    if (m_tagtransform->filter_tags(node, nullptr, nullptr,
-                                    *m_export_list.get(), outtags))
+    if (m_tagtransform->filter_tags(node, nullptr, nullptr, outtags))
         return 1;
 
     auto wkb = m_builder.get_wkb_node(node.location());
@@ -273,8 +271,7 @@ int output_pgsql_t::way_add(osmium::Way *way)
     taglist_t outtags;
 
     /* Check whether the way is: (1) Exportable, (2) Maybe a polygon */
-    auto filter = m_tagtransform->filter_tags(*way, &polygon, &roads,
-                                              *m_export_list.get(), outtags);
+    auto filter = m_tagtransform->filter_tags(*way, &polygon, &roads, outtags);
 
     if (!filter) {
         /* Get actual node data and generate output */
@@ -291,8 +288,7 @@ int output_pgsql_t::way_add(osmium::Way *way)
 int output_pgsql_t::pgsql_process_relation(osmium::Relation const &rel)
 {
     taglist_t prefiltered_tags;
-    if (m_tagtransform->filter_tags(rel, nullptr, nullptr, *m_export_list.get(),
-                                    prefiltered_tags)) {
+    if (m_tagtransform->filter_tags(rel, nullptr, nullptr, prefiltered_tags)) {
         return 1;
     }
 
@@ -318,9 +314,9 @@ int output_pgsql_t::pgsql_process_relation(osmium::Relation const &rel)
 
   // If it's a route relation make_boundary and make_polygon will be false
   // otherwise one or the other will be true.
-  if (m_tagtransform->filter_rel_member_tags(
-          prefiltered_tags, buffer, xrole, &make_boundary, &make_polygon,
-          &roads, *m_export_list.get(), outtags)) {
+  if (m_tagtransform->filter_rel_member_tags(prefiltered_tags, buffer, xrole,
+                                             &make_boundary, &make_polygon,
+                                             &roads, outtags)) {
       return 0;
   }
 
@@ -492,10 +488,9 @@ int output_pgsql_t::relation_modify(osmium::Relation const &rel)
 
 int output_pgsql_t::start()
 {
-    for(std::vector<std::shared_ptr<table_t> >::iterator table = m_tables.begin(); table != m_tables.end(); ++table)
-    {
+    for (auto &t : m_tables) {
         //setup the table in postgres
-        table->get()->start();
+        t->start();
     }
 
     return 0;
@@ -515,27 +510,18 @@ output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
   buffer(32768, osmium::memory::Buffer::auto_grow::yes),
   rels_buffer(1024, osmium::memory::Buffer::auto_grow::yes)
 {
-    m_export_list.reset(new export_list());
+    export_list exlist;
 
-    m_enable_way_area = read_style_file( m_options.style, m_export_list.get() );
+    m_enable_way_area = read_style_file(m_options.style, &exlist);
 
-    try {
-        m_tagtransform = tagtransform_t::make_tagtransform(&m_options);
-    }
-    catch(const std::runtime_error& e) {
-        fprintf(stderr, "%s\n", e.what());
-        fprintf(stderr, "Error: Failed to initialise tag processing.\n");
-        util::exit_nicely();
-    }
+    m_tagtransform = tagtransform_t::make_tagtransform(&m_options, exlist);
 
     //for each table
-    m_tables.reserve(t_MAX);
     for (int i = 0; i < t_MAX; i++) {
 
         //figure out the columns this table needs
-        columns_t columns = m_export_list->normal_columns((i == t_point)
-                            ? osmium::item_type::node
-                            : osmium::item_type::way);
+        columns_t columns = exlist.normal_columns(
+            (i == t_point) ? osmium::item_type::node : osmium::item_type::way);
 
         //figure out what name we are using for this and what type
         std::string name = m_options.prefix;
@@ -566,21 +552,20 @@ output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
         //tremble in awe of this massive constructor! seriously we are trying to avoid passing an
         //options object because we want to make use of the table_t in output_mutli_t which could
         //have a different tablespace/hstores/etc per table
-        m_tables.push_back(std::shared_ptr<table_t>(new table_t(
+        m_tables[i].reset(new table_t(
             m_options.database_options.conninfo(), name, type, columns,
             m_options.hstore_columns, m_options.projection->target_srs(),
             m_options.append, m_options.slim, m_options.droptemp,
             m_options.hstore_mode, m_options.enable_hstore_index,
-            m_options.tblsmain_data, m_options.tblsmain_index)));
+            m_options.tblsmain_data, m_options.tblsmain_index));
     }
 }
 
 output_pgsql_t::output_pgsql_t(output_pgsql_t const *other,
                                std::shared_ptr<middle_query_t> const &mid)
 : output_t(mid, other->m_options),
-  m_tagtransform(tagtransform_t::make_tagtransform(&m_options)),
+  m_tagtransform(other->m_tagtransform->clone()),
   m_enable_way_area(other->m_enable_way_area),
-  m_export_list(new export_list(*other->m_export_list)),
   m_builder(m_options.projection, other->m_options.enable_multi),
   expire(m_options.expire_tiles_zoom, m_options.expire_tiles_max_bbox,
          m_options.projection),
@@ -590,9 +575,9 @@ output_pgsql_t::output_pgsql_t(output_pgsql_t const *other,
   buffer(1024, osmium::memory::Buffer::auto_grow::yes),
   rels_buffer(1024, osmium::memory::Buffer::auto_grow::yes)
 {
-    for (auto const &t : other->m_tables) {
+    for (size_t i = 0; i < t_MAX; ++i) {
         //copy constructor will just connect to the already there table
-        m_tables.push_back(std::shared_ptr<table_t>(new table_t(*t.get())));
+        m_tables[i].reset(new table_t(*(other->m_tables[i].get())));
     }
 }
 

output-pgsql.hpp

@@ -13,7 +13,7 @@
 #include "table.hpp"
 #include "tagtransform.hpp"
 
-#include <vector>
+#include <array>
 #include <memory>
 
 class output_pgsql_t : public output_t {
@@ -71,9 +71,7 @@ class output_pgsql_t : public output_t {
     //enable output of a generated way_area tag to either hstore or its own column
     int m_enable_way_area;
 
-    std::vector<std::shared_ptr<table_t> > m_tables;
-
-    std::unique_ptr<export_list> m_export_list;
+    std::array<std::unique_ptr<table_t>, t_MAX> m_tables;
 
     geom::osmium_builder_t m_builder;
     expire_tiles expire;

tagtransform-c.cpp

@@ -79,11 +79,18 @@ void add_z_order(taglist_t &tags, int *roads)
 
 } // anonymous namespace
 
-c_tagtransform_t::c_tagtransform_t(options_t const *options)
-: m_options(options)
+c_tagtransform_t::c_tagtransform_t(options_t const *options,
+                                   export_list const &exlist)
+: m_options(options), m_export_list(exlist)
 {
 }
 
+std::unique_ptr<tagtransform_t> c_tagtransform_t::clone() const
+{
+    return std::unique_ptr<tagtransform_t>(
+        new c_tagtransform_t(m_options, m_export_list));
+}
+
 bool c_tagtransform_t::check_key(std::vector<taginfo> const &infos,
                                  char const *k, bool *filter, int *flags,
                                  bool strict)
@@ -134,8 +141,7 @@ bool c_tagtransform_t::check_key(std::vector<taginfo> const &infos,
 }
 
 bool c_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
-                                   int *roads, export_list const &exlist,
-                                   taglist_t &out_tags, bool strict)
+                                   int *roads, taglist_t &out_tags, bool strict)
 {
     //assume we dont like this set of tags
     bool filter = true;
@@ -147,7 +153,7 @@ bool c_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
     if (o.type() == osmium::item_type::relation) {
         export_type = osmium::item_type::way;
     }
-    const std::vector<taginfo> &infos = exlist.get(export_type);
+    const std::vector<taginfo> &infos = m_export_list.get(export_type);
 
     /* We used to only go far enough to determine if it's a polygon or not,
        but now we go through and filter stuff we don't need
@@ -205,8 +211,8 @@ bool c_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
 
 bool c_tagtransform_t::filter_rel_member_tags(
     taglist_t const &rel_tags, osmium::memory::Buffer const &,
-    rolelist_t const &, int *make_boundary, int *make_polygon, int *roads,
-    export_list const &, taglist_t &out_tags, bool allow_typeless)
+    rolelist_t const &, int *make_boundary, int *make_polygon,
+    int *roads, taglist_t &out_tags, bool allow_typeless)
 {
     //if it has a relation figure out what kind it is
     const std::string *type = rel_tags.get("type");

tagtransform-c.hpp

@@ -7,25 +7,26 @@
 class c_tagtransform_t : public tagtransform_t
 {
 public:
-    c_tagtransform_t(options_t const *options);
+    c_tagtransform_t(options_t const *options, export_list const &exlist);
+
+    std::unique_ptr<tagtransform_t> clone() const override;
 
     bool filter_tags(osmium::OSMObject const &o, int *polygon, int *roads,
-                     export_list const &exlist, taglist_t &out_tags,
-                     bool strict = false) override;
+                     taglist_t &out_tags, bool strict = false) override;
 
     bool filter_rel_member_tags(taglist_t const &rel_tags,
                                 osmium::memory::Buffer const &members,
                                 rolelist_t const &member_roles,
                                 int *make_boundary, int *make_polygon,
-                                int *roads, export_list const &exlist,
-                                taglist_t &out_tags,
+                                int *roads, taglist_t &out_tags,
                                 bool allow_typeless = false) override;
 
 private:
     bool check_key(std::vector<taginfo> const &infos, char const *k,
                    bool *filter, int *flags, bool strict);
 
     options_t const *m_options;
+    export_list m_export_list;
 };
 
 #endif // TAGTRANSFORM_C_H