From 96b20f4bf0c0d25800c496d209e60435f23c99e7 Mon Sep 17 00:00:00 2001
From: Sara <sara@saragerretsen.nl>
Date: Sun, 24 Nov 2024 00:27:48 +0100
Subject: [PATCH] feat: moved Callable class into it's own file

---
 src/core/callable.hpp | 69 +++++++++++++++++++++++++++++++++++++++++++
 src/core/signal.hpp   | 63 +--------------------------------------
 2 files changed, 70 insertions(+), 62 deletions(-)
 create mode 100644 src/core/callable.hpp

diff --git a/src/core/callable.hpp b/src/core/callable.hpp
new file mode 100644
index 0000000..7193d23
--- /dev/null
+++ b/src/core/callable.hpp
@@ -0,0 +1,69 @@
+#ifndef CANVAS_CALLABLE_HPP
+#define CANVAS_CALLABLE_HPP
+
+#include <functional>
+#include <memory>
+
+namespace ce {
+/* Base interface template for a member function pointer object
+ */
+template <class Return, class... Args>
+struct HiddenCallableBase {
+    virtual ~HiddenCallableBase() = default;
+    virtual Return call(Args... args) const = 0;
+    virtual bool equals(HiddenCallableBase<Return, Args...> const &other) const;
+};
+
+template <class Return, class... Args> bool HiddenCallableBase<Return, Args...>::equals(HiddenCallableBase<Return, Args...> const &other) const {
+    return &other == this;
+}
+
+/* Hidden component of a Callable, specialized for a specific target object
+ */
+template <class Target, class Return, class... Args>
+struct HiddenCallable : HiddenCallableBase<Return, Args...> {
+typedef Return (Target::*Signature)(Args...);
+    HiddenCallable(Target *target, Signature function);
+    Target *target{nullptr};
+    Signature function{nullptr};
+    virtual void call(Args...) const override;
+    virtual bool equals(HiddenCallableBase<Return, Args...> const &other) const override;
+};
+
+template <class Target, class Return, class... Args> bool HiddenCallable<Target, Return, Args...>::equals(HiddenCallableBase<Return, Args...> const &other) const {
+    HiddenCallable<Target, Return, Args...> const *cast{dynamic_cast<HiddenCallable<Target, Return, Args...> const *>(&other)};
+    return cast != nullptr && &other == this && cast->target == this->target && cast->function == this->function;
+}
+
+template <class Target, class Return, class... Args> HiddenCallable<Target, Return, Args...>::HiddenCallable(Target *target, Signature function) : target{target}, function{function} {}
+template <class Target, class Return, class... Args> void HiddenCallable<Target, Return, Args...>::call(Args... args) const {
+    std::invoke(this->function, this->target, args...);
+}
+
+/* Class for referring to a callable pointer to a member function.
+ */
+template <class Return, class... Args>
+class Callable {
+public:
+    std::shared_ptr<HiddenCallableBase<Return, Args...> const> hidden;
+    template <class Target> static Callable<Return, Args...> make(Target *target, Return (Target::*function)(Args...));
+    Return call(Args... args);
+};
+
+template <class Return, class... Args> template <class Target> Callable<Return, Args...>
+Callable<Return, Args...>::make(Target *target, Return (Target::*function)(Args...)) {
+    Callable<Return, Args...> callable;
+    callable.hidden = std::make_unique<HiddenCallable<Target, Return, Args...>>(target, function);
+    return callable;
+};
+
+template <class Return, class... Args> Return Callable<Return, Args...>::call(Args... args) {
+    return this->hidden->call(args...);
+}
+
+template <class Return, class... Args> bool operator==(Callable<Return, Args...> const &lhs, Callable<Return, Args...> const &rhs) {
+    return lhs.hidden->equals(*rhs.hidden.get());
+}
+}
+
+#endif // !CANVAS_CALLABLE_HPP
diff --git a/src/core/signal.hpp b/src/core/signal.hpp
index a7303fa..bc873cd 100644
--- a/src/core/signal.hpp
+++ b/src/core/signal.hpp
@@ -1,72 +1,11 @@
 #ifndef CANVAS_SIGNAL_HPP
 #define CANVAS_SIGNAL_HPP
 
+#include "callable.hpp"
 #include <cstdio>
-#include <functional>
-#include <memory>
 #include <vector>
 
 namespace ce {
-/* Base interface template for a member function pointer object
- */
-template <class Return, class... Args>
-struct HiddenCallableBase {
-    virtual ~HiddenCallableBase() = default;
-    virtual Return call(Args... args) const = 0;
-    virtual bool equals(HiddenCallableBase<Return, Args...> const &other) const;
-};
-
-template <class Return, class... Args> bool HiddenCallableBase<Return, Args...>::equals(HiddenCallableBase<Return, Args...> const &other) const {
-    return &other == this;
-}
-
-/* Hidden component of a Callable, specialized for a specific target object
- */
-template <class Target, class Return, class... Args>
-struct HiddenCallable : HiddenCallableBase<Return, Args...> {
-typedef Return (Target::*Signature)(Args...);
-    HiddenCallable(Target *target, Signature function);
-    Target *target{nullptr};
-    Signature function{nullptr};
-    virtual void call(Args...) const override;
-    virtual bool equals(HiddenCallableBase<Return, Args...> const &other) const override;
-};
-
-template <class Target, class Return, class... Args> bool HiddenCallable<Target, Return, Args...>::equals(HiddenCallableBase<Return, Args...> const &other) const {
-    HiddenCallable<Target, Return, Args...> const *cast{dynamic_cast<HiddenCallable<Target, Return, Args...> const *>(&other)};
-    return cast != nullptr && &other == this && cast->target == this->target && cast->function == this->function;
-}
-
-template <class Target, class Return, class... Args> HiddenCallable<Target, Return, Args...>::HiddenCallable(Target *target, Signature function) : target{target}, function{function} {}
-template <class Target, class Return, class... Args> void HiddenCallable<Target, Return, Args...>::call(Args... args) const {
-    std::invoke(this->function, this->target, args...);
-}
-
-/* Class for referring to a callable pointer to a member function.
- */
-template <class Return, class... Args>
-class Callable {
-public:
-    std::shared_ptr<HiddenCallableBase<Return, Args...> const> hidden;
-    template <class Target> static Callable<Return, Args...> make(Target *target, Return (Target::*function)(Args...));
-    Return call(Args... args);
-};
-
-template <class Return, class... Args> template <class Target> Callable<Return, Args...>
-Callable<Return, Args...>::make(Target *target, Return (Target::*function)(Args...)) {
-    Callable<Return, Args...> callable;
-    callable.hidden = std::make_unique<HiddenCallable<Target, Return, Args...>>(target, function);
-    return callable;
-};
-
-template <class Return, class... Args> Return Callable<Return, Args...>::call(Args... args) {
-    return this->hidden->call(args...);
-}
-
-template <class Return, class... Args> bool operator==(Callable<Return, Args...> const &lhs, Callable<Return, Args...> const &rhs) {
-    return lhs.hidden->equals(*rhs.hidden.get());
-}
-
 /*! Observer-listener implementation
  */
 template <class... Args>