refactor

include/cli/actions.hpp

@@ -42,12 +42,12 @@
 
 namespace repertory::cli::actions {
 using action = std::function<exit_code(
-    int, char **, const std::string &, const provider_type &,
+    std::vector<const char *>, const std::string &, const provider_type &,
     const std::string &, std::string, std::string)>;
 
 struct option_hasher {
   auto operator()(const utils::cli::option &opt) const -> std::size_t {
-    return std::hash<std::string>()(opt[0u] + '|' + opt[1u]);
+    return std::hash<std::string>()(opt[0U] + '|' + opt[1U]);
   }
 };
 
@@ -75,14 +75,14 @@ static const std::unordered_map<utils::cli::option, action, option_hasher>
 };
 
 [[nodiscard]] inline auto
-perform_action(const utils::cli::option &opt, int argc, char *argv[],
-               const std::string &data_directory, const provider_type &pt,
+perform_action(const utils::cli::option &opt, std::vector<const char *> args,
+               const std::string &data_directory, const provider_type &prov,
                const std::string &unique_id, std::string user,
                std::string password) -> exit_code {
-  if (utils::cli::has_option(argc, argv, opt)) {
+  if (utils::cli::has_option(args, opt)) {
     if (option_actions.find(opt) != option_actions.end()) {
-      return option_actions.at(opt)(argc, argv, data_directory, pt, unique_id,
-                                    user, password);
+      return option_actions.at(opt)(args, data_directory, prov, unique_id, user,
+                                    password);
     }
   }
 

include/cli/check_version.hpp

@@ -27,9 +27,10 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-check_version(int, char *[], const std::string & /* data_directory */,
-              const provider_type & /* pt */, const std::string &, std::string,
-              std::string) -> exit_code {
+check_version(std::vector<const char *> /* args */,
+              const std::string & /* data_directory */,
+              const provider_type & /* pt */, const std::string & /*unique_id*/,
+              std::string /*user*/, std::string /*password*/) -> exit_code {
   auto ret = exit_code::success;
 
   // TODO need to updated way to check version

include/cli/display_config.hpp

@@ -30,20 +30,22 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto
-display_config(int, char *[], const std::string &data_directory,
-               const provider_type &pt, const std::string &unique_id,
-               std::string user, std::string password) -> exit_code {
-  lock_data lock(pt, unique_id);
-  const auto res = lock.grab_lock(1u);
+[[nodiscard]] inline auto display_config(std::vector<const char *> /* args */,
+                                         const std::string &data_directory,
+                                         const provider_type &prov,
+                                         const std::string &unique_id,
+                                         std::string user, std::string password)
+    -> exit_code {
+  lock_data lock(prov, unique_id);
+  const auto res = lock.grab_lock(1U);
   if (res == lock_result::success) {
-    app_config config(pt, data_directory);
+    app_config config(prov, data_directory);
     const auto cfg = config.get_json();
     std::cout << 0 << std::endl;
     std::cout << cfg.dump(2) << std::endl;
   } else if (res == lock_result::locked) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).get_config();

include/cli/drive_information.hpp

@@ -31,24 +31,25 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-drive_information(int, char *[], const std::string &data_directory,
-                  const provider_type &pt, const std::string &unique_id,
-                  std::string user, std::string password) -> exit_code {
+drive_information(std::vector<const char *> /* args */,
+                  const std::string &data_directory, const provider_type &prov,
+                  const std::string &unique_id, std::string user,
+                  std::string password) -> exit_code {
   auto ret = exit_code::success;
 
-  lock_data lock(pt, unique_id);
-  const auto res = lock.grab_lock(1u);
+  lock_data lock(prov, unique_id);
+  const auto res = lock.grab_lock(1U);
   if (res == lock_result::locked) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).get_drive_information();
     std::cout << static_cast<int>(response.response_type) << std::endl;
     std::cout << response.data.dump(2) << std::endl;
   } else {
-    std::cerr << app_config::get_provider_display_name(pt) << " is not mounted."
-              << std::endl;
+    std::cerr << app_config::get_provider_display_name(prov)
+              << " is not mounted." << std::endl;
     ret = exit_code::not_mounted;
   }
 

include/cli/get.hpp

@@ -30,19 +30,19 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto get(int argc, char *argv[],
+[[nodiscard]] inline auto get(std::vector<const char *> args,
                               const std::string &data_directory,
-                              const provider_type &pt,
+                              const provider_type &prov,
                               const std::string &unique_id, std::string user,
                               std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
-      argc, argv, repertory::utils::cli::options::get_option, data);
+      args, repertory::utils::cli::options::get_option, data);
   if (ret == exit_code::success) {
-    lock_data lock(pt, unique_id);
+    lock_data lock(prov, unique_id);
     const auto res = lock.grab_lock(1);
     if (res == lock_result::success) {
-      app_config config(pt, data_directory);
+      app_config config(prov, data_directory);
       const auto value = config.get_value_by_name(data);
       std::cout << (value.empty()
                         ? static_cast<int>(
@@ -51,8 +51,8 @@ namespace repertory::cli::actions {
                 << std::endl;
       std::cout << json({{"value", value}}).dump(2) << std::endl;
     } else if (res == lock_result::locked) {
-      auto port = app_config::default_api_port(pt);
-      utils::cli::get_api_authentication_data(user, password, port, pt,
+      auto port = app_config::default_api_port(prov);
+      utils::cli::get_api_authentication_data(user, password, port, prov,
                                               data_directory);
       const auto response = client({"localhost", password, port, user})
                                 .get_config_value_by_name(data);

include/cli/get_directory_items.hpp

@@ -29,17 +29,16 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto
-get_directory_items(int argc, char *argv[], const std::string &data_directory,
-                    const provider_type &pt, const std::string &,
-                    std::string user, std::string password) -> exit_code {
+[[nodiscard]] inline auto get_directory_items(
+    std::vector<const char *> args, const std::string &data_directory,
+    const provider_type &prov, const std::string & /* unique_id */,
+    std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
-      argc, argv, repertory::utils::cli::options::get_directory_items_option,
-      data);
+      args, repertory::utils::cli::options::get_directory_items_option, data);
   if (ret == exit_code::success) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).get_directory_items(data);

include/cli/get_pinned_files.hpp

@@ -29,13 +29,15 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto
-get_pinned_files(int, char *[], const std::string &data_directory,
-                 const provider_type &pt, const std::string &, std::string user,
-                 std::string password) -> exit_code {
+[[nodiscard]] inline auto get_pinned_files(std::vector<const char *> /* args */,
+                                           const std::string &data_directory,
+                                           const provider_type &prov,
+                                           const std::string & /* unique_id */,
+                                           std::string user,
+                                           std::string password) -> exit_code {
   auto ret = exit_code::success;
-  auto port = app_config::default_api_port(pt);
-  utils::cli::get_api_authentication_data(user, password, port, pt,
+  auto port = app_config::default_api_port(prov);
+  utils::cli::get_api_authentication_data(user, password, port, prov,
                                           data_directory);
   const auto response =
       client({"localhost", password, port, user}).get_pinned_files();

include/cli/help.hpp

@@ -23,8 +23,8 @@
 #define INCLUDE_CLI_HELP_HPP_
 
 namespace repertory::cli::actions {
-template <typename drive> inline void help(int argc, char *argv[]) {
-  drive::display_options(argc, argv);
+template <typename drive> inline void help(std::vector<const char *> args) {
+  drive::display_options(args);
   std::cout << "Repertory options:" << std::endl;
   std::cout << "    -cv,--check_version               Check daemon version "
                "compatibility"

include/cli/mount.hpp

@@ -54,30 +54,30 @@ using remote_instance = repertory::remote_fuse::i_remote_instance;
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-mount(int argc, char *argv[], std::string data_directory, int &mount_result,
-      provider_type pt, const std::string &remote_host,
+mount(std::vector<const char *> args, std::string data_directory,
+      int &mount_result, provider_type prov, const std::string &remote_host,
       std::uint16_t remote_port, const std::string &unique_id) -> exit_code {
   auto ret = exit_code::success;
 
-  lock_data lock(pt, unique_id);
+  lock_data lock(prov, unique_id);
   const auto res = lock.grab_lock();
   if (res == lock_result::locked) {
     ret = exit_code::mount_active;
-    std::cerr << app_config::get_provider_display_name(pt)
+    std::cerr << app_config::get_provider_display_name(prov)
               << " mount is already active" << std::endl;
   } else if (res == lock_result::success) {
     const auto generate_config = utils::cli::has_option(
-        argc, argv, utils::cli::options::generate_config_option);
+        args, utils::cli::options::generate_config_option);
     if (generate_config) {
-      app_config config(pt, data_directory);
-      if (pt == provider_type::remote) {
+      app_config config(prov, data_directory);
+      if (prov == provider_type::remote) {
         config.set_enable_remote_mount(false);
         config.set_is_remote_mount(true);
         config.set_remote_host_name_or_ip(remote_host);
         config.set_remote_port(remote_port);
         config.save();
       }
-      std::cout << "Generated " << app_config::get_provider_display_name(pt)
+      std::cout << "Generated " << app_config::get_provider_display_name(prov)
                 << " Configuration" << std::endl;
       std::cout << config.get_config_file_path() << std::endl;
       ret = utils::file::is_file(config.get_config_file_path())
@@ -85,14 +85,13 @@ mount(int argc, char *argv[], std::string data_directory, int &mount_result,
                 : exit_code::file_creation_failed;
     } else {
 #ifdef _WIN32
-      if (utils::cli::has_option(argc, argv,
-                                 utils::cli::options::hidden_option)) {
+      if (utils::cli::has_option(args, utils::cli::options::hidden_option)) {
         ::ShowWindow(::GetConsoleWindow(), SW_HIDE);
       }
 #endif
       const auto drive_args =
-          utils::cli::parse_drive_options(argc, argv, pt, data_directory);
-      app_config config(pt, data_directory);
+          utils::cli::parse_drive_options(args, prov, data_directory);
+      app_config config(prov, data_directory);
 #ifdef _WIN32
       if (config.get_enable_mount_manager() &&
           not utils::is_process_elevated()) {
@@ -102,8 +101,8 @@ mount(int argc, char *argv[], std::string data_directory, int &mount_result,
         }
         lock.release();
 
-        mount_result = utils::run_process_elevated(argc, argv);
-        lock_data lock2(pt, unique_id);
+        mount_result = utils::run_process_elevated(args);
+        lock_data lock2(prov, unique_id);
         if (lock2.grab_lock() == lock_result::success) {
           if (not lock2.set_mount_state(false, "", -1)) {
             std::cerr << "failed to set mount state" << std::endl;
@@ -114,15 +113,16 @@ mount(int argc, char *argv[], std::string data_directory, int &mount_result,
         return exit_code::mount_result;
       }
 #endif
-      std::cout << "Initializing " << app_config::get_provider_display_name(pt)
+      std::cout << "Initializing "
+                << app_config::get_provider_display_name(prov)
                 << (unique_id.empty() ? ""
-                    : (pt == provider_type::s3)
+                    : (prov == provider_type::s3)
                         ? " [" + unique_id + ']'
                         : " [" + remote_host + ':' +
                               std::to_string(remote_port) + ']')
                 << " Drive" << std::endl;
-      if (pt == provider_type::remote) {
-        std::uint16_t port = 0u;
+      if (prov == provider_type::remote) {
+        std::uint16_t port{0U};
         if (utils::get_next_available_port(config.get_api_port(), port)) {
           config.set_remote_host_name_or_ip(remote_host);
           config.set_remote_port(remote_port);
@@ -155,7 +155,7 @@ mount(int argc, char *argv[], std::string data_directory, int &mount_result,
         config.set_is_remote_mount(false);
 
         try {
-          auto provider = create_provider(pt, config);
+          auto provider = create_provider(prov, config);
           repertory_drive drive(config, lock, *provider);
           if (not lock.set_mount_state(true, "", -1)) {
             std::cerr << "failed to set mount state" << std::endl;

include/cli/open_files.hpp

@@ -31,23 +31,24 @@
 
 namespace repertory::cli::actions {
 [[nodiscard]] inline auto
-open_files(int, char *[], const std::string &data_directory,
-           const provider_type &pt, const std::string &unique_id,
-           std::string user, std::string password) -> exit_code {
+open_files(std::vector<const char *> /* args */,
+           const std::string &data_directory, const provider_type &prov,
+           const std::string &unique_id, std::string user, std::string password)
+    -> exit_code {
   auto ret = exit_code::success;
-  lock_data lock(pt, unique_id);
-  const auto res = lock.grab_lock(1u);
+  lock_data lock(prov, unique_id);
+  const auto res = lock.grab_lock(1U);
   if (res == lock_result::locked) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).get_open_files();
     std::cout << static_cast<int>(response.response_type) << std::endl;
     std::cout << response.data.dump(2) << std::endl;
   } else {
-    std::cerr << app_config::get_provider_display_name(pt) << " is not mounted."
-              << std::endl;
+    std::cerr << app_config::get_provider_display_name(prov)
+              << " is not mounted." << std::endl;
     ret = exit_code::not_mounted;
   }
 

include/cli/pin_file.hpp

@@ -29,17 +29,16 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto pin_file(int argc, char *argv[],
-                                   const std::string &data_directory,
-                                   const provider_type &pt, const std::string &,
-                                   std::string user, std::string password)
-    -> exit_code {
+[[nodiscard]] inline auto
+pin_file(std::vector<const char *> args, const std::string &data_directory,
+         const provider_type &prov, const std::string & /* unique_id */,
+         std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
-      argc, argv, repertory::utils::cli::options::pin_file_option, data);
+      args, repertory::utils::cli::options::pin_file_option, data);
   if (ret == exit_code::success) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).pin_file(data);

include/cli/pinned_status.hpp

@@ -29,17 +29,16 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto pinned_status(int argc, char *argv[],
-                                        const std::string &data_directory,
-                                        const provider_type &pt,
-                                        const std::string &, std::string user,
-                                        std::string password) -> exit_code {
+[[nodiscard]] inline auto
+pinned_status(std::vector<const char *> args, const std::string &data_directory,
+              const provider_type &prov, const std::string & /*unique_id*/,
+              std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
-      argc, argv, repertory::utils::cli::options::pinned_status_option, data);
+      args, repertory::utils::cli::options::pinned_status_option, data);
   if (ret == exit_code::success) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).pinned_status(data);

include/cli/set.hpp

@@ -30,27 +30,27 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto set(int argc, char *argv[],
+[[nodiscard]] inline auto set(std::vector<const char *> args,
                               const std::string &data_directory,
-                              const provider_type &pt,
+                              const provider_type &prov,
                               const std::string &unique_id, std::string user,
                               std::string password) -> exit_code {
   auto ret = exit_code::success;
-  auto data = utils::cli::parse_option(argc, argv, "-set", 2u);
+  auto data = utils::cli::parse_option(args, "-set", 2U);
   if (data.empty()) {
-    data = utils::cli::parse_option(argc, argv, "--set", 2u);
+    data = utils::cli::parse_option(args, "--set", 2U);
     if (data.empty()) {
       ret = exit_code::invalid_syntax;
       std::cerr << "Invalid syntax for '-set'" << std::endl;
     }
   }
   if (ret == exit_code::success) {
-    lock_data lock(pt, unique_id);
-    const auto res = lock.grab_lock(1u);
+    lock_data lock(prov, unique_id);
+    const auto res = lock.grab_lock(1U);
     if (res == lock_result::success) {
-      app_config config(pt, data_directory);
-      const auto value = config.set_value_by_name(data[0u], data[1u]);
-      const auto notFound = value.empty() && not data[1u].empty();
+      app_config config(prov, data_directory);
+      const auto value = config.set_value_by_name(data[0U], data[1U]);
+      const auto notFound = value.empty() && not data[1U].empty();
       ret = notFound ? exit_code::set_option_not_found : exit_code::success;
       std::cout << (notFound ? static_cast<int>(
                                    rpc_response_type::config_value_not_found)
@@ -58,11 +58,11 @@ namespace repertory::cli::actions {
                 << std::endl;
       std::cout << json({{"value", value}}).dump(2) << std::endl;
     } else if (res == lock_result::locked) {
-      auto port = app_config::default_api_port(pt);
-      utils::cli::get_api_authentication_data(user, password, port, pt,
+      auto port = app_config::default_api_port(prov);
+      utils::cli::get_api_authentication_data(user, password, port, prov,
                                               data_directory);
       const auto response = client({"localhost", password, port, user})
-                                .set_config_value_by_name(data[0u], data[1u]);
+                                .set_config_value_by_name(data[0U], data[1U]);
       std::cout << static_cast<int>(response.response_type) << std::endl;
       std::cout << response.data.dump(2) << std::endl;
       ret = response.response_type == rpc_response_type::config_value_not_found

include/cli/status.hpp

@@ -26,13 +26,15 @@
 #include "types/repertory.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto status(int, char *[], const std::string &,
-                                 const provider_type &pt,
-                                 const std::string &unique_id, std::string,
-                                 std::string) -> exit_code {
+[[nodiscard]] inline auto status(std::vector<const char *> /* args */,
+                                 const std::string & /*data_directory*/,
+                                 const provider_type &prov,
+                                 const std::string &unique_id,
+                                 std::string /* user */,
+                                 std::string /* password */) -> exit_code {
   auto ret = exit_code::success;
-  lock_data lock(pt, unique_id);
-  [[maybe_unused]] auto status = lock.grab_lock(10u);
+  lock_data lock(prov, unique_id);
+  [[maybe_unused]] auto status = lock.grab_lock(10U);
   json mount_state;
   if (lock.get_mount_state(mount_state)) {
     std::cout << mount_state.dump(2) << std::endl;

include/cli/unmount.hpp

@@ -29,14 +29,13 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto unmount(int, char *[],
-                                  const std::string &data_directory,
-                                  const provider_type &pt, const std::string &,
-                                  std::string user, std::string password)
-    -> exit_code {
+[[nodiscard]] inline auto
+unmount(std::vector<const char *> /* args */, const std::string &data_directory,
+        const provider_type &prov, const std::string & /*unique_id*/,
+        std::string user, std::string password) -> exit_code {
   auto ret = exit_code::success;
-  auto port = app_config::default_api_port(pt);
-  utils::cli::get_api_authentication_data(user, password, port, pt,
+  auto port = app_config::default_api_port(prov);
+  utils::cli::get_api_authentication_data(user, password, port, prov,
                                           data_directory);
   const auto response = client({"localhost", password, port, user}).unmount();
   std::cout << static_cast<int>(response.response_type) << std::endl;

include/cli/unpin_file.hpp

@@ -29,17 +29,16 @@
 #include "utils/cli_utils.hpp"
 
 namespace repertory::cli::actions {
-[[nodiscard]] inline auto unpin_file(int argc, char *argv[],
-                                     const std::string &data_directory,
-                                     const provider_type &pt,
-                                     const std::string &, std::string user,
-                                     std::string password) -> exit_code {
+[[nodiscard]] inline auto
+unpin_file(std::vector<const char *> args, const std::string &data_directory,
+           const provider_type &prov, const std::string & /*unique_id*/,
+           std::string user, std::string password) -> exit_code {
   std::string data;
   auto ret = utils::cli::parse_string_option(
-      argc, argv, repertory::utils::cli::options::unpin_file_option, data);
+      args, repertory::utils::cli::options::unpin_file_option, data);
   if (ret == exit_code::success) {
-    auto port = app_config::default_api_port(pt);
-    utils::cli::get_api_authentication_data(user, password, port, pt,
+    auto port = app_config::default_api_port(prov);
+    utils::cli::get_api_authentication_data(user, password, port, prov,
                                             data_directory);
     const auto response =
         client({"localhost", password, port, user}).unpin_file(data);

include/cli/version.hpp

@@ -23,12 +23,12 @@
 #define INCLUDE_CLI_VERSION_HPP_
 
 namespace repertory::cli::actions {
-template <typename drive> inline void version(int argc, char *argv[]) {
+template <typename drive> inline void version(std::vector<const char *> args) {
   std::cout << "Repertory core version: " << get_repertory_version()
             << std::endl;
   std::cout << "Repertory Git revision: " << get_repertory_git_revision()
             << std::endl;
-  drive::display_version_information(argc, argv);
+  drive::display_version_information(args);
 }
 } // namespace repertory::cli::actions
 

include/drives/fuse/fuse_base.hpp

@@ -38,6 +38,12 @@ public:
 
   virtual ~fuse_base();
 
+public:
+  fuse_base(const fuse_base &) = delete;
+  fuse_base(fuse_base &&) = delete;
+  auto operator=(const fuse_base &) -> fuse_base & = delete;
+  auto operator=(fuse_base &&) -> fuse_base & = delete;
+
 protected:
   app_config &config_;
 
@@ -593,9 +599,9 @@ protected:
   virtual void shutdown();
 
 public:
-  static void display_options(int argc, char *argv[]);
+  static void display_options(std::vector<const char *> args);
 
-  static void display_version_information(int argc, char *argv[]);
+  static void display_version_information(std::vector<const char *> args);
 
   static auto unmount(const std::string &mount_location) -> int;
 

include/drives/fuse/fuse_drive_base.hpp

@@ -36,6 +36,12 @@ public:
 
   ~fuse_drive_base() override = default;
 
+public:
+  fuse_drive_base(const fuse_drive_base &) = delete;
+  fuse_drive_base(fuse_drive_base &&) = delete;
+  auto operator=(const fuse_drive_base &) -> fuse_drive_base & = delete;
+  auto operator=(fuse_drive_base &&) -> fuse_drive_base & = delete;
+
 protected:
   [[nodiscard]] auto access_impl(std::string api_path, int mask)
       -> api_error override;

include/drives/winfsp/winfsp_drive.hpp

@@ -193,9 +193,9 @@ public:
 
   void shutdown();
 
-  static void display_options(int argc, char *argv[]) {}
+  static void display_options(std::vector<const char *> args) {}
 
-  static void display_version_information(int argc, char *argv[]) {}
+  static void display_version_information(std::vector<const char *> args) {}
 };
 } // namespace repertory
 

include/providers/provider.hpp

@@ -28,7 +28,8 @@ namespace repertory {
 class app_config;
 class i_provider;
 
-[[nodiscard]] auto create_provider(const provider_type &pt, app_config &config)
+[[nodiscard]] auto create_provider(const provider_type &prov,
+                                   app_config &config)
     -> std::unique_ptr<i_provider>;
 } // namespace repertory
 

include/utils/cli_utils.hpp

@@ -88,26 +88,28 @@ static const std::vector<option> option_list = {
 
 // Prototypes
 void get_api_authentication_data(std::string &user, std::string &password,
-                                 std::uint16_t &port, const provider_type &pt,
+                                 std::uint16_t &port, const provider_type &prov,
                                  const std::string &data_directory);
 
-[[nodiscard]] auto get_provider_type_from_args(int argc, char *argv[])
+[[nodiscard]] auto get_provider_type_from_args(std::vector<const char *> args)
     -> provider_type;
 
-[[nodiscard]] auto has_option(int argc, char *argv[],
+[[nodiscard]] auto has_option(std::vector<const char *> args,
                               const std::string &option_name) -> bool;
 
-[[nodiscard]] auto has_option(int argc, char *argv[], const option &opt)
+[[nodiscard]] auto has_option(std::vector<const char *> args, const option &opt)
     -> bool;
 
-[[nodiscard]] auto parse_option(int argc, char *argv[],
+[[nodiscard]] auto parse_option(std::vector<const char *> args,
                                 const std::string &option_name,
                                 std::uint8_t count) -> std::vector<std::string>;
 
-[[nodiscard]] auto parse_string_option(int argc, char **argv, const option &opt,
-                                       std::string &value) -> exit_code;
+[[nodiscard]] auto parse_string_option(std::vector<const char *> args,
+                                       const option &opt, std::string &value)
+    -> exit_code;
 
-[[nodiscard]] auto parse_drive_options(int argc, char **argv, provider_type &pt,
+[[nodiscard]] auto parse_drive_options(std::vector<const char *> args,
+                                       provider_type &prov,
                                        std::string &data_directory)
     -> std::vector<std::string>;
 } // namespace repertory::utils::cli

include/utils/windows/windows_utils.hpp

@@ -50,7 +50,7 @@ namespace repertory::utils {
 
 [[nodiscard]] auto is_process_elevated() -> bool;
 
-[[nodiscard]] auto run_process_elevated(int argc, char *argv[]) -> int;
+[[nodiscard]] auto run_process_elevated(std::vector<const char *> args) -> int;
 
 void set_last_error_code(DWORD errorCode);