]> git.stg.codes - stg.git/blob - include/stg/tariff_conf.h
Ticket 37. In the TariffChangeIsAllowed() function return "" added and
[stg.git] / include / stg / tariff_conf.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  */
20
21  /*
22  $Revision: 1.9 $
23  $Date: 2010/10/05 20:41:11 $
24  $Author: faust $
25  */
26
27 #ifndef TARIFF_CONF_H
28 #define TARIFF_CONF_H
29
30 #include "tariff.h"
31 #include "resetable.h"
32 #include "const.h"
33
34 #include <string>
35 #include <vector>
36
37 //-----------------------------------------------------------------------------
38 struct DIRPRICE_DATA
39 {
40     DIRPRICE_DATA()
41         : hDay(0),
42           mDay(0),
43           hNight(0),
44           mNight(0),
45           priceDayA(0),
46           priceNightA(0),
47           priceDayB(0),
48           priceNightB(0),
49           threshold(0),
50           singlePrice(0),
51           noDiscount(0)
52         {}
53     int    hDay;
54     int    mDay;
55     int    hNight;
56     int    mNight;
57     double priceDayA;
58     double priceNightA;
59     double priceDayB;
60     double priceNightB;
61     int    threshold;
62     int    singlePrice; // Do not use day/night division
63     int    noDiscount; // Do not use threshold
64 };
65 //-----------------------------------------------------------------------------
66 struct DIRPRICE_DATA_RES
67 {
68     DIRPRICE_DATA_RES()
69         : hDay(),
70           mDay(),
71           hNight(),
72           mNight(),
73           priceDayA(),
74           priceNightA(),
75           priceDayB(),
76           priceNightB(),
77           threshold(),
78           singlePrice(),
79           noDiscount()
80         {}
81
82     DIRPRICE_DATA_RES & operator= (const DIRPRICE_DATA & rvalue)
83         {
84         hDay        = rvalue.hDay;
85         mDay        = rvalue.mDay;
86         hNight      = rvalue.hNight;
87         mNight      = rvalue.mNight;
88         priceDayA   = rvalue.priceDayA;
89         priceNightA = rvalue.priceNightA;
90         priceDayB   = rvalue.priceDayB;
91         priceNightB = rvalue.priceNightB;
92         threshold   = rvalue.threshold;
93         singlePrice = rvalue.singlePrice;
94         noDiscount  = rvalue.noDiscount;
95         return *this;
96         }
97
98     DIRPRICE_DATA GetData() const
99         {
100         DIRPRICE_DATA dd;
101         hDay.maybeSet(dd.hDay);
102         hNight.maybeSet(dd.hNight);
103         mDay.maybeSet(dd.mDay);
104         mNight.maybeSet(dd.mNight);
105         noDiscount.maybeSet(dd.noDiscount);
106         priceDayA.maybeSet(dd.priceDayA);
107         priceDayB.maybeSet(dd.priceDayB);
108         priceNightA.maybeSet(dd.priceNightA);
109         priceNightB.maybeSet(dd.priceNightB);
110         singlePrice.maybeSet(dd.singlePrice);
111         threshold.maybeSet(dd.threshold);
112         return dd;
113         }
114
115     void Splice(const DIRPRICE_DATA_RES & rhs)
116         {
117         hDay.splice(rhs.hDay);
118         mDay.splice(rhs.mDay);
119         hNight.splice(rhs.hNight);
120         mNight.splice(rhs.mNight);
121         priceDayA.splice(rhs.priceDayA);
122         priceNightA.splice(rhs.priceNightA);
123         priceDayB.splice(rhs.priceDayB);
124         priceNightB.splice(rhs.priceNightB);
125         threshold.splice(rhs.threshold);
126         singlePrice.splice(rhs.singlePrice);
127         noDiscount.splice(rhs.noDiscount);
128         }
129
130     RESETABLE<int>    hDay;
131     RESETABLE<int>    mDay;
132     RESETABLE<int>    hNight;
133     RESETABLE<int>    mNight;
134     RESETABLE<double> priceDayA;
135     RESETABLE<double> priceNightA;
136     RESETABLE<double> priceDayB;
137     RESETABLE<double> priceNightB;
138     RESETABLE<int>    threshold;
139     RESETABLE<int>    singlePrice;
140     RESETABLE<int>    noDiscount;
141 };
142 //-----------------------------------------------------------------------------
143 struct TARIFF_CONF
144 {
145     double             fee;
146     double             free;
147     TARIFF::TRAFF_TYPE traffType;
148     double             passiveCost;
149     std::string        name;
150     TARIFF::PERIOD     period;
151     TARIFF::CHANGE_POLICY changePolicy;
152     time_t changePolicyTimeout;
153
154     TARIFF_CONF()
155         : fee(0),
156           free(0),
157           traffType(TARIFF::TRAFF_UP_DOWN),
158           passiveCost(0),
159           name(),
160           period(TARIFF::MONTH),
161           changePolicy(TARIFF::ALLOW),
162           changePolicyTimeout(0)
163         {}
164
165     TARIFF_CONF(const std::string & n)
166         : fee(0),
167           free(0),
168           traffType(TARIFF::TRAFF_UP_DOWN),
169           passiveCost(0),
170           name(n),
171           period(TARIFF::MONTH),
172           changePolicy(TARIFF::ALLOW),
173           changePolicyTimeout(0)
174         {}
175 };
176 //-----------------------------------------------------------------------------
177 struct TARIFF_CONF_RES
178 {
179     TARIFF_CONF_RES()
180         : fee(),
181           free(),
182           traffType(),
183           passiveCost(),
184           name(),
185           period(),
186           changePolicy(),
187           changePolicyTimeout()
188         {}
189
190     TARIFF_CONF_RES & operator=(const TARIFF_CONF & tc)
191         {
192         fee         = tc.fee;
193         free        = tc.free;
194         traffType   = tc.traffType;
195         passiveCost = tc.passiveCost;
196         name        = tc.name;
197         period      = tc.period;
198         changePolicy = tc.changePolicy;
199         changePolicyTimeout = tc.changePolicyTimeout;
200         return *this;
201         }
202
203     TARIFF_CONF GetData() const
204         {
205         TARIFF_CONF tc;
206         fee.maybeSet(tc.fee);
207         free.maybeSet(tc.free);
208         name.maybeSet(tc.name);
209         passiveCost.maybeSet(tc.passiveCost);
210         traffType.maybeSet(tc.traffType);
211         period.maybeSet(tc.period);
212         changePolicy.maybeSet(tc.changePolicy);
213         changePolicyTimeout.maybeSet(tc.changePolicyTimeout);
214         return tc;
215         }
216
217     RESETABLE<double>             fee;
218     RESETABLE<double>             free;
219     RESETABLE<TARIFF::TRAFF_TYPE> traffType;
220     RESETABLE<double>             passiveCost;
221     RESETABLE<std::string>        name;
222     RESETABLE<TARIFF::PERIOD>     period;
223     RESETABLE<TARIFF::CHANGE_POLICY> changePolicy;
224     RESETABLE<time_t>             changePolicyTimeout;
225 };
226 //-----------------------------------------------------------------------------
227 struct TARIFF_DATA
228 {
229     TARIFF_CONF                tariffConf;
230     std::vector<DIRPRICE_DATA> dirPrice;
231
232     TARIFF_DATA()
233         : tariffConf(),
234           dirPrice(DIR_NUM)
235         {}
236
237     TARIFF_DATA(const std::string & name)
238         : tariffConf(name),
239           dirPrice(DIR_NUM)
240         {}
241
242     TARIFF_DATA(const TARIFF_DATA & td)
243         : tariffConf(td.tariffConf),
244           dirPrice(td.dirPrice)
245         {}
246
247     TARIFF_DATA & operator=(const TARIFF_DATA & td)
248         {
249         tariffConf = td.tariffConf;
250         dirPrice = td.dirPrice;
251         return *this;
252         }
253 };
254 //-----------------------------------------------------------------------------
255 struct TARIFF_DATA_RES
256 {
257     TARIFF_CONF_RES                tariffConf;
258     std::vector<DIRPRICE_DATA_RES> dirPrice;
259
260     TARIFF_DATA_RES()
261         : tariffConf(),
262           dirPrice(DIR_NUM)
263         {}
264
265     TARIFF_DATA_RES & operator=(const TARIFF_DATA & td)
266         {
267         tariffConf = td.tariffConf;
268         for (size_t i = 0; i < DIR_NUM; ++i)
269             dirPrice[i] = td.dirPrice[i];
270         return *this;
271         }
272
273     TARIFF_DATA GetData() const
274         {
275         TARIFF_DATA td;
276         td.tariffConf = tariffConf.GetData();
277         for (size_t i = 0; i < DIR_NUM; i++)
278             td.dirPrice[i] = dirPrice[i].GetData();
279         return td;
280         }
281 };
282 //-----------------------------------------------------------------------------
283 #endif