]> git.stg.codes - stg.git/blob - stargazer/plugins/configuration/sgconfig/parser_tariffs.h
9f9c50316e87c635a112e3e168274038ee41e2e3
[stg.git] / stargazer / plugins / configuration / sgconfig / parser_tariffs.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 : Boris Mikhailenko <stg34@stargazer.dp.ua>
19  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
20  */
21
22 #pragma once
23
24 #include "parser.h"
25
26 #include "stg/tariff_conf.h"
27 #include "stg/common.h"
28
29 #include <string>
30
31 namespace STG
32 {
33
34 struct Tariffs;
35 struct Users;
36 struct Admin;
37
38 namespace PARSER
39 {
40
41 class GET_TARIFFS: public BASE_PARSER
42 {
43     public:
44         class FACTORY : public BASE_PARSER::FACTORY
45         {
46             public:
47                 explicit FACTORY(const Tariffs & tariffs) : m_tariffs(tariffs) {}
48                 virtual BASE_PARSER * create(const Admin & admin) { return new GET_TARIFFS(admin, m_tariffs); }
49                 static void Register(REGISTRY & registry, const Tariffs & tariffs)
50                 { registry[ToLower(tag)] = new FACTORY(tariffs); }
51             private:
52                 const Tariffs & m_tariffs;
53         };
54
55         static const char * tag;
56
57         GET_TARIFFS(const Admin & admin, const Tariffs & tariffs)
58             : BASE_PARSER(admin, tag), m_tariffs(tariffs) {}
59
60     private:
61         const Tariffs & m_tariffs;
62
63         void CreateAnswer();
64 };
65
66 class ADD_TARIFF: public BASE_PARSER
67 {
68     public:
69         class FACTORY : public BASE_PARSER::FACTORY
70         {
71             public:
72                 explicit FACTORY(Tariffs & tariffs) : m_tariffs(tariffs) {}
73                 virtual BASE_PARSER * create(const Admin & admin) { return new ADD_TARIFF(admin, m_tariffs); }
74                 static void Register(REGISTRY & registry, Tariffs & tariffs)
75                 { registry[ToLower(tag)] = new FACTORY(tariffs); }
76             private:
77                 Tariffs & m_tariffs;
78         };
79
80         static const char * tag;
81
82         ADD_TARIFF(const Admin & admin, Tariffs & tariffs)
83             : BASE_PARSER(admin, tag), m_tariffs(tariffs) {}
84         int Start(void * data, const char * el, const char ** attr);
85
86     private:
87         std::string tariff;
88         Tariffs & m_tariffs;
89
90         void CreateAnswer();
91 };
92
93 class DEL_TARIFF: public BASE_PARSER
94 {
95     public:
96         class FACTORY : public BASE_PARSER::FACTORY
97         {
98             public:
99                 FACTORY(Tariffs & tariffs, const Users & users) : m_tariffs(tariffs), m_users(users) {}
100                 virtual BASE_PARSER * create(const Admin & admin) { return new DEL_TARIFF(admin, m_users, m_tariffs); }
101                 static void Register(REGISTRY & registry, Tariffs & tariffs, const Users & users)
102                 { registry[ToLower(tag)] = new FACTORY(tariffs, users); }
103             private:
104                 Tariffs & m_tariffs;
105                 const Users & m_users;
106         };
107
108         static const char * tag;
109
110         DEL_TARIFF(const Admin & admin, const Users & users, Tariffs & tariffs)
111             : BASE_PARSER(admin, tag), m_users(users), m_tariffs(tariffs) {}
112         int Start(void * data, const char * el, const char ** attr);
113
114     private:
115         std::string tariff;
116         const Users & m_users;
117         Tariffs & m_tariffs;
118
119         void CreateAnswer();
120 };
121
122 class CHG_TARIFF: public BASE_PARSER
123 {
124     public:
125         class FACTORY : public BASE_PARSER::FACTORY
126         {
127             public:
128                 explicit FACTORY(Tariffs & tariffs) : m_tariffs(tariffs) {}
129                 virtual BASE_PARSER * create(const Admin & admin) { return new CHG_TARIFF(admin, m_tariffs); }
130                 static void Register(REGISTRY & registry, Tariffs & tariffs)
131                 { registry[ToLower(tag)] = new FACTORY(tariffs); }
132             private:
133                 Tariffs & m_tariffs;
134         };
135
136         static const char * tag;
137
138         CHG_TARIFF(const Admin & admin, Tariffs & tariffs)
139             : BASE_PARSER(admin, tag), m_tariffs(tariffs) {}
140         int Start(void * data, const char * el, const char ** attr);
141
142     private:
143         TariffDataOpt td;
144         Tariffs & m_tariffs;
145
146         int CheckTariffData();
147         void CreateAnswer();
148 };
149
150 } // namespace PARSER
151 } // namespace STG