blob: e9e7b8519f9cc5aff7e974c2f419146edf0daf61 (
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#pragma once
#include "../Base.h"
#include <cru/base/Base.h>
#include <cru/base/ClonePtr.h>
#include <cru/base/xml/XmlNode.h>
#include <memory>
#include <optional>
#include <typeindex>
namespace cru::ui::mapper {
class CRU_UI_API MapException : public Exception {
public:
using Exception::Exception;
};
class CRU_UI_API MapperBase : public Object {
public:
explicit MapperBase(std::type_index type_index);
public:
std::type_index GetTypeIndex() const { return type_index_; }
virtual bool SupportMapFromString() { return false; }
virtual bool SupportMapFromXml() { return false; }
virtual bool XmlElementIsOfThisType(xml::XmlElementNode* node) {
return false;
}
private:
std::type_index type_index_;
};
template <typename T>
class CRU_UI_API BasicMapper : public MapperBase {
public:
BasicMapper() : MapperBase(typeid(T)) {}
T MapFromString(std::string str) {
if (!SupportMapFromString()) {
throw Exception("This mapper does not support map from string.");
}
return DoMapFromString(str);
}
T MapFromXml(xml::XmlElementNode* node) {
if (!SupportMapFromXml()) {
throw Exception("This mapper does not support map from xml.");
}
if (!XmlElementIsOfThisType(node)) {
throw Exception("This xml element is not of mapping type.");
}
return DoMapFromXml(node);
}
protected:
virtual T DoMapFromString(std::string str) { NotImplemented(); }
virtual T DoMapFromXml(xml::XmlElementNode* node) { NotImplemented(); }
T MapFromXmlAsStringValue(xml::XmlElementNode* node,
std::optional<T> default_value = std::nullopt) {
std::optional<T>& value = default_value;
auto value_attr = node->GetOptionalAttributeValueCaseInsensitive("value");
if (value_attr) {
value = DoMapFromString(*value_attr);
}
for (auto child : node->GetChildren()) {
if (child->IsElementNode()) {
throw MapException("XML node can't contain element child.");
} else if (auto c = child->AsText()) {
auto text = c->GetText();
if (!text.empty() && value.has_value()) {
throw MapException("XML node has multiple values specified.");
}
value = DoMapFromString(text);
}
}
if (!value.has_value()) {
throw MapException("XML node has no value specified.");
}
return *value;
}
};
template <typename T>
using BasicSharedPtrMapper = BasicMapper<std::shared_ptr<T>>;
template <typename T>
using BasicClonePtrMapper = BasicMapper<ClonePtr<T>>;
} // namespace cru::ui::mapper
#define CRU_UI_DECLARE_CAN_MAP_FROM_STRING(type) \
public: \
bool SupportMapFromString() override { return true; } \
\
protected: \
type DoMapFromString(std::string str) override;
#define CRU_UI_DECLARE_CAN_MAP_FROM_XML_ELEMENT(type) \
public: \
bool SupportMapFromXml() override { return true; } \
bool XmlElementIsOfThisType(xml::XmlElementNode* node) override; \
\
protected: \
type DoMapFromXml(xml::XmlElementNode* node) override;
#define CRU_UI_DECLARE_CAN_MAP_FROM_XML_ELEMENT_TAG(xml_tag, type) \
public: \
bool SupportMapFromXml() override { return true; } \
bool XmlElementIsOfThisType(xml::XmlElementNode* node) override { \
return node->HasTag(#xml_tag); \
} \
\
protected: \
type DoMapFromXml(xml::XmlElementNode* node) override;
|
