Allow to build with clang-tidy and clang-tidy fixes

Author: durner

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.10)
 
 project(AnyBlob)
 
@@ -55,6 +55,13 @@ if (ANYBLOB_LIBCXX_COMPAT)
     set(CMAKE_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_COVERAGE} -stdlib=libc++")
 endif()
 
+# Allow enabling clang-tidy
+option(ANYBLOB_CLANG_TIDY "enable clang-tidy" OFF)
+if(ANYBLOB_CLANG_TIDY)
+    find_program(ANYBLOB_CLANG_TIDY_BINARY "clang-tidy" REQUIRED)
+    set(CMAKE_CXX_CLANG_TIDY "${ANYBLOB_CLANG_TIDY_BINARY}")
+endif()
+
 # ---------------------------------------------------------------------------
 # Coverage Environment
 # ---------------------------------------------------------------------------

include/cloud/ibm.hpp

@@ -18,20 +18,23 @@ namespace cloud {
 //---------------------------------------------------------------------------
 /// Implements the IBM logic using the AWS S3 compatibility API
 class IBM : public AWS {
+    /// Get the address of the server
+    [[nodiscard]] std::string getAddressImpl() const;
+
     public:
     /// The constructor
     explicit IBM(const RemoteInfo& info) : AWS(info) {
         assert(info.provider == Provider::CloudService::IBM);
         // COS requires path-style bucket URLs - similar to MinIO, thus we use the endpoint setting
-        _settings.endpoint = getAddress();
+        _settings.endpoint = getAddressImpl();
     }
     /// The custom endpoint constructor
     IBM(const RemoteInfo& info, const std::string& keyId, const std::string& key) : AWS(info, keyId, key) {
         // COS requires path-style bucket URLs - similar to MinIO, thus we use the endpoint setting
-        _settings.endpoint = getAddress();
+        _settings.endpoint = getAddressImpl();
     }
     /// Get the address of the server
-    [[nodiscard]] std::string getAddress() const override;
+    [[nodiscard]] std::string getAddress() const override { return getAddressImpl(); }
     /// Get the instance details
     [[nodiscard]] Provider::Instance getInstanceDetails(network::TaskedSendReceiverHandle& sendReceiver) override;
 

include/network/tasked_send_receiver.hpp

@@ -175,7 +175,7 @@ class TaskedSendReceiverHandle {
     /// Default constructor is deleted
     TaskedSendReceiverHandle() = delete;
     /// Consturctor
-    explicit TaskedSendReceiverHandle(TaskedSendReceiverGroup* group);
+    explicit TaskedSendReceiverHandle(TaskedSendReceiverGroup* group, TaskedSendReceiver* _sendReceiver);
     /// Delete copy
     TaskedSendReceiverHandle(TaskedSendReceiverHandle& other) = delete;
     /// Delete copy assignment
@@ -186,9 +186,9 @@ class TaskedSendReceiverHandle {
 
     public:
     /// Move constructor
-    TaskedSendReceiverHandle(TaskedSendReceiverHandle&& other);
+    TaskedSendReceiverHandle(TaskedSendReceiverHandle&& other) noexcept;
     /// Move assignment
-    TaskedSendReceiverHandle& operator=(TaskedSendReceiverHandle&& other);
+    TaskedSendReceiverHandle& operator=(TaskedSendReceiverHandle&& other) noexcept;
     /// Destructor
     ~TaskedSendReceiverHandle();
 

include/utils/timer.hpp

@@ -93,7 +93,7 @@ class Timer {
     /// Default copy constructor
     Timer(const Timer&) = default;
     /// Move Assignment - Timer and Merge
-    Timer& operator=(Timer&& rhs);
+    Timer& operator=(Timer&& rhs) noexcept;
     /// Destructor
     ~Timer() {
         if (_outStream)

src/cloud/aws.cpp

@@ -110,7 +110,7 @@ unique_ptr<utils::DataVector<uint8_t>> AWS::downloadIAMUser() const
 unique_ptr<utils::DataVector<uint8_t>> AWS::downloadSecret(string_view content, string& iamUser)
 // Builds the secret http request
 {
-    auto pos = content.find("\n");
+    auto pos = content.find('\n');
     string httpHeader = "GET /latest/meta-data/iam/security-credentials/";
     if (!content.substr(0, pos).size())
         return nullptr;
@@ -132,31 +132,31 @@ bool AWS::updateSecret(string_view content, string_view iamUser)
     if (pos == content.npos)
         return false;
     pos += needle.length();
-    auto end = content.find("\"", pos);
+    auto end = content.find('\"', pos);
     secret->keyId = content.substr(pos, end - pos);
 
     needle = "\"SecretAccessKey\" : \"";
     pos = content.find(needle);
     if (pos == content.npos)
         return false;
     pos += needle.length();
-    end = content.find("\"", pos);
+    end = content.find('\"', pos);
     secret->secret = content.substr(pos, end - pos);
 
     needle = "\"Token\" : \"";
     pos = content.find(needle);
     if (pos == content.npos)
         return false;
     pos += needle.length();
-    end = content.find("\"", pos);
+    end = content.find('\"', pos);
     secret->token = content.substr(pos, end - pos);
 
     needle = "\"Expiration\" : \"";
     pos = content.find(needle);
     if (pos == content.npos)
         return false;
     pos += needle.length();
-    end = content.find("\"", pos);
+    end = content.find('\"', pos);
     auto sv = content.substr(pos, end - pos);
     string timestamp(sv.begin(), sv.end());
     secret->expiration = convertIAMTimestamp(timestamp);

src/cloud/azure.cpp

@@ -67,7 +67,7 @@ Provider::Instance Azure::getInstanceDetails(network::TaskedSendReceiverHandle&
     auto pos = s.find(needle);
     if (pos != s.npos) {
         pos += needle.length();
-        auto end = s.find("\"", pos);
+        auto end = s.find('\"', pos);
         auto vmType = s.substr(pos, end - pos);
 
         for (auto& instance : AzureInstance::getInstanceDetails())
@@ -98,7 +98,7 @@ string Azure::getRegion(network::TaskedSendReceiverHandle& sendReceiverHandle)
     if (pos == s.npos)
         throw runtime_error("Azure Region: No location found.");
     pos += needle.length();
-    auto end = s.find("\"", pos);
+    auto end = s.find('\"', pos);
     auto region = s.substr(pos, end - pos);
 
     return string(region);

src/cloud/ibm.cpp

@@ -20,7 +20,7 @@ Provider::Instance IBM::getInstanceDetails(network::TaskedSendReceiverHandle& /*
     return IBMInstance{"ibm", 0, 0, 0};
 }
 //---------------------------------------------------------------------------
-string IBM::getAddress() const
+string IBM::getAddressImpl() const
 // Gets the address of IBM COS
 {
     return "s3." + _settings.region + ".cloud-object-storage.appdomain.cloud";

src/cloud/provider.cpp

@@ -109,7 +109,7 @@ string Provider::getETag(string_view header)
     if (pos == header.npos)
         return "";
     pos += needle.length();
-    auto end = header.find("\"", pos);
+    auto end = header.find('\"', pos);
     return string(header.substr(pos, end - pos));
 }
 //---------------------------------------------------------------------------
@@ -209,6 +209,7 @@ unique_ptr<Provider> Provider::makeProvider(const string& filepath, bool https,
 
             if (keyId.empty()) {
                 auto aws = make_unique<anyblob::cloud::AWS>(info);
+                assert(sendReceiverHandle);
                 aws->initSecret(*sendReceiverHandle);
                 return aws;
             }

src/network/http_request.cpp

@@ -67,7 +67,7 @@ HttpRequest HttpRequest::deserialize(string_view data)
             }
 
             // parse path, requires HTTP type, otherwise invalid
-            pos = line.find(" ", 1);
+            pos = line.find(' ', 1);
             if (pos == line.npos)
                 throw runtime_error("Invalid HttpRequest: Could not find path, or missing HTTP type!");
             auto pathQuery = line.substr(1, pos - 1);

src/network/tasked_send_receiver.cpp

@@ -54,15 +54,11 @@ TaskedSendReceiverHandle TaskedSendReceiverGroup::getHandle()
 {
     auto result = _sendReceiverCache.consume();
     if (result.has_value()) {
-        TaskedSendReceiverHandle handle(this);
-        handle._sendReceiver = result.value();
-        return handle;
+        return TaskedSendReceiverHandle(this, result.value());
     }
     lock_guard<mutex> lg(_resizeMutex);
     auto& ref = _sendReceivers.emplace_back(unique_ptr<TaskedSendReceiver>(new TaskedSendReceiver(*this)));
-    TaskedSendReceiverHandle handle(this);
-    handle._sendReceiver = ref.get();
-    return handle;
+    return TaskedSendReceiverHandle(this, ref.get());
 }
 //---------------------------------------------------------------------------
 void TaskedSendReceiverGroup::process(bool oneQueueInvocation)
@@ -72,20 +68,20 @@ void TaskedSendReceiverGroup::process(bool oneQueueInvocation)
     handle.process(oneQueueInvocation);
 }
 //---------------------------------------------------------------------------
-TaskedSendReceiverHandle::TaskedSendReceiverHandle(TaskedSendReceiverGroup* group) : _group(group)
+TaskedSendReceiverHandle::TaskedSendReceiverHandle(TaskedSendReceiverGroup* group, TaskedSendReceiver* sendReceiver) : _group(group), _sendReceiver(sendReceiver)
 // The constructor
 {
 }
 //---------------------------------------------------------------------------
-TaskedSendReceiverHandle::TaskedSendReceiverHandle(TaskedSendReceiverHandle&& other)
+TaskedSendReceiverHandle::TaskedSendReceiverHandle(TaskedSendReceiverHandle&& other) noexcept
 // Move constructor
 {
     _group = other._group;
     _sendReceiver = other._sendReceiver;
     other._sendReceiver = nullptr;
 }
 //---------------------------------------------------------------------------
-TaskedSendReceiverHandle& TaskedSendReceiverHandle::operator=(TaskedSendReceiverHandle&& other)
+TaskedSendReceiverHandle& TaskedSendReceiverHandle::operator=(TaskedSendReceiverHandle&& other) noexcept
 // Move assignment
 {
     if (other._group == _group) {