Merge branch 'master' of https://github.com/edubart/otclient
Henrique
13 years ago
commit
48abbe0ed4
@ -0,0 +1,359 @@
|
|||||||
|
#include "fml.h"
|
||||||
|
|
||||||
|
#include <boost/algorithm/string.hpp>
|
||||||
|
#include <boost/tokenizer.hpp>
|
||||||
|
#include <boost/lexical_cast.hpp>
|
||||||
|
|
||||||
|
namespace FML {
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Utilities
|
||||||
|
|
||||||
|
bool fml_convert(const std::string& input, bool& b)
|
||||||
|
{
|
||||||
|
std::string names[5][2] = { { "1", "0" },
|
||||||
|
{ "y", "n" },
|
||||||
|
{ "yes", "no" },
|
||||||
|
{ "true", "false" },
|
||||||
|
{ "on", "off" } };
|
||||||
|
std::string processedInput = input;
|
||||||
|
boost::trim(processedInput);
|
||||||
|
boost::to_lower(processedInput);
|
||||||
|
for(int i=0;i<5;i++) {
|
||||||
|
if(names[i][0] == processedInput) {
|
||||||
|
b = true;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(names[i][1] == processedInput) {
|
||||||
|
b = false;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool fml_convert(const std::string& input, std::string& output) {
|
||||||
|
output = input;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Node
|
||||||
|
|
||||||
|
Node::~Node()
|
||||||
|
{
|
||||||
|
for(NodeList::iterator it = m_children.begin(); it != m_children.end(); ++it)
|
||||||
|
delete (*it);
|
||||||
|
}
|
||||||
|
|
||||||
|
Node* Node::at(const std::string& childTag) const
|
||||||
|
{
|
||||||
|
for(NodeList::const_iterator it = m_children.begin(); it != m_children.end(); ++it) {
|
||||||
|
if((*it)->tag() == childTag)
|
||||||
|
return (*it);
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
Node* Node::at(int pos) const
|
||||||
|
{
|
||||||
|
if(pos < 0 || pos >= size())
|
||||||
|
return NULL;
|
||||||
|
return m_children[pos];
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string Node::value(const std::string& def) const
|
||||||
|
{
|
||||||
|
if(!m_value.empty())
|
||||||
|
return m_value;
|
||||||
|
return def;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string Node::valueAt(const std::string childTag, const std::string& def) const
|
||||||
|
{
|
||||||
|
for(NodeList::const_iterator it = m_children.begin(); it != m_children.end(); ++it) {
|
||||||
|
if((*it)->tag() == childTag)
|
||||||
|
return (*it)->value();
|
||||||
|
}
|
||||||
|
return def;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Node::addNode(Node *node)
|
||||||
|
{
|
||||||
|
if(node->hasTag() && node->hasValue()) {
|
||||||
|
// remove nodes wit the same tag
|
||||||
|
for(NodeList::iterator it = m_children.begin(); it != m_children.end(); ++it) {
|
||||||
|
if((*it)->tag() == node->tag()) {
|
||||||
|
delete (*it);
|
||||||
|
m_children.erase(it);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
m_children.push_back(node);
|
||||||
|
node->setParent(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string Node::generateErrorMessage(const std::string& message) const
|
||||||
|
{
|
||||||
|
std::stringstream ss;
|
||||||
|
ss << "FML error ";
|
||||||
|
if(m_parser && !m_parser->getWhat().empty())
|
||||||
|
ss << "in " << m_parser->getWhat();
|
||||||
|
if(m_line > 0)
|
||||||
|
ss << "at line " << m_line;
|
||||||
|
ss << ": " << message;
|
||||||
|
return ss.str();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Parser
|
||||||
|
|
||||||
|
Parser::~Parser()
|
||||||
|
{
|
||||||
|
if(m_rootNode)
|
||||||
|
delete m_rootNode;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Parser::load(std::istream& in)
|
||||||
|
{
|
||||||
|
// initialize root node
|
||||||
|
if(m_rootNode)
|
||||||
|
delete m_rootNode;
|
||||||
|
m_rootNode = new Node();
|
||||||
|
m_rootNode->setTag("root");
|
||||||
|
|
||||||
|
m_currentParent = m_rootNode;
|
||||||
|
m_currentDepth = 0;
|
||||||
|
m_currentLine = 0;
|
||||||
|
m_multilineMode = DONT_MULTILINE;
|
||||||
|
m_multilineData.clear();
|
||||||
|
|
||||||
|
while(in.good() && !in.eof()) {
|
||||||
|
m_currentLine++;
|
||||||
|
std::string line;
|
||||||
|
std::getline(in, line);
|
||||||
|
parseLine(line);
|
||||||
|
if(hasError())
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// stop multilining if enabled
|
||||||
|
if(isMultilining())
|
||||||
|
stopMultilining();
|
||||||
|
|
||||||
|
return !hasError();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Parser::parseLine(std::string& line)
|
||||||
|
{
|
||||||
|
// process multiline data first
|
||||||
|
if(isMultilining() && parseMultiline(line))
|
||||||
|
return;
|
||||||
|
|
||||||
|
// calculate depth
|
||||||
|
std::size_t numSpaces = line.find_first_not_of(' ');
|
||||||
|
|
||||||
|
// trim left whitespaces
|
||||||
|
boost::trim_left(line);
|
||||||
|
|
||||||
|
// skip comment lines
|
||||||
|
if(line[0] == '#')
|
||||||
|
return;
|
||||||
|
|
||||||
|
// skip empty lines
|
||||||
|
if(line.empty())
|
||||||
|
return;
|
||||||
|
|
||||||
|
int depth = 0;
|
||||||
|
if(numSpaces != std::string::npos) {
|
||||||
|
depth = numSpaces / 2;
|
||||||
|
// check for syntax error
|
||||||
|
if(numSpaces % 2 != 0) {
|
||||||
|
setErrorMessage("file must be idented every 2 whitespaces", m_currentLine);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// a depth above
|
||||||
|
if(depth == m_currentDepth+1) {
|
||||||
|
// change current parent to the previous added node
|
||||||
|
m_currentParent = m_previousNode;
|
||||||
|
// a depth below, change parent to previus parent and add new node inside previuos parent
|
||||||
|
} else if(depth < m_currentDepth) {
|
||||||
|
// change current parent to the the new depth parent
|
||||||
|
for(int i=0;i<m_currentDepth-depth;++i)
|
||||||
|
m_currentParent = m_currentParent->parent();
|
||||||
|
// else if nots the same depth it's a syntax error
|
||||||
|
} else if(depth != m_currentDepth) {
|
||||||
|
setErrorMessage("invalid indentation level", m_currentLine);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// update current depth
|
||||||
|
m_currentDepth = depth;
|
||||||
|
|
||||||
|
// add node
|
||||||
|
Node *node = parseNode(line);
|
||||||
|
m_currentParent->addNode(node);
|
||||||
|
m_previousNode = node;
|
||||||
|
}
|
||||||
|
|
||||||
|
Node *Parser::parseNode(std::string& line)
|
||||||
|
{
|
||||||
|
// determine node tag and value
|
||||||
|
std::string tag;
|
||||||
|
std::string value;
|
||||||
|
|
||||||
|
// its a node that has tag and possible a value
|
||||||
|
std::size_t dotsPos = line.find_first_of(':');
|
||||||
|
if(dotsPos != std::string::npos) {
|
||||||
|
tag = line.substr(0, dotsPos);
|
||||||
|
value = line.substr(dotsPos+1);
|
||||||
|
}
|
||||||
|
// its a node that has a value but no tag
|
||||||
|
else if(line[0] == '-') {
|
||||||
|
value = line.substr(1);
|
||||||
|
}
|
||||||
|
// its a node that has only a tag
|
||||||
|
else {
|
||||||
|
tag = line;
|
||||||
|
}
|
||||||
|
|
||||||
|
// trim the tag and value
|
||||||
|
boost::trim(tag);
|
||||||
|
boost::trim(value);
|
||||||
|
|
||||||
|
// create the node
|
||||||
|
Node *node = new Node(this);
|
||||||
|
node->setLine(m_currentLine);
|
||||||
|
node->setTag(tag);
|
||||||
|
|
||||||
|
// process node value
|
||||||
|
if(!value.empty()) {
|
||||||
|
// multiline text scalar
|
||||||
|
if(value[0] == '|') {
|
||||||
|
startMultilining(value);
|
||||||
|
}
|
||||||
|
// sequence
|
||||||
|
else if(value[0] == '[') {
|
||||||
|
if(boost::ends_with(value, "]")) {
|
||||||
|
value.erase(value.length()-1, 1);
|
||||||
|
value.erase(0, 1);
|
||||||
|
boost::trim(value);
|
||||||
|
boost::tokenizer<boost::escaped_list_separator<char> > tokens(value);
|
||||||
|
for(boost::tokenizer<boost::escaped_list_separator<char> >::iterator it = tokens.begin(); it != tokens.end(); ++it) {
|
||||||
|
value = *it;
|
||||||
|
boost::trim(value);
|
||||||
|
|
||||||
|
Node *child = new Node(this);
|
||||||
|
child->setLine(m_currentLine);
|
||||||
|
child->setValue(value);
|
||||||
|
node->addNode(child);
|
||||||
|
}
|
||||||
|
} else
|
||||||
|
setErrorMessage("missing ']' in sequence", m_currentLine);
|
||||||
|
}
|
||||||
|
// text scalar
|
||||||
|
else {
|
||||||
|
node->setValue(parseTextScalar(value));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return node;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string Parser::parseTextScalar(std::string value)
|
||||||
|
{
|
||||||
|
if(value[0] == '"' && value[value.length()-1] == '"') {
|
||||||
|
value = value.substr(1, value.length()-2);
|
||||||
|
// escape characters
|
||||||
|
boost::replace_all(value, "\\\\", "\\");
|
||||||
|
boost::replace_all(value, "\\\"", "\"");
|
||||||
|
boost::replace_all(value, "\\n", "\n");
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Parser::startMultilining(const std::string& param)
|
||||||
|
{
|
||||||
|
m_multilineMode = MULTILINE_DONT_FOLD;
|
||||||
|
m_currentDepth++;
|
||||||
|
if(param.length() == 2) {
|
||||||
|
switch(param[1]) {
|
||||||
|
case '-':
|
||||||
|
m_multilineMode = MULTILINE_FOLD_BLOCK;
|
||||||
|
break;
|
||||||
|
case '+':
|
||||||
|
m_multilineMode = MULTILINE_FOLD_FLOW;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
setErrorMessage("invalid multiline identifier", m_currentLine);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void Parser::stopMultilining()
|
||||||
|
{
|
||||||
|
// remove all new lines at the end
|
||||||
|
if(m_multilineMode == MULTILINE_DONT_FOLD || m_multilineMode == MULTILINE_FOLD_BLOCK) {
|
||||||
|
while(true) {
|
||||||
|
int lastPos = m_multilineData.length()-1;
|
||||||
|
if(m_multilineData[lastPos] != '\n')
|
||||||
|
break;
|
||||||
|
m_multilineData.erase(lastPos, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if(m_multilineMode == MULTILINE_FOLD_BLOCK)
|
||||||
|
m_multilineData.append("\n");
|
||||||
|
|
||||||
|
m_previousNode->setValue(m_multilineData);
|
||||||
|
m_multilineMode = DONT_MULTILINE;
|
||||||
|
m_currentDepth--;
|
||||||
|
m_multilineData.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Parser::parseMultiline(std::string line)
|
||||||
|
{
|
||||||
|
// calculate depth
|
||||||
|
std::size_t numSpaces = line.find_first_not_of(' ');
|
||||||
|
|
||||||
|
// depth above or equal current depth, add the text to the multiline
|
||||||
|
if(numSpaces != std::string::npos && (int)numSpaces >= m_currentDepth*2) {
|
||||||
|
m_multilineData += parseTextScalar(line.substr(m_currentDepth*2)) + "\n";
|
||||||
|
return true;
|
||||||
|
// depth below the current depth, check if it is a node
|
||||||
|
} else if(numSpaces == std::string::npos || (int)numSpaces < m_currentDepth*2) {
|
||||||
|
// if it has contents, its a node, then we must end multiline
|
||||||
|
if(line.find_first_not_of(' ') != std::string::npos) {
|
||||||
|
stopMultilining();
|
||||||
|
// the line still have a node on it
|
||||||
|
}
|
||||||
|
// no contents, just an extra line
|
||||||
|
else {
|
||||||
|
m_multilineData += "\n";
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Parser::setErrorMessage(const std::string& message, int line)
|
||||||
|
{
|
||||||
|
std::stringstream ss;
|
||||||
|
ss << "FML syntax error in ";
|
||||||
|
if(!m_what.empty())
|
||||||
|
ss << m_what << " ";
|
||||||
|
if(line > 0)
|
||||||
|
ss << "at line " << line;
|
||||||
|
ss << ": " << message;
|
||||||
|
m_error = ss.str();
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace FML {
|
||||||
@ -0,0 +1,217 @@
|
|||||||
|
#ifndef FML_H
|
||||||
|
#define FML_H
|
||||||
|
|
||||||
|
#include <sstream>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
#include <iterator>
|
||||||
|
#include <map>
|
||||||
|
|
||||||
|
#include <boost/utility.hpp>
|
||||||
|
#include <boost/foreach.hpp>
|
||||||
|
|
||||||
|
namespace FML {
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Utilities
|
||||||
|
|
||||||
|
bool fml_convert(const std::string& input, bool& b);
|
||||||
|
bool fml_convert(const std::string& input, std::string& output);
|
||||||
|
|
||||||
|
template <typename V, typename T>
|
||||||
|
bool fml_convert(const V& in, T& out) {
|
||||||
|
std::stringstream ss;
|
||||||
|
ss << in;
|
||||||
|
ss >> out;
|
||||||
|
return !!ss;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Node
|
||||||
|
|
||||||
|
class Parser;
|
||||||
|
|
||||||
|
class Node : boost::noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef std::vector<Node*> NodeList;
|
||||||
|
|
||||||
|
Node(Parser* parser = 0) : m_parser(parser), m_parent(0), m_line(0) { }
|
||||||
|
~Node();
|
||||||
|
|
||||||
|
bool hasTag() const { return !m_tag.empty(); }
|
||||||
|
bool hasChildren() const { return size() > 0; }
|
||||||
|
bool hasValue() const { return !m_value.empty(); }
|
||||||
|
bool hasNode(const std::string childTag) const { return at(childTag) != 0; }
|
||||||
|
|
||||||
|
void setTag(std::string tag) { m_tag = tag; }
|
||||||
|
void setLine(int line) { m_line = line; }
|
||||||
|
void setValue(const std::string& value) { m_value = value; }
|
||||||
|
void setParent(Node* parent) { m_parent = parent; }
|
||||||
|
|
||||||
|
std::string tag() const { return m_tag; }
|
||||||
|
int line() const { return m_line; }
|
||||||
|
int size() const { return m_children.size(); }
|
||||||
|
Node* parent() { return m_parent; }
|
||||||
|
|
||||||
|
// iterators
|
||||||
|
typedef NodeList::iterator iterator;
|
||||||
|
typedef NodeList::const_iterator const_iterator;
|
||||||
|
|
||||||
|
iterator begin() { return m_children.begin(); }
|
||||||
|
iterator end() { return m_children.end(); }
|
||||||
|
const_iterator begin() const { return m_children.begin(); }
|
||||||
|
const_iterator end() const { return m_children.end(); }
|
||||||
|
|
||||||
|
Node* front() const { return at(0); }
|
||||||
|
Node* back() const { return at(size()-1); }
|
||||||
|
|
||||||
|
// util for generating error message
|
||||||
|
std::string generateErrorMessage(const std::string& message) const;
|
||||||
|
|
||||||
|
// extracting values operator
|
||||||
|
template <typename T>
|
||||||
|
friend void operator >> (const Node& node, T& value);
|
||||||
|
|
||||||
|
// get nodes
|
||||||
|
Node* at(const std::string& childTag) const;
|
||||||
|
Node* at(int pos) const;
|
||||||
|
|
||||||
|
// get values
|
||||||
|
std::string value(const std::string& def = std::string()) const;
|
||||||
|
std::string valueAt(const std::string childTag, const std::string& def = std::string()) const;
|
||||||
|
|
||||||
|
// read values
|
||||||
|
template <typename T>
|
||||||
|
T read(T def = T()) const {
|
||||||
|
T value = def;
|
||||||
|
*this >> value;
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T readAt(const std::string childTag, T def = T()) const {
|
||||||
|
T v = def;
|
||||||
|
for(NodeList::const_iterator it = m_children.begin(); it != m_children.end(); ++it) {
|
||||||
|
if((*it)->tag() == childTag) {
|
||||||
|
*(*it) >> v;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
|
||||||
|
void addNode(Node* node);
|
||||||
|
|
||||||
|
private:
|
||||||
|
Parser* m_parser;
|
||||||
|
Node* m_parent;
|
||||||
|
int m_line;
|
||||||
|
NodeList m_children;
|
||||||
|
std::string m_tag;
|
||||||
|
std::string m_value;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Node operators
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
void operator >> (const Node& node, T& v)
|
||||||
|
{
|
||||||
|
fml_convert(node.value(), v);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
void operator >> (const Node& node, std::vector<T>& v)
|
||||||
|
{
|
||||||
|
v.clear();
|
||||||
|
v.resize(node.size());
|
||||||
|
for(unsigned i=0;i<node.size();++i)
|
||||||
|
*node.at(i) >> v[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename K, typename T>
|
||||||
|
void operator >> (const Node& node, std::map<K, T>& m)
|
||||||
|
{
|
||||||
|
m.clear();
|
||||||
|
for(Node::const_iterator it = node.begin(); it != node.end(); ++it) {
|
||||||
|
Node* child = (*it);
|
||||||
|
K k;
|
||||||
|
T v;
|
||||||
|
if(fml_convert<std::string, K>(child->tag(), k)) {
|
||||||
|
*child >> v;
|
||||||
|
m[k] = v;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
|
// Parser
|
||||||
|
|
||||||
|
class Parser
|
||||||
|
{
|
||||||
|
enum MultilineMode {
|
||||||
|
DONT_MULTILINE = 0,
|
||||||
|
MULTILINE_DONT_FOLD,
|
||||||
|
MULTILINE_FOLD_BLOCK,
|
||||||
|
MULTILINE_FOLD_FLOW
|
||||||
|
};
|
||||||
|
|
||||||
|
public:
|
||||||
|
Parser(std::string what = std::string()) : m_rootNode(0), m_what(what) { }
|
||||||
|
Parser(std::istream& in, std::string what = std::string()) : m_rootNode(0), m_what(what) { load(in); }
|
||||||
|
~Parser();
|
||||||
|
|
||||||
|
bool load(std::istream& in);
|
||||||
|
|
||||||
|
Node* getDocument() const { return m_rootNode; }
|
||||||
|
bool hasError() const { return !m_error.empty(); }
|
||||||
|
std::string getErrorMessage() { return m_error; }
|
||||||
|
std::string getWhat() { return m_what; }
|
||||||
|
|
||||||
|
protected:
|
||||||
|
void parseLine(std::string& line);
|
||||||
|
Node* parseNode(std::string& line);
|
||||||
|
std::string parseTextScalar(std::string value);
|
||||||
|
|
||||||
|
void startMultilining(const std::string& param);
|
||||||
|
void stopMultilining();
|
||||||
|
bool parseMultiline(std::string line);
|
||||||
|
bool isMultilining() { return m_multilineMode != DONT_MULTILINE; }
|
||||||
|
|
||||||
|
void setErrorMessage(const std::string& message, int line = 0);
|
||||||
|
|
||||||
|
private:
|
||||||
|
int m_currentDepth;
|
||||||
|
int m_currentLine;
|
||||||
|
Node* m_currentParent;
|
||||||
|
Node* m_previousNode;
|
||||||
|
Node* m_rootNode;
|
||||||
|
MultilineMode m_multilineMode;
|
||||||
|
std::string m_multilineData;
|
||||||
|
std::string m_error;
|
||||||
|
std::string m_what;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace FML {
|
||||||
|
|
||||||
|
// enable usage with foreach
|
||||||
|
namespace boost
|
||||||
|
{
|
||||||
|
// specialize range_mutable_iterator and range_const_iterator in namespace boost
|
||||||
|
template<>
|
||||||
|
struct range_mutable_iterator< FML::Node >
|
||||||
|
{
|
||||||
|
typedef FML::Node::iterator type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template<>
|
||||||
|
struct range_const_iterator< FML::Node >
|
||||||
|
{
|
||||||
|
typedef FML::Node::const_iterator type;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
#endif // FML_H
|
||||||
@ -1,125 +0,0 @@
|
|||||||
/* The MIT License
|
|
||||||
*
|
|
||||||
* Copyright (c) 2010 OTClient, https://github.com/edubart/otclient
|
|
||||||
*
|
|
||||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
* of this software and associated documentation files (the "Software"), to deal
|
|
||||||
* in the Software without restriction, including without limitation the rights
|
|
||||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
* copies of the Software, and to permit persons to whom the Software is
|
|
||||||
* furnished to do so, subject to the following conditions:
|
|
||||||
*
|
|
||||||
* The above copyright notice and this permission notice shall be included in
|
|
||||||
* all copies or substantial portions of the Software.
|
|
||||||
*
|
|
||||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
* THE SOFTWARE.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef YAML_H
|
|
||||||
#define YAML_H
|
|
||||||
|
|
||||||
#include <prerequisites.h>
|
|
||||||
#include <yaml-cpp/yaml.h>
|
|
||||||
|
|
||||||
inline void operator>>(const YAML::Node& node, Color& color)
|
|
||||||
{
|
|
||||||
int r, g, b, a;
|
|
||||||
node[0] >> r;
|
|
||||||
node[1] >> g;
|
|
||||||
node[2] >> b;
|
|
||||||
node[3] >> a;
|
|
||||||
color.setRGBA(r,g,b,a);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline void operator>>(const YAML::Node& node, TPoint<T>& point)
|
|
||||||
{
|
|
||||||
node[0] >> point.x;
|
|
||||||
node[1] >> point.y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline void operator>>(const YAML::Node& node, TRect<T>& rect)
|
|
||||||
{
|
|
||||||
T x, y, width, height;
|
|
||||||
node[0] >> x;
|
|
||||||
node[1] >> y;
|
|
||||||
node[2] >> width;
|
|
||||||
node[3] >> height;
|
|
||||||
rect.setRect(x, y, width, height);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline void operator>>(const YAML::Node& node, TSize<T>& size)
|
|
||||||
{
|
|
||||||
T w, h;
|
|
||||||
node[0] >> w;
|
|
||||||
node[1] >> h;
|
|
||||||
size.setSize(w, h);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
inline T yamlRead(const YAML::Node& node)
|
|
||||||
{
|
|
||||||
return node.to<T>();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
inline T yamlRead(const YAML::Node& node, const char *name)
|
|
||||||
{
|
|
||||||
T value;
|
|
||||||
if(node.Type() == YAML::NodeType::Map)
|
|
||||||
node[name] >> value;
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
inline T yamlRead(const YAML::Node& node, const char *name, const T& defaultValue)
|
|
||||||
{
|
|
||||||
T value = defaultValue;
|
|
||||||
if(node.Type() == YAML::NodeType::Map && node.FindValue(name))
|
|
||||||
node[name] >> value;
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline bool yamlHasValue(const YAML::Node& node, const char *name)
|
|
||||||
{
|
|
||||||
return (node.Type() == YAML::NodeType::Map && node.FindValue(name) != NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline std::string yamlErrorDesc(const YAML::Node& node, const std::string& error)
|
|
||||||
{
|
|
||||||
return YAML::Exception(node.GetMark(), error.c_str()).what();
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void yamlThrowError(const YAML::Node& node, const std::string& error)
|
|
||||||
{
|
|
||||||
throw YAML::Exception(node.GetMark(), error.c_str());
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class A, class B>
|
|
||||||
inline std::map<A,B> yamlReadMap(const YAML::Node& node, const char *name)
|
|
||||||
{
|
|
||||||
std::map<A,B> map;
|
|
||||||
if(node.Type() == YAML::NodeType::Map) {
|
|
||||||
if(const YAML::Node* mapNode = node.FindValue(name)) {
|
|
||||||
for(auto it = mapNode->begin(); it != mapNode->end(); ++it) {
|
|
||||||
A a;
|
|
||||||
B b;
|
|
||||||
it.first() >> a;
|
|
||||||
it.second() >> b;
|
|
||||||
map[a] = b;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return map;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // YAML_H
|
|
||||||
Loading…
Reference in new issue