]> git.stg.codes - stg.git/blob - libs/json/include/stg/json_parser.h
Enable binaries and mods in test builds.
[stg.git] / libs / json / include / stg / json_parser.h
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
19  */
20
21 #ifndef __STG_STGLIBS_JSON_PARSER_H__
22 #define __STG_STGLIBS_JSON_PARSER_H__
23
24 #include "stg/common.h"
25
26 #include <string>
27 #include <map>
28 #include <memory>
29
30 namespace STG
31 {
32 namespace JSON
33 {
34
35 struct NodeParser
36 {
37     virtual ~NodeParser() {}
38
39     virtual NodeParser* parseNull() { return this; }
40     virtual NodeParser* parseBoolean(const bool& /*value*/) { return this; }
41     virtual NodeParser* parseNumber(const std::string& /*value*/) { return this; }
42     virtual NodeParser* parseString(const std::string& /*value*/) { return this; }
43     virtual NodeParser* parseStartMap() { return this; }
44     virtual NodeParser* parseMapKey(const std::string& /*value*/) { return this; }
45     virtual NodeParser* parseEndMap() { return this; }
46     virtual NodeParser* parseStartArray() { return this; }
47     virtual NodeParser* parseEndArray() { return this; }
48 };
49
50 class Parser
51 {
52     public:
53         explicit Parser(NodeParser* topParser);
54         virtual ~Parser();
55
56         bool append(const char* data, size_t size);
57         bool last();
58
59     private:
60         class Impl;
61         std::unique_ptr<Impl> m_impl;
62 };
63
64 template <typename T>
65 class EnumParser : public NodeParser
66 {
67     public:
68         typedef std::map<std::string, T> Codes;
69         EnumParser(NodeParser* next, T& data, std::string& dataStr, const Codes& codes)
70             : m_next(next), m_data(data), m_dataStr(dataStr), m_codes(codes) {}
71         virtual NodeParser* parseString(const std::string& value)
72         {
73             m_dataStr = value;
74             const typename Codes::const_iterator it = m_codes.find(ToLower(value));
75             if (it != m_codes.end())
76                 m_data = it->second;
77             return m_next;
78         }
79     private:
80         NodeParser* m_next;
81         T& m_data;
82         std::string& m_dataStr;
83         const Codes& m_codes;
84 };
85
86 class PairsParser : public NodeParser
87 {
88     public:
89         typedef std::map<std::string, std::string> Pairs;
90
91         PairsParser(NodeParser* next, Pairs& pairs) : m_next(next), m_pairs(pairs) {}
92
93         virtual NodeParser* parseStartMap() { return this; }
94         virtual NodeParser* parseString(const std::string& value) { m_pairs[m_key] = value; return this; }
95         virtual NodeParser* parseMapKey(const std::string& value) { m_key = value; return this; }
96         virtual NodeParser* parseEndMap() { return m_next; }
97     private:
98         NodeParser* m_next;
99         Pairs& m_pairs;
100         std::string m_key;
101 };
102
103 }
104 }
105
106 #endif