Merge pull request #137 from ImJimmi/misc-utils

Various useful bits and bobs
ImJimmi · Feb 7, 2024 · 9797773 · 9797773
2 parents bd953c4 + da003a8
commit 9797773
Show file tree

Hide file tree

Showing 16 changed files with 767 additions and 80 deletions.
diff --git a/jive_core/algorithms/jive_Visitor.h b/jive_core/algorithms/jive_Visitor.h
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace jive
+{
+    template <class... Variants>
+    struct Visitor : Variants...
+    {
+        using Variants::operator()...;
+    };
+
+    template <class... Variants>
+    Visitor(Variants...) -> Visitor<Variants...>;
+} // namespace jive
diff --git a/jive_core/geometry/jive_Length.cpp b/jive_core/geometry/jive_Length.cpp
@@ -42,7 +42,7 @@ namespace jive
 
     [[nodiscard]] double Length::getRelativeParentLength(const juce::Rectangle<double>& parentBounds) const
     {
-        jassert(tree.getParent().isValid());
+        jassert(isValid(getParent(source)));
 
         if (id.toString().containsIgnoreCase("width") || id.toString().containsIgnoreCase("x"))
             return parentBounds.getWidth();
@@ -52,11 +52,11 @@ namespace jive
 
     [[nodiscard]] float Length::getFontSize() const
     {
-        for (auto toSearch = tree;
-             toSearch.isValid();
-             toSearch = toSearch.getParent())
+        for (auto toSearch = source;
+             isValid(source);
+             toSearch = getParent(source))
         {
-            if (const auto style = toSearch["style"];
+            if (const auto style = getVar(toSearch, "style");
                 style.isObject())
             {
                 if (const auto fontSize = style["font-size"];
@@ -72,7 +72,7 @@ namespace jive
 
     [[nodiscard]] float Length::getRootFontSize() const
     {
-        if (const auto style = tree.getRoot()["style"];
+        if (const auto style = getVar(getRoot(source), "style");
             style.isObject())
         {
             if (const auto fontSize = style["font-size"];

diff --git a/jive_core/jive_core.cpp b/jive_core/jive_core.cpp
@@ -27,3 +27,5 @@
 #include "graphics/jive_LookAndFeel.cpp"
 
 #include "interface/jive_ComponentInteractionState.cpp"
+
+#include "time/jive_Timer.cpp"
diff --git a/jive_core/jive_core.h b/jive_core/jive_core.h
@@ -17,6 +17,7 @@ END_JUCE_MODULE_DECLARATION */
 #include "logging/jive_StringStreams.h"
 
 #include "algorithms/jive_Find.h"
+#include "algorithms/jive_Visitor.h"
 
 #include "values/jive_Colours.h"
 #include "values/jive_Event.h"
@@ -42,3 +43,5 @@ END_JUCE_MODULE_DECLARATION */
 #include "graphics/jive_Fill.h"
 
 #include "interface/jive_ComponentInteractionState.h"
+
+#include "time/jive_Timer.h"
diff --git a/jive_core/logging/jive_StringStreams.cpp b/jive_core/logging/jive_StringStreams.cpp
@@ -41,4 +41,9 @@ namespace juce
     {
         return str << juce::String{ static_cast<double>(value) };
     }
+
+    String& operator<<(String& str, RelativeTime relativeTime)
+    {
+        return str << juce::String{ relativeTime.inSeconds() } << "s";
+    }
 } // namespace juce
diff --git a/jive_core/logging/jive_StringStreams.h b/jive_core/logging/jive_StringStreams.h
@@ -8,6 +8,7 @@ namespace juce
     String& operator<<(String& str, const var& value);
     String& operator<<(String& str, const Time& time);
     String& operator<<(String& str, long double value);
+    String& operator<<(String& str, RelativeTime relativeTime);
 
     template <typename T>
     String& operator<<(String& str, const Point<T>& point)
@@ -29,4 +30,17 @@ namespace juce
                    << ", " << rect.getHeight()
                    << " }";
     }
+
+    template <typename T>
+    String& operator<<(String& str, const std::optional<T>& optional)
+    {
+        str << "std::optional<" << typeid(T).name() << "> { ";
+
+        if (optional.has_value())
+            str << *optional;
+        else
+            str << "NULL";
+
+        return str << " }";
+    }
 } // namespace juce
diff --git a/jive_core/time/jive_Timer.cpp b/jive_core/time/jive_Timer.cpp
@@ -0,0 +1,121 @@
+#include "jive_Timer.h"
+
+namespace jive
+{
+#if JIVE_UNIT_TESTS
+    FakeTime::~FakeTime()
+    {
+        clearSingletonInstance();
+    }
+
+    void FakeTime::addListener(Listener& listener)
+    {
+        listeners.add(&listener);
+    }
+
+    void FakeTime::removeListener(Listener& listener)
+    {
+        listeners.remove(&listener);
+    }
+
+    void FakeTime::incrementTime(juce::RelativeTime increment)
+    {
+        getInstance()->incrementTimeInternal(increment);
+    }
+
+    juce::Time FakeTime::now() noexcept
+    {
+        return getInstance()->currentTime;
+    }
+
+    void FakeTime::incrementTimeInternal(juce::RelativeTime increment)
+    {
+        currentTime += increment;
+        listeners.call(&Listener::timeChanged);
+    }
+
+    JUCE_IMPLEMENT_SINGLETON(FakeTime)
+#endif
+
+    Timer::Timer(Timer::Callback timerCallback,
+                 juce::RelativeTime callbackInterval)
+        : callback{ timerCallback }
+        , interval{ callbackInterval }
+    {
+#if JIVE_UNIT_TESTS
+        timeLastCallbackInvoked = FakeTime::now();
+        FakeTime::getInstance()->addListener(*this);
+#else
+        timeLastCallbackInvoked = juce::Time::getCurrentTime();
+        startTimer(static_cast<int>(interval.inMilliseconds()));
+#endif
+    }
+
+    Timer::~Timer()
+    {
+#if JIVE_UNIT_TESTS
+        FakeTime::getInstance()->removeListener(*this);
+#endif
+    }
+
+#if JIVE_UNIT_TESTS
+    void Timer::timeChanged()
+    {
+        for (auto elapsed = FakeTime::now() - timeLastCallbackInvoked;
+             elapsed.inMilliseconds() > interval.inMilliseconds();
+             elapsed -= interval)
+        {
+            timeLastCallbackInvoked = FakeTime::now() - elapsed + interval;
+            callback(timeLastCallbackInvoked);
+        }
+    }
+#else
+    void Timer::timerCallback()
+    {
+        callback(juce::Time::getCurrentTime());
+    }
+#endif
+} // namespace jive
+
+#if JIVE_UNIT_TESTS
+class TimerUnitTest : public juce::UnitTest
+{
+public:
+    TimerUnitTest()
+        : juce::UnitTest{ "jive::Timer", "jive" }
+    {
+    }
+
+    void runTest() final
+    {
+        const auto initialTime = jive::FakeTime::now();
+
+        beginTest("faking the passing of time");
+        jive::FakeTime::incrementTime(juce::RelativeTime::seconds(5.3));
+        expectEquals(jive::FakeTime::now(), initialTime + juce::RelativeTime::seconds(5.3));
+
+        beginTest("getting callbacks");
+        juce::Array<juce::Time> invokeTimes;
+        jive::Timer timer{
+            [&invokeTimes](juce::Time now) mutable {
+                invokeTimes.add(now);
+            },
+            juce::RelativeTime::seconds(0.1),
+        };
+        jive::FakeTime::incrementTime(juce::RelativeTime::seconds(0.25));
+        expectEquals(invokeTimes.size(), 2);
+        expectEquals(invokeTimes[0], initialTime + juce::RelativeTime::seconds(5.4));
+        expectEquals(invokeTimes[1], initialTime + juce::RelativeTime::seconds(5.5));
+
+        jive::FakeTime::incrementTime(juce::RelativeTime::seconds(0.3333));
+        expectEquals(invokeTimes.size(), 5);
+        expectEquals(invokeTimes[0], initialTime + juce::RelativeTime::seconds(5.4));
+        expectEquals(invokeTimes[1], initialTime + juce::RelativeTime::seconds(5.5));
+        expectEquals(invokeTimes[2], initialTime + juce::RelativeTime::seconds(5.6));
+        expectEquals(invokeTimes[3], initialTime + juce::RelativeTime::seconds(5.7));
+        expectEquals(invokeTimes[4], initialTime + juce::RelativeTime::seconds(5.8));
+    }
+};
+
+static TimerUnitTest timerUnitTest;
+#endif
diff --git a/jive_core/time/jive_Timer.h b/jive_core/time/jive_Timer.h
@@ -0,0 +1,68 @@
+#pragma once
+
+namespace jive
+{
+#if JIVE_UNIT_TESTS
+    class FakeTime : public juce::DeletedAtShutdown
+    {
+    public:
+        struct Listener
+        {
+            virtual ~Listener() = default;
+
+            virtual void timeChanged() = 0;
+        };
+
+        FakeTime() = default;
+        ~FakeTime();
+
+        void addListener(Listener& listener);
+        void removeListener(Listener& listener);
+
+        static void incrementTime(juce::RelativeTime);
+        static juce::Time now() noexcept;
+
+        JUCE_DECLARE_SINGLETON(FakeTime, false)
+
+    private:
+        void incrementTimeInternal(juce::RelativeTime);
+
+        juce::Time currentTime;
+        juce::ListenerList<Listener> listeners;
+    };
+#endif
+
+    class Timer
+#if JIVE_UNIT_TESTS
+        : private FakeTime::Listener
+#else
+        : private juce::Timer
+#endif
+    {
+    public:
+        using Callback = std::function<void(juce::Time)>;
+
+        Timer(Callback timerCallback,
+              juce::RelativeTime callbackInterval);
+        ~Timer();
+
+    private:
+#if JIVE_UNIT_TESTS
+        void timeChanged() final;
+#else
+        void timerCallback() final;
+#endif
+        Callback callback;
+        juce::RelativeTime interval;
+        juce::Time timeLastCallbackInvoked;
+    };
+
+    [[nodiscard]] static inline juce::Time now() noexcept
+    {
+#if JIVE_UNIT_TESTS
+        return FakeTime::now();
+#else
+        return juce::Time::getCurrentTime();
+#endif
+    }
+} // namespace jive
diff --git a/jive_core/values/jive_Object.cpp b/jive_core/values/jive_Object.cpp
@@ -82,6 +82,9 @@ namespace jive
     void Object::setProperty(const juce::Identifier& propertyName,
                              const juce::var& newValue)
     {
+        if (auto* childObject = dynamic_cast<Object*>(newValue.getDynamicObject()))
+            childObject->parent = this;
+
         const auto propertyChanged = DynamicObject::getProperties()
                                          .set(propertyName, newValue);
 
@@ -94,6 +97,32 @@ namespace jive
         return dynamic_cast<juce::DynamicObject*>(const_cast<Object*>(this))->getProperties();
     }
 
+    Object* Object::getParent() noexcept
+    {
+        return parent;
+    }
+
+    const Object* Object::getParent() const noexcept
+    {
+        return parent;
+    }
+
+    Object* Object::getRoot() noexcept
+    {
+        if (parent == nullptr)
+            return this;
+
+        return parent->getRoot();
+    }
+
+    const Object* Object::getRoot() const noexcept
+    {
+        if (parent == nullptr)
+            return this;
+
+        return parent->getRoot();
+    }
+
     void Object::addListener(Listener& listener) const
     {
         listeners.add(&listener);

diff --git a/jive_core/values/jive_Object.h b/jive_core/values/jive_Object.h
@@ -25,6 +25,11 @@ namespace jive
                          const juce::var& newValue) override;
         const juce::NamedValueSet& getProperties() const;
 
+        Object* getParent() noexcept;
+        const Object* getParent() const noexcept;
+        Object* getRoot() noexcept;
+        const Object* getRoot() const noexcept;
+
         void addListener(Listener& listener) const;
         void removeListener(Listener& listener) const;
 
@@ -35,6 +40,7 @@ namespace jive
 
         mutable juce::ListenerList<Listener> listeners;
         const std::unique_ptr<Listener> internalListener;
+        Object* parent = nullptr;
 
         JUCE_LEAK_DETECTOR(Object)
     };
Original file line number	Diff line number	Diff line change
Expand Up		@@ -27,3 +27,5 @@
		#include "graphics/jive_LookAndFeel.cpp"

		#include "interface/jive_ComponentInteractionState.cpp"

		#include "time/jive_Timer.cpp"