1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
#pragma once
#include "Export.hpp"
#include "NodeDataModel.hpp"
#include "QStringStdHash.hpp"
#include "TypeConverter.hpp"
#include "memory.hpp"
#include <QtCore/QString>
#include <functional>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
namespace QtNodes
{
/// Class uses map for storing models (name, model)
class NODE_EDITOR_PUBLIC DataModelRegistry
{
public:
using RegistryItemPtr = std::unique_ptr<NodeDataModel>;
using RegistryItemCreator = std::function<RegistryItemPtr()>;
using RegisteredModelCreatorsMap = std::unordered_map<QString, RegistryItemCreator>;
using RegisteredModelsCategoryMap = std::unordered_map<QString, QString>;
using CategoriesSet = std::set<QString>;
using RegisteredTypeConvertersMap = std::map<TypeConverterId, TypeConverter>;
DataModelRegistry() = default;
~DataModelRegistry() = default;
DataModelRegistry(DataModelRegistry const &) = delete;
DataModelRegistry(DataModelRegistry &&) = default;
DataModelRegistry &operator=(DataModelRegistry const &) = delete;
DataModelRegistry &operator=(DataModelRegistry &&) = default;
public:
template<typename ModelType>
void registerModel(RegistryItemCreator creator, QString const &category = "Nodes")
{
registerModelImpl<ModelType>(std::move(creator), category);
}
template<typename ModelType>
void registerModel(QString const &category = "Nodes")
{
RegistryItemCreator creator = []() {
return std::make_unique<ModelType>();
};
registerModelImpl<ModelType>(std::move(creator), category);
}
template<typename ModelType>
void registerModel(QString const &category, RegistryItemCreator creator)
{
registerModelImpl<ModelType>(std::move(creator), category);
}
void registerTypeConverter(TypeConverterId const &id, TypeConverter typeConverter)
{
_registeredTypeConverters[id] = std::move(typeConverter);
}
std::unique_ptr<NodeDataModel> create(QString const &modelName);
RegisteredModelCreatorsMap const ®isteredModelCreators() const;
RegisteredModelsCategoryMap const ®isteredModelsCategoryAssociation() const;
CategoriesSet const &categories() const;
TypeConverter getTypeConverter(NodeDataTypeId const &d1, NodeDataTypeId const &d2) const;
private:
RegisteredModelsCategoryMap _registeredModelsCategory;
CategoriesSet _categories;
RegisteredModelCreatorsMap _registeredItemCreators;
RegisteredTypeConvertersMap _registeredTypeConverters;
private:
// If the registered ModelType class has the static member method
//
// static Qstring Name();
//
// use it. Otherwise use the non-static method:
//
// 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
{
};
template<typename ModelType>
typename std::enable_if<HasStaticMethodName<ModelType>::value>::type registerModelImpl(RegistryItemCreator creator,
QString const &category)
{
const QString name = ModelType::Name();
if (_registeredItemCreators.count(name) == 0)
{
_registeredItemCreators[name] = std::move(creator);
_categories.insert(category);
_registeredModelsCategory[name] = category;
}
}
template<typename ModelType>
typename std::enable_if<!HasStaticMethodName<ModelType>::value>::type registerModelImpl(RegistryItemCreator creator,
QString const &category)
{
const QString name = creator()->name();
if (_registeredItemCreators.count(name) == 0)
{
_registeredItemCreators[name] = std::move(creator);
_categories.insert(category);
_registeredModelsCategory[name] = category;
}
}
};
} // namespace QtNodes
|
