clang-tidy

source/pause_manager.h

@@ -3,6 +3,7 @@
 #include <cstdint>
 #include <functional>
 #include <string>
+#include <utility>
 
 // Clase dedicada para manejar el sistema de pausa
 class PauseManager {
@@ -16,48 +17,48 @@ class PauseManager {
         };
 
         // Operadores para trabajar con las banderas (funciones friend)
-        friend Source operator|(Source a, Source b) {
+        friend auto operator|(Source a, Source b) -> Source {
             return static_cast<Source>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
         }
 
-        friend Source operator&(Source a, Source b) {
+        friend auto operator&(Source a, Source b) -> Source {
             return static_cast<Source>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
         }
 
-        friend Source operator~(Source a) {
+        friend auto operator~(Source a) -> Source {
             return static_cast<Source>(~static_cast<uint8_t>(a));
         }
 
-        friend Source& operator|=(Source& a, Source b) {
+        friend auto operator|=(Source& a, Source b) -> Source& {
             return a = a | b;
         }
 
-        friend Source& operator&=(Source& a, Source b) {
+        friend auto operator&=(Source& a, Source b) -> Source& {
             return a = a & b;
         }
 
     private:
         Source flags_ = Source::NONE;
-        std::function<void(bool)> onPauseChangedCallback_;
+        std::function<void(bool)> on_pause_changed_callback_;
 
-        bool hasFlag(Source flag) const {
+        [[nodiscard]] auto hasFlag(Source flag) const -> bool {
             return (flags_ & flag) != Source::NONE;
         }
 
         void notifyPauseChanged() {
-            if (onPauseChangedCallback_) {
-                onPauseChangedCallback_(isPaused());
+            if (on_pause_changed_callback_) {
+                on_pause_changed_callback_(isPaused());
             }
         }
 
     public:
         // Constructor con callback opcional
         explicit PauseManager(std::function<void(bool)> callback = nullptr)
-            : onPauseChangedCallback_(callback) {}
+            : on_pause_changed_callback_(std::move(callback)) {}
 
         // Establece/quita una fuente de pausa específica
         void setFlag(Source source, bool enable) {
-            bool wasPaused = isPaused();
+            bool was_paused = isPaused();
 
             if (enable) {
                 flags_ |= source;
@@ -66,7 +67,7 @@ class PauseManager {
             }
 
             // Solo notifica si cambió el estado general de pausa
-            if (wasPaused != isPaused()) {
+            if (was_paused != isPaused()) {
                 notifyPauseChanged();
             }
         }
@@ -80,13 +81,13 @@ class PauseManager {
         void togglePlayerPause() { setPlayerPause(!isPlayerPaused()); }
 
         // Getters
-        bool isPaused() const { return flags_ != Source::NONE; }
-        bool isPlayerPaused() const { return hasFlag(Source::PLAYER); }
-        bool isServiceMenuPaused() const { return hasFlag(Source::SERVICE_MENU); }
-        bool isFocusLossPaused() const { return hasFlag(Source::FOCUS_LOST); }
+        [[nodiscard]] auto isPaused() const -> bool { return flags_ != Source::NONE; }
+        [[nodiscard]] auto isPlayerPaused() const -> bool { return hasFlag(Source::PLAYER); }
+        [[nodiscard]] auto isServiceMenuPaused() const -> bool { return hasFlag(Source::SERVICE_MENU); }
+        [[nodiscard]] auto isFocusLossPaused() const -> bool { return hasFlag(Source::FOCUS_LOST); }
 
         // Obtiene las banderas actuales
-        Source getFlags() const { return flags_; }
+        [[nodiscard]] auto getFlags() const -> Source { return flags_; }
 
         // Limpia todas las pausas (útil para reset)
         void clearAll() {
@@ -97,24 +98,32 @@ class PauseManager {
         }
 
         // Método para debug
-        std::string getStatusString() const {
-            if (flags_ == Source::NONE) return "Active";
+        [[nodiscard]] auto getStatusString() const -> std::string {
+            if (flags_ == Source::NONE) {
+                return "Active";
+            }
 
             std::string result = "Paused by: ";
             bool first = true;
 
             if (hasFlag(Source::PLAYER)) {
-                if (!first) result += ", ";
+                if (!first) {
+                    result += ", ";
+                }
                 result += "Player";
                 first = false;
             }
             if (hasFlag(Source::SERVICE_MENU)) {
-                if (!first) result += ", ";
+                if (!first) {
+                    result += ", ";
+                }
                 result += "ServiceMenu";
                 first = false;
             }
             if (hasFlag(Source::FOCUS_LOST)) {
-                if (!first) result += ", ";
+                if (!first) {
+                    result += ", ";
+                }
                 result += "FocusLoss";
                 first = false;
             }
@@ -124,6 +133,6 @@ class PauseManager {
 
         // Permite cambiar el callback en runtime
         void setCallback(std::function<void(bool)> callback) {
-            onPauseChangedCallback_ = callback;
+            on_pause_changed_callback_ = callback;
         }
 };