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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
Ousía
Copyright (C) 2014 Benjamin Paaßen, Andreas Stöckel
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <QXmlStreamReader>
#include <functional>
#include <iostream>
#include <sstream>
#include "XmlAttributeHandler.hpp"
#include "XmlElementHandler.hpp"
#include "XmlReader.hpp"
namespace ousia {
namespace xml {
XmlReader::XmlReader(QXmlStreamReader &xml) :
xml(xml)
{
// Do nothing here
}
bool XmlReader::expectOneOf(std::vector<XmlElementHandler> &handlers)
{
// Skip all tokens except for "start element" and "end element"
while (!xml.atEnd()) {
// TODO: Implement mechanism for using the current state of the
// XmlStreamReader instead of always reading the next token?
const auto tokenType = xml.readNext();
switch (tokenType) {
case QXmlStreamReader::StartElement:
for (auto &h : handlers) {
if (h.matches(xml.name())) {
return h.execute();
}
}
// Expected tag was not found, display error message
// TODO: Use better logging mechanism!
std::cout << "Expected one of the following tags: ("
<< XmlElementHandler::expectedElementsStr(handlers)
<< "); but found element \""
<< xml.name().toString().toStdString()
<< "\" instead!" << std::endl;
return false;
/* This is Benjamins noob way of handling things: We just ignore them.
case QXmlStreamReader::EndElement:
// Expected tag was not found, instead we found a closing tag!
// TODO: Use better logging mechanism!
std::cout << "Expected one of the following tags: ("
<< XmlElementHandler::expectedElementsStr(handlers)
<< "); but found end of element \""
<< xml.name().toString().toStdString()
<< "\" instead!" << std::endl;
return false;*/
default:
continue;
}
}
return false;
}
bool XmlReader::parseArguments(std::map<std::string, XmlAttributeHandler> &handlers)
{
// Iterate the attributes of the current xml node
for (auto &attr : xml.attributes()) {
// Convert the name to a std string
const std::string name = attr.name().toString().toStdString();
const std::string value = attr.value().toString().toStdString();
// Try to fetch a corresponding attribute in the handlers map
auto it = handlers.find(name);
if (it != handlers.end()) {
XmlAttributeHandler &handler = (*it).second;
if (handler.isValid(value)) {
handler.executeSettter(value);
} else {
std::cout << "Invalid attribute value \"" << value
<< "\" for attribute " << name << std::endl;
return false;
}
} else {
std::cout << "Unexpected attribute " << name << std::endl;
return false;
}
}
// Iterate over all handlers to check whether all required handlers have
// been handled and in order to pass the default value to unhandled handlers
for (auto &it : handlers) {
// Fetch the name of the attribute and the handler
const std::string &name = it.first;
XmlAttributeHandler &handler = it.second;
if (!handler.isHandled()) {
if (handler.isRequired()) {
std::cout << "Attribute " << name
<< " is required but was not set!" << std::endl;
return false;
} else if (handler.getDefaultValue()) {
handler.executeSettter(handler.getDefaultValue());
}
}
}
return true;
}
std::shared_ptr<model::GraphNode> XmlReader::process()
{
std::shared_ptr<model::GraphNode> res{nullptr};
std::vector<XmlElementHandler> handlers{
{"domain", [&](){return (res = this->readDomain()) != nullptr;}}
};
if (!expectOneOf(handlers)) {
std::cout << "Errors occured while parsing XML file!" << std::endl;
return nullptr;
}
return res;
}
std::shared_ptr<model::domain::Domain> XmlReader::readDomain()
{
std::shared_ptr<model::domain::Domain> res{new model::domain::Domain()};
std::map<std::string, XmlAttributeHandler> handlers{
std::make_pair("name", XmlAttributeHandler(
true,
[&](const std::string& v) -> bool {return true;},
[&](const std::string& v) -> void {res->setName(v);}
))
};
if (!parseArguments(handlers)) {
std::cout << "Errors while parsing arguments for domain node!" << std::endl;
}
std::cout << res->getName() << std::endl;
return res;
}
}
}
|
