Add clang-tidy config and associated fixes

.clang-format

@@ -105,6 +105,7 @@ PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Left
+QualifierAlignment: Left
 ReflowComments:  true
 SortIncludes:    true
 SortUsingDeclarations: true

.clang-tidy

@@ -0,0 +1,58 @@
+Checks: >
+    *,
+    bugprone-*,
+    cert-*,
+    concurrency-*,
+    cppcoreguidelines-*,
+    misc-*,
+    performance-*,
+    -abseil-*,
+    -altera-*,
+    -android-*,
+    -boost-*,
+    -fuchsia-*,
+    -google-*,
+    -hicpp-*,
+    -llvm-*,
+    -llvmlibc-*,
+    -zircon-*,
+    -bugprone-easily-swappable-parameters,
+    -cert-err60-cpp,
+    -cppcoreguidelines-non-private-member-variables-in-classes,
+    -cppcoreguidelines-use-default-member-init,
+    -misc-include-cleaner,
+    -misc-non-private-member-variables-in-classes,
+    -modernize-pass-by-value,
+    -modernize-use-trailing-return-type,
+    -modernize-use-default-member-init,
+    -modernize-return-braced-init-list,
+    -modernize-use-scoped-lock,
+    -modernize-concat-nested-namespaces,
+    -modernize-use-nodiscard,
+    -modernize-raw-string-literal,
+    -performance-avoid-endl,
+    -performance-enum-size,
+    -performance-unnecessary-value-param,
+    -readability-avoid-const-params-in-decls,
+    -readability-function-cognitive-complexity,
+    -readability-identifier-length,
+    -readability-magic-numbers,
+    -readability-qualified-auto,
+    -readability-simplify-boolean-expr,
+    -readability-use-anyofallof,
+    -readability-use-std-min-max,
+    -concurrency-mt-unsafe,
+    -portability-avoid-pragma-once,
+    -portability-template-virtual-member-function,
+    -cppcoreguidelines-avoid-const-or-ref-data-members,
+    -cppcoreguidelines-avoid-do-while,
+    -cppcoreguidelines-avoid-magic-numbers,
+    -cppcoreguidelines-macro-usage,
+    -cppcoreguidelines-special-member-functions,
+    -cppcoreguidelines-pro-type-vararg,
+    -cppcoreguidelines-pro-type-member-init,
+    -cert-err58-cpp,
+# (the last -cppcoreguidelines and -cert-err58-cpp lines are temporary)
+HeaderFilterRegex:  ".*"
+CheckOptions:
+  - { key: performance-unnecessary-value-param.AllowedTypes, value: ((std::shared_ptr)) }

.gitignore

@@ -1,4 +1,4 @@
-/build
+/build*
 !.gitignore
 *vscode
 .cache/
@@ -7,3 +7,5 @@ CMakeLists.txt.user
 __pycache__
 !doc/build-with-fetchcontent
 /dist
+clang-tidy-*.yaml
+clang-tidy-*.txt

3rd_party/websocketpp_utils/base64.hpp

@@ -33,14 +33,14 @@
 
 */
 
-#ifndef _BASE64_EVEREST_HPP_
-#define _BASE64_EVEREST_HPP_
+#ifndef BASE64_EVEREST_HPP_
+#define BASE64_EVEREST_HPP_
 
 #include <string>
 
 namespace ocpp {
 
-static std::string const base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                         "abcdefghijklmnopqrstuvwxyz"
                                         "0123456789+/";
 
@@ -62,14 +62,14 @@ static inline bool is_base64(unsigned char c) {
  * @param len The length of input in bytes
  * @return A base64 encoded string representing input
  */
-inline std::string base64_encode(unsigned char const* input, size_t len) {
+inline std::string base64_encode(const unsigned char* input, size_t len) {
     std::string ret;
     int i = 0;
     int j = 0;
     unsigned char char_array_3[3];
     unsigned char char_array_4[4];
 
-    while (len--) {
+    while ((len--) != 0) {
         char_array_3[i++] = *(input++);
         if (i == 3) {
             char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
@@ -84,7 +84,7 @@ inline std::string base64_encode(unsigned char const* input, size_t len) {
         }
     }
 
-    if (i) {
+    if (i != 0) {
         for (j = i; j < 3; j++) {
             char_array_3[j] = '\0';
         }
@@ -111,7 +111,7 @@ inline std::string base64_encode(unsigned char const* input, size_t len) {
  * @param input The input data
  * @return A base64 encoded string representing input
  */
-inline std::string base64_encode(std::string const& input) {
+inline std::string base64_encode(const std::string& input) {
     return base64_encode(reinterpret_cast<const unsigned char*>(input.data()), input.size());
 }
 
@@ -120,15 +120,16 @@ inline std::string base64_encode(std::string const& input) {
  * @param input The base64 encoded input data
  * @return A string representing the decoded raw bytes
  */
-inline std::string base64_decode(std::string const& input) {
+inline std::string base64_decode(const std::string& input) {
     size_t in_len = input.size();
     int i = 0;
     int j = 0;
     int in_ = 0;
-    unsigned char char_array_4[4], char_array_3[3];
+    unsigned char char_array_4[4];
+    unsigned char char_array_3[3];
     std::string ret;
 
-    while (in_len-- && (input[in_] != '=') && is_base64(input[in_])) {
+    while (((in_len--) != 0) && (input[in_] != '=') && is_base64(input[in_])) {
         char_array_4[i++] = input[in_];
         in_++;
         if (i == 4) {
@@ -147,12 +148,14 @@ inline std::string base64_decode(std::string const& input) {
         }
     }
 
-    if (i) {
-        for (j = i; j < 4; j++)
+    if (i != 0) {
+        for (j = i; j < 4; j++) {
             char_array_4[j] = 0;
+        }
 
-        for (j = 0; j < 4; j++)
+        for (j = 0; j < 4; j++) {
             char_array_4[j] = static_cast<unsigned char>(base64_chars.find(char_array_4[j]));
+        }
 
         char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
         char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
@@ -168,4 +171,4 @@ inline std::string base64_decode(std::string const& input) {
 
 } // namespace ocpp
 
-#endif // _BASE64_HPP_
+#endif // BASE64_EVEREST_HPP_

3rd_party/websocketpp_utils/uri.hpp

@@ -29,6 +29,7 @@
 #define WEBSOCKETPP_URI_EVEREST_HPP
 
 #include <algorithm>
+#include <cstdint>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -38,20 +39,20 @@ namespace ocpp {
 // TODO: figure out why this fixes horrible linking errors.
 
 /// Default port for ws://
-static uint16_t const uri_default_port = 80;
+static const uint16_t uri_default_port = 80;
 /// Default port for wss://
-static uint16_t const uri_default_secure_port = 443;
+static const uint16_t uri_default_secure_port = 443;
 
 class uri {
 public:
-    explicit uri(std::string const& uri_string) : m_valid(false) {
+    explicit uri(const std::string& uri_string) : m_valid(false) {
         std::string::const_iterator it;
         std::string::const_iterator temp;
 
         int state = 0;
 
         it = uri_string.begin();
-        size_t uri_len = uri_string.length();
+        const size_t uri_len = uri_string.length();
 
         if (uri_len >= 7 && std::equal(it, it + 6, "wss://")) {
             m_secure = true;
@@ -95,11 +96,11 @@ class uri {
 
             if (temp == uri_string.end()) {
                 return;
-            } else {
-                // validate IPv6 literal parts
-                // can contain numbers, a-f and A-F
-                m_host.append(it, temp);
             }
+            // validate IPv6 literal parts
+            // can contain numbers, a-f and A-F
+            m_host.append(it, temp);
+
             it = temp + 1;
             if (it == uri_string.end()) {
                 state = 2;
@@ -120,7 +121,8 @@ class uri {
                 if (it == uri_string.end()) {
                     state = 2;
                     break;
-                } else if (*it == '/') {
+                }
+                if (*it == '/') {
                     state = 2;
                 } else if (*it == ':') {
                     // end hostname start port
@@ -141,7 +143,8 @@ class uri {
                 // refactoring
                 // state = 3;
                 break;
-            } else if (*it == '/') {
+            }
+            if (*it == '/') {
                 state = 3;
             } else {
                 port += *it;
@@ -155,7 +158,7 @@ class uri {
         m_resource.append(it, uri_string.end());
     }
 
-    uri(bool secure, std::string const& host, uint16_t port, std::string const& resource) :
+    uri(bool secure, const std::string& host, uint16_t port, const std::string& resource) :
         m_scheme(secure ? "wss" : "ws"),
         m_host(host),
         m_resource(resource.empty() ? "/" : resource),
@@ -164,7 +167,7 @@ class uri {
         m_valid(true) {
     }
 
-    uri(bool secure, std::string const& host, std::string const& resource) :
+    uri(bool secure, const std::string& host, const std::string& resource) :
         m_scheme(secure ? "wss" : "ws"),
         m_host(host),
         m_resource(resource.empty() ? "/" : resource),
@@ -173,12 +176,12 @@ class uri {
         m_valid(true) {
     }
 
-    uri(bool secure, std::string const& host, std::string const& port, std::string const& resource) :
+    uri(bool secure, const std::string& host, const std::string& port, const std::string& resource) :
         m_scheme(secure ? "wss" : "ws"), m_host(host), m_resource(resource.empty() ? "/" : resource), m_secure(secure) {
         m_port = get_port_from_string(port, m_valid);
     }
 
-    uri(std::string const& scheme, std::string const& host, uint16_t port, std::string const& resource) :
+    uri(const std::string& scheme, const std::string& host, uint16_t port, const std::string& resource) :
         m_scheme(scheme),
         m_host(host),
         m_resource(resource.empty() ? "/" : resource),
@@ -187,7 +190,7 @@ class uri {
         m_valid(true) {
     }
 
-    uri(std::string scheme, std::string const& host, std::string const& resource) :
+    uri(std::string scheme, const std::string& host, const std::string& resource) :
         m_scheme(scheme),
         m_host(host),
         m_resource(resource.empty() ? "/" : resource),
@@ -196,7 +199,7 @@ class uri {
         m_valid(true) {
     }
 
-    uri(std::string const& scheme, std::string const& host, std::string const& port, std::string const& resource) :
+    uri(const std::string& scheme, const std::string& host, const std::string& port, const std::string& resource) :
         m_scheme(scheme),
         m_host(host),
         m_resource(resource.empty() ? "/" : resource),
@@ -212,22 +215,21 @@ class uri {
         return m_secure;
     }
 
-    std::string const& get_scheme() const {
+    const std::string& get_scheme() const {
         return m_scheme;
     }
 
-    std::string const& get_host() const {
+    const std::string& get_host() const {
         return m_host;
     }
 
     std::string get_host_port() const {
         if (m_port == (m_secure ? uri_default_secure_port : uri_default_port)) {
             return m_host;
-        } else {
-            std::stringstream p;
-            p << m_host << ":" << m_port;
-            return p.str();
         }
+        std::stringstream p;
+        p << m_host << ":" << m_port;
+        return p.str();
     }
 
     std::string get_authority() const {
@@ -246,7 +248,7 @@ class uri {
         return p.str();
     }
 
-    std::string const& get_resource() const {
+    const std::string& get_resource() const {
         return m_resource;
     }
 
@@ -271,22 +273,21 @@ class uri {
      * @return query portion of the URI.
      */
     std::string get_query() const {
-        std::size_t found = m_resource.find('?');
+        const std::size_t found = m_resource.find('?');
         if (found != std::string::npos) {
             return m_resource.substr(found + 1);
-        } else {
-            return "";
         }
+        return "";
     }
 
 private:
-    uint16_t get_port_from_string(std::string const& port, bool& out_valid) const {
+    uint16_t get_port_from_string(const std::string& port, bool& out_valid) const {
         out_valid = true;
         if (port.empty()) {
             return (m_secure ? uri_default_secure_port : uri_default_port);
         }
 
-        unsigned int t_port = static_cast<unsigned int>(atoi(port.c_str()));
+        const auto t_port = std::stoul(port);
 
         if (t_port > 65535) {
             out_valid = false;
@@ -302,9 +303,9 @@ class uri {
     std::string m_scheme;
     std::string m_host;
     std::string m_resource;
-    uint16_t m_port;
-    bool m_secure;
-    bool m_valid;
+    uint16_t m_port = 0;
+    bool m_secure = false;
+    bool m_valid = false;
 };
 
 } // namespace ocpp

include/ocpp/common/aligned_timer.hpp

@@ -15,7 +15,7 @@ class ClockAlignedTimer : private Everest::Timer<std::chrono::system_clock> {
 
 private:
     system_time_point start_point;
-    std::chrono::seconds call_interval;
+    std::chrono::seconds call_interval = std::chrono::seconds(0);
 
     std::function<void()> callback;