]> git.stg.codes - stg.git/blob - libs/json/include/stg/json_parser.h
a614257944441c9c85248d0eec9ae68c504a7c01
[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
29 #include <boost/scoped_ptr.hpp>
30
31 namespace STG
32 {
33 namespace JSON
34 {
35
36 struct NodeParser
37 {
38     virtual ~NodeParser() {}
39
40     virtual NodeParser* parseNull() { return this; }
41     virtual NodeParser* parseBoolean(const bool& /*value*/) { return this; }
42     virtual NodeParser* parseNumber(const std::string& /*value*/) { return this; }
43     virtual NodeParser* parseString(const std::string& /*value*/) { return this; }
44     virtual NodeParser* parseStartMap() { return this; }
45     virtual NodeParser* parseMapKey(const std::string& /*value*/) { return this; }
46     virtual NodeParser* parseEndMap() { return this; }
47     virtual NodeParser* parseStartArray() { return this; }
48     virtual NodeParser* parseEndArray() { return this; }
49 };
50
51 class Parser
52 {
53     public:
54         explicit Parser(NodeParser* topParser);
55         virtual ~Parser();
56
57         bool append(const char* data, size_t size);
58         bool last();
59
60     private:
61         class Impl;
62         boost::scoped_ptr<Impl> m_impl;
63 };
64
65 template <typename T>
66 class EnumParser : public NodeParser
67 {
68     public:
69         typedef std::map<std::string, T> Codes;
70         EnumParser(NodeParser* next, T& data, std::string& dataStr, const Codes& codes)
71             : m_next(next), m_data(data), m_dataStr(dataStr), m_codes(codes) {}
72         virtual NodeParser* parseString(const std::string& value)
73         {
74             m_dataStr = value;
75             const typename Codes::const_iterator it = m_codes.find(ToLower(value));
76             if (it != m_codes.end())
77                 m_data = it->second;
78             return m_next;
79         }
80     private:
81         NodeParser* m_next;
82         T& m_data;
83         std::string& m_dataStr;
84         const Codes& m_codes;
85 };
86
87 class PairsParser : public NodeParser
88 {
89     public:
90         typedef std::map<std::string, std::string> Pairs;
91
92         PairsParser(NodeParser* next, Pairs& pairs) : m_next(next), m_pairs(pairs) {}
93
94         virtual NodeParser* parseStartMap() { return this; }
95         virtual NodeParser* parseString(const std::string& value) { m_pairs[m_key] = value; return this; }
96         virtual NodeParser* parseMapKey(const std::string& value) { m_key = value; return this; }
97         virtual NodeParser* parseEndMap() { return m_next; }
98     private:
99         NodeParser* m_next;
100         Pairs& m_pairs;
101         std::string m_key;
102 };
103
104 }
105 }
106
107 #endif