Generalizer: Add "append" flag as parameter to all generalizers

and make it accessible through the append_mode() function.

Author: joto

src/gen/gen-base.cpp

@@ -14,8 +14,8 @@
 
 #include <fmt/args.h>
 
-gen_base_t::gen_base_t(pg_conn_t *connection, params_t *params)
-: m_connection(connection), m_params(params)
+gen_base_t::gen_base_t(pg_conn_t *connection, bool append, params_t *params)
+: m_connection(connection), m_params(params), m_append(append)
 {
     assert(connection);
     assert(params);

src/gen/gen-base.hpp

@@ -67,8 +67,10 @@ class gen_base_t
         }
     }
 
+    bool append_mode() const noexcept { return m_append; }
+
 protected:
-    gen_base_t(pg_conn_t *connection, params_t *params);
+    gen_base_t(pg_conn_t *connection, bool append, params_t *params);
 
     /**
      * Check that the 'src_table' and 'dest_table' parameters exist and that
@@ -106,6 +108,7 @@ class gen_base_t
     std::vector<util::timer_t> m_timers;
     pg_conn_t *m_connection;
     params_t *m_params;
+    bool m_append;
     bool m_debug = false;
 }; // class gen_base_t
 

src/gen/gen-create.cpp

@@ -18,24 +18,25 @@
 
 std::unique_ptr<gen_base_t> create_generalizer(std::string const &strategy,
                                                pg_conn_t *connection,
-                                               params_t *params)
+                                               bool append, params_t *params)
 {
     auto generalizer = [&]() -> std::unique_ptr<gen_base_t> {
         if (strategy == "builtup") {
-            return std::make_unique<gen_tile_builtup_t>(connection, params);
+            return std::make_unique<gen_tile_builtup_t>(connection, append,
+                                                        params);
         }
         if (strategy == "discrete-isolation") {
-            return std::make_unique<gen_di_t>(connection, params);
+            return std::make_unique<gen_di_t>(connection, append, params);
         }
         if (strategy == "raster-union") {
-            return std::make_unique<gen_tile_raster_union_t>(connection,
+            return std::make_unique<gen_tile_raster_union_t>(connection, append,
                                                              params);
         }
         if (strategy == "rivers") {
-            return std::make_unique<gen_rivers_t>(connection, params);
+            return std::make_unique<gen_rivers_t>(connection, append, params);
         }
         if (strategy == "vector-union") {
-            return std::make_unique<gen_tile_vector_union_t>(connection,
+            return std::make_unique<gen_tile_vector_union_t>(connection, append,
                                                              params);
         }
         throw fmt_error("Unknown generalization strategy '{}'.", strategy);

src/gen/gen-create.hpp

@@ -21,6 +21,6 @@ class pg_conn_t;
 /// Instantiate a generalizer for the specified strategy.
 std::unique_ptr<gen_base_t> create_generalizer(std::string const &strategy,
                                                pg_conn_t *connection,
-                                               params_t *params);
+                                               bool append, params_t *params);
 
 #endif // OSM2PGSQL_GEN_CREATE_HPP

src/gen/gen-discrete-isolation.cpp

@@ -17,8 +17,8 @@
 #include <algorithm>
 #include <vector>
 
-gen_di_t::gen_di_t(pg_conn_t *connection, params_t *params)
-: gen_base_t(connection, params), m_timer_get(add_timer("get")),
+gen_di_t::gen_di_t(pg_conn_t *connection, bool append, params_t *params)
+: gen_base_t(connection, append, params), m_timer_get(add_timer("get")),
   m_timer_sort(add_timer("sort")), m_timer_di(add_timer("di")),
   m_timer_reorder(add_timer("reorder")), m_timer_write(add_timer("write"))
 {

src/gen/gen-discrete-isolation.hpp

@@ -17,7 +17,7 @@
 class gen_di_t : public gen_base_t
 {
 public:
-    gen_di_t(pg_conn_t *connection, params_t *params);
+    gen_di_t(pg_conn_t *connection, bool append, params_t *params);
 
     void process() override;
 

src/gen/gen-rivers.cpp

@@ -22,8 +22,8 @@
 #include <unordered_map>
 #include <vector>
 
-gen_rivers_t::gen_rivers_t(pg_conn_t *connection, params_t *params)
-: gen_base_t(connection, params), m_timer_area(add_timer("area")),
+gen_rivers_t::gen_rivers_t(pg_conn_t *connection, bool append, params_t *params)
+: gen_base_t(connection, append, params), m_timer_area(add_timer("area")),
   m_timer_prep(add_timer("prep")), m_timer_get(add_timer("get")),
   m_timer_sort(add_timer("sort")), m_timer_net(add_timer("net")),
   m_timer_remove(add_timer("remove")), m_timer_width(add_timer("width")),

src/gen/gen-rivers.hpp

@@ -17,7 +17,7 @@
 class gen_rivers_t : public gen_base_t
 {
 public:
-    gen_rivers_t(pg_conn_t *connection, params_t *params);
+    gen_rivers_t(pg_conn_t *connection, bool append, params_t *params);
 
     void process() override;
 

src/gen/gen-tile-builtup.cpp

@@ -26,8 +26,9 @@ static std::size_t round_up(std::size_t value, std::size_t multiple) noexcept
     return ((value + multiple - 1U) / multiple) * multiple;
 }
 
-gen_tile_builtup_t::gen_tile_builtup_t(pg_conn_t *connection, params_t *params)
-: gen_tile_t(connection, params), m_timer_draw(add_timer("draw")),
+gen_tile_builtup_t::gen_tile_builtup_t(pg_conn_t *connection, bool append,
+                                       params_t *params)
+: gen_tile_t(connection, append, params), m_timer_draw(add_timer("draw")),
   m_timer_simplify(add_timer("simplify")),
   m_timer_vectorize(add_timer("vectorize")), m_timer_write(add_timer("write"))
 {

src/gen/gen-tile-builtup.hpp

@@ -19,7 +19,7 @@
 class gen_tile_builtup_t final : public gen_tile_t
 {
 public:
-    gen_tile_builtup_t(pg_conn_t *connection, params_t *params);
+    gen_tile_builtup_t(pg_conn_t *connection, bool append, params_t *params);
 
     ~gen_tile_builtup_t() override = default;