2025-12-20 08:10:10 +01:00
16 changed files with 82 additions and 290 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -52,7 +52,7 @@ target_include_directories(
  PUBLIC "./include"
  PRIVATE "./src")
 set_target_properties(hyprutils PROPERTIES VERSION ${hyprutils_VERSION}
-                                           SOVERSION 10)
+                                           SOVERSION 9)
 target_link_libraries(hyprutils PkgConfig::deps)

 if(BUILD_TESTING)
--- a/2
+++ b/2
@ -1 +1 @@
-0.11.0
+0.10.4
--- a/include/hyprutils/animation/AnimatedVariable.hpp
+++ b/include/hyprutils/animation/AnimatedVariable.hpp
@ -22,7 +22,6 @@ namespace Hyprutils {
            };

            void create(CAnimationManager*, int, Memory::CSharedPointer<CBaseAnimatedVariable>);
-            void create2(CAnimationManager*, int, Memory::CWeakPointer<CBaseAnimatedVariable>);
            void connectToActive();
            void disconnectFromActive();

@ -137,7 +136,6 @@ namespace Hyprutils {
          public:
            CGenericAnimatedVariable() = default;

-            /* Deprecated: use create2 */
            void create(const int typeInfo, CAnimationManager* pAnimationManager, Memory::CSharedPointer<CGenericAnimatedVariable<VarType, AnimationContext>> pSelf,
                        const VarType& initialValue) {
                m_Begun = initialValue;
@ -147,16 +145,6 @@ namespace Hyprutils {
                CBaseAnimatedVariable::create(pAnimationManager, typeInfo, pSelf);
            }

-            /* Equivalent to create, except that it allows animated variables to be UP's */
-            void create2(const int typeInfo, CAnimationManager* pAnimationManager, Memory::CWeakPointer<CGenericAnimatedVariable<VarType, AnimationContext>> pSelf,
-                        const VarType& initialValue) {
-                m_Begun = initialValue;
-                m_Value = initialValue;
-                m_Goal  = initialValue;
-
-                CBaseAnimatedVariable::create2(pAnimationManager, typeInfo, pSelf);
-            }
-
            CGenericAnimatedVariable(const CGenericAnimatedVariable&)            = delete;
            CGenericAnimatedVariable(CGenericAnimatedVariable&&)                 = delete;
            CGenericAnimatedVariable& operator=(const CGenericAnimatedVariable&) = delete;
--- a/include/hyprutils/memory/Atomic.hpp
+++ b/include/hyprutils/memory/Atomic.hpp
@ -54,11 +54,11 @@ namespace Hyprutils::Memory {
        using validHierarchy = std::enable_if_t<std::is_assignable_v<CAtomicSharedPointer<T>&, X>, CAtomicSharedPointer&>;

      public:
-        explicit CAtomicSharedPointer(T* object) noexcept : m_ptr(new Atomic_::impl(sc<void*>(object), _delete), sc<void*>(object)) {
+        explicit CAtomicSharedPointer(T* object) noexcept : m_ptr(new Atomic_::impl(sc<void*>(object), _delete)) {
            ;
        }

-        CAtomicSharedPointer(Impl_::impl_base* impl, void* data) noexcept : m_ptr(impl, data) {
+        CAtomicSharedPointer(Impl_::impl_base* impl) noexcept : m_ptr(impl) {
            ;
        }

@ -219,17 +219,13 @@ namespace Hyprutils::Memory {
            return m_ptr.impl_ ? m_ptr.impl_->ref() : 0;
        }

-        Atomic_::impl* impl() const {
-            return sc<Atomic_::impl*>(m_ptr.impl_);
-        }
-
      private:
        static void _delete(void* p) {
            std::default_delete<T>{}(sc<T*>(p));
        }

        std::lock_guard<std::recursive_mutex> implLockGuard() const {
-            return impl()->lockGuard();
+            return sc<Atomic_::impl*>(m_ptr.impl_)->lockGuard();
        }

        CSharedPointer<T> m_ptr;
@ -395,16 +391,12 @@ namespace Hyprutils::Memory {
            if (!m_ptr.impl_->dataNonNull() || m_ptr.impl_->destroying() || !m_ptr.impl_->lockable())
                return {};

-            return CAtomicSharedPointer<T>(m_ptr.impl_, m_ptr.m_data);
-        }
-
-        Atomic_::impl* impl() const {
-            return sc<Atomic_::impl*>(m_ptr.impl_);
+            return CAtomicSharedPointer<T>(m_ptr.impl_);
        }

      private:
        std::lock_guard<std::recursive_mutex> implLockGuard() const {
-            return impl()->lockGuard();
+            return sc<Atomic_::impl*>(m_ptr.impl_)->lockGuard();
        }

        CWeakPointer<T> m_ptr;
@ -419,19 +411,4 @@ namespace Hyprutils::Memory {
    [[nodiscard]] inline CAtomicSharedPointer<U> makeAtomicShared(Args&&... args) {
        return CAtomicSharedPointer<U>(new U(std::forward<Args>(args)...));
    }
-
-    template <typename T, typename U>
-    CAtomicSharedPointer<T> reinterpretPointerCast(const CAtomicSharedPointer<U>& ref) {
-        return CAtomicSharedPointer<T>(ref.impl(), ref.m_data);
-    }
-
-    template <typename T, typename U>
-    CAtomicSharedPointer<T> dynamicPointerCast(const CAtomicSharedPointer<U>& ref) {
-        if (!ref)
-            return nullptr;
-        T* newPtr = dynamic_cast<T*>(sc<U*>(ref.impl()->getData()));
-        if (!newPtr)
-            return nullptr;
-        return CAtomicSharedPointer<T>(ref.impl(), newPtr);
-    }
 }
--- a/include/hyprutils/memory/SharedPtr.hpp
+++ b/include/hyprutils/memory/SharedPtr.hpp
@ -28,33 +28,31 @@ namespace Hyprutils {

            /* creates a new shared pointer managing a resource
               avoid calling. Could duplicate ownership. Prefer makeShared */
-            explicit CSharedPointer(T* object) noexcept : impl_(new Impl_::impl_base(sc<void*>(object), _delete)), m_data(sc<void*>(object)) {
+            explicit CSharedPointer(T* object) noexcept : impl_(new Impl_::impl_base(sc<void*>(object), _delete)) {
                increment();
            }

            /* creates a shared pointer from a reference */
            template <typename U, typename = isConstructible<U>>
-            CSharedPointer(const CSharedPointer<U>& ref) noexcept : impl_(ref.impl_), m_data(ref.m_data) {
+            CSharedPointer(const CSharedPointer<U>& ref) noexcept : impl_(ref.impl_) {
                increment();
            }

-            CSharedPointer(const CSharedPointer& ref) noexcept : impl_(ref.impl_), m_data(ref.m_data) {
+            CSharedPointer(const CSharedPointer& ref) noexcept : impl_(ref.impl_) {
                increment();
            }

            template <typename U, typename = isConstructible<U>>
            CSharedPointer(CSharedPointer<U>&& ref) noexcept {
                std::swap(impl_, ref.impl_);
-                std::swap(m_data, ref.m_data);
            }

            CSharedPointer(CSharedPointer&& ref) noexcept {
                std::swap(impl_, ref.impl_);
-                std::swap(m_data, ref.m_data);
            }

            /* allows weakPointer to create from an impl */
-            CSharedPointer(Impl_::impl_base* implementation, void* data) noexcept : impl_(implementation), m_data(data) {
+            CSharedPointer(Impl_::impl_base* implementation) noexcept : impl_(implementation) {
                increment();
            }

@ -76,8 +74,7 @@ namespace Hyprutils {
                    return *this;

                decrement();
-                impl_  = rhs.impl_;
-                m_data = rhs.m_data;
+                impl_ = rhs.impl_;
                increment();
                return *this;
            }
@ -87,8 +84,7 @@ namespace Hyprutils {
                    return *this;

                decrement();
-                impl_  = rhs.impl_;
-                m_data = rhs.m_data;
+                impl_ = rhs.impl_;
                increment();
                return *this;
            }
@ -96,13 +92,11 @@ namespace Hyprutils {
            template <typename U>
            validHierarchy<const CSharedPointer<U>&> operator=(CSharedPointer<U>&& rhs) {
                std::swap(impl_, rhs.impl_);
-                std::swap(m_data, rhs.m_data);
                return *this;
            }

            CSharedPointer& operator=(CSharedPointer&& rhs) noexcept {
                std::swap(impl_, rhs.impl_);
-                std::swap(m_data, rhs.m_data);
                return *this;
            }

@ -110,8 +104,6 @@ namespace Hyprutils {
                return impl_ && impl_->dataNonNull();
            }

-            // this compares that the pointed-to object is the same, but in multiple inheritance,
-            // different typed pointers can be equal if the object is the same
            bool operator==(const CSharedPointer& rhs) const {
                return impl_ == rhs.impl_;
            }
@ -134,12 +126,11 @@ namespace Hyprutils {

            void reset() {
                decrement();
-                impl_  = nullptr;
-                m_data = nullptr;
+                impl_ = nullptr;
            }

            T* get() const {
-                return impl_ && impl_->dataNonNull() ? sc<T*>(m_data) : nullptr;
+                return impl_ ? sc<T*>(impl_->getData()) : nullptr;
            }

            unsigned int strongRef() const {
@ -148,9 +139,6 @@ namespace Hyprutils {

            Impl_::impl_base* impl_ = nullptr;

-            // Never use directly: raw data ptr, could be UAF
-            void* m_data = nullptr;
-
          private:
            static void _delete(void* p) {
                std::default_delete<T>{}(sc<T*>(p));
@ -200,17 +188,7 @@ namespace Hyprutils {

        template <typename T, typename U>
        CSharedPointer<T> reinterpretPointerCast(const CSharedPointer<U>& ref) {
-            return CSharedPointer<T>(ref.impl_, ref.m_data);
-        }
-
-        template <typename T, typename U>
-        CSharedPointer<T> dynamicPointerCast(const CSharedPointer<U>& ref) {
-            if (!ref)
-                return nullptr;
-            T* newPtr = dynamic_cast<T*>(sc<U*>(ref.impl_->getData()));
-            if (!newPtr)
-                return nullptr;
-            return CSharedPointer<T>(ref.impl_, newPtr);
+            return CSharedPointer<T>(ref.impl_);
        }
    }
 }
--- a/include/hyprutils/memory/WeakPtr.hpp
+++ b/include/hyprutils/memory/WeakPtr.hpp
@ -26,8 +26,7 @@ namespace Hyprutils {
                if (!ref.impl_)
                    return;

-                impl_  = ref.impl_;
-                m_data = ref.m_data;
+                impl_ = ref.impl_;
                incrementWeak();
            }

@ -37,8 +36,7 @@ namespace Hyprutils {
                if (!ref.impl_)
                    return;

-                impl_  = ref.impl_;
-                m_data = ref.impl_->getData();
+                impl_ = ref.impl_;
                incrementWeak();
            }

@ -48,8 +46,7 @@ namespace Hyprutils {
                if (!ref.impl_)
                    return;

-                impl_  = ref.impl_;
-                m_data = ref.m_data;
+                impl_ = ref.impl_;
                incrementWeak();
            }

@ -57,20 +54,17 @@ namespace Hyprutils {
                if (!ref.impl_)
                    return;

-                impl_  = ref.impl_;
-                m_data = ref.m_data;
+                impl_ = ref.impl_;
                incrementWeak();
            }

            template <typename U, typename = isConstructible<U>>
            CWeakPointer(CWeakPointer<U>&& ref) noexcept {
                std::swap(impl_, ref.impl_);
-                std::swap(m_data, ref.m_data);
            }

            CWeakPointer(CWeakPointer&& ref) noexcept {
                std::swap(impl_, ref.impl_);
-                std::swap(m_data, ref.m_data);
            }

            /* create a weak ptr from another weak ptr with assignment */
@ -80,8 +74,7 @@ namespace Hyprutils {
                    return *this;

                decrementWeak();
-                impl_  = rhs.impl_;
-                m_data = rhs.m_data;
+                impl_ = rhs.impl_;
                incrementWeak();
                return *this;
            }
@ -91,8 +84,7 @@ namespace Hyprutils {
                    return *this;

                decrementWeak();
-                impl_  = rhs.impl_;
-                m_data = rhs.m_data;
+                impl_ = rhs.impl_;
                incrementWeak();
                return *this;
            }
@ -104,8 +96,7 @@ namespace Hyprutils {
                    return *this;

                decrementWeak();
-                impl_  = rhs.impl_;
-                m_data = rhs.m_data;
+                impl_ = rhs.impl_;
                incrementWeak();
                return *this;
            }
@ -134,15 +125,14 @@ namespace Hyprutils {

            void reset() {
                decrementWeak();
-                impl_  = nullptr;
-                m_data = nullptr;
+                impl_ = nullptr;
            }

            CSharedPointer<T> lock() const {
                if (!impl_ || !impl_->dataNonNull() || impl_->destroying() || !impl_->lockable())
                    return {};

-                return CSharedPointer<T>(impl_, m_data);
+                return CSharedPointer<T>(impl_);
            }

            /* this returns valid() */
@ -179,7 +169,7 @@ namespace Hyprutils {
            }

            T* get() const {
-                return impl_ && impl_->dataNonNull() ? sc<T*>(m_data) : nullptr;
+                return impl_ ? sc<T*>(impl_->getData()) : nullptr;
            }

            T* operator->() const {
@ -192,9 +182,6 @@ namespace Hyprutils {

            Impl_::impl_base* impl_ = nullptr;

-            // Never use directly: raw data ptr, could be UAF
-            void* m_data = nullptr;
-
          private:
            /* no-op if there is no impl_ */
            void decrementWeak() {
@ -220,16 +207,6 @@ namespace Hyprutils {
                impl_->incWeak();
            }
        };
-
-        template <typename T, typename U>
-        CWeakPointer<T> dynamicPointerCast(const CWeakPointer<U>& ref) {
-            if (!ref)
-                return nullptr;
-            T* newPtr = dynamic_cast<T*>(sc<U*>(ref.impl_->getData()));
-            if (!newPtr)
-                return nullptr;
-            return CWeakPointer<T>(ref.impl_, newPtr);
-        }
    }
 }

--- a/include/hyprutils/signal/Signal.hpp
+++ b/include/hyprutils/signal/Signal.hpp
@ -26,13 +26,10 @@ namespace Hyprutils {
        template <typename... Args>
        class CSignalT : public CSignalBase {
            template <typename T>
-            using RefArg = std::conditional_t<std::is_trivially_copyable_v<T>, T, const T&>;
+            using RefArg = std::conditional_t<std::is_reference_v<T> || std::is_arithmetic_v<T>, T, const T&>;

          public:
            void emit(RefArg<Args>... args) {
-                if (m_vListeners.empty() && m_vStaticListeners.empty())
-                    return;
-
                if constexpr (sizeof...(Args) == 0)
                    emitInternal(nullptr);
                else {
--- a/src/animation/AnimatedVariable.cpp
+++ b/src/animation/AnimatedVariable.cpp
@ -13,16 +13,7 @@ static const std::string DEFAULTSTYLE      = "";

 void CBaseAnimatedVariable::create(CAnimationManager* pManager, int typeInfo, SP<CBaseAnimatedVariable> pSelf) {
    m_Type  = typeInfo;
-    m_pSelf = std::move(pSelf);
-
-    m_pAnimationManager = pManager;
-    m_pSignals          = pManager->getSignals();
-    m_bDummy            = false;
-}
-
-void CBaseAnimatedVariable::create2(CAnimationManager* pManager, int typeInfo, WP<CBaseAnimatedVariable> pSelf) {
-    m_Type  = typeInfo;
-    m_pSelf = std::move(pSelf);
+    m_pSelf = pSelf;

    m_pAnimationManager = pManager;
    m_pSignals          = pManager->getSignals();
@ -46,22 +37,28 @@ void CBaseAnimatedVariable::disconnectFromActive() {
 }

 bool Hyprutils::Animation::CBaseAnimatedVariable::enabled() const {
-    if (m_pConfig && m_pConfig->pValues)
-        return m_pConfig->pValues->internalEnabled;
+    if (const auto PCONFIG = m_pConfig.lock()) {
+        const auto PVALUES = PCONFIG->pValues.lock();
+        return PVALUES ? PVALUES->internalEnabled : false;
+    }

    return false;
 }

 const std::string& CBaseAnimatedVariable::getBezierName() const {
-    if (m_pConfig && m_pConfig->pValues)
-        return m_pConfig->pValues->internalBezier;
+    if (const auto PCONFIG = m_pConfig.lock()) {
+        const auto PVALUES = PCONFIG->pValues.lock();
+        return PVALUES ? PVALUES->internalBezier : DEFAULTBEZIERNAME;
+    }

    return DEFAULTBEZIERNAME;
 }

 const std::string& CBaseAnimatedVariable::getStyle() const {
-    if (m_pConfig && m_pConfig->pValues)
-        return m_pConfig->pValues->internalStyle;
+    if (const auto PCONFIG = m_pConfig.lock()) {
+        const auto PVALUES = PCONFIG->pValues.lock();
+        return PVALUES ? PVALUES->internalStyle : DEFAULTSTYLE;
+    }

    return DEFAULTSTYLE;
 }
@ -69,8 +66,10 @@ const std::string& CBaseAnimatedVariable::getStyle() const {
 float CBaseAnimatedVariable::getPercent() const {
    const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - animationBegin).count();

-    if (m_pConfig && m_pConfig->pValues)
-        return std::clamp((DURATIONPASSED / 100.f) / m_pConfig->pValues->internalSpeed, 0.f, 1.f);
+    if (const auto PCONFIG = m_pConfig.lock()) {
+        const auto PVALUES = PCONFIG->pValues.lock();
+        return PVALUES ? std::clamp((DURATIONPASSED / 100.f) / PVALUES->internalSpeed, 0.f, 1.f) : 1.f;
+    }

    return 1.f;
 }
@ -79,7 +78,14 @@ float CBaseAnimatedVariable::getCurveValue() const {
    if (!m_bIsBeingAnimated || isAnimationManagerDead())
        return 1.f;

-    const auto BEZIER = m_pAnimationManager->getBezier(getBezierName());
+    std::string bezierName = "";
+    if (const auto PCONFIG = m_pConfig.lock()) {
+        const auto PVALUES = PCONFIG->pValues.lock();
+        if (PVALUES)
+            bezierName = PVALUES->internalBezier;
+    }
+
+    const auto BEZIER = m_pAnimationManager->getBezier(bezierName);
    if (!BEZIER)
        return 1.f;

--- a/src/animation/AnimationManager.cpp
+++ b/src/animation/AnimationManager.cpp
@ -64,13 +64,14 @@ void CAnimationManager::rotateActive() {
    std::vector<CWeakPointer<CBaseAnimatedVariable>> active;
    active.reserve(m_vActiveAnimatedVariables.size()); // avoid reallocations
    for (auto const& av : m_vActiveAnimatedVariables) {
-        if (!av)
+        const auto PAV = av.lock();
+        if (!PAV)
            continue;

-        if (av->ok() && av->isBeingAnimated())
+        if (PAV->ok() && PAV->isBeingAnimated())
            active.emplace_back(av);
        else
-            av->m_bIsConnectedToActive = false;
+            PAV->m_bIsConnectedToActive = false;
    }

    m_vActiveAnimatedVariables = std::move(active);
--- a/src/cli/ArgumentParser.cpp
+++ b/src/cli/ArgumentParser.cpp
@ -96,17 +96,12 @@ CArgumentParserImpl::CArgumentParserImpl(const std::span<const char*>& args) {
 }

 std::vector<SArgumentKey>::iterator CArgumentParserImpl::getValue(const std::string_view& sv) {
-    if (sv.empty())
-        return m_values.end();
    auto it = std::ranges::find_if(m_values, [&sv](const auto& e) { return e.full == sv || e.abbrev == sv; });
    return it;
 }

 std::expected<void, std::string> CArgumentParserImpl::registerOption(const std::string_view& name, const std::string_view& abbrev, const std::string_view& description,
                                                                     eArgumentType type) {
-    if (name.empty())
-        return std::unexpected("Name cannot be empty");
-
    if (getValue(name) != m_values.end() || getValue(abbrev) != m_values.end())
        return std::unexpected("Value already exists");

@ -253,16 +248,12 @@ std::string CArgumentParserImpl::getDescription(const std::string_view& header,
        rolling += pad(maxArgWidth - lenUsed);
        lenUsed = maxArgWidth;

-        if (!v.abbrev.empty()) {
-            rolling += " -" + v.abbrev;
-            lenUsed += 2 + v.abbrev.size();
-
-            rolling += " ";
-            rolling += TYPE_STRS[v.argType];
-            lenUsed += std::string_view{TYPE_STRS[v.argType]}.length() + 1;
-            rolling += pad(maxArgWidth + maxShortWidth - lenUsed);
-        } else
-            rolling += pad(maxShortWidth);
+        rolling += " -" + v.abbrev;
+        lenUsed += 2 + v.abbrev.size();
+        rolling += " ";
+        rolling += TYPE_STRS[v.argType];
+        lenUsed += std::string_view{TYPE_STRS[v.argType]}.length() + 1;
+        rolling += pad(maxArgWidth + maxShortWidth - lenUsed);
        lenUsed = maxArgWidth + maxShortWidth;

        rolling += " | ";
@ -279,7 +270,7 @@ std::string CArgumentParserImpl::getDescription(const std::string_view& header,

        for (size_t i = 1; i < ROWS.size(); ++i) {
            lenUsed = LEN_START_DESC;
-            rolling += "┃";
+            rolling += "┣";
            rolling += pad(LEN_START_DESC);
            rolling += ROWS[i];
            lenUsed += ROWS[i].size();
--- a/src/cli/Logger.cpp
+++ b/src/cli/Logger.cpp
@ -131,14 +131,8 @@ void CLoggerImpl::log(eLogLevel level, const std::string_view& msg, const std::s
    logMsg += "]: ";
    logMsg += msg;

-    if (m_stdoutEnabled) {
-        try {
-            std::println("{}{}", m_colorEnabled ? logPrefixColor : logPrefix, logMsg);
-            std::fflush(stdout);
-        } catch (std::exception& e) {
-            ; // this could be e.g. stdout closed
-        }
-    }
+    if (m_stdoutEnabled)
+        std::println("{}{}", m_colorEnabled ? logPrefixColor : logPrefix, logMsg);
    if (m_fileEnabled)
        m_logOfs << logPrefix << logMsg << "\n";

--- a/src/i18n/I18nEngine.cpp
+++ b/src/i18n/I18nEngine.cpp
@ -131,7 +131,7 @@ std::string CI18nEngine::localizeEntry(const std::string& locale, uint64_t key,
        return std::string{rawStr};

    // build the new string. First, sort our entries
-    std::ranges::sort(rangesFound, [](const auto& a, const auto& b) { return a.begin < b.begin; });
+    std::ranges::sort(rangesFound, [](const auto& a, const auto& b) { return a.begin - b.begin; });

    // calc the size
    size_t stringLen = 0;
--- a/tests/animation/Animation.cpp
+++ b/tests/animation/Animation.cpp
@ -21,7 +21,7 @@ template <typename VarType>
 using CAnimatedVariable = CGenericAnimatedVariable<VarType, EmtpyContext>;

 template <typename VarType>
-using PANIMVAR = UP<CAnimatedVariable<VarType>>;
+using PANIMVAR = SP<CAnimatedVariable<VarType>>;

 template <typename VarType>
 using PANIMVARREF = WP<CAnimatedVariable<VarType>>;
@ -47,7 +47,8 @@ CAnimationConfigTree animationTree;
 class CMyAnimationManager : public CAnimationManager {
  public:
    void tick() {
-        for (const auto& PAV : m_vActiveAnimatedVariables) {
+        for (size_t i = 0; i < m_vActiveAnimatedVariables.size(); i++) {
+            const auto PAV = m_vActiveAnimatedVariables[i].lock();
            if (!PAV || !PAV->ok() || !PAV->isBeingAnimated())
                continue;

@ -67,7 +68,7 @@ class CMyAnimationManager : public CAnimationManager {
                    if (!avInt)
                        std::cout << "Dynamic cast upcast failed\n";

-                    const auto DELTA = avInt->goal() - avInt->begun();
+                    const auto DELTA = avInt->goal() - avInt->value();
                    avInt->value()   = avInt->begun() + (DELTA * POINTY);
                } break;
                case eAVTypes::TEST: {
@ -92,10 +93,11 @@ class CMyAnimationManager : public CAnimationManager {
    template <typename VarType>
    void createAnimation(const VarType& v, PANIMVAR<VarType>& av, const std::string& animationConfigName) {
        constexpr const eAVTypes EAVTYPE = std::is_same_v<VarType, int> ? eAVTypes::INT : eAVTypes::TEST;
-        av                               = makeUnique<CGenericAnimatedVariable<VarType, EmtpyContext>>();
+        const auto               PAV     = makeShared<CGenericAnimatedVariable<VarType, EmtpyContext>>();

-        av->create2(EAVTYPE, sc<CAnimationManager*>(this), av, v);
-        av->setConfig(animationTree.getConfig(animationConfigName));
+        PAV->create(EAVTYPE, sc<CAnimationManager*>(this), PAV, v);
+        PAV->setConfig(animationTree.getConfig(animationConfigName));
+        av = std::move(PAV);
    }

    virtual void scheduleTick() {
@ -296,7 +298,7 @@ TEST(Animation, animation) {
    // test adding / removing vars during a tick
    s.m_iA->resetAllCallbacks();
    s.m_iA->setUpdateCallback([&vars](WP<CBaseAnimatedVariable> v) {
-        if (v.get() != vars.back().get())
+        if (v.lock() != vars.back())
            vars.back()->warp();
    });
    s.m_iA->setCallbackOnEnd([&s, &vars](auto) {
@ -348,7 +350,7 @@ TEST(Animation, animation) {
    *s.m_iA = 5;
    s.m_iA->setCallbackOnEnd([&endCallbackRan](WP<CBaseAnimatedVariable> v) {
        endCallbackRan++;
-        const auto PAV = dc<CAnimatedVariable<int>*>(v.get());
+        const auto PAV = dc<CAnimatedVariable<int>*>(v.lock().get());

        *PAV = 10;
        PAV->setCallbackOnEnd([&endCallbackRan](WP<CBaseAnimatedVariable> v) { endCallbackRan++; });
--- a/tests/cli/ArgumentParser.cpp
+++ b/tests/cli/ArgumentParser.cpp
@ -10,12 +10,12 @@ using namespace Hyprutils;
 constexpr const char* DESC_TEST = R"#(┏ My description
 ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 ┣ --hello                  -h          | Says hello                              ┃
-┣ --hello2                             | Says hello 2                            ┃
+┣ --hello2                 -e          | Says hello 2                            ┃
 ┣ --value                  -v [float]  | Sets a valueeeeeee                      ┃
 ┣ --longlonglonglongintopt -l [int]    | Long long                               ┃
-┃                                        maaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa┃
-┃                                        aaaaaaaaaaan maaan man maaan man maaan  ┃
-┃                                        man maaan man                           ┃
+┣                                        maaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa┃
+┣                                        aaaaaaaaaaan maaan man maaan man maaan  ┃
+┣                                        man maaan man                           ┃
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 )#";

@ -25,7 +25,7 @@ TEST(CLI, ArgumentParser) {
    CArgumentParser          parser(argv);

    EXPECT_TRUE(parser.registerBoolOption("hello", "h", "Says hello"));
-    EXPECT_TRUE(parser.registerBoolOption("hello2", "", "Says hello 2"));
+    EXPECT_TRUE(parser.registerBoolOption("hello2", "e", "Says hello 2"));
    EXPECT_TRUE(parser.registerFloatOption("value", "v", "Sets a valueeeeeee"));
    EXPECT_TRUE(parser.registerIntOption("longlonglonglongintopt", "l", "Long long maaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan maaan man maaan man maaan man maaan man"));

@ -49,8 +49,6 @@ TEST(CLI, ArgumentParser) {
    EXPECT_TRUE(parser2.registerBoolOption("hello2", "e", "Says hello 2"));
    EXPECT_TRUE(parser2.registerFloatOption("value", "v", "Sets a valueeeeeee"));
    EXPECT_TRUE(parser2.registerIntOption("longlonglonglongintopt", "l", "Long long maaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaan maaan man maaan man maaan man maaan man"));
-    EXPECT_TRUE(parser2.registerFloatOption("value2", "", "Sets a valueeeeeee 2"));
-    EXPECT_TRUE(!parser2.registerFloatOption("", "a", "Sets a valueeeeeee 2"));

    auto result2 = parser2.parse();

--- a/tests/i18n/Engine.cpp
+++ b/tests/i18n/Engine.cpp
@ -75,6 +75,4 @@ TEST(I18n, Engine) {
    EXPECT_EQ(engine.localizeEntry("ts", 42069 /* invalid key */, {{"count", "1"}}), "");

    EXPECT_EQ(engine.localizeEntry("ts_TST", TXT_KEY_FALLBACK, {{"var1", "hi"}, {"var2", "!"}}), "Hello hi world !");
-    // Order shouldn't matter
-    EXPECT_EQ(engine.localizeEntry("ts_TST", TXT_KEY_FALLBACK, {{"var2", "!"}, {"var1", "hi"}}), "Hello hi world !");
-}
+}
--- a/tests/memory/Memory.cpp
+++ b/tests/memory/Memory.cpp
@ -123,119 +123,6 @@ static void testAtomicImpl() {
    }
 }

-class InterfaceA {
-  public:
-    virtual ~InterfaceA() = default;
-    int m_ifaceAInt       = 69;
-    int m_ifaceAShit      = 1;
-};
-
-class InterfaceB {
-  public:
-    virtual ~InterfaceB() = default;
-    int m_ifaceBInt       = 2;
-    int m_ifaceBShit      = 3;
-};
-
-class CChild : public InterfaceA, public InterfaceB {
-  public:
-    virtual ~CChild() = default;
-    int m_childInt    = 4;
-};
-
-class CChildA : public InterfaceA {
-  public:
-    int m_childAInt = 4;
-};
-
-static void testHierarchy() {
-    // Same test for atomic and non-atomic
-    {
-        SP<CChildA> childA = makeShared<CChildA>();
-        auto        ifaceA = SP<InterfaceA>(childA);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-
-        auto ifaceB = dynamicPointerCast<InterfaceA>(SP<CChildA>{});
-        EXPECT_TRUE(!ifaceB);
-    }
-
-    {
-        SP<CChild>     child  = makeShared<CChild>();
-        SP<InterfaceA> ifaceA = dynamicPointerCast<InterfaceA>(child);
-        SP<InterfaceB> ifaceB = dynamicPointerCast<InterfaceB>(child);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_TRUE(ifaceB);
-
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-        EXPECT_EQ(ifaceB->m_ifaceBInt, 2);
-
-        WP<InterfaceA> ifaceAWeak = ifaceA;
-
-        child.reset();
-        EXPECT_TRUE(ifaceAWeak);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_EQ(ifaceAWeak->m_ifaceAInt, 69);
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-        ifaceA.reset();
-        EXPECT_TRUE(ifaceAWeak);
-        EXPECT_EQ(ifaceAWeak->m_ifaceAInt, 69);
-        EXPECT_TRUE(ifaceB);
-        EXPECT_EQ(ifaceB->m_ifaceBInt, 2);
-        ifaceB.reset();
-        EXPECT_TRUE(!ifaceAWeak);
-    }
-
-    //
-
-    {
-        ASP<CChildA> childA = makeAtomicShared<CChildA>();
-        auto         ifaceA = ASP<InterfaceA>(childA);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-
-        auto ifaceB = dynamicPointerCast<InterfaceA>(ASP<CChildA>{});
-        EXPECT_TRUE(!ifaceB);
-    }
-
-    {
-        ASP<CChild>     child  = makeAtomicShared<CChild>();
-        ASP<InterfaceA> ifaceA = dynamicPointerCast<InterfaceA>(child);
-        ASP<InterfaceB> ifaceB = dynamicPointerCast<InterfaceB>(child);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_TRUE(ifaceB);
-
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-        EXPECT_EQ(ifaceB->m_ifaceBInt, 2);
-
-        AWP<InterfaceA> ifaceAWeak = ifaceA;
-        AWP<InterfaceB> ifaceBWeak = dynamicPointerCast<InterfaceB>(ifaceA);
-
-        child.reset();
-        EXPECT_TRUE(ifaceAWeak);
-        EXPECT_TRUE(ifaceBWeak);
-        EXPECT_TRUE(ifaceA);
-        EXPECT_EQ(ifaceAWeak->m_ifaceAInt, 69);
-        EXPECT_EQ(ifaceA->m_ifaceAInt, 69);
-        EXPECT_EQ(ifaceBWeak->m_ifaceBInt, 2);
-        ifaceA.reset();
-        EXPECT_TRUE(ifaceAWeak);
-        EXPECT_EQ(ifaceAWeak->m_ifaceAInt, 69);
-        EXPECT_TRUE(ifaceB);
-        EXPECT_EQ(ifaceB->m_ifaceBInt, 2);
-        EXPECT_EQ(ifaceBWeak->m_ifaceBInt, 2);
-        ifaceB.reset();
-        EXPECT_TRUE(!ifaceAWeak);
-        EXPECT_TRUE(!ifaceBWeak);
-    }
-
-    // test for leaks
-    for (size_t i = 0; i < 10000; ++i) {
-        auto child  = makeAtomicShared<CChild>();
-        auto child2 = makeShared<CChild>();
-    }
-}
-
 TEST(Memory, memory) {
    SP<int> intPtr    = makeShared<int>(10);
    SP<int> intPtr2   = makeShared<int>(-1337);
@ -289,6 +176,4 @@ TEST(Memory, memory) {
    EXPECT_EQ(*intPtr2, 10);

    testAtomicImpl();
-
-    testHierarchy();
 }
 @ -1 +1 @@
 .11.0
 .10.4