Add string_joiner_t class and helper function

There are several places where we need to join several elements into a
string and it gets tedious to write them correctly. Here is a new class
string_joiner_t that helps with that job.

Author: joto

src/flex-table.cpp

@@ -202,18 +202,15 @@ std::string flex_table_t::build_sql_column_list() const
 {
     assert(!m_columns.empty());
 
-    std::string result;
+    util::string_joiner_t joiner{',', '"'};
+
     for (auto const &column : m_columns) {
         if (!column.create_only()) {
-            result += '"';
-            result += column.name();
-            result += '"';
-            result += ',';
+            joiner.add(column.name());
         }
     }
-    result.resize(result.size() - 1);
 
-    return result;
+    return joiner();
 }
 
 std::string flex_table_t::build_sql_create_id_index() const

src/table.cpp

@@ -155,28 +155,29 @@ void table_t::prepare()
 
 void table_t::generate_copy_column_list()
 {
-    m_target->rows = "osm_id,";
-    //first with the regular columns
+    util::string_joiner_t joiner{',', '"'};
+
+    joiner.add("osm_id");
+
+    // first with the regular columns
     for (auto const &column : m_columns) {
-        m_target->rows += '"';
-        m_target->rows += column.name;
-        m_target->rows += "\",";
+        joiner.add(column.name);
     }
 
-    //then with the hstore columns
+    // then with the hstore columns
     for (auto const &hcolumn : m_hstore_columns) {
-        m_target->rows += '"';
-        m_target->rows += hcolumn;
-        m_target->rows += "\",";
+        joiner.add(hcolumn);
     }
 
-    //add tags column and geom column
+    // add tags column
     if (m_hstore_mode != hstore_column::none) {
-        m_target->rows += "tags,way";
-        //or just the geom column
-    } else {
-        m_target->rows += "way";
+        joiner.add("tags");
     }
+
+    // add geom column
+    joiner.add("way");
+
+    m_target->rows = joiner();
 }
 
 void table_t::stop(bool updateable, bool enable_hstore_index,

src/util.cpp

@@ -83,4 +83,49 @@ std::string get_password()
     return password;
 }
 
+string_joiner_t::string_joiner_t(char delim, char quote, char before,
+                                 char after)
+: m_delim(delim), m_quote(quote), m_before(before), m_after(after)
+{
+    if (m_before) {
+        m_result += m_before;
+    }
+}
+
+void string_joiner_t::add(std::string const &item)
+{
+    if (m_quote) {
+        m_result += m_quote;
+        m_result += item;
+        m_result += m_quote;
+    } else {
+        m_result += item;
+    }
+    m_result += m_delim;
+}
+
+std::string string_joiner_t::operator()()
+{
+    if (m_result.size() == 1 && m_before) {
+        m_result.clear();
+    } else if (m_result.size() > 1) {
+        if (m_after) {
+            m_result.back() = m_after;
+        } else {
+            m_result.resize(m_result.size() - 1);
+        }
+    }
+    return std::move(m_result);
+}
+
+std::string join(std::vector<std::string> const &items, char delim, char quote,
+                 char before, char after)
+{
+    string_joiner_t joiner{delim, quote, before, after};
+    for (auto const &item : items) {
+        joiner.add(item);
+    }
+    return joiner();
+}
+
 } // namespace util

src/util.hpp

@@ -21,6 +21,7 @@
 #include <cstdlib>
 #include <ctime>
 #include <string>
+#include <vector>
 
 namespace util {
 
@@ -158,6 +159,63 @@ auto find_by_name(CONTAINER &container, std::string const &name)
     return &*it;
 }
 
+/**
+ * Class to help with joining strings.
+ *
+ * After construction call add() as many times as you want. Call the
+ * call operator to get the result, after which the class is unusable.
+ *
+ * Writes out a string like '("A","B","C")' with "delim" set to the comma,
+ * the double quotes as "quote" character and parentheses as "before" and
+ * "after" characters. If there are no items (i.e. add() is never called),
+ * the result is always empty, so the "before" and "after" characters are
+ * not added in this case.
+ */
+class string_joiner_t
+{
+public:
+    /**
+     * Constructor
+     * \param delim Char to output between items.
+     * \param quote Char to output before and after items (use '\0' for none).
+     * \param before Char to output before everything else (use '\0' for none).
+     * \param after Char to output after everything else (use '\0' for none).
+     */
+    explicit string_joiner_t(char delim, char quote = '\0', char before = '\0',
+                             char after = '\0');
+
+    /**
+     * Add one item to be joined. The quote character is added before and
+     * after the item, but the item itself is added as-is without escaping
+     * the quote character or anything like that.
+     */
+    void add(std::string const &item);
+
+    /// Return result (as value!)
+    std::string operator()();
+
+private:
+    std::string m_result;
+    char m_delim;
+    char m_quote;
+    char m_before;
+    char m_after;
+};
+
+/**
+ * Join all strings in the input vector. This is a convenient wrapper around
+ * the string_joiner_t class.
+ *
+ * \param items The input strings.
+ * \param delim Character to output between items.
+ * \param quote Character to output before and after items (use '\0' for none).
+ * \param before Character to output before everything else (use '\0' for none).
+ * \param after Character to output after everything else (use '\0' for none).
+ * \returns Result string.
+ */
+std::string join(std::vector<std::string> const &items, char delim,
+                 char quote = '\0', char before = '\0', char after = '\0');
+
 } // namespace util
 
 #endif // OSM2PGSQL_UTIL_HPP

tests/test-util.cpp

@@ -112,3 +112,62 @@ TEST_CASE("find_by_name()", "[NoDB]")
     REQUIRE(util::find_by_name(t, "baz") == &t[2]);
     REQUIRE(util::find_by_name(t, "nothing") == nullptr);
 }
+
+TEST_CASE("Use string_joiner_t with delim only without items", "[NoDB]")
+{
+    util::string_joiner_t joiner{','};
+    REQUIRE(joiner().empty());
+}
+
+TEST_CASE("Use string_joiner_t with all params without items", "[NoDB]")
+{
+    util::string_joiner_t joiner{',', '"', '(', ')'};
+    REQUIRE(joiner().empty());
+}
+
+TEST_CASE("Use string_joiner_t without quote char", "[NoDB]")
+{
+    util::string_joiner_t joiner{',', '\0', '(', ')'};
+    joiner.add("foo");
+    joiner.add("bar");
+    REQUIRE(joiner() == "(foo,bar)");
+}
+
+TEST_CASE("string_joiner_t without before/after", "[NoDB]")
+{
+    util::string_joiner_t joiner{','};
+    joiner.add("xxx");
+    joiner.add("yyy");
+    REQUIRE(joiner() == "xxx,yyy");
+}
+
+TEST_CASE("string_joiner_t with single single-char item", "[NoDB]")
+{
+    util::string_joiner_t joiner{','};
+    joiner.add("x");
+    REQUIRE(joiner() == "x");
+}
+
+TEST_CASE("string_joiner_t with single single-char item and wrapper", "[NoDB]")
+{
+    util::string_joiner_t joiner{',', '\0', '(', ')'};
+    joiner.add("x");
+    REQUIRE(joiner() == "(x)");
+}
+
+TEST_CASE("join strings", "[NoDB]")
+{
+    std::vector<std::string> const t{"abc", "def", "", "ghi"};
+
+    REQUIRE(util::join(t, ',') == "abc,def,,ghi");
+    REQUIRE(util::join(t, '-', '#', '[', ']') == "[#abc#-#def#-##-#ghi#]");
+    REQUIRE(util::join(t, '-', '#', '[', ']') == "[#abc#-#def#-##-#ghi#]");
+}
+
+TEST_CASE("join strings with empty list", "[NoDB]")
+{
+    std::vector<std::string> const t{};
+
+    REQUIRE(util::join(t, ',').empty());
+    REQUIRE(util::join(t, '-', '#', '[', ']').empty());
+}