test conversion

src/zm_analysis_thread.cpp

@@ -4,14 +4,11 @@
 #include "zm_signal.h"
 #include "zm_time.h"
 
-AnalysisThread::AnalysisThread(Monitor *monitor) :
-    monitor_(monitor), terminate_(false) {
+AnalysisThread::AnalysisThread(Monitor *monitor) : monitor_(monitor), terminate_(false) {
   thread_ = std::thread(&AnalysisThread::Run, this);
 }
 
-AnalysisThread::~AnalysisThread() {
-  Stop();
-}
+AnalysisThread::~AnalysisThread() { Stop(); }
 
 void AnalysisThread::Start() {
   if (thread_.joinable()) thread_.join();
@@ -30,8 +27,10 @@ void AnalysisThread::Run() {
     // Some periodic updates are required for variable capturing framerate
     if (!monitor_->Analyse()) {
       if (!(terminate_ or zm_terminate)) {
-        // We only sleep when Analyse returns false because it is an error condition and we will spin like mad if it persists.
-        Microseconds sleep_for = monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
+        // We only sleep when Analyse returns false because it is an error condition and we will
+        // spin like mad if it persists.
+        Microseconds sleep_for =
+            monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
         Debug(2, "Sleeping for %" PRId64 "us", int64(sleep_for.count()));
         std::this_thread::sleep_for(sleep_for);
       }

src/zm_box.h

@@ -1,27 +1,28 @@
 //
 // ZoneMinder Box Class Interfaces, $Date$, $Revision$
 // Copyright (C) 2001-2008 Philip Coombes
-// 
+//
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
-// 
+//
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-// 
+//
 
 #ifndef ZM_BOX_H
 #define ZM_BOX_H
 
 #include "zm_line.h"
 #include "zm_vector2.h"
+
 #include <cmath>
 #include <vector>
 
@@ -49,9 +50,7 @@ class Box {
   }
 
   // Get vertices of the box in a counter-clockwise order
-  std::vector<Vector2> Vertices() const {
-    return {lo_, {hi_.x_, lo_.y_}, hi_, {lo_.x_, hi_.y_}};
-  }
+  std::vector<Vector2> Vertices() const { return {lo_, {hi_.x_, lo_.y_}, hi_, {lo_.x_, hi_.y_}}; }
 
   // Get edges of the box in a counter-clockwise order
   std::vector<LineSegment> Edges() const {
@@ -77,4 +76,4 @@ class Box {
   Vector2 size_;
 };
 
-#endif // ZM_BOX_H
+#endif  // ZM_BOX_H

src/zm_crypt.h

@@ -1,21 +1,21 @@
 //
 // ZoneMinder General Utility Functions, $Date$, $Revision$
 // Copyright (C) 2001-2008 Philip Coombes
-// 
+//
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
-// 
+//
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-// 
+//
 
 #ifndef ZM_CRYPT_H
 #define ZM_CRYPT_H
@@ -24,6 +24,7 @@
 #include "zm_crypto_gnutls.h"
 #include "zm_crypto_openssl.h"
 #include "zm_define.h"
+
 #include <string>
 
 bool verifyPassword(const char *username, const char *input_password, const char *db_password_hash);
@@ -35,21 +36,21 @@ namespace crypto {
 namespace impl {
 
 #if defined(HAVE_LIBGNUTLS)
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 using Hash = gnutls::GenericHashImpl<Algorithm>;
 #elif defined(HAVE_LIBOPENSSL)
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 using Hash = openssl::GenericHashImpl<Algorithm>;
 #endif
-}
-}
-}
+}  // namespace impl
+}  // namespace crypto
+}  // namespace zm
 
 namespace zm {
 namespace crypto {
 using MD5 = impl::Hash<impl::HashAlgorithms::kMD5>;
 using SHA1 = impl::Hash<impl::HashAlgorithms::kSHA1>;
-}
-}
+}  // namespace crypto
+}  // namespace zm
 
-#endif // ZM_CRYPT_H
+#endif  // ZM_CRYPT_H

src/zm_crypto_generics.h

@@ -20,32 +20,30 @@
 
 #include "zm_define.h"
 #include "zm_utils.h"
+
 #include <array>
 #include <cstring>
 
 namespace zm {
 namespace crypto {
 namespace impl {
 
-enum class HashAlgorithms {
-  kMD5,
-  kSHA1
-};
+enum class HashAlgorithms { kMD5, kSHA1 };
 
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 struct HashAlgorithm;
 
-template<>
+template <>
 struct HashAlgorithm<HashAlgorithms::kMD5> {
   static constexpr size_t digest_length = 16;
 };
 
-template<>
+template <>
 struct HashAlgorithm<HashAlgorithms::kSHA1> {
   static constexpr size_t digest_length = 20;
 };
 
-template<typename Impl, HashAlgorithms Algorithm>
+template <typename Impl, HashAlgorithms Algorithm>
 class GenericHash {
  public:
   static constexpr size_t DIGEST_LENGTH = HashAlgorithm<Algorithm>::digest_length;
@@ -58,8 +56,8 @@ class GenericHash {
     return hash.GetDigest();
   }
 
-  template<typename... Ts>
-  static Digest GetDigestOf(Ts &&... pack) {
+  template <typename... Ts>
+  static Digest GetDigestOf(Ts &&...pack) {
     Impl hash;
     UpdateData(hash, std::forward<Ts>(pack)...);
     hash.Finalize();
@@ -75,34 +73,32 @@ class GenericHash {
   void UpdateData(const char *str) {
     UpdateData(reinterpret_cast<const uint8 *>(str), strlen(str));
   }
-  template<typename Container>
+  template <typename Container>
   void UpdateData(Container const &c) {
     UpdateData(zm::data(c), zm::size(c));
   }
 
-  void Finalize() {
-    static_cast<Impl &>(*this).DoFinalize();
-  }
+  void Finalize() { static_cast<Impl &>(*this).DoFinalize(); }
 
   const Digest &GetDigest() const { return digest_; }
 
  protected:
   Digest digest_ = {};
 
  private:
-  template<typename T>
+  template <typename T>
   static void UpdateData(Impl &hash, T const &data) {
     hash.UpdateData(data);
   }
 
-  template<typename T, typename... TRest>
-  static void UpdateData(Impl &hash, T const &data, TRest &&... rest) {
+  template <typename T, typename... TRest>
+  static void UpdateData(Impl &hash, T const &data, TRest &&...rest) {
     hash.UpdateData(data);
     UpdateData(hash, std::forward<TRest>(rest)...);
   }
 };
-}
-}
-}
+}  // namespace impl
+}  // namespace crypto
+}  // namespace zm
 
-#endif //ZONEMINDER_SRC_ZM_CRYPTO_GENERICS_H_
+#endif  // ZONEMINDER_SRC_ZM_CRYPTO_GENERICS_H_

src/zm_crypto_gnutls.h

@@ -22,27 +22,28 @@
 
 #include "zm_crypto_generics.h"
 #include "zm_utils.h"
+
 #include <gnutls/crypto.h>
 
 namespace zm {
 namespace crypto {
 namespace impl {
 namespace gnutls {
 
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 struct HashAlgorithmMapper;
 
-template<>
+template <>
 struct HashAlgorithmMapper<HashAlgorithms::kMD5> {
   static constexpr gnutls_digest_algorithm_t algorithm = GNUTLS_DIG_MD5;
 };
 
-template<>
+template <>
 struct HashAlgorithmMapper<HashAlgorithms::kSHA1> {
   static constexpr gnutls_digest_algorithm_t algorithm = GNUTLS_DIG_SHA1;
 };
 
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 class GenericHashImpl : public GenericHash<GenericHashImpl<Algorithm>, Algorithm> {
  public:
   GenericHashImpl() {
@@ -55,21 +56,19 @@ class GenericHashImpl : public GenericHash<GenericHashImpl<Algorithm>, Algorithm
     ASSERT(res == 0);
   }
 
-  void DoFinalize() {
-    gnutls_hash_deinit(handle_, digest_.data());
-  }
+  void DoFinalize() { gnutls_hash_deinit(handle_, digest_.data()); }
 
  private:
   gnutls_hash_hd_t handle_ = {};
 
   using Base = GenericHash<GenericHashImpl<Algorithm>, Algorithm>;
   using Base::digest_;
 };
-}
-}
-}
-}
+}  // namespace gnutls
+}  // namespace impl
+}  // namespace crypto
+}  // namespace zm
 
-#endif // HAVE_LIBGNUTLS
+#endif  // HAVE_LIBGNUTLS
 
-#endif // ZONEMINDER_SRC_ZM_CRYPTO_GNUTLS_H_
+#endif  // ZONEMINDER_SRC_ZM_CRYPTO_GNUTLS_H_

src/zm_crypto_openssl.h

@@ -22,6 +22,7 @@
 
 #include "zm_crypto_generics.h"
 #include "zm_utils.h"
+
 #include <openssl/evp.h>
 
 namespace zm {
@@ -31,10 +32,10 @@ namespace openssl {
 
 typedef EVP_MD const *(*HashCreator)();
 
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 struct HashAlgorithmMapper;
 
-template<>
+template <>
 struct HashAlgorithmMapper<HashAlgorithms::kMD5> {
 // TODO: Remove conditional once Jessie and CentOS 7 are deprecated
 // This is needed since GCC 4.8 is faulty (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60199)
@@ -48,7 +49,7 @@ struct HashAlgorithmMapper<HashAlgorithms::kMD5> {
 #endif
 };
 
-template<>
+template <>
 struct HashAlgorithmMapper<HashAlgorithms::kSHA1> {
 // TODO: Remove conditional once Jessie and CentOS 7 are deprecated
 // This is needed since GCC 4.8 is faulty (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60199)
@@ -62,7 +63,7 @@ struct HashAlgorithmMapper<HashAlgorithms::kSHA1> {
 #endif
 };
 
-template<HashAlgorithms Algorithm>
+template <HashAlgorithms Algorithm>
 class GenericHashImpl : public GenericHash<GenericHashImpl<Algorithm>, Algorithm> {
  public:
   GenericHashImpl() {
@@ -98,11 +99,11 @@ class GenericHashImpl : public GenericHash<GenericHashImpl<Algorithm>, Algorithm
   using Base = GenericHash<GenericHashImpl<Algorithm>, Algorithm>;
   using Base::digest_;
 };
-}
-}
-}
-}
+}  // namespace openssl
+}  // namespace impl
+}  // namespace crypto
+}  // namespace zm
 
-#endif // HAVE_LIBOPENSSL
+#endif  // HAVE_LIBOPENSSL
 
-#endif // ZONEMINDER_SRC_ZM_CRYPTO_OPENSSL_H_
+#endif  // ZONEMINDER_SRC_ZM_CRYPTO_OPENSSL_H_

src/zm_decoder_thread.cpp

@@ -3,14 +3,11 @@
 #include "zm_monitor.h"
 #include "zm_signal.h"
 
-DecoderThread::DecoderThread(Monitor *monitor) :
-    monitor_(monitor), terminate_(false) {
+DecoderThread::DecoderThread(Monitor *monitor) : monitor_(monitor), terminate_(false) {
   thread_ = std::thread(&DecoderThread::Run, this);
 }
 
-DecoderThread::~DecoderThread() {
-  Stop();
-}
+DecoderThread::~DecoderThread() { Stop(); }
 
 void DecoderThread::Start() {
   if (thread_.joinable()) thread_.join();
@@ -29,8 +26,10 @@ void DecoderThread::Run() {
   while (!(terminate_ or zm_terminate)) {
     if (!monitor_->Decode()) {
       if (!(terminate_ or zm_terminate)) {
-        // We only sleep when Decode returns false because it is an error condition and we will spin like mad if it persists.
-        Microseconds sleep_for = monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
+        // We only sleep when Decode returns false because it is an error condition and we will spin
+        // like mad if it persists.
+        Microseconds sleep_for =
+            monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
         Debug(2, "Sleeping for %" PRId64 "us", int64(sleep_for.count()));
         std::this_thread::sleep_for(sleep_for);
       }