Merge pull request diffblue#93 from diffblue/nathan/feature/string_join-allow-string-constant

Updated string_join to allow string constant arguments

Author: NathanJPhillips

src/taint-analysis/taint_summary_dump.cpp

@@ -36,8 +36,8 @@ dumper taint_sett::dump(const taint_tokent::named_tokenst &named_tokens) const
         ostr << "\u22A5";
         return;
       }
-      std::string set_separator(" \u222A "),
-        set_element_separator(", ");
+      const char *set_separator(" \u222A "),
+        *set_element_separator(", ");
       if(!tokens.empty() || !variables.empty())
       {
         ostr << "{ " << join(
@@ -401,13 +401,14 @@ bool taint_functions_for_dumping_taint_summary_in_htmlt::
                 ostr << " and ";
               if(props.get_sink_conditions().size()>1U && set.size()>1U)
                 ostr << " ( ";
-              const taint_tokent::named_tokenst * const named_tokens_ptr=
-                  &named_tokens;
+              const taint_tokent::named_tokenst &named_tokens=
+                this->named_tokens;
               ostr << html_encoding()
-                   << join(set | boost::adaptors::transformed(
-                        [named_tokens_ptr](const taint_subject_conditiont &cond)
-                        { return cond.dump(*named_tokens_ptr); }),
-                        std::string(" or "));
+                   << join(
+                      set | boost::adaptors::transformed(
+                        [&named_tokens] (const taint_subject_conditiont &cond)
+                        { return cond.dump(named_tokens); }),
+                      " or ");
               if(props.get_sink_conditions().size()>1U && set.size()>1U)
                 ostr << " ) ";
             }

src/util/string_join.h

@@ -1,42 +1,77 @@
+/*******************************************************************\
+
+Module: String joiner
+
+Author: [email protected]
+
+Purpose:
+  To join multiple objects that can be piped to a stream into a list separated
+  by a string provided by the user.
+
+\*******************************************************************/
+
 #ifndef CPROVER__util__string_join
 #define CPROVER__util__string_join
 
-
 #include <iterator>
 #include <sstream>
 
-template<typename Str, typename It>
+
+template<typename T>
+struct string_traitst final
+{
+  typedef typename T::value_type char_typet;
+  typedef typename T::traits_type traits_typet;
+  typedef typename T::allocator_type allocator_typet;
+};
+
+template<>
+struct string_traitst<const char *> final
+{
+  typedef char char_typet;
+  typedef typename std::char_traits<char> traits_typet;
+  typedef typename std::allocator<char> allocator_typet;
+};
+
+
+template<typename Str, typename It, typename Str_Traits = string_traitst<Str>>
 class joined_strings
 {
   private:
     const It begin, end;
     Str sep;
 
   public:
-    typedef typename Str::value_type char_type;
-    typedef typename Str::traits_type traits_type;
-    typedef typename Str::allocator_type allocator_type;
+    typedef typename Str_Traits::char_typet char_typet;
+    typedef typename Str_Traits::traits_typet traits_typet;
+    typedef typename Str_Traits::allocator_typet allocator_typet;
+    typedef
+      typename std::basic_string<char_typet, traits_typet, allocator_typet>
+      string_typet;
 
   private:
-    typedef std::basic_ostringstream<char_type, traits_type, allocator_type>
-      ostringstream_type;
+    typedef std::basic_ostringstream<char_typet, traits_typet, allocator_typet>
+      ostringstream_typet;
 
   public:
-    joined_strings(It begin, const It end, const Str &sep)
-      : begin(begin), end(end), sep(sep)
+    template<typename It_In, typename Str_In>
+    joined_strings(It_In &&begin, It_In &&end, Str_In &&sep)
+      : begin(std::forward<It_In>(begin)),
+        end(std::forward<It_In>(end)),
+        sep(std::forward<Str_In>(sep))
     {
     }
 
-    operator Str() const
+    operator string_typet() const
     {
-      ostringstream_type result;
+      ostringstream_typet result;
       result << *this;
       return result.str();
     }
 
-    template<typename ostream_type>
-    friend ostream_type& operator<<(
-      ostream_type &ostr, const joined_strings<Str, It> &joined)
+    template<typename ostream_typet>
+    friend ostream_typet& operator<<(
+      ostream_typet &ostr, const joined_strings<Str, It> &joined)
     {
       It it = joined.begin;
       if(it!=joined.end)
@@ -50,12 +85,24 @@ class joined_strings
     }
 };
 
+
 template<typename Str, typename It>
-inline joined_strings<Str, It> join(It begin, const It end, const Str &sep)
+inline joined_strings<Str, It> join(It begin, It end, const Str &sep)
 {
-  return joined_strings<Str, It>(begin, end, sep);
+  return joined_strings<Str, It>(std::move(begin), std::move(end), sep);
 }
 
+template<typename It>
+inline joined_strings<const char *, It> join(
+  It begin, It end, const char *sep)
+{
+  return joined_strings<const char *, It>(
+    std::move(begin),
+    std::move(end),
+    sep);
+}
+
+
 template<typename Str, typename Container>
 class joined_strings_container
   : public joined_strings<Str, typename Container::const_iterator>
@@ -64,10 +111,11 @@ class joined_strings_container
     Container container;
 
   public:
-    joined_strings_container(const Container &container, const Str &sep)
+    template<typename Container_In, typename Str_In>
+    joined_strings_container(Container_In &&container, Str_In &&sep)
       : joined_strings<Str, typename Container::const_iterator>(
-          container.begin(), container.end(), sep),
-        container(container)
+          container.begin(), container.end(), std::forward<Str_In>(sep)),
+        container(std::forward<Container_In>(container))
     {
     }
 };
@@ -79,5 +127,12 @@ inline joined_strings_container<Str, Container> join(
   return joined_strings_container<Str, Container>(container, sep);
 }
 
+template<typename Container>
+inline joined_strings_container<const char *, Container> join(
+  const Container &container, const char *sep)
+{
+  return joined_strings_container<const char *, Container>(container, sep);
+}
+
 
 #endif

unit/range_union/main.cpp

@@ -23,12 +23,12 @@ int main()
     << "Testing range_union" << indentation.add(2) << endl_ind;
   std::vector<int> a = { 2, 4, 8 },
     b = { 3, 4, 9 };
-  std::cout << join(a, std::string(", ")) << " union itself = "
-    << join(range_union(a, a), std::string(", ")) << endl_ind;
+  std::cout << join(a, ", ") << " union itself = "
+    << join(range_union(a, a), ", ") << endl_ind;
   test_assert(boost::size(range_union(a, a)) == 3, "Exact duplicate collapses");
-  std::cout << join(a, std::string(", "))
-    << " union " << join(b, std::string(", "))
-    << " = " << join(range_union(a, b), std::string(", ")) << endl_ind;
+  std::cout << join(a, ", ")
+    << " union " << join(b, ", ")
+    << " = " << join(range_union(a, b), ", ") << endl_ind;
   test_assert(boost::size(range_union(a, b)) == 5, "Duplicates are removed");
   test_assert(boost::size(range_union(b, a)) == 5, "Commutative");
   std::vector<std::string> strs = { "hi", "lo" };

unit/serialization/json_map_serializer.cpp

@@ -68,7 +68,7 @@ void test_json_map_serializer()
   boost::sort(expected_keys);
   boost::push_back(actual_keys, serializer.keys());
   std::cout
-    << "Checking keys: " << join(actual_keys, std::string(", ")) << endl_ind;
+    << "Checking keys: " << join(actual_keys, ", ") << endl_ind;
   test_assert(
     expected_keys == actual_keys,
     "Keys returns sorted expected keys");

unit/serialization/virtual_map.cpp

@@ -105,7 +105,7 @@ void test_virtual_map()
   boost::sort(expected_keys);
   boost::push_back(actual_keys, map.keys());
   std::cout
-    << "Checking keys: " << join(actual_keys, std::string(", ")) << endl_ind;
+    << "Checking keys: " << join(actual_keys, ", ") << endl_ind;
   test_assert(
     expected_keys == actual_keys,
     "Keys returns sorted expected keys");