foreach_file.hh

Go to the documentation of this file.

#ifndef FOREACH_FILE_HH
#define FOREACH_FILE_HH
 
#include "FileOperations.hh"
#include "ReadDir.hh"
#include "StringOp.hh"
#include "one_of.hh"
#include <functional>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace openmsx {
        namespace detail {
                using namespace FileOperations;
 
                // Take an action that accepts the following parameters:
                // - a 'std::string&' or 'const std::string&' parameter
                // - optionally a std::string_view parameter
                // - optionally a 'FileOperations::Stat&' parameter
                // And returns a wrapper that makes the 2nd and 3rd parameter
                // non-optional, but (possibly) ignores those parameters when
                // delegating to the wrapped action.
                template<typename Action>
                [[nodiscard]] auto adaptParams(Action action) {
                        if constexpr (std::is_invocable_v<Action, std::string&, std::string_view, Stat&>) {
                                return std::tuple(action, true);
                        } else if constexpr (std::is_invocable_v<Action, std::string&, std::string_view>) {
                                return std::tuple([action](std::string& p, std::string_view f, Stat& /*st*/) {
                                                          return action(p, f);
                                                  }, false);
                        } else if constexpr (std::is_invocable_v<Action, std::string&, Stat&>) {
                                return std::tuple([action](std::string& p, std::string_view /*f*/, Stat& st) {
                                                          return action(p, st);
                                                  }, true);
                        } else if constexpr (std::is_invocable_v<Action, std::string&>) {
                                return std::tuple([action](std::string& p, std::string_view /*f*/, Stat& /*st*/) {
                                                          return action(p);
                                                  }, false);
                        } else {
                                static_assert((Action{}, false), "Wrong signature for action");
                        }
                }
 
                // Take an action and
                // - return it unchanged if it already returned a non-void result
                // - otherwise return a wrapper that invokes the given action and then returns 'true'.
                template<typename Action>
                [[nodiscard]] auto adaptReturn(Action action) {
                        using ResultType = std::invoke_result_t<Action, std::string&, std::string_view, Stat&>;
                        if constexpr (std::is_same_v<ResultType, void>) {
                                return [=](auto&&... params) {
                                        action(std::forward<decltype(params)>(params)...);
                                        return true; // continue directory-traversal
                                };
                        } else {
                                return action;
                        }
                }
 
                template<typename FileAction, typename DirAction>
                bool foreach_dirent(std::string& path, FileAction fileAction, DirAction dirAction) {
                        auto [invokeFile, statFile] = adaptParams(fileAction);
                        auto [invokeDir,  statDir ] = adaptParams(dirAction);
                        auto invokeFileAction = adaptReturn(invokeFile);
                        auto invokeDirAction  = adaptReturn(invokeDir);
                        bool needStat = statFile || statDir;
 
                        ReadDir dir(path);
                        bool addSlash = !path.empty() && (path.back() != '/');
                        if (addSlash) path += '/';
                        auto origLen = path.size();
                        while (dirent* d = dir.getEntry()) {
                                std::string_view f(d->d_name);
                                if (f == one_of(".", "..")) continue;
                                path += f;
                                auto file = std::string_view(path).substr(origLen);
 
                                // When the action is not interested in 'Stat' and on operation systems
                                // that support it: avoid doing an extra 'stat()' system call.
                                auto type = needStat ? static_cast<unsigned char>(DT_UNKNOWN) : d->d_type;
                                if (type == DT_REG) {
                                        Stat dummy;
                                        if (!invokeFileAction(path, file, dummy)) {
                                                return false; // aborted
                                        }
                                } else if (type == DT_DIR) {
                                        Stat dummy;
                                        if (!invokeDirAction(path, file, dummy)) {
                                                return false;
                                        }
                                } else {
                                        if (auto st = getStat(path)) {
                                                if (isRegularFile(*st)) {
                                                        if (!invokeFileAction(path, file, *st)) {
                                                                return false;
                                                        }
                                                } else if (isDirectory(*st)) {
                                                        if (!invokeDirAction(path, file, *st)) {
                                                                return false;
                                                        }
                                                }
                                        }
                                }
 
                                path.resize(origLen);
                        }
                        if (addSlash) path.pop_back();
 
                        return true; // finished normally
                }
        }
 
        template<typename FileAction>
        bool foreach_file(std::string path, FileAction fileAction)
        {
                auto dirAction = [&](const std::string& /*dirPath*/) { /*nothing*/ };
                return detail::foreach_dirent(path, fileAction, dirAction);
        }
 
        template<typename FileAction, typename DirAction>
        bool foreach_file_and_directory(std::string path, FileAction fileAction, DirAction dirAction)
        {
                return detail::foreach_dirent(path, fileAction, dirAction);
        }
 
        template<typename FileAction>
        bool foreach_file_recursive(std::string path, FileAction fileAction)
        {
                std::function<bool(std::string&)> dirAction;
                dirAction = [&](std::string& dirPath) {
                        return detail::foreach_dirent(dirPath, fileAction, dirAction);
                };
                return dirAction(path);
        }
 
} // namespace openmsx
 
#endif