move export_list into c transform

Avoid having to hand in the export list on every filter call.

output-multi.cpp

@@ -13,13 +13,12 @@
 
 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_tagtransform(tagtransform_t::make_tagtransform(&m_options, export_list)),
-  m_export_list(new export_list(export_list_)), m_processor(processor_),
+  m_processor(processor_), m_proj(m_options.projection),
-  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)
@@ -27,7 +26,7 @@ output_multi_t::output_multi_t(std::string const &name,
                  : 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_tagtransform(other->m_tagtransform->clone()),
-  m_export_list(new export_list(*other->m_export_list)),
   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(),
+    auto filter = m_tagtransform->filter_tags(node, 0, 0, outtags, true);
-                                              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(
+    unsigned int filter =
-        *way, 0, 0, *m_export_list.get(), outtags, true);
+        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(),
+    auto filter = m_tagtransform->filter_tags(rel, 0, 0, rel_outtags, true);
-                                              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(),
+            &make_boundary, &make_polygon, &roads, outtags, true);
-            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 @@ protected:
                        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,
+        if (!m_tagtransform->filter_tags(way, &polygon, &roads, outtags)) {
-                                         *m_export_list.get(), outtags)) {
             auto nnodes = m_mid->nodes_get_list(&(way.nodes()));
             if (nnodes > 1) {
                 pgsql_out_way(way, &outtags, polygon, roads);
@@ -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,
+    if (m_tagtransform->filter_tags(node, nullptr, nullptr, outtags))
-                                    *m_export_list.get(), 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,
+    auto filter = m_tagtransform->filter_tags(*way, &polygon, &roads, outtags);
-                                              *m_export_list.get(), 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(),
+    if (m_tagtransform->filter_tags(rel, nullptr, nullptr, prefiltered_tags)) {
-                                    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(
+  if (m_tagtransform->filter_rel_member_tags(prefiltered_tags, buffer, xrole,
-          prefiltered_tags, buffer, xrole, &make_boundary, &make_polygon,
+                                             &make_boundary, &make_polygon,
-          &roads, *m_export_list.get(), outtags)) {
+                                             &roads, outtags)) {
       return 0;
   }
 
@@ -514,26 +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, exlist);
-        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();
-    }
 
     //for each table
     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)
+        columns_t columns = exlist.normal_columns(
-                            ? osmium::item_type::node
+            (i == t_point) ? osmium::item_type::node : osmium::item_type::way);
-                            : osmium::item_type::way);
 
         //figure out what name we are using for this and what type
         std::string name = m_options.prefix;
@@ -576,9 +564,8 @@ output_pgsql_t::output_pgsql_t(std::shared_ptr<middle_query_t> const &mid,
 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),

output-pgsql.hpp

@@ -73,8 +73,6 @@ protected:
 
     std::array<std::unique_ptr<table_t>, t_MAX> m_tables;
 
-    std::unique_ptr<export_list> m_export_list;
-
     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)
+c_tagtransform_t::c_tagtransform_t(options_t const *options,
-: m_options(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,
+                                   int *roads, taglist_t &out_tags, bool strict)
-                                   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,
+    rolelist_t const &, int *make_boundary, int *make_polygon,
-    export_list const &, taglist_t &out_tags, bool allow_typeless)
+    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,18 +7,18 @@
 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,
+                     taglist_t &out_tags, bool strict = false) override;
-                     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,
+                                int *roads, taglist_t &out_tags,
-                                taglist_t &out_tags,
                                 bool allow_typeless = false) override;
 
 private:
@@ -26,6 +26,7 @@ private:
                    bool *filter, int *flags, bool strict);
 
     options_t const *m_options;
+    export_list m_export_list;
 };
 
 #endif // TAGTRANSFORM_C_H

tagtransform-lua.cpp

@@ -9,17 +9,24 @@ extern "C" {
 #include "tagtransform-lua.hpp"
 
 lua_tagtransform_t::lua_tagtransform_t(options_t const *options)
-: L(luaL_newstate()), m_node_func(options->tag_transform_node_func.get_value_or(
+: m_node_func(
-                          "filter_tags_node")),
+      options->tag_transform_node_func.get_value_or("filter_tags_node")),
   m_way_func(options->tag_transform_way_func.get_value_or("filter_tags_way")),
   m_rel_func(
       options->tag_transform_rel_func.get_value_or("filter_basic_tags_rel")),
   m_rel_mem_func(options->tag_transform_rel_mem_func.get_value_or(
       "filter_tags_relation_member")),
+  m_lua_file(options->tag_transform_script.get()),
   m_extra_attributes(options->extra_attributes)
 {
+    open_style();
+}
+
+void lua_tagtransform_t::open_style()
+{
+    L = luaL_newstate();
     luaL_openlibs(L);
-    if (luaL_dofile(L, options->tag_transform_script->c_str())) {
+    if (luaL_dofile(L, m_lua_file.c_str())) {
         throw std::runtime_error(
             (boost::format("Lua tag transform style error: %1%") %
              lua_tostring(L, -1))
@@ -34,6 +41,14 @@ lua_tagtransform_t::lua_tagtransform_t(options_t const *options)
 
 lua_tagtransform_t::~lua_tagtransform_t() { lua_close(L); }
 
+std::unique_ptr<tagtransform_t> lua_tagtransform_t::clone() const
+{
+    auto c = std::unique_ptr<lua_tagtransform_t>(new lua_tagtransform_t(*this));
+    c->open_style();
+
+    return std::unique_ptr<tagtransform_t>(c.release());
+}
+
 void lua_tagtransform_t::check_lua_function_exists(const std::string &func_name)
 {
     lua_getglobal(L, func_name.c_str());
@@ -48,8 +63,7 @@ void lua_tagtransform_t::check_lua_function_exists(const std::string &func_name)
 }
 
 bool lua_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
-                                     int *roads, export_list const &,
+                                     int *roads, taglist_t &out_tags, bool)
-                                     taglist_t &out_tags, bool)
 {
     switch (o.type()) {
     case osmium::item_type::node:
@@ -141,7 +155,7 @@ bool lua_tagtransform_t::filter_tags(osmium::OSMObject const &o, int *polygon,
 bool lua_tagtransform_t::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 &, taglist_t &out_tags, bool)
+    int *roads, taglist_t &out_tags, bool)
 {
     size_t num_members = member_roles.size();
     lua_getglobal(L, m_rel_mem_func.c_str());

tagtransform-lua.hpp

@@ -11,27 +11,31 @@ extern "C" {
 
 class lua_tagtransform_t : public tagtransform_t
 {
+    lua_tagtransform_t(lua_tagtransform_t const &other) = default;
+
 public:
     lua_tagtransform_t(options_t const *options);
     ~lua_tagtransform_t();
 
+    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,
+                     taglist_t &out_tags, bool strict = false) override;
-                     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,
+                                int *roads, taglist_t &out_tags,
-                                taglist_t &out_tags,
                                 bool allow_typeless = false) override;
 
 private:
+    void open_style();
     void check_lua_function_exists(std::string const &func_name);
 
     lua_State *L;
     std::string m_node_func, m_way_func, m_rel_func, m_rel_mem_func;
+    std::string m_lua_file;
     bool m_extra_attributes;
 };
 

tagtransform.cpp

@@ -8,7 +8,8 @@
 #endif
 
 std::unique_ptr<tagtransform_t>
-tagtransform_t::make_tagtransform(options_t const *options)
+tagtransform_t::make_tagtransform(options_t const *options,
+                                  export_list const &exlist)
 {
     if (options->tag_transform_script) {
 #ifdef HAVE_LUA
@@ -24,7 +25,8 @@ tagtransform_t::make_tagtransform(options_t const *options)
     }
 
     fprintf(stderr, "Using built-in tag processing pipeline\n");
-    return std::unique_ptr<tagtransform_t>(new c_tagtransform_t(options));
+    return std::unique_ptr<tagtransform_t>(
+        new c_tagtransform_t(options, exlist));
 }
 
 tagtransform_t::~tagtransform_t() = default;

tagtransform.hpp

@@ -14,20 +14,21 @@ class tagtransform_t
 {
 public:
     static std::unique_ptr<tagtransform_t>
-    make_tagtransform(options_t const *options);
+    make_tagtransform(options_t const *options, export_list const &exlist);
 
     virtual ~tagtransform_t() = 0;
 
+    virtual std::unique_ptr<tagtransform_t> clone() const = 0;
+
     virtual bool filter_tags(osmium::OSMObject const &o, int *polygon,
-                             int *roads, export_list const &exlist,
+                             int *roads, taglist_t &out_tags,
-                             taglist_t &out_tags, bool strict = false) = 0;
+                             bool strict = false) = 0;
 
     virtual 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,
+                                        int *roads, taglist_t &out_tags,
-                                        taglist_t &out_tags,
                                         bool allow_typeless = false) = 0;
 };
 

tests/test-options-parse.cpp

@@ -4,6 +4,7 @@
 #include "output-pgsql.hpp"
 #include "output-gazetteer.hpp"
 #include "output-null.hpp"
+#include "taginfo_impl.hpp"
 
 #include <stdio.h>
 #include <string.h>
@@ -135,8 +136,9 @@ void test_lua_styles()
     options_t options = options_t(len(a1), const_cast<char **>(a1));
 
     try {
+        export_list exlist;
         std::unique_ptr<tagtransform_t> tagtransform =
-            tagtransform_t::make_tagtransform(&options);
+            tagtransform_t::make_tagtransform(&options, exlist);
         throw std::logic_error("Expected 'No such file or directory'");
     } catch (const std::runtime_error &e) {
         if (!alg::icontains(e.what(), "No such file or directory"))