blob: 5bf140cde0dc976bc99ccf9f0183a86e6e409d34 (
plain)
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
|
#pragma once
#include "../Base.h"
#include "cru/common/ClonablePtr.h"
#include "cru/common/Exception.h"
#include "cru/xml/XmlNode.h"
#include <memory>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
namespace cru::ui::mapper {
template <typename T>
class BasicMapper;
class CRU_UI_API MapperBase : public Object {
public:
explicit MapperBase(std::type_index type_index);
CRU_DELETE_COPY(MapperBase)
CRU_DELETE_MOVE(MapperBase)
~MapperBase() override = default;
public:
std::type_index GetTypeIndex() const { return type_index_; }
template <typename T>
BasicMapper<T>* StaticCast() {
return static_cast<BasicMapper<T>*>(this);
}
template <typename T>
BasicMapper<T>* DynamicCast() {
return dynamic_cast<BasicMapper<T>*>(this);
}
virtual bool SupportMapFromString() { return false; }
virtual bool SupportMapFromXml() { return false; }
virtual bool XmlElementIsOfThisType(xml::XmlElementNode* node);
protected:
void SetAllowedTags(std::vector<String> allowed_tags) {
allowed_tags_ = std::move(allowed_tags);
}
private:
std::type_index type_index_;
std::vector<String> allowed_tags_;
};
template <typename T>
class CRU_UI_API BasicMapper : public MapperBase {
public:
static_assert(std::is_default_constructible_v<T>,
"T must be default constructible.");
BasicMapper() : MapperBase(typeid(T)) {}
CRU_DELETE_COPY(BasicMapper)
CRU_DELETE_MOVE(BasicMapper)
~BasicMapper() override = default;
virtual T MapFromString(String str) {
if (!SupportMapFromString()) {
throw Exception(u"This mapper does not support map from string.");
}
return DoMapFromString(str);
}
T MapFromXml(xml::XmlElementNode* node) {
if (!SupportMapFromXml()) {
throw Exception(u"This mapper does not support map from xml.");
}
if (!XmlElementIsOfThisType(node)) {
throw Exception(u"This xml element is not of mapping type.");
}
return DoMapFromXml(node);
}
protected:
virtual T DoMapFromString(String str) { return {}; }
virtual T DoMapFromXml(xml::XmlElementNode* node) { return {}; }
};
template <typename T>
using BasicRefMapper = BasicMapper<std::shared_ptr<T>>;
template <typename T>
using BasicPtrMapper = BasicMapper<ClonablePtr<T>>;
} // namespace cru::ui::mapper
|
