restyle remaining modules to match project style

For this change I decided to bundle the remaining modules that need to be
resytyled because only two were large enough to warrant doing on their own.

Reduces lint errors from 225 to 162 (-28%). Line count from 3073 to 2465 (-20%).

Another step in resolving issue #2902.

1 files changed, 152 insertions, 254 deletions

diff --git a/src/wutil.cpp b/src/wutil.cpp
index 1cee8320..c8b9e3f4 100644
--- a/src/wutil.cpp
+++ b/src/wutil.cpp
@@ -1,30 +1,27 @@
-/** \file wutil.c
-  Wide character equivalents of various standard unix
-  functions.
-*/
+// Wide character equivalents of various standard unix functions.
 #include "config.h"
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+#include <assert.h>
+#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <wchar.h>
-#include <string.h>
-#include <dirent.h>
-#include <limits.h>
 #include <libgen.h>
+#include <limits.h>
 #include <pthread.h>
-#include <assert.h>
-#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wchar.h>
 #include <map>
 #include <memory>
+#include <string>
 
 #include "common.h"
 #include "fallback.h"  // IWYU pragma: keep
-#include "wutil.h"  // IWYU pragma: keep
+#include "wutil.h"     // IWYU pragma: keep
 
 typedef std::string cstring;
 
@@ -34,65 +31,53 @@ const file_id_t kInvalidFileID = {(dev_t)-1LL, (ino_t)-1LL, (uint64_t)-1LL, -1,
 #ifdef MAXPATHLEN
 #define PATH_MAX MAXPATHLEN
 #else
-/**
-   Fallback length of MAXPATHLEN. Just a hopefully sane value...
-*/
+/// Fallback length of MAXPATHLEN. Hopefully a sane value.
 #define PATH_MAX 4096
 #endif
 #endif
 
-/* Lock to protect wgettext */
+/// Lock to protect wgettext.
 static pthread_mutex_t wgettext_lock;
 
-/* Map used as cache by wgettext. */
+/// Map used as cache by wgettext.
 typedef std::map<wcstring, wcstring> wgettext_map_t;
 static wgettext_map_t wgettext_map;
 
-bool wreaddir_resolving(DIR *dir, const std::wstring &dir_path, std::wstring &out_name, bool *out_is_dir)
-{
+bool wreaddir_resolving(DIR *dir, const std::wstring &dir_path, std::wstring &out_name,
+                        bool *out_is_dir) {
     struct dirent *d = readdir(dir);
     if (!d) return false;
 
     out_name = str2wcstring(d->d_name);
-    if (out_is_dir)
-    {
-        /* The caller cares if this is a directory, so check */
+    if (out_is_dir) {
+        // The caller cares if this is a directory, so check.
         bool is_dir = false;
-        
-        /* We may be able to skip stat, if the readdir can tell us the file type directly */
+
+        // We may be able to skip stat, if the readdir can tell us the file type directly.
         bool check_with_stat = true;
 #ifdef HAVE_STRUCT_DIRENT_D_TYPE
-        if (d->d_type == DT_DIR)
-        {
-            /* Known directory */
+        if (d->d_type == DT_DIR) {
+            // Known directory.
             is_dir = true;
             check_with_stat = false;
-        }
-        else if (d->d_type == DT_LNK || d->d_type == DT_UNKNOWN)
-        {
-            /* We want to treat symlinks to directories as directories. Use stat to resolve it. */
+        } else if (d->d_type == DT_LNK || d->d_type == DT_UNKNOWN) {
+            // We want to treat symlinks to directories as directories. Use stat to resolve it.
             check_with_stat = true;
-        }
-        else
-        {
-            /* Regular file */
+        } else {
+            // Regular file.
             is_dir = false;
             check_with_stat = false;
         }
-#endif // HAVE_STRUCT_DIRENT_D_TYPE
-        if (check_with_stat)
-        {
-            /* We couldn't determine the file type from the dirent; check by stat'ing it */
+#endif  // HAVE_STRUCT_DIRENT_D_TYPE
+        if (check_with_stat) {
+            // We couldn't determine the file type from the dirent; check by stat'ing it.
             cstring fullpath = wcs2string(dir_path);
             fullpath.push_back('/');
             fullpath.append(d->d_name);
             struct stat buf;
-            if (stat(fullpath.c_str(), &buf) != 0)
-            {
+            if (stat(fullpath.c_str(), &buf) != 0) {
                 is_dir = false;
-            }
-            else
-            {
+            } else {
                 is_dir = !!(S_ISDIR(buf.st_mode));
             }
         }
@@ -101,8 +86,7 @@ bool wreaddir_resolving(DIR *dir, const std::wstring &dir_path, std::wstring &ou
     return true;
 }
 
-bool wreaddir(DIR *dir, std::wstring &out_name)
-{
+bool wreaddir(DIR *dir, std::wstring &out_name) {
     struct dirent *d = readdir(dir);
     if (!d) return false;
 
@@ -110,53 +94,45 @@ bool wreaddir(DIR *dir, std::wstring &out_name)
     return true;
 }
 
-bool wreaddir_for_dirs(DIR *dir, wcstring *out_name)
-{
+bool wreaddir_for_dirs(DIR *dir, wcstring *out_name) {
     struct dirent *result = NULL;
-    while (result == NULL)
-    {
+    while (result == NULL) {
         struct dirent *d = readdir(dir);
         if (!d) break;
-        
+
 #if HAVE_STRUCT_DIRENT_D_TYPE
-        switch (d->d_type)
-        {
-            // These may be directories
+        switch (d->d_type) {
             case DT_DIR:
             case DT_LNK:
-            case DT_UNKNOWN:
+            case DT_UNKNOWN: {
+                // These may be directories.
                 result = d;
                 break;
-                
-            // Nothing else can
-            default:
+            }
+            default: {
+                // Nothing else can.
                 break;
+            }
         }
 #else
-        /* We can't determine if it's a directory or not, so just return it */
+        // We can't determine if it's a directory or not, so just return it.
         result = d;
 #endif
     }
-    if (result && out_name)
-    {
+    if (result && out_name) {
         *out_name = str2wcstring(result->d_name);
     }
     return result != NULL;
 }
 
-
-const wcstring wgetcwd()
-{
+const wcstring wgetcwd() {
     wcstring retval;
 
     char *res = getcwd(NULL, 0);
-    if (res)
-    {
+    if (res) {
         retval = str2wcstring(res);
         free(res);
-    }
-    else
-    {
+    } else {
         debug(0, _(L"getcwd() failed with errno %d/%s"), errno, strerror(errno));
         retval = wcstring();
     }
@@ -164,176 +140,147 @@ const wcstring wgetcwd()
     return retval;
 }
 
-int wchdir(const wcstring &dir)
-{
+int wchdir(const wcstring &dir) {
     cstring tmp = wcs2string(dir);
     return chdir(tmp.c_str());
 }
 
-FILE *wfopen(const wcstring &path, const char *mode)
-{
+FILE *wfopen(const wcstring &path, const char *mode) {
     int permissions = 0, options = 0;
     size_t idx = 0;
-    switch (mode[idx++])
-    {
-        case 'r':
+    switch (mode[idx++]) {
+        case 'r': {
             permissions = O_RDONLY;
             break;
-        case 'w':
+        }
+        case 'w': {
             permissions = O_WRONLY;
             options = O_CREAT | O_TRUNC;
             break;
-        case 'a':
+        }
+        case 'a': {
             permissions = O_WRONLY;
             options = O_CREAT | O_APPEND;
             break;
-        default:
+        }
+        default: {
             errno = EINVAL;
             return NULL;
             break;
+        }
     }
-    /* Skip binary */
-    if (mode[idx] == 'b')
-        idx++;
+    // Skip binary.
+    if (mode[idx] == 'b') idx++;
 
-    /* Consider append option */
-    if (mode[idx] == '+')
-        permissions = O_RDWR;
+    // Consider append option.
+    if (mode[idx] == '+') permissions = O_RDWR;
 
     int fd = wopen_cloexec(path, permissions | options, 0666);
-    if (fd < 0)
-        return NULL;
+    if (fd < 0) return NULL;
     FILE *result = fdopen(fd, mode);
-    if (result == NULL)
-        close(fd);
+    if (result == NULL) close(fd);
     return result;
 }
 
-bool set_cloexec(int fd)
-{
+bool set_cloexec(int fd) {
     int flags = fcntl(fd, F_GETFD, 0);
-    if (flags < 0)
-    {
+    if (flags < 0) {
         return false;
-    }
-    else if (flags & FD_CLOEXEC)
-    {
+    } else if (flags & FD_CLOEXEC) {
         return true;
-    }
-    else
-    {
+    } else {
         return fcntl(fd, F_SETFD, flags | FD_CLOEXEC) >= 0;
     }
 }
 
-static int wopen_internal(const wcstring &pathname, int flags, mode_t mode, bool cloexec)
-{
+static int wopen_internal(const wcstring &pathname, int flags, mode_t mode, bool cloexec) {
     ASSERT_IS_NOT_FORKED_CHILD();
     cstring tmp = wcs2string(pathname);
-    /* Prefer to use O_CLOEXEC. It has to both be defined and nonzero. */
+// Prefer to use O_CLOEXEC. It has to both be defined and nonzero.
 #ifdef O_CLOEXEC
-    if (cloexec && (O_CLOEXEC != 0))
-    {
+    if (cloexec && (O_CLOEXEC != 0)) {
         flags |= O_CLOEXEC;
         cloexec = false;
     }
 #endif
     int fd = ::open(tmp.c_str(), flags, mode);
-    if (cloexec && fd >= 0 && ! set_cloexec(fd))
-    {
+    if (cloexec && fd >= 0 && !set_cloexec(fd)) {
         close(fd);
         fd = -1;
     }
     return fd;
-
 }
 
-int wopen_cloexec(const wcstring &pathname, int flags, mode_t mode)
-{
+int wopen_cloexec(const wcstring &pathname, int flags, mode_t mode) {
     return wopen_internal(pathname, flags, mode, true);
 }
 
-DIR *wopendir(const wcstring &name)
-{
+DIR *wopendir(const wcstring &name) {
     const cstring tmp = wcs2string(name);
     return opendir(tmp.c_str());
 }
 
-int wstat(const wcstring &file_name, struct stat *buf)
-{
+int wstat(const wcstring &file_name, struct stat *buf) {
     const cstring tmp = wcs2string(file_name);
     return stat(tmp.c_str(), buf);
 }
 
-int lwstat(const wcstring &file_name, struct stat *buf)
-{
+int lwstat(const wcstring &file_name, struct stat *buf) {
     const cstring tmp = wcs2string(file_name);
     return lstat(tmp.c_str(), buf);
 }
 
-int waccess(const wcstring &file_name, int mode)
-{
+int waccess(const wcstring &file_name, int mode) {
     const cstring tmp = wcs2string(file_name);
     return access(tmp.c_str(), mode);
 }
 
-int wunlink(const wcstring &file_name)
-{
+int wunlink(const wcstring &file_name) {
     const cstring tmp = wcs2string(file_name);
     return unlink(tmp.c_str());
 }
 
-void wperror(const wchar_t *s)
-{
+void wperror(const wchar_t *s) {
     int e = errno;
-    if (s[0] != L'\0')
-    {
+    if (s[0] != L'\0') {
         fwprintf(stderr, L"%ls: ", s);
     }
     fwprintf(stderr, L"%s\n", strerror(e));
 }
 
-int make_fd_nonblocking(int fd)
-{
+int make_fd_nonblocking(int fd) {
     int flags = fcntl(fd, F_GETFL, 0);
     int err = 0;
-    if (!(flags & O_NONBLOCK))
-    {
+    if (!(flags & O_NONBLOCK)) {
         err = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
     }
     return err == -1 ? errno : 0;
 }
 
-int make_fd_blocking(int fd)
-{
+int make_fd_blocking(int fd) {
     int flags = fcntl(fd, F_GETFL, 0);
     int err = 0;
-    if (flags & O_NONBLOCK)
-    {
+    if (flags & O_NONBLOCK) {
         err = fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
     }
     return err == -1 ? errno : 0;
 }
 
-static inline void safe_append(char *buffer, const char *s, size_t buffsize)
-{
+static inline void safe_append(char *buffer, const char *s, size_t buffsize) {
     strncat(buffer, s, buffsize - strlen(buffer) - 1);
 }
 
-// In general, strerror is not async-safe, and therefore we cannot use it directly
-// So instead we have to grub through sys_nerr and sys_errlist directly
-// On GNU toolchain, this will produce a deprecation warning from the linker (!!),
-// which appears impossible to suppress!
-const char *safe_strerror(int err)
-{
+// In general, strerror is not async-safe, and therefore we cannot use it directly. So instead we
+// have to grub through sys_nerr and sys_errlist directly On GNU toolchain, this will produce a
+// deprecation warning from the linker (!!), which appears impossible to suppress!
+const char *safe_strerror(int err) {
 #if defined(__UCLIBC__)
-    // uClibc does not have sys_errlist, however, its strerror is believed to be async-safe
-    // See #808
+    // uClibc does not have sys_errlist, however, its strerror is believed to be async-safe.
+    // See issue #808.
     return strerror(err);
 #elif defined(HAVE__SYS__ERRS) || defined(HAVE_SYS_ERRLIST)
 #ifdef HAVE_SYS_ERRLIST
-    if (err >= 0 && err < sys_nerr && sys_errlist[err] != NULL)
-    {
+    if (err >= 0 && err < sys_nerr && sys_errlist[err] != NULL) {
         return sys_errlist[err];
     }
 #elif defined(HAVE__SYS__ERRS)
@@ -342,15 +289,15 @@ const char *safe_strerror(int err)
     extern int _sys_num_err;
 
     if (err >= 0 && err < _sys_num_err) {
-		return &_sys_errs[_sys_index[err]];
+        return &_sys_errs[_sys_index[err]];
     }
-#endif // either HAVE__SYS__ERRS or HAVE_SYS_ERRLIST
+#endif  // either HAVE__SYS__ERRS or HAVE_SYS_ERRLIST
     else
-#endif // defined(HAVE__SYS__ERRS) || defined(HAVE_SYS_ERRLIST)
+#endif  // defined(HAVE__SYS__ERRS) || defined(HAVE_SYS_ERRLIST)
     {
         int saved_err = errno;
 
-        /* Use a shared buffer for this case */
+        // Use a shared buffer for this case.
         static char buff[384];
         char errnum_buff[64];
         format_long_safe(errnum_buff, err);
@@ -365,16 +312,14 @@ const char *safe_strerror(int err)
     }
 }
 
-void safe_perror(const char *message)
-{
-    // Note we cannot use strerror, because on Linux it uses gettext, which is not safe
+void safe_perror(const char *message) {
+    // Note we cannot use strerror, because on Linux it uses gettext, which is not safe.
     int err = errno;
 
     char buff[384];
     buff[0] = '\0';
 
-    if (message)
-    {
+    if (message) {
         safe_append(buff, message, sizeof buff);
         safe_append(buff, ": ", sizeof buff);
     }
@@ -387,23 +332,18 @@ void safe_perror(const char *message)
 
 #ifdef HAVE_REALPATH_NULL
 
-wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path)
-{
+wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path) {
     cstring narrow_path = wcs2string(pathname);
     char *narrow_res = realpath(narrow_path.c_str(), NULL);
 
-    if (!narrow_res)
-        return NULL;
+    if (!narrow_res) return NULL;
 
     wchar_t *res;
     wcstring wide_res = str2wcstring(narrow_res);
-    if (resolved_path)
-    {
+    if (resolved_path) {
         wcslcpy(resolved_path, wide_res.c_str(), PATH_MAX);
         res = resolved_path;
-    }
-    else
-    {
+    } else {
         res = wcsdup(wide_res.c_str());
     }
 
@@ -414,24 +354,19 @@ wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path)
 
 #else
 
-wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path)
-{
+wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path) {
     cstring tmp = wcs2string(pathname);
     char narrow_buff[PATH_MAX];
     char *narrow_res = realpath(tmp.c_str(), narrow_buff);
     wchar_t *res;
 
-    if (!narrow_res)
-        return 0;
+    if (!narrow_res) return 0;
 
     const wcstring wide_res = str2wcstring(narrow_res);
-    if (resolved_path)
-    {
+    if (resolved_path) {
         wcslcpy(resolved_path, wide_res.c_str(), PATH_MAX);
         res = resolved_path;
-    }
-    else
-    {
+    } else {
         res = wcsdup(wide_res.c_str());
     }
     return res;
@@ -439,9 +374,7 @@ wchar_t *wrealpath(const wcstring &pathname, wchar_t *resolved_path)
 
 #endif
 
-
-wcstring wdirname(const wcstring &path)
-{
+wcstring wdirname(const wcstring &path) {
     char *tmp = wcs2str(path.c_str());
     char *narrow_res = dirname(tmp);
     wcstring result = format_string(L"%s", narrow_res);
@@ -449,8 +382,7 @@ wcstring wdirname(const wcstring &path)
     return result;
 }
 
-wcstring wbasename(const wcstring &path)
-{
+wcstring wbasename(const wcstring &path) {
     char *tmp = wcs2str(path.c_str());
     char *narrow_res = basename(tmp);
     wcstring result = format_string(L"%s", narrow_res);
@@ -458,29 +390,24 @@ wcstring wbasename(const wcstring &path)
     return result;
 }
 
-/* Really init wgettext */
-static void wgettext_really_init()
-{
+// Really init wgettext.
+static void wgettext_really_init() {
     pthread_mutex_init(&wgettext_lock, NULL);
     fish_bindtextdomain(PACKAGE_NAME, LOCALEDIR);
     fish_textdomain(PACKAGE_NAME);
 }
 
-/**
-   For wgettext: Internal init function. Automatically called when a translation is first requested.
-*/
-static void wgettext_init_if_necessary()
-{
+/// For wgettext: Internal init function. Automatically called when a translation is first
+/// requested.
+static void wgettext_init_if_necessary() {
     static pthread_once_t once = PTHREAD_ONCE_INIT;
     pthread_once(&once, wgettext_really_init);
 }
 
-const wchar_t *wgettext(const wchar_t *in)
-{
-    if (!in)
-        return in;
+const wchar_t *wgettext(const wchar_t *in) {
+    if (!in) return in;
 
-    // preserve errno across this since this is often used in printing error messages
+    // Preserve errno across this since this is often used in printing error messages.
     int err = errno;
 
     wgettext_init_if_necessary();
@@ -489,59 +416,51 @@ const wchar_t *wgettext(const wchar_t *in)
     scoped_lock lock(wgettext_lock);
 
     wcstring &val = wgettext_map[key];
-    if (val.empty())
-    {
+    if (val.empty()) {
         cstring mbs_in = wcs2string(key);
         char *out = fish_gettext(mbs_in.c_str());
         val = format_string(L"%s", out);
     }
     errno = err;
 
-    // The returned string is stored in the map
-    // TODO: If we want to shrink the map, this would be a problem
+    // The returned string is stored in the map.
+    // TODO: If we want to shrink the map, this would be a problem.
     return val.c_str();
 }
 
-int wmkdir(const wcstring &name, int mode)
-{
+int wmkdir(const wcstring &name, int mode) {
     cstring name_narrow = wcs2string(name);
     return mkdir(name_narrow.c_str(), mode);
 }
 
-int wrename(const wcstring &old, const wcstring &newv)
-{
+int wrename(const wcstring &old, const wcstring &newv) {
     cstring old_narrow = wcs2string(old);
-    cstring new_narrow =wcs2string(newv);
+    cstring new_narrow = wcs2string(newv);
     return rename(old_narrow.c_str(), new_narrow.c_str());
 }
 
-int fish_wcstoi(const wchar_t *str, wchar_t ** endptr, int base)
-{
+int fish_wcstoi(const wchar_t *str, wchar_t **endptr, int base) {
     long ret = wcstol(str, endptr, base);
-    if (ret > INT_MAX)
-    {
+    if (ret > INT_MAX) {
         ret = INT_MAX;
         errno = ERANGE;
-    }
-    else if (ret < INT_MIN)
-    {
+    } else if (ret < INT_MIN) {
         ret = INT_MIN;
         errno = ERANGE;
     }
     return (int)ret;
 }
 
-file_id_t file_id_t::file_id_from_stat(const struct stat *buf)
-{
+file_id_t file_id_t::file_id_from_stat(const struct stat *buf) {
     assert(buf != NULL);
-    
+
     file_id_t result = {};
     result.device = buf->st_dev;
     result.inode = buf->st_ino;
     result.size = buf->st_size;
     result.change_seconds = buf->st_ctime;
     result.mod_seconds = buf->st_mtime;
-    
+
 #if STAT_HAVE_NSEC
     result.change_nanoseconds = buf->st_ctime_nsec;
     result.mod_nanoseconds = buf->st_mtime_nsec;
@@ -555,74 +474,53 @@ file_id_t file_id_t::file_id_from_stat(const struct stat *buf)
     result.change_nanoseconds = 0;
     result.mod_nanoseconds = 0;
 #endif
-    
+
     return result;
 }
 
-
-file_id_t file_id_for_fd(int fd)
-{
+file_id_t file_id_for_fd(int fd) {
     file_id_t result = kInvalidFileID;
     struct stat buf = {};
-    if (0 == fstat(fd, &buf))
-    {
+    if (0 == fstat(fd, &buf)) {
         result = file_id_t::file_id_from_stat(&buf);
     }
     return result;
 }
 
-file_id_t file_id_for_path(const wcstring &path)
-{
+file_id_t file_id_for_path(const wcstring &path) {
     file_id_t result = kInvalidFileID;
     struct stat buf = {};
-    if (0 == wstat(path, &buf))
-    {
+    if (0 == wstat(path, &buf)) {
         result = file_id_t::file_id_from_stat(&buf);
     }
     return result;
-
 }
 
-bool file_id_t::operator==(const file_id_t &rhs) const
-{
-    return this->compare_file_id(rhs) == 0;
-}
+bool file_id_t::operator==(const file_id_t &rhs) const { return this->compare_file_id(rhs) == 0; }
 
-bool file_id_t::operator!=(const file_id_t &rhs) const
-{
-    return ! (*this == rhs);
-}
+bool file_id_t::operator!=(const file_id_t &rhs) const { return !(*this == rhs); }
 
-template<typename T>
-int compare(T a, T b)
-{
-    if (a < b)
-    {
+template <typename T>
+int compare(T a, T b) {
+    if (a < b) {
         return -1;
-    }
-    else if (a > b)
-    {
+    } else if (a > b) {
         return 1;
     }
     return 0;
 }
 
-int file_id_t::compare_file_id(const file_id_t &rhs) const
-{
-    /* Compare each field, stopping when we get to a non-equal field */
+int file_id_t::compare_file_id(const file_id_t &rhs) const {
+    // Compare each field, stopping when we get to a non-equal field.
     int ret = 0;
-    if (! ret) ret = compare(device, rhs.device);
-    if (! ret) ret = compare(inode, rhs.inode);
-    if (! ret) ret = compare(size, rhs.size);
-    if (! ret) ret = compare(change_seconds, rhs.change_seconds);
-    if (! ret) ret = compare(change_nanoseconds, rhs.change_nanoseconds);
-    if (! ret) ret = compare(mod_seconds, rhs.mod_seconds);
-    if (! ret) ret = compare(mod_nanoseconds, rhs.mod_nanoseconds);
+    if (!ret) ret = compare(device, rhs.device);
+    if (!ret) ret = compare(inode, rhs.inode);
+    if (!ret) ret = compare(size, rhs.size);
+    if (!ret) ret = compare(change_seconds, rhs.change_seconds);
+    if (!ret) ret = compare(change_nanoseconds, rhs.change_nanoseconds);
+    if (!ret) ret = compare(mod_seconds, rhs.mod_seconds);
+    if (!ret) ret = compare(mod_nanoseconds, rhs.mod_nanoseconds);
     return ret;
 }
 
-
-bool file_id_t::operator<(const file_id_t &rhs) const
-{
-    return this->compare_file_id(rhs) < 0;
-}
+bool file_id_t::operator<(const file_id_t &rhs) const { return this->compare_file_id(rhs) < 0; }