cleanup

repertory/librepertory/include/app_config.hpp

@@ -22,11 +22,9 @@
 #ifndef REPERTORY_INCLUDE_APP_CONFIG_HPP_
 #define REPERTORY_INCLUDE_APP_CONFIG_HPP_
 
-#include "events/event_system.hpp"
-#include "events/events.hpp"
+#include "events/event.hpp"
 #include "types/remote.hpp"
 #include "types/repertory.hpp"
-#include "utils/error_utils.hpp"
 
 namespace repertory {
 class app_config final {

repertory/librepertory/include/drives/remote/remote_server_base.hpp

@@ -29,6 +29,8 @@
 #include "drives/fuse/remotefuse/i_remote_instance.hpp"
 #include "drives/remote/remote_open_file_table.hpp"
 #include "drives/winfsp/remotewinfsp/i_remote_instance.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "types/remote.hpp"
 #include "types/repertory.hpp"
 #include "utils/base64.hpp"

repertory/librepertory/src/app_config.cpp

@@ -21,6 +21,8 @@
 */
 #include "app_config.hpp"
 
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "platform/platform.hpp"
 #include "types/startup_exception.hpp"
 #include "utils/common.hpp"

repertory/librepertory/src/drives/fuse/fuse_base.cpp

@@ -30,6 +30,7 @@
 #include "initialize.hpp"
 #include "platform/platform.hpp"
 #include "utils/collection.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file_utils.hpp"
 #include "utils/path.hpp"
 #include "utils/string.hpp"

repertory/librepertory/src/file_manager/ring_buffer_open_file.cpp

@@ -28,7 +28,7 @@
 #include "providers/i_provider.hpp"
 #include "types/repertory.hpp"
 #include "utils/common.hpp"
-#include "utils/encrypting_reader.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file_utils.hpp"
 #include "utils/path.hpp"
 #include "utils/utils.hpp"
@@ -78,7 +78,7 @@ ring_buffer_open_file::ring_buffer_open_file(std::string buffer_directory,
   fsi_.source_path =
       utils::path::combine(buffer_directory, {utils::create_uuid_string()});
   nf_ = utils::file::file::open_or_create_file(fsi_.source_path);
-  if (not*nf_) {
+  if (not *nf_) {
     throw std::runtime_error("failed to create buffer file|err|" +
                              std::to_string(utils::get_last_error_code()));
   }
@@ -234,8 +234,8 @@ void ring_buffer_open_file::reverse(std::size_t count) {
 }
 
 auto ring_buffer_open_file::read(std::size_t read_size,
-                                 std::uint64_t read_offset, data_buffer &data)
-    -> api_error {
+                                 std::uint64_t read_offset,
+                                 data_buffer &data) -> api_error {
   if (fsi_.directory) {
     return api_error::invalid_operation;
   }

repertory/librepertory/src/platform/unix_platform.cpp

@@ -24,6 +24,8 @@
 #include "platform/unix_platform.hpp"
 
 #include "app_config.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "providers/i_provider.hpp"
 #include "types/startup_exception.hpp"
 #include "utils/common.hpp"

repertory/librepertory/src/providers/base_provider.cpp

@@ -28,6 +28,7 @@
 #include "file_manager/cache_size_mgr.hpp"
 #include "file_manager/i_file_manager.hpp"
 #include "platform/platform.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file_utils.hpp"
 #include "utils/path.hpp"
 #include "utils/polling.hpp"
@@ -50,8 +51,8 @@ void base_provider::add_all_items(const stop_type &stop_requested) {
 }
 
 auto base_provider::create_api_file(std::string path, std::string key,
-                                    std::uint64_t size, std::uint64_t file_time)
-    -> api_file {
+                                    std::uint64_t size,
+                                    std::uint64_t file_time) -> api_file {
   api_file file{};
   file.api_path = utils::path::create_api_path(path);
   file.api_parent = utils::path::get_parent_api_path(file.api_path);
@@ -83,8 +84,8 @@ auto base_provider::create_api_file(std::string path, std::uint64_t size,
 }
 
 auto base_provider::create_directory_clone_source_meta(
-    const std::string &source_api_path, const std::string &api_path)
-    -> api_error {
+    const std::string &source_api_path,
+    const std::string &api_path) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   bool exists{};
@@ -181,8 +182,8 @@ auto base_provider::create_directory(const std::string &api_path,
   return set_item_meta(api_path, meta);
 }
 
-auto base_provider::create_file(const std::string &api_path, api_meta_map &meta)
-    -> api_error {
+auto base_provider::create_file(const std::string &api_path,
+                                api_meta_map &meta) -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   bool exists{};
@@ -239,9 +240,8 @@ auto base_provider::create_file(const std::string &api_path, api_meta_map &meta)
   return api_error::error;
 }
 
-auto base_provider::get_api_path_from_source(const std::string &source_path,
-                                             std::string &api_path) const
-    -> api_error {
+auto base_provider::get_api_path_from_source(
+    const std::string &source_path, std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (source_path.empty()) {
@@ -254,9 +254,8 @@ auto base_provider::get_api_path_from_source(const std::string &source_path,
   return db3_->get_api_path(source_path, api_path);
 }
 
-auto base_provider::get_directory_items(const std::string &api_path,
-                                        directory_item_list &list) const
-    -> api_error {
+auto base_provider::get_directory_items(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   bool exists{};
@@ -320,10 +319,9 @@ auto base_provider::get_file_size(const std::string &api_path,
   return api_error::success;
 }
 
-auto base_provider::get_filesystem_item(const std::string &api_path,
-                                        bool directory,
-                                        filesystem_item &fsi) const
-    -> api_error {
+auto base_provider::get_filesystem_item(
+    const std::string &api_path, bool directory,
+    filesystem_item &fsi) const -> api_error {
   bool exists{};
   auto res = is_directory(api_path, exists);
   if (res != api_error::success) {
@@ -356,10 +354,9 @@ auto base_provider::get_filesystem_item(const std::string &api_path,
   return api_error::success;
 }
 
-auto base_provider::get_filesystem_item_and_file(const std::string &api_path,
-                                                 api_file &file,
-                                                 filesystem_item &fsi) const
-    -> api_error {
+auto base_provider::get_filesystem_item_and_file(
+    const std::string &api_path, api_file &file,
+    filesystem_item &fsi) const -> api_error {
   auto res = get_file(api_path, file);
   if (res != api_error::success) {
     return res;

repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp

@@ -29,22 +29,18 @@
 #include "utils/collection.hpp"
 #include "utils/encrypting_reader.hpp"
 #include "utils/encryption.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file_utils.hpp"
 #include "utils/path.hpp"
 #include "utils/polling.hpp"
 
-namespace {
-const std::string file_table = "file";
-} // namespace
-
 namespace repertory {
 encrypt_provider::encrypt_provider(app_config &config)
     : config_(config), encrypt_config_(config.get_encrypt_config()) {}
 
-auto encrypt_provider::create_api_file(const std::string &api_path,
-                                       bool directory,
-                                       const std::string &source_path)
-    -> api_file {
+auto encrypt_provider::create_api_file(
+    const std::string &api_path, bool directory,
+    const std::string &source_path) -> api_file {
   auto times = utils::file::get_times(source_path);
   if (not times.has_value()) {
     throw std::runtime_error("failed to get file times");
@@ -70,10 +66,10 @@ auto encrypt_provider::create_api_file(const std::string &api_path,
 void encrypt_provider::create_item_meta(api_meta_map &meta, bool directory,
                                         const api_file &file) {
 #if defined(_WIN32)
-  struct _stat64 buf{};
+  struct _stat64 buf {};
   _stat64(file.source_path.c_str(), &buf);
 #else  // !defined(_WIN32)
-  struct stat buf{};
+  struct stat buf {};
   stat(file.source_path.c_str(), &buf);
 #endif // defined(_WIN32)
 
@@ -153,9 +149,8 @@ auto encrypt_provider::do_fs_operation(
   return callback(cfg, source_path);
 }
 
-auto encrypt_provider::get_api_path_from_source(const std::string &source_path,
-                                                std::string &api_path) const
-    -> api_error {
+auto encrypt_provider::get_api_path_from_source(
+    const std::string &source_path, std::string &api_path) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -194,9 +189,8 @@ auto encrypt_provider::get_directory_item_count(
   return count;
 }
 
-auto encrypt_provider::get_directory_items(const std::string &api_path,
-                                           directory_item_list &list) const
-    -> api_error {
+auto encrypt_provider::get_directory_items(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   return do_fs_operation(
@@ -324,9 +318,8 @@ auto encrypt_provider::get_file(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_list(api_file_list &list,
-                                     std::string & /* marker */) const
-    -> api_error {
+auto encrypt_provider::get_file_list(
+    api_file_list &list, std::string & /* marker */) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg = get_encrypt_config();
@@ -349,9 +342,8 @@ auto encrypt_provider::get_file_list(api_file_list &list,
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_size(const std::string &api_path,
-                                     std::uint64_t &file_size) const
-    -> api_error {
+auto encrypt_provider::get_file_size(
+    const std::string &api_path, std::uint64_t &file_size) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -372,10 +364,9 @@ auto encrypt_provider::get_file_size(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::get_filesystem_item(const std::string &api_path,
-                                           bool directory,
-                                           filesystem_item &fsi) const
-    -> api_error {
+auto encrypt_provider::get_filesystem_item(
+    const std::string &api_path, bool directory,
+    filesystem_item &fsi) const -> api_error {
   std::string source_path;
   if (directory) {
     auto result = db_->get_directory_source_path(api_path, source_path);
@@ -426,10 +417,9 @@ auto encrypt_provider::get_filesystem_item_from_source_path(
   return get_filesystem_item(api_path, false, fsi);
 }
 
-auto encrypt_provider::get_filesystem_item_and_file(const std::string &api_path,
-                                                    api_file &file,
-                                                    filesystem_item &fsi) const
-    -> api_error {
+auto encrypt_provider::get_filesystem_item_and_file(
+    const std::string &api_path, api_file &file,
+    filesystem_item &fsi) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -554,8 +544,8 @@ auto encrypt_provider::is_directory(const std::string &api_path,
   return api_error::error;
 }
 
-auto encrypt_provider::is_file(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto encrypt_provider::is_file(const std::string &api_path,
+                               bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {

repertory/librepertory/src/providers/s3/s3_provider.cpp

@@ -23,6 +23,8 @@
 
 #include "app_config.hpp"
 #include "comm/i_http_comm.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "file_manager/i_file_manager.hpp"
 #include "types/repertory.hpp"
 #include "types/s3.hpp"
@@ -41,9 +43,8 @@ namespace repertory {
 s3_provider::s3_provider(app_config &config, i_http_comm &comm)
     : base_provider(config, comm) {}
 
-auto s3_provider::add_if_not_found(api_file &file,
-                                   const std::string &object_name) const
-    -> api_error {
+auto s3_provider::add_if_not_found(
+    api_file &file, const std::string &object_name) const -> api_error {
   api_meta_map meta{};
   if (get_item_meta(file.api_path, meta) == api_error::item_not_found) {
     auto err = create_path_directories(
@@ -69,7 +70,7 @@ auto s3_provider::convert_api_date(std::string_view date) -> std::uint64_t {
                 utils::string::split(date_parts.at(1U), 'Z', true).at(0U)) *
                 1000000UL;
 
-  struct tm tm1{};
+  struct tm tm1 {};
 #if defined(_WIN32)
   utils::time::strptime(date_time.c_str(), "%Y-%m-%dT%T", &tm1);
   return nanos + utils::time::windows_time_t_to_unix_time(_mkgmtime(&tm1));
@@ -161,9 +162,8 @@ auto s3_provider::create_file_extra(const std::string &api_path,
   return api_error::success;
 }
 
-auto s3_provider::create_path_directories(const std::string &api_path,
-                                          const std::string &key) const
-    -> api_error {
+auto s3_provider::create_path_directories(
+    const std::string &api_path, const std::string &key) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   if (api_path == "/") {
@@ -330,9 +330,8 @@ auto s3_provider::get_directory_item_count(const std::string &api_path) const
   return 0U;
 }
 
-auto s3_provider::get_directory_items_impl(const std::string &api_path,
-                                           directory_item_list &list) const
-    -> api_error {
+auto s3_provider::get_directory_items_impl(
+    const std::string &api_path, directory_item_list &list) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   const auto &cfg = get_s3_config();
@@ -477,8 +476,8 @@ auto s3_provider::get_directory_items_impl(const std::string &api_path,
   return ret;
 }
 
-auto s3_provider::get_file(const std::string &api_path, api_file &file) const
-    -> api_error {
+auto s3_provider::get_file(const std::string &api_path,
+                           api_file &file) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -517,8 +516,8 @@ auto s3_provider::get_file(const std::string &api_path, api_file &file) const
   return api_error::error;
 }
 
-auto s3_provider::get_file_list(api_file_list &list, std::string &marker) const
-    -> api_error {
+auto s3_provider::get_file_list(api_file_list &list,
+                                std::string &marker) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   std::string response_data;
@@ -593,9 +592,8 @@ auto s3_provider::get_file_list(api_file_list &list, std::string &marker) const
   return grab_more ? api_error::more_data : api_error::success;
 }
 
-auto s3_provider::get_last_modified(bool directory,
-                                    const std::string &api_path) const
-    -> std::uint64_t {
+auto s3_provider::get_last_modified(
+    bool directory, const std::string &api_path) const -> std::uint64_t {
   bool is_encrypted{};
   std::string object_name;
   head_object_result result{};
@@ -605,10 +603,9 @@ auto s3_provider::get_last_modified(bool directory,
              : utils::time::get_time_now();
 }
 
-auto s3_provider::get_object_info(bool directory, const std::string &api_path,
-                                  bool &is_encrypted, std::string &object_name,
-                                  head_object_result &result) const
-    -> api_error {
+auto s3_provider::get_object_info(
+    bool directory, const std::string &api_path, bool &is_encrypted,
+    std::string &object_name, head_object_result &result) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -657,12 +654,10 @@ auto s3_provider::get_object_info(bool directory, const std::string &api_path,
   return api_error::error;
 }
 
-auto s3_provider::get_object_list(std::string &response_data,
-                                  long &response_code,
-                                  std::optional<std::string> delimiter,
-                                  std::optional<std::string> prefix,
-                                  std::optional<std::string> token) const
-    -> bool {
+auto s3_provider::get_object_list(
+    std::string &response_data, long &response_code,
+    std::optional<std::string> delimiter, std::optional<std::string> prefix,
+    std::optional<std::string> token) const -> bool {
   curl::requests::http_get get{};
   get.allow_timeout = true;
   get.aws_service = "aws:amz:" + get_s3_config().region + ":s3";
@@ -691,8 +686,8 @@ auto s3_provider::get_total_drive_space() const -> std::uint64_t {
   return std::numeric_limits<std::int64_t>::max() / std::int64_t(2);
 }
 
-auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto s3_provider::is_directory(const std::string &api_path,
+                               bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   exists = false;
@@ -719,8 +714,8 @@ auto s3_provider::is_directory(const std::string &api_path, bool &exists) const
   return api_error::error;
 }
 
-auto s3_provider::is_file(const std::string &api_path, bool &exists) const
-    -> api_error {
+auto s3_provider::is_file(const std::string &api_path,
+                          bool &exists) const -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   exists = false;

repertory/librepertory/src/rpc/server/full_server.cpp

@@ -22,10 +22,13 @@
 #include "rpc/server/full_server.hpp"
 
 #include "app_config.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "file_manager/i_file_manager.hpp"
 #include "providers/i_provider.hpp"
 #include "types/repertory.hpp"
 #include "types/rpc.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file.hpp"
 #include "utils/path.hpp"
 

repertory/librepertory/src/rpc/server/server.cpp

@@ -22,6 +22,8 @@
 #include "rpc/server/server.hpp"
 
 #include "app_config.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "utils/base64.hpp"
 #include "utils/error_utils.hpp"
 

repertory/librepertory/src/utils/polling.cpp

@@ -22,6 +22,8 @@
 #include "utils/polling.hpp"
 
 #include "app_config.hpp"
+#include "events/event_system.hpp"
+#include "events/events.hpp"
 #include "utils/tasks.hpp"
 
 namespace repertory {

repertory/librepertory/src/utils/tasks.cpp

@@ -22,6 +22,7 @@
 #include "utils/tasks.hpp"
 
 #include "app_config.hpp"
+#include "utils/error_utils.hpp"
 
 namespace repertory {
 tasks tasks::instance_;

repertory/librepertory/src/utils/utils.cpp

@@ -24,6 +24,7 @@
 #include "app_config.hpp"
 #include "types/startup_exception.hpp"
 #include "utils/common.hpp"
+#include "utils/error_utils.hpp"
 #include "utils/file.hpp"
 #include "utils/path.hpp"
 #include "utils/string.hpp"
@@ -50,8 +51,8 @@ void calculate_allocation_size(bool directory, std::uint64_t file_size,
 auto create_rocksdb(
     const app_config &cfg, const std::string &name,
     const std::vector<rocksdb::ColumnFamilyDescriptor> &families,
-    std::vector<rocksdb::ColumnFamilyHandle *> &handles, bool clear)
-    -> std::unique_ptr<rocksdb::TransactionDB> {
+    std::vector<rocksdb::ColumnFamilyHandle *> &handles,
+    bool clear) -> std::unique_ptr<rocksdb::TransactionDB> {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto db_dir = utils::path::combine(cfg.get_data_directory(), {"db"});