clean up

Author: Andrew Naplavkov

README.md

@@ -26,7 +26,7 @@ Step20 is a C++20, header-only library of STL-like algorithms and data structure
 * [longest repeated substring](https://en.wikipedia.org/wiki/Longest_repeated_substring_problem):
   [snippet](https://github.com/storm-ptr/step20/blob/main/test/main.cpp#L366-L368)
 * [suffix array](https://en.wikipedia.org/wiki/Suffix_array):
-  [snippet](https://github.com/storm-ptr/step20/blob/main/test/main.cpp#L443-L444)
+  [snippet](https://github.com/storm-ptr/step20/blob/main/test/main.cpp#L447-L448)
 * [suffix tree](https://en.wikipedia.org/wiki/Suffix_tree):
-  [snippet](https://github.com/storm-ptr/step20/blob/main/test/main.cpp#L472-L473),
+  [snippet](https://github.com/storm-ptr/step20/blob/main/test/main.cpp#L476-L477),
   [example](https://github.com/storm-ptr/step20/blob/main/example/suffix_tree_viz/suffix_tree_viz.hpp#L16-L42)

detail/utility.hpp

@@ -52,28 +52,28 @@ auto try_reverse(std::ranges::borrowed_range auto&& range)
 }
 
 template <class Container>
-class insert_iterator {
+class emplace_iterator {
     Container* c_;
 
 public:
     using iterator_category = std::output_iterator_tag;
     using difference_type = std::ptrdiff_t;
     using value_type = void;
     using reference = void;
-    explicit constexpr insert_iterator(Container& c) : c_(std::addressof(c)) {}
-    constexpr insert_iterator& operator*() { return *this; }
-    constexpr insert_iterator& operator++() { return *this; }
-    constexpr insert_iterator operator++(int) { return *this; }
+    explicit constexpr emplace_iterator(Container& c) : c_(std::addressof(c)) {}
+    constexpr emplace_iterator& operator*() { return *this; }
+    constexpr emplace_iterator& operator++() { return *this; }
+    constexpr emplace_iterator operator++(int) { return *this; }
 
-    constexpr insert_iterator& operator=(
-        const typename Container::value_type& value)
+    template <class T>
+    constexpr emplace_iterator& operator=(T&& val)
     {
-        if constexpr (requires { c_->insert(value); })
-            c_->insert(value);
-        else if constexpr (requires { c_->push(value); })
-            c_->push(value);
-        else if constexpr (requires { c_->push_back(value); })
-            c_->push_back(value);
+        if constexpr (requires { c_->emplace(std::forward<T>(val)); })
+            c_->emplace(std::forward<T>(val));
+        else if constexpr (requires { c_->emplace_back(std::forward<T>(val)); })
+            c_->emplace_back(std::forward<T>(val));
+        else if constexpr (requires { c_->push_back(std::forward<T>(val)); })
+            c_->push_back(std::forward<T>(val));  //< std::basic_string
         else
             lazy_static_assert<false>();
         return *this;

example/diff/gcc.sh

@@ -1,3 +1,3 @@
-g++ -I ../../.. -std=c++20 -Wall -O2 -fmax-errors=1 main.cpp
-./a.out ./file1.txt ./file2.txt
-rm ./a.out
+${1:-g++} -I ../../.. -std=c++20 -Wall -O2 -o result main.cpp
+./result ./file1.txt ./file2.txt
+rm ./result

example/suffix_tree_viz/gcc.sh

@@ -1,3 +1,3 @@
-g++ -I ../../.. -std=c++20 -Wall -O2 -fmax-errors=1 main.cpp
-./a.out banana$
-rm ./a.out
+${1:-g++} -I ../../.. -std=c++20 -Wall -O2 -o result main.cpp
+./result banana$
+rm ./result

substring_search.hpp

@@ -12,8 +12,9 @@ namespace step20::substring_search {
 
 /// Time complexity O(M*log(N)), where:
 /// M - substring length, N - text length.
-template <class... Ts, std::ranges::forward_range R>
-auto find_any(const suffix_array<Ts...>& arr, R&& str)
+template <class... Ts>
+auto find_any(const suffix_array<Ts...>& arr,
+              std::ranges::forward_range auto&& str)
     -> std::optional<typename suffix_array<Ts...>::size_type>
 {
     if (std::ranges::empty(str))
@@ -24,8 +25,9 @@ auto find_any(const suffix_array<Ts...>& arr, R&& str)
 }
 
 /// Find all occurrences of the substring.
-template <class... Ts, std::ranges::forward_range R>
-auto find_all(const suffix_array<Ts...>& arr, R&& str)
+template <class... Ts>
+auto find_all(const suffix_array<Ts...>& arr,
+              std::basic_string<typename suffix_array<Ts...>::value_type> str)
     -> generator<typename suffix_array<Ts...>::size_type>
 {
     if (std::ranges::empty(str))
@@ -37,8 +39,9 @@ auto find_all(const suffix_array<Ts...>& arr, R&& str)
 /// Find offset of the first occurrence of the substring.
 
 /// Time complexity O(M), where: M - substring length.
-template <class... Ts, std::ranges::forward_range R>
-auto find_first(const suffix_tree<Ts...>& tree, R&& str)
+template <class... Ts>
+auto find_first(const suffix_tree<Ts...>& tree,
+                std::ranges::forward_range auto&& str)
     -> std::optional<typename suffix_tree<Ts...>::size_type>
 {
     if (auto edge = tree.find(str))
@@ -51,8 +54,9 @@ auto find_first(const suffix_tree<Ts...>& tree, R&& str)
 /// Suffix tree must be explicit - padded with a terminal symbol.
 /// Space complexity asymptotically close to O(log(N)), O(N) at worst,
 /// where: N - text length.
-template <class... Ts, std::ranges::forward_range R>
-auto find_all(const suffix_tree<Ts...>& tree, R&& str)
+template <class... Ts>
+auto find_all(const suffix_tree<Ts...>& tree,
+              std::basic_string<typename suffix_tree<Ts...>::value_type> str)
     -> generator<typename suffix_tree<Ts...>::size_type>
 {
     if (std::ranges::empty(str))

suffix_array.hpp

@@ -47,9 +47,9 @@ class suffix_array {
         std::ranges::transform(sufs, pos_.begin(), &suffix::pos);
     }
 
-    explicit suffix_array(std::ranges::input_range auto&& r,
-                          const Compare& comp = {})
-        : suffix_array(to<std::basic_string>(r), comp)
+    template <std::ranges::input_range R>
+    explicit suffix_array(R&& r, const Compare& comp = {})
+        : suffix_array(to<std::basic_string>(std::forward<R>(r)), comp)
     {
     }
 

suffix_tree.hpp

@@ -119,7 +119,7 @@ class suffix_tree {
 
     /// Space complexity asymptotically close to O(log(N)), O(N) at worst,
     /// where: N - text length.
-    generator<edge_type> depth_first_search(const edge_type& start) const
+    generator<edge_type> depth_first_search(edge_type start) const
     {
         for (auto stack = std::stack<edge_type>{{start}}; !stack.empty();) {
             auto edge = stack.top();
@@ -134,7 +134,7 @@ class suffix_tree {
                                 item.second,
                                 edge.labels_len + label(item.second).length()};
                         }),
-                    insert_iterator(stack));
+                    emplace_iterator(stack));
         }
     }
 

test/gcc.sh

@@ -1,3 +1,3 @@
-g++ -I ../.. -std=c++20 -Wall -O2 -fmax-errors=1 main.cpp
-./a.out
-rm ./a.out
+${1:-g++} -I ../.. -std=c++20 -Wall -O2 -o result main.cpp
+./result
+rm ./result

test/main.cpp

@@ -423,7 +423,9 @@ void test_substring_search()
         else
             check(std::ranges::empty(expect));
         check(std::ranges::is_permutation(
-            expect, to<std::vector>(substring_search::find_all(arr, substr))));
+            expect,
+            to<std::vector>(
+                substring_search::find_all(arr, std::string{substr}))));
         auto tree = to<suffix_tree>(str);
         check(substring_search::find_first(tree, str) == 0);
         check(substring_search::find_first(tree, ""sv) == 0);
@@ -433,7 +435,9 @@ void test_substring_search()
         else
             check(std::ranges::empty(expect));
         check(std::ranges::is_permutation(
-            expect, to<std::vector>(substring_search::find_all(tree, substr))));
+            expect,
+            to<std::vector>(
+                substring_search::find_all(tree, std::string{substr}))));
     }
 }
 

to.hpp

@@ -15,14 +15,14 @@ To to(From&& from)
     auto result = To{};
     if constexpr (requires { result.reserve(std::ranges::size(from)); })
         result.reserve(std::ranges::size(from));
-    std::ranges::copy(from, insert_iterator(result));
+    std::ranges::copy(from, emplace_iterator(result));
     return result;
 }
 
 template <template <class...> class To, std::ranges::input_range From>
 auto to(From&& from)
 {
-    return to<To<std::ranges::range_value_t<From>>>(from);
+    return to<To<std::ranges::range_value_t<From>>>(std::forward<From>(from));
 }
 
 }  // namespace step20