Bunch of updates and cleanup.

Author: GhostofCookie

include/flow/core/Module.hpp

@@ -19,6 +19,11 @@ class NodeFactory;
 
 class Module
 {
+    struct HandleDelete
+    {
+        void operator()(void*);
+    };
+
   public:
     /**
      * @brief Constructs a flow module from a given directory.
@@ -42,6 +47,8 @@ class Module
      */
     bool Unload();
 
+    bool IsLoaded() const noexcept { return _handle != nullptr; }
+
     const std::string& GetName() const noexcept { return _name; }
 
     const std::string& GetVersion() const noexcept { return _version; }
@@ -52,6 +59,9 @@ class Module
 
     const std::vector<std::string>& GetDependencies() const noexcept { return _dependencies; }
 
+  private:
+    void Validate(const json& module_json);
+
   public:
     static const std::string FileExtension;
     static const std::string BinaryExtension;
@@ -64,7 +74,7 @@ class Module
     std::vector<std::string> _dependencies;
 
     std::shared_ptr<NodeFactory> _factory;
-    void* _handle = nullptr;
+    std::unique_ptr<void, HandleDelete> _handle;
 };
 
 FLOW_NAMESPACE_END

include/flow/core/Node.hpp

@@ -11,7 +11,7 @@
 #include "Port.hpp"
 #include "UUID.hpp"
 
-#include <nlohmann/json_fwd.hpp>
+#include <nlohmann/json.hpp>
 
 #include <mutex>
 #include <string>
@@ -165,15 +165,29 @@ class Node
     void EmitUpdate(const IndexableName& key, const SharedNodeData& data);
 
   public:
+    /// Event broadcasted called on Compute.
     EventDispatcher<> OnCompute;
+
+    /// Event broadcasted on setting an input.
     EventDispatcher<const IndexableName&, const SharedNodeData&> OnSetInput;
+
+    /// Event broadcasted on setting an output.
     EventDispatcher<const IndexableName&, const SharedNodeData&> OnSetOutput;
+
+    /// Event broadcasted on Compute  throwing an error.
     EventDispatcher<const std::exception&> OnError;
+
+    /// Event broadcasted on output updates being emitted.
     EventDispatcher<const UUID&, const IndexableName&, const SharedNodeData&> OnEmitOutput;
 
   protected:
     mutable std::mutex _mutex;
 
+    /// Event to be used by the graph to propagate output updates.
+    Event<const UUID&, const IndexableName&, const SharedNodeData&> _propagate_output_update;
+
+    friend class Graph;
+
   private:
     UUID _id;
     std::string _class_name;
@@ -185,33 +199,140 @@ class Node
     PortMap _output_ports;
 };
 
-#define OVERLOAD_PORT_TYPE(Original, As)                                                                               \
-    template<>                                                                                                         \
-    inline auto FLOW_NAMESPACE::Node::GetInputData<Original>(const IndexableName& key) const noexcept                  \
-    {                                                                                                                  \
-        return GetInputData<As>(key);                                                                                  \
-    }                                                                                                                  \
-    template<>                                                                                                         \
-    inline auto FLOW_NAMESPACE::Node::GetOutputData<Original>(const IndexableName& key) const noexcept                 \
-    {                                                                                                                  \
-        return GetOutputData<As>(key);                                                                                 \
-    }                                                                                                                  \
-    template<>                                                                                                         \
-    inline void FLOW_NAMESPACE::Node::AddInput<Original>(std::string_view key, const std::string& caption,             \
-                                                         SharedNodeData data)                                          \
-    {                                                                                                                  \
-        return AddInput<As>(key, caption, std::move(data));                                                            \
-    }                                                                                                                  \
-    template<>                                                                                                         \
-    inline void FLOW_NAMESPACE::Node::AddOutput<Original>(std::string_view key, const std::string& caption,            \
-                                                          SharedNodeData data)                                         \
-    {                                                                                                                  \
-        return AddOutput<As>(key, caption, std::move(data));                                                           \
-    }
+/**
+ * @brief Structure that reveals the types of the return value and arguments of a function at compile-time.
+ * @tparam F The function type being analyzed.
+ */
+template<typename F>
+struct FunctionTraits;
+
+template<typename R, typename... Args>
+struct FunctionTraits<R(Args...)>
+{
+    using ReturnType = std::invoke_result_t<R(Args...), Args...>;
+    using ArgTypes   = std::tuple<Args...>;
+};
 
 /**
- * Specialise const char* to use std::string for type safety.
+ * @brief Node class that wraps a declared function.
+ *
+ * @details Wraps a declared function as a node type with inputs labeled in increasing alphabetical order starting at
+ *          'a'. Requires that the function node be overloaded. If the function is overloaded, then supplying the
+ *          specific overload to wrap is required.
+ *
+ * @tparam F
+ * @tparam Func
  */
-OVERLOAD_PORT_TYPE(const char*, std::string);
+
+template<typename F, std::add_pointer_t<std::remove_pointer_t<F>> Func>
+class FunctionWrapperNode : public Node
+{
+  protected:
+    using traits   = FunctionTraits<std::remove_pointer_t<F>>;
+    using output_t = typename traits::ReturnType;
+    using arg_ts   = typename traits::ArgTypes;
+
+  private:
+    template<int... Idx>
+    void ParseArguments(std::integer_sequence<int, Idx...>)
+    {
+        (
+            [&] {
+                if constexpr (std::is_lvalue_reference_v<std::tuple_element_t<Idx, arg_ts>> &&
+                              !std::is_const_v<std::remove_reference_t<std::tuple_element_t<Idx, arg_ts>>>)
+                {
+                    AddOutput<std::tuple_element_t<Idx, arg_ts>>({output_names[Idx] = 'a' + Idx}, "");
+                }
+                else
+                {
+                    AddInput<std::tuple_element_t<Idx, arg_ts>>({input_names[Idx] = 'a' + Idx}, "");
+                }
+            }(),
+            ...);
+    }
+
+    template<int... Idx>
+    auto GetInputs(std::integer_sequence<int, Idx...>)
+    {
+        return std::make_tuple(GetInputData<std::tuple_element_t<Idx, arg_ts>>(IndexableName{input_names[Idx]})...);
+    }
+
+    template<int... Idx>
+    json SaveInputs(std::integer_sequence<int, Idx...>) const
+    {
+        json inputs_json;
+        (
+            [&, this] {
+                const auto& key = input_names[Idx];
+                if (auto x = GetInputData<std::tuple_element_t<Idx, arg_ts>>(IndexableName{key}))
+                {
+                    inputs_json[key] = x->Get();
+                }
+            }(),
+            ...);
+
+        return inputs_json;
+    }
+
+    template<int... Idx>
+    void RestoreInputs(json& j, std::integer_sequence<int, Idx...>)
+    {
+        (
+            [&, this] {
+                const auto& key = input_names[Idx];
+                if (!j.contains(key))
+                {
+                    return;
+                }
+
+                if constexpr (!std::is_lvalue_reference_v<std::tuple_element_t<Idx, arg_ts>>)
+                {
+                    SetInputData(IndexableName{key}, MakeNodeData<std::tuple_element_t<Idx, arg_ts>>(j[key]), false);
+                }
+            }(),
+            ...);
+    }
+
+  public:
+    explicit FunctionWrapperNode(const UUID& uuid, const std::string& name, std::shared_ptr<Env> env)
+        : Node(uuid, TypeName_v<FunctionWrapperNode<F, Func>>, name, std::move(env)), _func{Func}
+    {
+        ParseArguments(std::make_integer_sequence<int, std::tuple_size_v<arg_ts>>{});
+        AddOutput<output_t>("result", "result");
+    }
+
+    virtual ~FunctionWrapperNode() = default;
+
+  protected:
+    void Compute() override
+    {
+        auto inputs = GetInputs(std::make_integer_sequence<int, std::tuple_size_v<arg_ts>>{});
+
+        if (std::apply([](auto&&... args) { return (!args || ...); }, inputs))
+        {
+            return;
+        }
+
+        auto result = std::apply([&](auto&&... args) { return _func(args->Get()...); }, inputs);
+        this->SetOutputData("result", MakeNodeData(std::move(result)));
+    }
+
+    json SaveInputs() const override
+    {
+        return SaveInputs(std::make_integer_sequence<int, std::tuple_size_v<arg_ts>>{});
+    }
+
+    void RestoreInputs(const json& j) override
+    {
+        RestoreInputs(const_cast<json&>(j), std::make_integer_sequence<int, std::tuple_size_v<arg_ts>>{});
+    }
+
+  private:
+    std::add_pointer_t<std::remove_pointer_t<F>> _func;
+    static inline std::array<std::string, std::tuple_size_v<arg_ts>> input_names{""};
+    static inline std::array<std::string, std::tuple_size_v<arg_ts>> output_names{""};
+};
+
+#define DECLARE_FUNCTION_NODE_TYPE(func) FunctionWrapperNode<decltype(func), func>
 
 FLOW_NAMESPACE_END

include/flow/core/NodeData.hpp

@@ -321,6 +321,20 @@ class NodeData<T&> : public INodeData
         return "Error: " + std::string(e.what());
     }
 
+  protected:
+    void* AsPointer() const override { return std::bit_cast<void*>(&this->_value); }
+    void FromPointer(void* value) override
+    {
+        if constexpr (std::is_copy_assignable_v<T>)
+        {
+            this->_value = *std::bit_cast<T*>(value);
+        }
+        else
+        {
+            this->_value = std::move(*std::bit_cast<T*>(value));
+        }
+    }
+
   protected:
     T& _value;
 };
@@ -400,24 +414,6 @@ class NodeData<Ptr> : public detail::NodeData<Ptr>
     constexpr auto operator->() const noexcept { return this->_value.operator->(); }
 };
 
-/**
- * @brief Specialisation for std::string to allow easy conversion to const char*.
- */
-template<>
-class NodeData<std::string> : public detail::NodeData<std::string>
-{
-    using Base = detail::NodeData<std::string>;
-
-  public:
-    virtual ~NodeData() = default;
-
-    using Base::Base;
-    using Base::operator=;
-
-    [[nodiscard]] operator const char*() const { return this->_value.c_str(); }
-    [[nodiscard]] const char* Get() const { return this->_value.c_str(); }
-};
-
 /**
  * @brief Disallow the use of const char* data type, and instead use the std::string version.
  */

include/flow/core/NodeFactory.hpp

@@ -46,7 +46,7 @@ class NodeFactory
      * @param name The friendly name of the node to register it under.
      */
     template<concepts::NodeType T>
-    void RegisterNodeClass(const std::string& category, const std::string& name);
+    void RegisterNodeClass(const std::string& category, const std::string& name = std::string{TypeName_v<T>});
 
     /**
      * @brief Removes a node's construction method from the factory.
@@ -246,7 +246,8 @@ class Category
      * @param name The friendly name of the node to register it under.
      */
     template<concepts::NodeType T>
-    void RegisterNodeClass(const std::shared_ptr<NodeFactory>& factory, const std::string& friendly_name)
+    void RegisterNodeClass(const std::shared_ptr<NodeFactory>& factory,
+                           const std::string& friendly_name = std::string{TypeName_v<T>})
     {
         factory->RegisterNodeClass<T>(_category_name, friendly_name);
         _classes.insert(std::make_pair(std::string{TypeName_v<T>}, friendly_name));

include/flow/core/TypeName.hpp

@@ -40,15 +40,30 @@ constexpr std::string_view wrapped_type_name()
 #endif
 }
 
-constexpr std::size_t wrapped_type_name_prefix_length()
+constexpr std::size_t wrapped_type_name_prefix_length() noexcept
 {
     return wrapped_type_name<void>().find(TypeName<void>::value);
 }
 
-constexpr std::size_t wrapped_type_name_suffix_length()
+constexpr std::size_t wrapped_type_name_suffix_length() noexcept
 {
     return wrapped_type_name<void>().length() - wrapped_type_name_prefix_length() - TypeName<void>::value.length();
 }
+
+template<typename T>
+constexpr std::string_view get_typename() noexcept
+{
+    constexpr auto wrapped_name    = detail::wrapped_type_name<T>();
+    constexpr auto prefix_length   = detail::wrapped_type_name_prefix_length();
+    constexpr auto suffix_length   = detail::wrapped_type_name_suffix_length();
+    constexpr auto TypeName_length = wrapped_name.length() - prefix_length - suffix_length;
+    constexpr auto name            = wrapped_name.substr(prefix_length, TypeName_length);
+
+    constexpr auto adjusted_prefix_length   = (name.starts_with("class") ? 6 : (name.starts_with("struct") ? 7 : 0));
+    constexpr auto adjusted_TypeName_length = name.length() - adjusted_prefix_length;
+
+    return name.substr(adjusted_prefix_length, adjusted_TypeName_length);
+}
 } // namespace detail
 
 template<typename T>
@@ -57,18 +72,37 @@ struct TypeName
     /**
      * @brief The string representation of the given type.
      */
-    static constexpr std::string_view value = [] {
-        constexpr auto wrapped_name    = detail::wrapped_type_name<T>();
-        constexpr auto prefix_length   = detail::wrapped_type_name_prefix_length();
-        constexpr auto suffix_length   = detail::wrapped_type_name_suffix_length();
-        constexpr auto TypeName_length = wrapped_name.length() - prefix_length - suffix_length;
-        constexpr auto name            = wrapped_name.substr(prefix_length, TypeName_length);
-
-        constexpr auto adjusted_prefix_length = (name.starts_with("class") ? 6 : (name.starts_with("struct") ? 7 : 0));
-        constexpr auto adjusted_TypeName_length = name.length() - adjusted_prefix_length;
-
-        return name.substr(adjusted_prefix_length, adjusted_TypeName_length);
-    }();
+    static constexpr std::string_view value = detail::get_typename<T>();
+
+    static constexpr bool is_reference = false;
+
+    static constexpr bool is_const = std::is_const_v<T>;
+};
+
+template<typename T>
+struct TypeName<T&>
+{
+    /**
+     * @brief The string representation of the given type.
+     */
+    static constexpr std::string_view value = detail::get_typename<T&>();
+
+    static constexpr bool is_reference = true;
+
+    static constexpr bool is_const = std::is_const_v<T>;
+};
+
+template<typename T>
+struct TypeName<T&&>
+{
+    /**
+     * @brief The string representation of the given type.
+     */
+    static constexpr std::string_view value = detail::get_typename<T&>();
+
+    static constexpr bool is_reference = true;
+
+    static constexpr bool is_const = std::is_const_v<T>;
 };
 
 template<typename T, typename U>