Clang-Tidy And cppcheck For Fedora43 Including Header Linting

.clang-tidy

@@ -38,8 +38,14 @@ Checks: '*,
 -cppcoreguidelines-avoid-do-while,
 -llvmlibc-inline-function-decl,
 -altera-struct-pack-align,
--boost-use-ranges
+-boost-use-ranges,
+-cppcoreguidelines-special-member-functions,
+-hicpp-special-member-functions,
+-misc-header-include-cycle,
+-cppcoreguidelines-avoid-const-or-ref-data-members,
+-google-explicit-constructor,
+-hicpp-explicit-conversions
 '
 WarningsAsErrors: '*'
-HeaderFilterRegex: 'src\/*.hpp'
+HeaderFilterRegex: 'include\/cpr\/.*\.h(pp)?'
 FormatStyle: file

cppcheck-suppressions.xml

@@ -39,4 +39,8 @@
     <suppress>
         <id>postfixOperator</id>
     </suppress>
+    <suppress>
+        <id>syntaxError</id>
+        <fileName>*/cpr/util.cpp</fileName>
+    </suppress>
 </suppressions>

cpr/async.cpp

@@ -3,6 +3,6 @@
 namespace cpr {
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-CPR_SINGLETON_IMPL(GlobalThreadPool)
+CPR_SINGLETON_IMPL(GlobalThreadPool);
 
 } // namespace cpr

cpr/callback.cpp

@@ -3,12 +3,12 @@
 #include <functional>
 
 namespace cpr {
-
 void CancellationCallback::SetProgressCallback(ProgressCallback& u_cb) {
     user_cb.emplace(std::reference_wrapper{u_cb});
 }
+
 bool CancellationCallback::operator()(cpr_pf_arg_t dltotal, cpr_pf_arg_t dlnow, cpr_pf_arg_t ultotal, cpr_pf_arg_t ulnow) const {
-    const bool cont_operation{!cancellation_state->load()};
-    return user_cb ? (cont_operation && (*user_cb)(dltotal, dlnow, ultotal, ulnow)) : cont_operation;
+    const bool const_operation = !(cancellation_state->load());
+    return user_cb ? (const_operation && (*user_cb)(dltotal, dlnow, ultotal, ulnow)) : const_operation;
 }
 } // namespace cpr

cpr/connection_pool.cpp

@@ -7,33 +7,32 @@ namespace cpr {
 ConnectionPool::ConnectionPool() {
     CURLSH* curl_share = curl_share_init();
     this->connection_mutex_ = std::make_shared<std::mutex>();
-    
+
     auto lock_f = +[](CURL* /*handle*/, curl_lock_data /*data*/, curl_lock_access /*access*/, void* userptr) {
         std::mutex* lock = static_cast<std::mutex*>(userptr);
         lock->lock(); // cppcheck-suppress localMutex  // False positive: mutex is used as callback for libcurl, not local scope
     };
-    
+
     auto unlock_f = +[](CURL* /*handle*/, curl_lock_data /*data*/, void* userptr) {
         std::mutex* lock = static_cast<std::mutex*>(userptr);
         lock->unlock();
     };
-    
+
     curl_share_setopt(curl_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
     curl_share_setopt(curl_share, CURLSHOPT_USERDATA, this->connection_mutex_.get());
     curl_share_setopt(curl_share, CURLSHOPT_LOCKFUNC, lock_f);
     curl_share_setopt(curl_share, CURLSHOPT_UNLOCKFUNC, unlock_f);
-
-    this->curl_sh_ = std::shared_ptr<CURLSH>(curl_share, 
-        [](CURLSH* ptr) { 
-            // Make sure to reset callbacks before cleanup to avoid deadlocks
-            curl_share_setopt(ptr, CURLSHOPT_LOCKFUNC, nullptr);
-            curl_share_setopt(ptr, CURLSHOPT_UNLOCKFUNC, nullptr);
-            curl_share_cleanup(ptr); 
-        });
+
+    this->curl_sh_ = std::shared_ptr<CURLSH>(curl_share, [](CURLSH* ptr) {
+        // Make sure to reset callbacks before cleanup to avoid deadlocks
+        curl_share_setopt(ptr, CURLSHOPT_LOCKFUNC, nullptr);
+        curl_share_setopt(ptr, CURLSHOPT_UNLOCKFUNC, nullptr);
+        curl_share_cleanup(ptr);
+    });
 }
 
 void ConnectionPool::SetupHandler(CURL* easy_handler) const {
     curl_easy_setopt(easy_handler, CURLOPT_SHARE, this->curl_sh_.get());
 }
 
-} // namespace cpr 
+} // namespace cpr

cpr/cprtypes.cpp

@@ -1,9 +1,9 @@
 #include "cpr/cprtypes.h"
-
 #include <algorithm>
 #include <cctype>
 #include <string>
 
+
 namespace cpr {
 bool CaseInsensitiveCompare::operator()(const std::string& a, const std::string& b) const noexcept {
     return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), [](unsigned char ac, unsigned char bc) { return std::tolower(ac) < std::tolower(bc); });

cpr/curlholder.cpp

@@ -22,7 +22,7 @@ CurlHolder::CurlHolder() {
     assert(handle);
 }
 
-CurlHolder::CurlHolder(CurlHolder&& old) noexcept : handle(old.handle), chunk(old.chunk), resolveCurlList(old.resolveCurlList), multipart(old.multipart), error(std::move(old.error)) {
+CurlHolder::CurlHolder(CurlHolder&& old) noexcept : handle(old.handle), chunk(old.chunk), resolveCurlList(old.resolveCurlList), multipart(old.multipart), error(old.error) {
     // Avoid double free
     old.handle = nullptr;
     old.chunk = nullptr;
@@ -49,7 +49,7 @@ CurlHolder& CurlHolder::operator=(CurlHolder&& old) noexcept {
     chunk = old.chunk;
     resolveCurlList = old.resolveCurlList;
     multipart = old.multipart;
-    error = std::move(old.error);
+    error = old.error;
 
     // Avoid double free
     old.handle = nullptr;