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/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) {
-        if (locked)
+    CWindowOverridableVar<T>& operator=(CWindowOverridableVar<T> const& other) {
+        // Self-assignment check
+        if (this == &other)
             return *this;
 
-        locked = other.locked;
-        value  = other.value;
+        // Check if the current object is locked
+        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;
     }