fix: fix many clang tidy errors (4/x)

this is part 4 of 143 errors in the whole codebase, it is split into multiple commits, so that each patch is not to big

Author: Totto16

src/libs/core/helper/color.hpp

@@ -87,7 +87,7 @@ namespace { //NOLINT(cert-dcl59-cpp,google-build-namespaces)
             return std::fmod(value, divisor);
         }
 
-        return value - static_cast<T>(static_cast<u64>(value / divisor)) * divisor;
+        return value - (static_cast<T>(static_cast<u64>(value / divisor)) * divisor);
     }
 
     template<typename T>

src/libs/core/helper/errors.hpp

@@ -5,6 +5,8 @@
 #include "./types.hpp"
 #include "./windows.hpp"
 
+#include <core/helper/types.hpp>
+
 #include <exception>
 #include <string>
 

src/libs/core/helper/meson.build

@@ -6,6 +6,7 @@ core_src_files += files(
     'random.cpp',
     'sleep.cpp',
     'string_manipulation.cpp',
+    'timer.cpp',
 )
 
 _header_files = files(

src/libs/core/helper/point.hpp

@@ -15,7 +15,9 @@ namespace shapes {
         T y;
 
         constexpr AbstractPoint() : AbstractPoint{ 0, 0 } { }
-        constexpr AbstractPoint(T x, T y) : x{ x }, y{ y } { } // NOLINT(bugprone-easily-swappable-parameters)
+        constexpr AbstractPoint(T x_pos, T y_pos)
+            : x{ x_pos },
+              y{ y_pos } { } // NOLINT(bugprone-easily-swappable-parameters)
 
         static constexpr AbstractPoint<T> zero() {
             return AbstractPoint<T>{ 0, 0 };
@@ -46,7 +48,7 @@ namespace shapes {
         }
 
         constexpr AbstractPoint<T> operator-(AbstractPoint<T> rhs) const {
-            if constexpr (std::is_signed<T>::value) {
+            if constexpr (std::is_signed_v<T>) {
                 return *this + (-rhs);
             } else {
                 assert(x >= rhs.x && y >= rhs.y && "underflow in subtraction");
@@ -66,11 +68,34 @@ namespace shapes {
 
         template<typename S>
         constexpr AbstractPoint<S> cast() const {
-            if constexpr (std::is_signed<T>::value and not std::is_signed<T>::value) {
-                assert(x >= 0 && y >= 0 && "Not allowed to cast away negative number into an unsigned type");
-            } else {
-                return AbstractPoint<S>{ static_cast<S>(x), static_cast<S>(y) };
+            assert(x >= std::numeric_limits<S>::min() && y >= std::numeric_limits<S>::min()
+                   && "cast invalid, value to small");
+            assert(x <= std::numeric_limits<S>::max() && y >= std::numeric_limits<S>::max()
+                   && "cast invalid, value to big");
+
+            return AbstractPoint<S>{ static_cast<S>(x), static_cast<S>(y) };
+        }
+
+        template<typename S>
+        constexpr AbstractPoint<S> cast_truncate() const {
+
+            auto x_final = x;
+
+            if (x < std::numeric_limits<S>::min()) {
+                x_final = std::numeric_limits<S>::min();
+            } else if (x > std::numeric_limits<S>::max()) {
+                x_final = std::numeric_limits<S>::max();
             }
+
+            auto y_final = y;
+
+            if (y < std::numeric_limits<S>::min()) {
+                y_final = std::numeric_limits<S>::min();
+            } else if (y > std::numeric_limits<S>::max()) {
+                y_final = std::numeric_limits<S>::max();
+            }
+
+            return AbstractPoint<S>{ static_cast<S>(x_final), static_cast<S>(y_final) };
         }
     };
 

src/libs/core/helper/timer.cpp

@@ -0,0 +1,32 @@
+
+
+#include "./timer.hpp"
+
+
+helper::Timer::Timer(Callback callback, const Duration& interval)
+    : m_callback{ std::move(callback) },
+      m_interval{ interval } { }
+
+void helper::Timer::start() {
+    m_running = true;
+    m_last_measured = Clock::now();
+}
+
+void helper::Timer::stop() {
+    m_running = false;
+}
+
+void helper::Timer::check() {
+    if (not m_running) {
+        return;
+    }
+
+    const auto now = Clock::now();
+
+    const auto difference = now - m_last_measured;
+
+    if (difference >= m_interval) {
+        m_callback();
+        m_last_measured = now;
+    }
+}

src/libs/core/helper/timer.hpp

@@ -14,39 +14,19 @@ namespace helper {
         using Duration = std::chrono::nanoseconds;
 
         bool m_running{ false };
-        std::chrono::time_point<Clock> last_measured;
+        std::chrono::time_point<Clock> m_last_measured;
         Callback m_callback;
         Duration m_interval;
 
 
     public:
-        Timer(Callback callback, const Duration& interval)
-            : m_callback{ std::move(callback) },
-              m_interval{ interval } { }
+        Timer(Callback callback, const Duration& interval);
 
-        void start() {
-            m_running = true;
-            last_measured = Clock::now();
-        }
+        void start();
 
-        void stop() {
-            m_running = false;
-        }
+        void stop();
 
-        void check() {
-            if (not m_running) {
-                return;
-            }
-
-            const auto now = Clock::now();
-
-            const auto difference = now - last_measured;
-
-            if (difference >= m_interval) {
-                m_callback();
-                last_measured = now;
-            }
-        }
+        void check();
     };