Address compiler warnings #10

src/file_manager/file_manager_open_file.cpp

@@ -35,29 +35,30 @@ namespace repertory {
 file_manager::open_file::open_file(std::uint64_t chunk_size,
                                    std::uint8_t chunk_timeout,
                                    filesystem_item fsi, i_provider &provider,
-                                   i_upload_manager &um)
+                                   i_upload_manager &mgr)
     : open_file(chunk_size, chunk_timeout, fsi, {}, provider, std::nullopt,
-                um) {}
+                mgr) {}
 
 file_manager::open_file::open_file(
     std::uint64_t chunk_size, std::uint8_t chunk_timeout, filesystem_item fsi,
     std::map<std::uint64_t, open_file_data> open_data, i_provider &provider,
-    i_upload_manager &um)
+    i_upload_manager &mgr)
     : open_file(chunk_size, chunk_timeout, fsi, open_data, provider,
-                std::nullopt, um) {}
+                std::nullopt, mgr) {}
 
 file_manager::open_file::open_file(
     std::uint64_t chunk_size, std::uint8_t chunk_timeout, filesystem_item fsi,
     i_provider &provider, std::optional<boost::dynamic_bitset<>> read_state,
-    i_upload_manager &um)
-    : open_file(chunk_size, chunk_timeout, fsi, {}, provider, read_state, um) {}
+    i_upload_manager &mgr)
+    : open_file(chunk_size, chunk_timeout, fsi, {}, provider, read_state, mgr) {
+}
 
 file_manager::open_file::open_file(
     std::uint64_t chunk_size, std::uint8_t chunk_timeout, filesystem_item fsi,
     std::map<std::uint64_t, open_file_data> open_data, i_provider &provider,
-    std::optional<boost::dynamic_bitset<>> read_state, i_upload_manager &um)
+    std::optional<boost::dynamic_bitset<>> read_state, i_upload_manager &mgr)
     : open_file_base(chunk_size, chunk_timeout, fsi, open_data, provider),
-      um_(um) {
+      mgr_(mgr) {
   if (fsi_.directory && read_state.has_value()) {
     throw startup_exception("cannot resume a directory|" + fsi.api_path);
   }
@@ -68,9 +69,9 @@ file_manager::open_file::open_file(
     if (get_api_error() == api_error::success) {
       if (read_state.has_value()) {
         modified_ = true;
-        um_.store_resume(*this);
+        mgr_.store_resume(*this);
         read_state_ = read_state.value();
-      } else if (fsi_.size > 0u) {
+      } else if (fsi_.size > 0U) {
         read_state_.resize(static_cast<std::size_t>(utils::divide_with_ceiling(
                                fsi_.size, chunk_size)),
                            false);
@@ -78,7 +79,7 @@ file_manager::open_file::open_file(
         std::uint64_t file_size{};
         if (nf_->get_file_size(file_size)) {
           if (provider_.is_direct_only() || file_size == fsi.size) {
-            read_state_.set(0u, read_state_.size(), true);
+            read_state_.set(0U, read_state_.size(), true);
           } else if (not nf_->truncate(fsi.size)) {
             set_api_error(api_error::os_error);
           }
@@ -119,8 +120,8 @@ void file_manager::open_file::download_chunk(std::size_t chunk,
 
     const auto data_offset = chunk * chunk_size_;
     const auto data_size =
-        (chunk == read_state_.size() - 1u) ? last_chunk_size_ : chunk_size_;
-    if (active_downloads_.empty() && (read_state_.count() == 0u)) {
+        (chunk == read_state_.size() - 1U) ? last_chunk_size_ : chunk_size_;
+    if (active_downloads_.empty() && (read_state_.count() == 0U)) {
       event_system::instance().raise<download_begin>(fsi_.api_path,
                                                      fsi_.source_path);
     }
@@ -237,19 +238,19 @@ auto file_manager::open_file::is_complete() const -> bool {
 }
 
 auto file_manager::open_file::native_operation(
-    const i_open_file::native_operation_callback &operation) -> api_error {
+    const i_open_file::native_operation_callback &callback) -> api_error {
   unique_recur_mutex_lock file_lock(file_mtx_);
   if (stop_requested_) {
     return api_error::download_stopped;
   }
   file_lock.unlock();
 
-  return do_io([&]() -> api_error { return operation(nf_->get_handle()); });
+  return do_io([&]() -> api_error { return callback(nf_->get_handle()); });
 }
 
 auto file_manager::open_file::native_operation(
     std::uint64_t new_file_size,
-    const i_open_file::native_operation_callback &operation) -> api_error {
+    const i_open_file::native_operation_callback &callback) -> api_error {
   if (fsi_.directory) {
     return api_error::invalid_operation;
   }
@@ -260,17 +261,17 @@ auto file_manager::open_file::native_operation(
   }
   file_lock.unlock();
 
-  const auto is_empty_file = new_file_size == 0u;
+  const auto is_empty_file = new_file_size == 0U;
   const auto last_chunk =
-      is_empty_file ? std::size_t(0u)
+      is_empty_file ? std::size_t(0U)
                     : static_cast<std::size_t>(utils::divide_with_ceiling(
                           new_file_size, chunk_size_)) -
-                          1u;
+                          1U;
 
   file_lock.lock();
   if (not is_empty_file && (last_chunk < read_state_.size())) {
     file_lock.unlock();
-    update_background_reader(0u);
+    update_background_reader(0U);
 
     download_chunk(last_chunk, false, true);
     if (get_api_error() != api_error::success) {
@@ -281,7 +282,7 @@ auto file_manager::open_file::native_operation(
 
   const auto original_file_size = get_file_size();
 
-  auto res = do_io([&]() -> api_error { return operation(nf_->get_handle()); });
+  auto res = do_io([&]() -> api_error { return callback(nf_->get_handle()); });
   if (res != api_error::success) {
     utils::error::raise_api_path_error(__FUNCTION__, get_api_path(),
                                        utils::get_last_error_code(),
@@ -308,25 +309,25 @@ auto file_manager::open_file::native_operation(
     }
   }
 
-  if (is_empty_file || (read_state_.size() != (last_chunk + 1u))) {
-    read_state_.resize(is_empty_file ? 0u : last_chunk + 1u);
+  if (is_empty_file || (read_state_.size() != (last_chunk + 1U))) {
+    read_state_.resize(is_empty_file ? 0U : last_chunk + 1U);
 
     if (not is_empty_file) {
       read_state_[last_chunk] = true;
     }
 
     last_chunk_size_ = static_cast<std::size_t>(
-        new_file_size <= chunk_size_  ? new_file_size
-        : new_file_size % chunk_size_ ? new_file_size % chunk_size_
-                                      : chunk_size_);
+        new_file_size <= chunk_size_          ? new_file_size
+        : (new_file_size % chunk_size_) == 0U ? chunk_size_
+                                              : new_file_size % chunk_size_);
   }
 
   if (original_file_size != new_file_size) {
     if (not modified_) {
-      um_.store_resume(*this);
+      mgr_.store_resume(*this);
     }
     modified_ = true;
-    um_.remove_upload(get_api_path());
+    mgr_.remove_upload(get_api_path());
 
     fsi_.size = new_file_size;
     const auto now = std::to_string(utils::get_file_time_now());
@@ -356,7 +357,7 @@ auto file_manager::open_file::read(std::size_t read_size,
 
   read_size =
       utils::calculate_read_size(get_file_size(), read_size, read_offset);
-  if (read_size == 0u) {
+  if (read_size == 0U) {
     return api_error::success;
   }
 
@@ -405,7 +406,7 @@ void file_manager::open_file::remove(std::uint64_t handle) {
   open_file_base::remove(handle);
   if (modified_ && read_state_.all() &&
       (get_api_error() == api_error::success)) {
-    um_.queue_upload(*this);
+    mgr_.queue_upload(*this);
     modified_ = false;
   }
 }
@@ -443,7 +444,7 @@ auto file_manager::open_file::close() -> bool {
             err == api_error::download_stopped) {
           if (modified_ && not read_state_.all()) {
             set_api_error(api_error::download_incomplete);
-          } else if (not modified_ && (fsi_.size > 0u) &&
+          } else if (not modified_ && (fsi_.size > 0U) &&
                      not read_state_.all()) {
             set_api_error(api_error::download_stopped);
           }
@@ -454,12 +455,12 @@ auto file_manager::open_file::close() -> bool {
       nf_.reset();
 
       if (modified_ && (get_api_error() == api_error::success)) {
-        um_.queue_upload(*this);
+        mgr_.queue_upload(*this);
       } else if (modified_ &&
                  (get_api_error() == api_error::download_incomplete)) {
-        um_.store_resume(*this);
+        mgr_.store_resume(*this);
       } else if (get_api_error() != api_error::success) {
-        um_.remove_resume(get_api_path(), get_source_path());
+        mgr_.remove_resume(get_api_path(), get_source_path());
         if (not utils::file::retry_delete_file(fsi_.source_path)) {
           utils::error::raise_api_path_error(
               __FUNCTION__, get_api_path(), fsi_.source_path,
@@ -494,7 +495,7 @@ void file_manager::open_file::update_background_reader(std::size_t read_chunk) {
       std::size_t next_chunk{};
       while (not stop_requested_) {
         unique_recur_mutex_lock file_lock(file_mtx_);
-        if ((fsi_.size == 0u) || read_state_.all()) {
+        if ((fsi_.size == 0U) || read_state_.all()) {
           file_lock.unlock();
 
           unique_mutex_lock io_lock(io_thread_mtx_);
@@ -506,10 +507,10 @@ void file_manager::open_file::update_background_reader(std::size_t read_chunk) {
         } else {
           do {
             next_chunk = read_chunk_index_ =
-                ((read_chunk_index_ + 1u) >= read_state_.size())
-                    ? 0u
-                    : read_chunk_index_ + 1u;
-          } while ((next_chunk != 0u) && (active_downloads_.find(next_chunk) !=
+                ((read_chunk_index_ + 1U) >= read_state_.size())
+                    ? 0U
+                    : read_chunk_index_ + 1U;
+          } while ((next_chunk != 0U) && (active_downloads_.find(next_chunk) !=
                                           active_downloads_.end()));
 
           file_lock.unlock();
@@ -523,7 +524,7 @@ void file_manager::open_file::update_background_reader(std::size_t read_chunk) {
 auto file_manager::open_file::write(std::uint64_t write_offset,
                                     const data_buffer &data,
                                     std::size_t &bytes_written) -> api_error {
-  bytes_written = 0u;
+  bytes_written = 0U;
 
   if (fsi_.directory || provider_.is_direct_only()) {
     return api_error::invalid_operation;
@@ -547,7 +548,7 @@ auto file_manager::open_file::write(std::uint64_t write_offset,
   update_background_reader(start_chunk_index);
 
   download_range(start_chunk_index,
-                 std::min(read_state_.size() - 1u, end_chunk_index), true);
+                 std::min(read_state_.size() - 1U, end_chunk_index), true);
   if (get_api_error() != api_error::success) {
     return get_api_error();
   }
@@ -586,10 +587,10 @@ auto file_manager::open_file::write(std::uint64_t write_offset,
   }
 
   if (not modified_) {
-    um_.store_resume(*this);
+    mgr_.store_resume(*this);
   }
   modified_ = true;
-  um_.remove_upload(get_api_path());
+  mgr_.remove_upload(get_api_path());
 
   return api_error::success;
 }

src/file_manager/file_manager_open_file_base.cpp

@@ -37,9 +37,9 @@ file_manager::open_file_base::open_file_base(
       chunk_timeout_(chunk_timeout),
       fsi_(std::move(fsi)),
       last_chunk_size_(static_cast<std::size_t>(
-          fsi.size <= chunk_size  ? fsi.size
-          : fsi.size % chunk_size ? fsi.size % chunk_size
-                                  : chunk_size)),
+          fsi.size <= chunk_size          ? fsi.size
+          : (fsi.size % chunk_size) == 0U ? chunk_size
+                                          : fsi.size % chunk_size)),
       open_data_(std::move(open_data)),
       provider_(provider) {
   if (not fsi.directory) {
@@ -51,7 +51,7 @@ void file_manager::open_file_base::add(std::uint64_t handle,
                                        open_file_data ofd) {
   recur_mutex_lock file_lock(file_mtx_);
   open_data_[handle] = ofd;
-  if (open_data_.size() == 1u) {
+  if (open_data_.size() == 1U) {
     event_system::instance().raise<filesystem_item_opened>(
         fsi_.api_path, fsi_.source_path, fsi_.directory);
   }
@@ -157,8 +157,8 @@ auto file_manager::open_file_base::get_handles() const
     -> std::vector<std::uint64_t> {
   recur_mutex_lock file_lock(file_mtx_);
   std::vector<std::uint64_t> ret;
-  for (const auto &kv : open_data_) {
-    ret.emplace_back(kv.first);
+  for (const auto &item : open_data_) {
+    ret.emplace_back(item.first);
   }
 
   return ret;
@@ -201,14 +201,14 @@ void file_manager::open_file_base::reset_timeout() {
   last_access_ = std::chrono::system_clock::now();
 }
 
-auto file_manager::open_file_base::set_api_error(const api_error &e)
+auto file_manager::open_file_base::set_api_error(const api_error &err)
     -> api_error {
   mutex_lock error_lock(error_mtx_);
-  if (error_ != e) {
+  if (error_ != err) {
     return ((error_ = (error_ == api_error::success ||
                                error_ == api_error::download_incomplete ||
                                error_ == api_error::download_stopped
-                           ? e
+                           ? err
                            : error_)));
   }
 

src/file_manager/file_manager_ring_buffer_open_file.cpp

@@ -37,7 +37,7 @@ file_manager::ring_buffer_open_file::ring_buffer_open_file(
     std::uint8_t chunk_timeout, filesystem_item fsi, i_provider &provider)
     : ring_buffer_open_file(std::move(buffer_directory), chunk_size,
                             chunk_timeout, std::move(fsi), provider,
-                            (1024ull * 1024ull * 1024ull) / chunk_size) {}
+                            (1024ULL * 1024ULL * 1024ULL) / chunk_size) {}
 
 file_manager::ring_buffer_open_file::ring_buffer_open_file(
     std::string buffer_directory, std::uint64_t chunk_size,
@@ -47,11 +47,11 @@ file_manager::ring_buffer_open_file::ring_buffer_open_file(
       ring_state_(ring_size),
       total_chunks_(static_cast<std::size_t>(
           utils::divide_with_ceiling(fsi.size, chunk_size_))) {
-  if (ring_size % 2u) {
+  if ((ring_size % 2U) != 0U) {
     throw std::runtime_error("ring size must be a multiple of 2");
   }
 
-  if (ring_size < 4u) {
+  if (ring_size < 4U) {
     throw std::runtime_error("ring size must be greater than or equal to 4");
   }
 
@@ -59,8 +59,8 @@ file_manager::ring_buffer_open_file::ring_buffer_open_file(
     throw std::runtime_error("file size is less than ring buffer size");
   }
 
-  last_chunk_ = ring_state_.size() - 1u;
-  ring_state_.set(0u, ring_state_.size(), true);
+  last_chunk_ = ring_state_.size() - 1U;
+  ring_state_.set(0U, ring_state_.size(), true);
 
   buffer_directory = utils::path::absolute(buffer_directory);
   if (not utils::file::create_full_directory_path(buffer_directory)) {
@@ -113,7 +113,7 @@ auto file_manager::file_manager::ring_buffer_open_file::download_chunk(
     chunk_notify_.notify_all();
     chunk_lock.unlock();
 
-    data_buffer buffer((chunk == (total_chunks_ - 1u)) ? last_chunk_size_
+    data_buffer buffer((chunk == (total_chunks_ - 1U)) ? last_chunk_size_
                                                        : chunk_size_);
 
     stop_type stop_requested = !!ring_state_[chunk % ring_state_.size()];
@@ -149,8 +149,8 @@ auto file_manager::file_manager::ring_buffer_open_file::download_chunk(
 
 void file_manager::ring_buffer_open_file::forward(std::size_t count) {
   mutex_lock chunk_lock(chunk_mtx_);
-  if ((current_chunk_ + count) > (total_chunks_ - 1u)) {
-    count = (total_chunks_ - 1u) - current_chunk_;
+  if ((current_chunk_ + count) > (total_chunks_ - 1U)) {
+    count = (total_chunks_ - 1U) - current_chunk_;
   }
 
   if ((current_chunk_ + count) <= last_chunk_) {
@@ -158,19 +158,19 @@ void file_manager::ring_buffer_open_file::forward(std::size_t count) {
   } else {
     const auto added = count - (last_chunk_ - current_chunk_);
     if (added >= ring_state_.size()) {
-      ring_state_.set(0u, ring_state_.size(), true);
+      ring_state_.set(0U, ring_state_.size(), true);
       current_chunk_ += count;
       first_chunk_ += added;
       last_chunk_ =
-          std::min(total_chunks_ - 1u, first_chunk_ + ring_state_.size() - 1u);
+          std::min(total_chunks_ - 1U, first_chunk_ + ring_state_.size() - 1U);
     } else {
-      for (std::size_t i = 0u; i < added; i++) {
+      for (std::size_t i = 0U; i < added; i++) {
         ring_state_[(first_chunk_ + i) % ring_state_.size()] = true;
       }
       first_chunk_ += added;
       current_chunk_ += count;
       last_chunk_ =
-          std::min(total_chunks_ - 1u, first_chunk_ + ring_state_.size() - 1u);
+          std::min(total_chunks_ - 1U, first_chunk_ + ring_state_.size() - 1U);
     }
   }
 
@@ -195,8 +195,8 @@ auto file_manager::ring_buffer_open_file::is_download_complete() const -> bool {
 }
 
 auto file_manager::ring_buffer_open_file::native_operation(
-    const i_open_file::native_operation_callback &operation) -> api_error {
-  return do_io([&]() -> api_error { return operation(nf_->get_handle()); });
+    const i_open_file::native_operation_callback &callback) -> api_error {
+  return do_io([&]() -> api_error { return callback(nf_->get_handle()); });
 }
 
 void file_manager::ring_buffer_open_file::reverse(std::size_t count) {
@@ -210,19 +210,19 @@ void file_manager::ring_buffer_open_file::reverse(std::size_t count) {
   } else {
     const auto removed = count - (current_chunk_ - first_chunk_);
     if (removed >= ring_state_.size()) {
-      ring_state_.set(0u, ring_state_.size(), true);
+      ring_state_.set(0U, ring_state_.size(), true);
       current_chunk_ -= count;
       first_chunk_ = current_chunk_;
       last_chunk_ =
-          std::min(total_chunks_ - 1u, first_chunk_ + ring_state_.size() - 1u);
+          std::min(total_chunks_ - 1U, first_chunk_ + ring_state_.size() - 1U);
     } else {
-      for (std::size_t i = 0u; i < removed; i++) {
+      for (std::size_t i = 0U; i < removed; i++) {
         ring_state_[(last_chunk_ - i) % ring_state_.size()] = true;
       }
       first_chunk_ -= removed;
       current_chunk_ -= count;
       last_chunk_ =
-          std::min(total_chunks_ - 1u, first_chunk_ + ring_state_.size() - 1u);
+          std::min(total_chunks_ - 1U, first_chunk_ + ring_state_.size() - 1U);
     }
   }
 
@@ -239,7 +239,7 @@ auto file_manager::ring_buffer_open_file::read(std::size_t read_size,
   reset_timeout();
 
   read_size = utils::calculate_read_size(fsi_.size, read_size, read_offset);
-  if (read_size == 0u) {
+  if (read_size == 0U) {
     return api_error::success;
   }
 
@@ -250,7 +250,7 @@ auto file_manager::ring_buffer_open_file::read(std::size_t read_size,
 
   auto res = api_error::success;
   for (std::size_t chunk = start_chunk_index;
-       (res == api_error::success) && (read_size > 0u); chunk++) {
+       (res == api_error::success) && (read_size > 0U); chunk++) {
     if (chunk > current_chunk_) {
       forward(chunk - current_chunk_);
     } else if (chunk < current_chunk_) {
@@ -277,7 +277,7 @@ auto file_manager::ring_buffer_open_file::read(std::size_t read_size,
 
         return ret;
       });
-      read_offset = 0u;
+      read_offset = 0U;
       read_size -= to_read;
     }
   }
@@ -294,7 +294,7 @@ void file_manager::ring_buffer_open_file::set(std::size_t first_chunk,
   }
 
   first_chunk_ = first_chunk;
-  last_chunk_ = first_chunk_ + ring_state_.size() - 1u;
+  last_chunk_ = first_chunk_ + ring_state_.size() - 1U;
 
   if (current_chunk > last_chunk_) {
     chunk_notify_.notify_all();
@@ -303,7 +303,7 @@ void file_manager::ring_buffer_open_file::set(std::size_t first_chunk,
   }
 
   current_chunk_ = current_chunk;
-  ring_state_.set(0u, ring_state_.size(), false);
+  ring_state_.set(0U, ring_state_.size(), false);
 
   chunk_notify_.notify_all();
 }