Общая библиотека для работы с торговым оборудованием.  1.0.0
cmdparser.h
1 /****************************************************************************
2 ** $Id: cmdparser.h,v 1.10 2006/03/03 13:11:04 red75 Exp $
3 **
4 ** Trade equipment common portable library project
5 **
6 ** Copyright (C) 1999-2006 Leader InfoTech. All rights reserved.
7 **
8 ** This file is part of the Library of the Ananas
9 ** automation accounting system.
10 **
11 ** This file may be distributed and/or modified under the terms of the
12 ** GNU General Public License version 2 as published by the Free Software
13 ** Foundation and appearing in the file LICENSE.GPL included in the
14 ** packaging of this file.
15 **
16 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
17 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18 **
19 ** See http://www.leaderit.ru/ or email sales@leaderit.ru
20 **
21 ** Contact org@leaderit.ru if any conditions of this licensing are
22 ** not clear to you.
23 **
24 **********************************************************************/
25 
26 #ifndef _CMDPARSER_H_
27 #define _CMDPARSER_H_
28 
29 #include "teglobal.h"
30 #include <qstring.h>
31 #include <qstringlist.h>
32 #include <qpair.h>
33 #include <qtextcodec.h>
34 #include <qvariant.h>
35 #include <qvaluevector.h>
36 #include "conv.h"
37 
38 // This class is intended to parse command lines and to handle different encodings,
39 // along with call forwarding.
40 
41 LIB_TEMPLATE_EXTERN template struct LIB_EXPORT QPair<QString,int>;
42 LIB_TEMPLATE_EXTERN template class LIB_EXPORT QMap<QPair<QString,int>,memFunc*>;
43 LIB_TEMPLATE_EXTERN template class LIB_EXPORT QMap<QPair<QString,int>,memProc*>;
44 
45 class LIB_EXPORT ExecEngine
46 {
47  QTextCodec * m_pTextCodec;
48  QString m_error;
49  QString m_result;
50  // function name, arity
51  typedef QPair<QString,int> FuncDesc;
52 
53  // This class maps function description to functor
54  typedef QMap<FuncDesc,memFunc*> FuncDescToMemFunc;
55  typedef QMap<FuncDesc,memProc*> FuncDescToMemProc;
56 
57  FuncDescToMemFunc m_mapMemFunc;
58  FuncDescToMemProc m_mapMemProc;
59 
60 public:
61  ExecEngine();
62  virtual ~ExecEngine();
63 
64  int execute(const char * cmd);
65  int execute(const QString & ucmd);
66  QString result() const {return m_result;};
67  QString error() const {return m_error;};
68  QString help() const; // it returns list of all functions
69 
70  void setEncoding(const QString & encoding);
71  int parse(const char * cmd, QString & func, QValueVector<QVariant> & parms);
72  int parse(const QString & ucmd, QString & func, QValueVector<QVariant> & parms);
73 
74  template <class T, class R>
75  int addFuncBinding(T * pobj, R (T::*pfunc)(void), const QString & name)
76  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
77  delete m_mapMemFunc[FuncDesc(name,0)];
78  m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R>(pobj,pfunc);
79  return 0;
80  };
81 
82  template <class T, class R>
83  int addFuncBinding(T * pobj, R (T::*pfunc)(void) const, const QString & name)
84  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
85  delete m_mapMemFunc[FuncDesc(name,0)];
86  m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R, ConstFunc0<T,R> >(pobj,pfunc);
87  return 0;
88  };
89 
90  template <class T, class R, class P1>
91  int addFuncBinding(T * pobj, R (T::*pfunc)(P1), const QString & name)
92  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
93  delete m_mapMemFunc[FuncDesc(name,1)];
94  m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1>(pobj,pfunc);
95  return 0;
96  };
97 
98  template <class T, class R, class P1>
99  int addFuncBinding(T * pobj, R (T::*pfunc)(P1) const, const QString & name)
100  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
101  delete m_mapMemFunc[FuncDesc(name,1)];
102  m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1, ConstFunc1<T,R,P1> >(pobj,pfunc);
103  return 0;
104  };
105 
106  template <class T, class R, class P1, class P2>
107  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2), const QString & name)
108  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
109  delete m_mapMemFunc[FuncDesc(name,2)];
110  m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2>(pobj,pfunc);
111  return 0;
112  };
113 
114  template <class T, class R, class P1, class P2>
115  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2) const, const QString & name)
116  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
117  delete m_mapMemFunc[FuncDesc(name,2)];
118  m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2, ConstFunc2<T,R,P1,P2> >(pobj,pfunc);
119  return 0;
120  };
121 
122  template <class T, class R, class P1, class P2, class P3>
123  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3), const QString & name)
124  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
125  delete m_mapMemFunc[FuncDesc(name,3)];
126  m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3>(pobj,pfunc);
127  return 0;
128  };
129 
130  template <class T, class R, class P1, class P2, class P3>
131  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3) const, const QString & name)
132  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
133  delete m_mapMemFunc[FuncDesc(name,3)];
134  m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3, ConstFunc3<T,R,P1,P2,P3> >(pobj,pfunc);
135  return 0;
136  };
137 
138  template <class T, class R, class P1, class P2, class P3, class P4>
139  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4), const QString & name)
140  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
141  delete m_mapMemFunc[FuncDesc(name,4)];
142  m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4>(pobj,pfunc);
143  return 0;
144  };
145 
146  template <class T, class R, class P1, class P2, class P3, class P4>
147  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4) const, const QString & name)
148  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
149  delete m_mapMemFunc[FuncDesc(name,4)];
150  m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4, ConstFunc4<T,R,P1,P2,P3,P4> >(pobj,pfunc);
151  return 0;
152  };
153 
154  template <class T, class R, class P1, class P2, class P3, class P4, class P5>
155  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4,P5), const QString & name)
156  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
157  delete m_mapMemFunc[FuncDesc(name,5)];
158  m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5>(pobj,pfunc);
159  return 0;
160  };
161 
162  template <class T, class R, class P1, class P2, class P3, class P4, class P5>
163  int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4,P5) const, const QString & name)
164  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
165  delete m_mapMemFunc[FuncDesc(name,5)];
166  m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5, ConstFunc5<T,R,P1,P2,P3,P4,P5> >(pobj,pfunc);
167  return 0;
168  };
169 
170  template <class T, class R>
171  int addFuncBinding0(T * pobj, typename memFunc0<T,R>::memFunPtr pfunc, const QString & name)
172  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
173  delete m_mapMemFunc[FuncDesc(name,0)];
174  m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R>(pobj,pfunc);
175  return 0;
176  };
177 
178  template <class T, class R, class FuncType >
179  int addFuncBinding0(T * pobj, typename memFunc0<T,R,FuncType>::memFunPtr pfunc, const QString & name)
180  { // if there was no value, this string evaluates to 'delete 0', which is acceptable
181  delete m_mapMemFunc[FuncDesc(name,0)];
182  m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R,FuncType>(pobj,pfunc);
183  return 0;
184  };
185 
186  template <class T, class R, class P1>
187  int addFuncBinding1(T * pobj, typename memFunc1<T,R,P1>::memFunPtr pfunc, const QString & name)
188  {
189  delete m_mapMemFunc[FuncDesc(name,1)];
190  m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1>(pobj,pfunc);
191  return 0;
192  };
193 
194  template <class T, class R, class P1, class P2>
195  int addFuncBinding2(T * pobj, typename memFunc2<T,R,P1,P2>::memFunPtr pfunc, const QString & name)
196  {
197  delete m_mapMemFunc[FuncDesc(name,2)];
198  m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2>(pobj,pfunc);
199  return 0;
200  };
201 
202  template <class T, class R, class P1, class P2, class P3>
203  int addFuncBinding3(T * pobj, typename memFunc3<T,R,P1,P2,P3>::memFunPtr pfunc, const QString & name)
204  {
205  delete m_mapMemFunc[FuncDesc(name,3)];
206  m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3>(pobj,pfunc);
207  return 0;
208  };
209  template <class T, class R, class P1, class P2, class P3, class P4>
210  int addFuncBinding4(T * pobj, typename memFunc4<T,R,P1,P2,P3,P4>::memFunPtr pfunc, const QString & name)
211  {
212  delete m_mapMemFunc[FuncDesc(name,4)];
213  m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4>(pobj,pfunc);
214  return 0;
215  };
216 
217  template <class T, class R, class P1, class P2, class P3, class P4, class P5>
218  int addFuncBinding5(T * pobj, typename memFunc5<T,R,P1,P2,P3,P4,P5>::memFunPtr pfunc, const QString & name)
219  {
220  delete m_mapMemFunc[FuncDesc(name,5)];
221  m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5>(pobj,pfunc);
222  return 0;
223  };
224 
225  template <class T, class P1, class P2, class P3, class P4, class P5>
226  int addProcBinding5(T * pobj, typename memProc5<T,P1,P2,P3,P4,P5>::memProcPtr pfunc, const QString & name)
227  {
228  delete m_mapMemProc[FuncDesc(name,5)];
229  m_mapMemProc[FuncDesc(name,5)]=new memProc5<T,P1,P2,P3,P4,P5>(pobj,pfunc);
230  return 0;
231  };
232 
233  template <class T, class P1, class P2, class P3, class P4>
234  int addProcBinding4(T * pobj, typename memProc4<T,P1,P2,P3,P4>::memProcPtr pfunc, const QString & name)
235  {
236  delete m_mapMemProc[FuncDesc(name,4)];
237  m_mapMemProc[FuncDesc(name,4)]=new memProc4<T,P1,P2,P3,P4>(pobj,pfunc);
238  return 0;
239  };
240 
241  template <class T, class P1, class P2, class P3>
242  int addProcBinding3(T * pobj, typename memProc3<T,P1,P2,P3>::memProcPtr pfunc, const QString & name)
243  {
244  delete m_mapMemProc[FuncDesc(name,3)];
245  m_mapMemProc[FuncDesc(name,3)]=new memProc3<T,P1,P2,P3>(pobj,pfunc);
246  return 0;
247  };
248 
249  template <class T, class P1, class P2>
250  int addProcBinding2(T * pobj, typename memProc2<T,P1,P2>::memProcPtr pfunc, const QString & name)
251  {
252  delete m_mapMemProc[FuncDesc(name,2)];
253  m_mapMemProc[FuncDesc(name,2)]=new memProc2<T,P1,P2>(pobj,pfunc);
254  return 0;
255  };
256 
257  template <class T, class P1>
258  int addProcBinding1(T * pobj, typename memProc1<T,P1>::memProcPtr pfunc, const QString & name)
259  {
260  delete m_mapMemProc[FuncDesc(name,1)];
261  m_mapMemProc[FuncDesc(name,1)]=new memProc1<T,P1>(pobj,pfunc);
262  return 0;
263  };
264 
265  template <class T>
266  int addProcBinding0(T * pobj, typename memProc0<T>::memProcPtr pfunc, const QString & name)
267  {
268  delete m_mapMemProc[FuncDesc(name,0)];
269  m_mapMemProc[FuncDesc(name,0)]=new memProc0<T>(pobj,pfunc);
270  return 0;
271  };
272 
273  template <class T, class FT>
274  int addProcBinding0(T * pobj, typename memProc0<T,FT>::memProcPtr pfunc, const QString & name)
275  {
276  delete m_mapMemProc[FuncDesc(name,0)];
277  m_mapMemProc[FuncDesc(name,0)]=new memProc0<T,FT>(pobj,pfunc);
278  return 0;
279  };
280 };
281 
282 // Helper functions, which are intended to simplify function binding code
283 
284 /*
285 template <class T>
286 int addProcBinding(ExecEngine & ee, T * pObj, void (T::*func)() const, const QString & name)
287 {
288  return ee.addProcBinding0<T, ConstProc0<T> >(pObj, func, name);
289 }
290 
291 template <class T>
292 int addProcBinding(ExecEngine & ee, T * pObj, void (T::*func)(), const QString & name)
293 {
294  return ee.addProcBinding0<T>(pObj,func,name);
295 }
296 
297 template <class Ty, class R>
298 int addFuncBinding(ExecEngine & ee, Ty * pObj, R (Ty::*func)() const, const QString & name)
299 {
300  return ee.addFuncBinding0<Ty,R,ConstFunc0<Ty,R> >(pObj,func,name);
301 }
302 
303 template <class T, class R>
304 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(), const QString & name)
305 {
306  return ee.addFuncBinding0<T,R>(pObj,func,name);
307 }
308 
309 template <class T, class R, class P1>
310 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1), const QString & name)
311 {
312  return ee.addFuncBinding1<T,R,P1>(pObj,func,name);
313 }
314 
315 template <class T, class R, class P1>
316 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1) const, const QString & name)
317 {
318  return ee.addFuncBinding1<T,R,P1,ConstFunc1<T,R,P1> >(pObj,func,name);
319 }
320 
321 template <class T, class R, class P1, class P2>
322 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1,P2), const QString & name)
323 {
324  return ee.addFuncBinding2<T,R,P1,P2>(pObj,func,name);
325 }
326 
327 template <class T, class R, class P1, class P2>
328 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1,P2) const, const QString & name)
329 {
330  return ee.addFuncBinding2<T,R,P1,P2,ConstFunc1<T,R,P1,P2> >(pObj,func,name);
331 }
332 */
333 
334 #endif
Definition: conv.h:336
Definition: conv.h:258
Definition: conv.h:524
Definition: conv.h:446
Definition: conv.h:366
Definition: conv.h:162
Definition: conv.h:554
Definition: conv.h:282
Definition: conv.h:432
Definition: conv.h:470
Definition: conv.h:399
Definition: conv.h:308
Definition: conv.h:586
Definition: conv.h:496
Command interpreter for TEBase classes.
Definition: cmdparser.h:45