misc: a few compiler level performance optimisations (#6559)

* window: use const references instead of copies

use const references instead of wasteful copies and make the = operator
check for self assignment and return early. also use const in all the
other operators.

* listener: pass std::function as const reference

instead of copies pass the std::functions as const references.

* config: dont unnecessarily convert to c_str

getHyprlangConfigValuePtr wants an std::string and we already have an
std::string, dont convert it to a c_str only for it to be converted back
to an std::string.

* buffer: pass attributes as const reference

pass attributes as const reference instead of copies.

src/config/ConfigValue.hpp

@@ -11,7 +11,7 @@ template <typename T>
 class CConfigValue {
   public:
     CConfigValue(const std::string& val) {
-        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val.c_str());
+        const auto PVHYPRLANG = g_pConfigManager->getHyprlangConfigValuePtr(val);
 
         p_ = PVHYPRLANG->getDataStaticPtr();
 

src/desktop/Window.hpp

@@ -62,18 +62,22 @@ class IWindowTransformer;
 template <typename T>
 class CWindowOverridableVar {
   public:
-    CWindowOverridableVar(T val) {
+    CWindowOverridableVar(T const& val) {
         value = val;
     }
 
     ~CWindowOverridableVar() = default;
 
-    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> other) {
+    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> const& other) {
-        if (locked)
+        // Self-assignment check
+        if (this == &other)
             return *this;
 
-        locked = other.locked;
+        // Check if the current object is locked
-        value  = other.value;
+        if (!locked) {
+            locked = other.locked;
+            value  = other.value;
+        }
 
         return *this;
     }
@@ -85,36 +89,36 @@ class CWindowOverridableVar {
         return other;
     }
 
-    void forceSetIgnoreLocked(T val, bool lock = false) {
+    void forceSetIgnoreLocked(T const& val, bool lock = false) {
         value  = val;
         locked = lock;
     }
 
-    T operator*(T& other) {
+    T operator*(T const& other) {
         return value * other;
     }
 
-    T operator+(T& other) {
+    T operator+(T const& other) {
         return value + other;
     }
 
-    bool operator==(T& other) {
+    bool operator==(T const& other) {
         return other == value;
     }
 
-    bool operator>=(T& other) {
+    bool operator>=(T const& other) {
         return value >= other;
     }
 
-    bool operator<=(T& other) {
+    bool operator<=(T const& other) {
         return value <= other;
     }
 
-    bool operator>(T& other) {
+    bool operator>(T const& other) {
         return value > other;
     }
 
-    bool operator<(T& other) {
+    bool operator<(T const& other) {
         return value < other;
     }
 

src/helpers/WLListener.cpp

@@ -18,7 +18,7 @@ void handleWrapped(wl_listener* listener, void* data) {
         g_pWatchdog->endWatching();
 }
 
-CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, void*)> callback, void* pOwner) {
+CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, void*)> const& callback, void* pOwner) {
     initCallback(pSignal, callback, pOwner);
 }
 
@@ -44,7 +44,7 @@ bool CHyprWLListener::isConnected() {
     return !wl_list_empty(&m_swWrapper.m_sListener.link);
 }
 
-void CHyprWLListener::initCallback(wl_signal* pSignal, std::function<void(void*, void*)> callback, void* pOwner, std::string author) {
+void CHyprWLListener::initCallback(wl_signal* pSignal, std::function<void(void*, void*)> const& callback, void* pOwner, std::string author) {
     if (isConnected()) {
         Debug::log(ERR, "Tried to connect a listener twice?!");
         return;

src/helpers/WLListener.hpp

@@ -6,7 +6,7 @@
 
 class CHyprWLListener {
   public:
-    CHyprWLListener(wl_signal*, std::function<void(void*, void*)>, void* owner);
+    CHyprWLListener(wl_signal*, std::function<void(void*, void*)> const&, void* owner);
     CHyprWLListener();
     ~CHyprWLListener();
 
@@ -15,7 +15,7 @@ class CHyprWLListener {
     CHyprWLListener& operator=(const CHyprWLListener&) = delete;
     CHyprWLListener& operator=(CHyprWLListener&&)      = delete;
 
-    void             initCallback(wl_signal*, std::function<void(void*, void*)>, void* owner, std::string author = "");
+    void             initCallback(wl_signal*, std::function<void(void*, void*)> const&, void* owner, std::string author = "");
 
     void             removeCallback();
 

src/protocols/types/DMABuffer.cpp

@@ -3,7 +3,7 @@
 #include "../../render/Renderer.hpp"
 #include "../../helpers/Format.hpp"
 
-CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, SDMABUFAttrs attrs_) : attrs(attrs_) {
+CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, SDMABUFAttrs const& attrs_) : attrs(attrs_) {
     g_pHyprRenderer->makeEGLCurrent();
 
     listeners.resourceDestroy = events.destroy.registerListener([this](std::any d) {

src/protocols/types/DMABuffer.hpp

@@ -4,7 +4,7 @@
 
 class CDMABuffer : public IWLBuffer {
   public:
-    CDMABuffer(uint32_t id, wl_client* client, SDMABUFAttrs attrs_);
+    CDMABuffer(uint32_t id, wl_client* client, SDMABUFAttrs const& attrs_);
     virtual ~CDMABuffer();
 
     virtual eBufferCapability                      caps();