optimize and cleanup

- use algorithms instead of 'raw loops'
- use std::string_view instead of std::string in some places
- don't initialize std::regex multiple times in the loop
- use move iterators
- remove fnmatch from header
- remove unused headers
- move our glob header to the top
- separate C lib header from C++ headers

improvements 2.80-4.93x

some benches

Ryzen 5 1600
original:
```
❯ hyperfine -r 412 -N --warmup 10 './build/standalone/glob -i /home/vl/Downloads/**/*.cpp'
Benchmark 1: ./build/standalone/glob -i /home/vl/Downloads/**/*.cpp
  Time (mean ± σ):      51.3 ms ±  10.4 ms    [User: 47.3 ms, System: 3.3 ms]
  Range (min … max):    37.2 ms …  75.5 ms    412 runs
```

optimized version:
```
❯ hyperfine -r 412 -N --warmup 10 './build/standalone/glob -i /home/vl/Downloads/**/*.cpp'
Benchmark 1: ./build/standalone/glob -i /home/vl/Downloads/**/*.cpp
  Time (mean ± σ):      10.4 ms ±   3.9 ms    [User: 6.4 ms, System: 3.6 ms]
  Range (min … max):     6.3 ms …  17.7 ms    412 run
```

Ryzen 9 7950X3D

original version recursive on a lot of files:
peak ram usage 391M
```
❯ hyperfine -N './glob -r -i /var/lib/temppath/**/*.tar.zst'
Benchmark 1: ./glob -r -i /var/lib/temppath/**/*.tar.zst
  Time (mean ± σ):     16.163 s ±  1.225 s    [User: 13.867 s, System: 2.273 s]
  Range (min … max):   15.344 s … 18.979 s    10 runs
```

optimized version recursive on a lot of files:
peak ram usage 261M
```
❯ hyperfine -N './glob -r -i /var/lib/temppath/**/*.tar.zst'
Benchmark 1: ./glob -r -i /var/lib/temppath/**/*.tar.zst
  Time (mean ± σ):      5.757 s ±  0.602 s    [User: 3.469 s, System: 2.278 s]
  Range (min … max):    4.519 s …  6.659 s    10 runs
```

Author: vnepogodin

include/glob/glob.h

@@ -45,7 +45,4 @@ std::vector<fs::path> glob(const std::initializer_list<std::string> &pathnames);
 /// Initializer list overload for convenience
 std::vector<fs::path> rglob(const std::initializer_list<std::string> &pathnames);
 
-/// Returns true if the input path matche the glob pattern
-  bool fnmatch(const fs::path &name, const std::string &pattern);
-
 } // namespace glob

source/glob.cpp

@@ -1,24 +1,29 @@
+#include <glob/glob.h>
 
 #include <cassert>
-#include <functional>
-#include <glob/glob.h>
-#include <iostream>
+
+#include <algorithm>
 #include <map>
 #include <regex>
+#include <string_view>
 
 namespace glob {
 
 namespace {
 
-bool string_replace(std::string &str, const std::string &from, const std::string &to) {
+static constexpr auto SPECIAL_CHARACTERS = std::string_view{"()[]{}?*+-|^$\\.&~# \t\n\r\v\f"};
+static const auto ESCAPE_SET_OPER = std::regex(std::string{R"([&~|])"});
+static const auto ESCAPE_REPL_STR = std::string{R"(\\\1)"};
+
+bool string_replace(std::string &str, std::string_view from, std::string_view to) {
   std::size_t start_pos = str.find(from);
   if (start_pos == std::string::npos)
     return false;
   str.replace(start_pos, from.length(), to);
   return true;
 }
 
-std::string translate(const std::string &pattern) {
+std::string translate(std::string_view pattern) {
   std::size_t i = 0, n = pattern.size();
   std::string result_string;
 
@@ -45,7 +50,7 @@ std::string translate(const std::string &pattern) {
       } else {
         auto stuff = std::string(pattern.begin() + i, pattern.begin() + j);
         if (stuff.find("--") == std::string::npos) {
-          string_replace(stuff, std::string{"\\"}, std::string{R"(\\)"});
+          string_replace(stuff, std::string_view{"\\"}, std::string_view{R"(\\)"});
         } else {
           std::vector<std::string> chunks;
           std::size_t k = 0;
@@ -57,7 +62,7 @@ std::string translate(const std::string &pattern) {
 
           while (true) {
             k = pattern.find("-", k, j);
-            if (k == std::string::npos) {
+            if (k == std::string_view::npos) {
               break;
             }
             chunks.push_back(std::string(pattern.begin() + i, pattern.begin() + k));
@@ -69,24 +74,24 @@ std::string translate(const std::string &pattern) {
           // Escape backslashes and hyphens for set difference (--).
           // Hyphens that create ranges shouldn't be escaped.
           bool first = true;
-          for (auto &s : chunks) {
-            string_replace(s, std::string{"\\"}, std::string{R"(\\)"});
-            string_replace(s, std::string{"-"}, std::string{R"(\-)"});
+          for (auto &chunk : chunks) {
+            string_replace(chunk, std::string_view{"\\"}, std::string_view{R"(\\)"});
+            string_replace(chunk, std::string_view{"-"}, std::string_view{R"(\-)"});
             if (first) {
-              stuff += s;
+              stuff += chunk;
               first = false;
             } else {
-              stuff += "-" + s;
+              stuff += "-" + chunk;
             }
           }
         }
 
         // Escape set operations (&&, ~~ and ||).
-        std::string result;
-        std::regex_replace(std::back_inserter(result),          // ressult
-                           stuff.begin(), stuff.end(),          // string
-                           std::regex(std::string{R"([&~|])"}), // pattern
-                           std::string{R"(\\\1)"});             // repl
+        std::string result{};
+        std::regex_replace(std::back_inserter(result), // result
+                           stuff.begin(), stuff.end(), // string
+                           ESCAPE_SET_OPER,            // pattern
+                           ESCAPE_REPL_STR);           // repl
         stuff = result;
         i = j + 1;
         if (stuff[0] == '!') {
@@ -102,16 +107,14 @@ std::string translate(const std::string &pattern) {
       // '-' (a range in character set)
       // '&', '~', (extended character set operations)
       // '#' (comment) and WHITESPACE (ignored) in verbose mode
-      static std::string special_characters = "()[]{}?*+-|^$\\.&~# \t\n\r\v\f";
       static std::map<int, std::string> special_characters_map;
       if (special_characters_map.empty()) {
-        for (auto &sc : special_characters) {
-          special_characters_map.insert(
-              std::make_pair(static_cast<int>(sc), std::string{"\\"} + std::string(1, sc)));
+        for (auto &&sc : SPECIAL_CHARACTERS) {
+          special_characters_map.emplace(static_cast<int>(sc), std::string{"\\"} + std::string(1, sc));
         }
       }
 
-      if (special_characters.find(c) != std::string::npos) {
+      if (SPECIAL_CHARACTERS.find(c) != std::string_view::npos) {
         result_string += special_characters_map[static_cast<int>(c)];
       } else {
         result_string += c;
@@ -121,24 +124,22 @@ std::string translate(const std::string &pattern) {
   return std::string{"(("} + result_string + std::string{R"()|[\r\n])$)"};
 }
 
-std::regex compile_pattern(const std::string &pattern) {
+std::regex compile_pattern(std::string_view pattern) {
   return std::regex(translate(pattern), std::regex::ECMAScript);
 }
 
-bool fnmatch(const fs::path &name, const std::string &pattern) {
-  return std::regex_match(name.string(), compile_pattern(pattern));
+bool fnmatch(std::string&& name, const std::regex& pattern) {
+  return std::regex_match(std::move(name), pattern);
 }
 
 std::vector<fs::path> filter(const std::vector<fs::path> &names,
-                             const std::string &pattern) {
+                             std::string_view pattern) {
   // std::cout << "Pattern: " << pattern << "\n";
+  const auto pattern_re = compile_pattern(pattern);
   std::vector<fs::path> result;
-  for (auto &name : names) {
-    // std::cout << "Checking for " << name.string() << "\n";
-    if (fnmatch(name, pattern)) {
-      result.push_back(name);
-    }
-  }
+  std::copy_if(std::make_move_iterator(names.begin()), std::make_move_iterator(names.end()),
+               std::back_inserter(result),
+               [&pattern_re](const fs::path& name) { return fnmatch(name.string(), pattern_re); });
   return result;
 }
 
@@ -158,21 +159,20 @@ fs::path expand_tilde(fs::path path) {
 
   std::string s = path.string();
   if (s[0] == '~') {
-    s = std::string(home) + s.substr(1, s.size() - 1);
+    s = std::string{home} + s.substr(1, s.size() - 1);
     return fs::path(s);
-  } else {
-    return path;
   }
+  return path;
 }
 
 bool has_magic(const std::string &pathname) {
   static const auto magic_check = std::regex("([*?[])");
   return std::regex_search(pathname, magic_check);
 }
 
-bool is_hidden(const std::string &pathname) { return pathname[0] == '.'; }
+constexpr bool is_hidden(std::string_view pathname) noexcept { return pathname[0] == '.'; }
 
-bool is_recursive(const std::string &pattern) { return pattern == "**"; }
+constexpr bool is_recursive(std::string_view pattern) noexcept { return pattern == std::string_view{"**"}; }
 
 std::vector<fs::path> iter_directory(const fs::path &dirname, bool dironly) {
   std::vector<fs::path> result;
@@ -208,12 +208,11 @@ std::vector<fs::path> iter_directory(const fs::path &dirname, bool dironly) {
 std::vector<fs::path> rlistdir(const fs::path &dirname, bool dironly) {
   std::vector<fs::path> result;
   auto names = iter_directory(dirname, dironly);
-  for (auto &x : names) {
-    if (!is_hidden(x.string())) {
-      result.push_back(x);
-      for (auto &y : rlistdir(x, dironly)) {
-        result.push_back(y);
-      }
+  for (auto &&name : names) {
+    if (!is_hidden(name.string())) {
+      result.push_back(name);
+      auto matched_dirs = rlistdir(name, dironly);
+      std::copy(std::make_move_iterator(matched_dirs.begin()), std::make_move_iterator(matched_dirs.end()), std::back_inserter(result));
     }
   }
   return result;
@@ -226,9 +225,8 @@ std::vector<fs::path> glob2(const fs::path &dirname, [[maybe_unused]] const fs::
   // std::cout << "In glob2\n";
   std::vector<fs::path> result{"."};
   assert(is_recursive(pattern.string()));
-  for (auto &dir : rlistdir(dirname, dironly)) {
-    result.push_back(dir);
-  }
+  auto matched_dirs = rlistdir(dirname, dironly);
+  std::copy(std::make_move_iterator(matched_dirs.begin()), std::make_move_iterator(matched_dirs.end()), std::back_inserter(result));
   return result;
 }
 
@@ -239,17 +237,17 @@ std::vector<fs::path> glob2(const fs::path &dirname, [[maybe_unused]] const fs::
 std::vector<fs::path> glob1(const fs::path &dirname, const fs::path &pattern,
                             bool dironly) {
   // std::cout << "In glob1\n";
-  auto names = iter_directory(dirname, dironly);
   std::vector<fs::path> filtered_names;
-  for (auto &n : names) {
-    if (!is_hidden(n.string())) {
-      filtered_names.push_back(n.filename());
-      // if (n.is_relative()) {
-      //   // std::cout << "Filtered (Relative): " << n << "\n";
-      //   filtered_names.push_back(fs::relative(n));
+  auto names = iter_directory(dirname, dironly);
+  for (auto &&name : names) {
+    if (!is_hidden(name.string())) {
+      filtered_names.push_back(name.filename());
+      // if (name.is_relative()) {
+      //   // std::cout << "Filtered (Relative): " << name << "\n";
+      //   filtered_names.push_back(fs::relative(name));
       // } else {
-      //   // std::cout << "Filtered (Absolute): " << n << "\n";
-      //   filtered_names.push_back(n.filename());
+      //   // std::cout << "Filtered (Absolute): " << name << "\n";
+      //   filtered_names.push_back(name.filename());
       // }
     }
   }
@@ -259,18 +257,12 @@ std::vector<fs::path> glob1(const fs::path &dirname, const fs::path &pattern,
 std::vector<fs::path> glob0(const fs::path &dirname, const fs::path &basename,
                             bool /*dironly*/) {
   // std::cout << "In glob0\n";
-  std::vector<fs::path> result;
-  if (basename.empty()) {
-    // 'q*x/' should match only directories.
-    if (fs::is_directory(dirname)) {
-      result = {basename};
-    }
-  } else {
-    if (fs::exists(dirname / basename)) {
-      result = {basename};
-    }
+
+  // 'q*x/' should match only directories.
+  if ((basename.empty() && fs::is_directory(dirname)) || (!basename.empty() && fs::exists(dirname / basename))) {
+    return {basename};
   }
-  return result;
+  return {};
 }
 
 std::vector<fs::path> glob(const fs::path &inpath, bool recursive = false,
@@ -290,48 +282,37 @@ std::vector<fs::path> glob(const fs::path &inpath, bool recursive = false,
 
   if (!has_magic(pathname)) {
     assert(!dironly);
-    if (!basename.empty()) {
-      if (fs::exists(path)) {
-        result.push_back(path);
-      }
-    } else {
-      // Patterns ending with a slash should match only directories
-      if (fs::is_directory(dirname)) {
-        result.push_back(path);
-      }
+
+    // Patterns ending with a slash should match only directories
+    if ((!basename.empty() && fs::exists(path)) || (basename.empty() && fs::is_directory(dirname))) {
+      result.push_back(path);
     }
     return result;
   }
 
   if (dirname.empty()) {
     if (recursive && is_recursive(basename.string())) {
       return glob2(dirname, basename, dironly);
-    } else {
-      return glob1(dirname, basename, dironly);
     }
+    return glob1(dirname, basename, dironly);
   }
 
-  std::vector<fs::path> dirs;
+  std::vector<fs::path> dirs{dirname};
   if (dirname != fs::path(pathname) && has_magic(dirname.string())) {
     dirs = glob(dirname, recursive, true);
-  } else {
-    dirs = {dirname};
   }
 
-  std::function<std::vector<fs::path>(const fs::path &, const fs::path &, bool)>
-      glob_in_dir;
+  auto glob_in_dir = glob0;
   if (has_magic(basename.string())) {
     if (recursive && is_recursive(basename.string())) {
       glob_in_dir = glob2;
     } else {
       glob_in_dir = glob1;
     }
-  } else {
-    glob_in_dir = glob0;
   }
 
   for (auto &d : dirs) {
-    for (auto &name : glob_in_dir(d, basename, dironly)) {
+    for (auto &&name : glob_in_dir(d, basename, dironly)) {
       fs::path subresult = name;
       if (name.parent_path().empty()) {
         subresult = d / name;
@@ -355,20 +336,18 @@ std::vector<fs::path> rglob(const std::string &pathname) {
 
 std::vector<fs::path> glob(const std::vector<std::string> &pathnames) {
   std::vector<fs::path> result;
-  for (auto &pathname : pathnames) {
-    for (auto &match : glob(pathname, false)) {
-      result.push_back(std::move(match));
-    }
+  for (const auto &pathname : pathnames) {
+    auto matched_res = glob(pathname, false);
+    std::copy(std::make_move_iterator(matched_res.begin()), std::make_move_iterator(matched_res.end()), std::back_inserter(result));
   }
   return result;
 }
 
 std::vector<fs::path> rglob(const std::vector<std::string> &pathnames) {
   std::vector<fs::path> result;
-  for (auto &pathname : pathnames) {
-    for (auto &match : glob(pathname, true)) {
-      result.push_back(std::move(match));
-    }
+  for (const auto &pathname : pathnames) {
+    auto matched_res = glob(pathname, true);
+    std::copy(std::make_move_iterator(matched_res.begin()), std::make_move_iterator(matched_res.end()), std::back_inserter(result));
   }
   return result;
 }