nodeeditor 源码阅读 - NodeDelegateModelRegistry节点代理模型注册器

目录

NodeDelegateModelRegistry.hpp 

NodeDelegateModelRegistry.cpp

---

NodeDelegateModelRegistry.hpp 

#include "Export.hpp"
#include "NodeData.hpp"
#include "NodeDelegateModel.hpp"
#include "QStringStdHash.hpp"

#include <QtCore/QString>

#include <functional>
#include <memory>
#include <set>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

namespace QtNodes {

/// 用于注册和管理节点委托模型的类
class NODE_EDITOR_PUBLIC NodeDelegateModelRegistry
{
public:
    using RegistryItemPtr = std::unique_ptr<NodeDelegateModel>; // 存储节点委托模型的智能指针类型
    using RegistryItemCreator = std::function<RegistryItemPtr>(); // 创建节点委托模型的函数类型
    using RegisteredModelCreatorsMap = std::unordered_map<QString, RegistryItemCreator>; // 注册的节点模型创建器的映射
    using RegisteredModelsCategoryMap = std::unordered_map<QString, QString>; // 节点模型和其所属类别的映射
    using CategoriesSet = std::set<QString>; // 存储节点模型类别的集合

    NodeDelegateModelRegistry() = default; // 默认构造函数
    ~NodeDelegateModelRegistry() = default; // 析构函数

    NodeDelegateModelRegistry(NodeDelegateModelRegistry const &) = delete;
    NodeDelegateModelRegistry(NodeDelegateModelRegistry &&) = default;

    NodeDelegateModelRegistry &operator=(NodeDelegateModelRegistry const &) = delete;

    NodeDelegateModelRegistry &operator=(NodeDelegateModelRegistry &&) = default;

public:
    // 注册节点模型的模板函数，通过创建节点模型的函数和所属类别
    template<typename ModelType>
    void registerModel(RegistryItemCreator creator, QString const &category = "Nodes")
    {
        QString const name = computeName<ModelType>(HasStaticMethodName<ModelType>{}, creator);
        if (!_registeredItemCreators.count(name)) {
            _registeredItemCreators[name] = std::move(creator);
            _categories.insert(category);
            _registeredModelsCategory[name] = category;
        }
    }

    // 注册节点模型的模板函数，通过节点模型的类型和所属类别
    template<typename ModelType>
    void registerModel(QString const &category = "Nodes")
    {
        RegistryItemCreator creator = []() { return std::make_unique<ModelType>(); };
        registerModel<ModelType>(std::move(creator), category);
    }

    // 创建指定名称的节点委托模型
    std::unique_ptr<NodeDelegateModel> create(QString const &modelName);

    // 获取已注册节点模型创建器的映射
    RegisteredModelCreatorsMap const &registeredModelCreators() const;

    // 获取已注册节点模型和其所属类别的映射
    RegisteredModelsCategoryMap const &registeredModelsCategoryAssociation() const;

    // 获取已注册的节点模型类别集合
    CategoriesSet const &categories() const;

private:
    RegisteredModelsCategoryMap _registeredModelsCategory; // 存储已注册节点模型和其所属类别的映射

    CategoriesSet _categories; // 存储节点模型类别的集合

    RegisteredModelCreatorsMap _registeredItemCreators; // 存储已注册节点模型创建器的映射

private:
    // 如果已注册的 ModelType 类具有静态成员方法 `static QString Name();`，则使用该方法，否则使用非静态方法 `virtual QString name() const;`
    template<typename T, typename = void>
    struct HasStaticMethodName : std::false_type
    {};

    template<typename T>
    struct HasStaticMethodName<
        T,
        typename std::enable_if<std::is_same<decltype(T::Name()), QString>::value>::type>
        : std::true_type
    {};

    // 根据 ModelType 类型和创建器获取节点模型的名称
    template<typename ModelType>
    static QString computeName(std::true_type, RegistryItemCreator const &)
    {
        return ModelType::Name();
    }

    template<typename ModelType>
    static QString computeName(std::false_type, RegistryItemCreator const &creator)
    {
        return creator()->name();
    }

    // 用于解包 std::unique_ptr 类型并获取模型类型
    template<typename T>
    struct UnwrapUniquePtr
    {
        // 断言总是触发，但是编译器不知道这一点：
        static_assert(!std::is_same<T, T>::value,
                      "ModelCreator 必须返回 std::unique_ptr<T>，其中 T 继承自 NodeDelegateModel");
    };

    template<typename T>
    struct UnwrapUniquePtr<std::unique_ptr<T>>
    {
        static_assert(std::is_base_of<NodeDelegate

NodeDelegateModelRegistry.cpp

待续。。。